#define DEBUG
using System;
using System.Buffers;
using System.Buffers.Binary;
using System.Buffers.Text;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Configuration.Assemblies;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Diagnostics.Tracing;
using System.Globalization;
using System.IO;
using System.IO.Enumeration;
using System.IO.Strategies;
using System.Numerics;
using System.Private.CoreLib;
using System.Reflection;
using System.Reflection.Emit;
using System.Reflection.Metadata;
using System.Resources;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
using System.Runtime.Intrinsics.X86;
using System.Runtime.Loader;
using System.Runtime.Remoting;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Security.Principal;
using System.StubHelpers;
using System.Text;
using System.Text.Unicode;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Sources;
using Internal;
using Internal.Runtime.CompilerServices;
using Internal.Win32;
using Internal.Win32.SafeHandles;
using Microsoft.CodeAnalysis;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MetadataUpdateHandler(typeof(RuntimeTypeMetadataUpdateHandler))]
[assembly: CLSCompliant(true)]
[assembly: ComVisible(false)]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata(".NETFrameworkAssembly", "")]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("System.Private.CoreLib")]
[assembly: AssemblyFileVersion("6.0.722.32202")]
[assembly: AssemblyInformationalVersion("6.0.7+0ec02c8c96e2eda06dc5b5edfdbdba0f36415082")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("System.Private.CoreLib")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: AssemblyVersion("6.0.0.0")]
[module: NullablePublicOnly(false)]
[module: SkipLocalsInit]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

		public NativeIntegerAttribute()
		{
			TransformFlags = new bool[1] { true };
		}

		public NativeIntegerAttribute(bool[] P_0)
		{
			TransformFlags = P_0;
		}
	}
}
internal static class Interop
{
	internal static class OleAut32
	{
		[DllImport("oleaut32.dll")]
		internal static extern void VariantClear(IntPtr variant);

		[DllImport("oleaut32.dll")]
		internal static extern IntPtr SysAllocStringByteLen(byte[] str, uint len);

		[DllImport("oleaut32.dll", CharSet = CharSet.Unicode)]
		internal static extern IntPtr SysAllocStringLen(IntPtr src, uint len);

		[DllImport("oleaut32.dll")]
		internal static extern void SysFreeString(IntPtr bstr);
	}

	internal static class Globalization
	{
		internal enum ResultCode
		{
			Success,
			UnknownError,
			InsufficentBuffer,
			OutOfMemory
		}

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetCalendars")]
		internal static extern int GetCalendars(string localeName, CalendarId[] calendars, int calendarsCapacity);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetCalendarInfo")]
		internal unsafe static extern ResultCode GetCalendarInfo(string localeName, CalendarId calendarId, CalendarDataType calendarDataType, char* result, int resultCapacity);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_EnumCalendarInfo")]
		internal unsafe static extern bool EnumCalendarInfo(delegate* unmanaged<char*, IntPtr, void> callback, string localeName, CalendarId calendarId, CalendarDataType calendarDataType, IntPtr context);

		[DllImport("System.Globalization.Native", EntryPoint = "GlobalizationNative_GetLatestJapaneseEra")]
		internal static extern int GetLatestJapaneseEra();

		[DllImport("System.Globalization.Native", EntryPoint = "GlobalizationNative_GetJapaneseEraStartDate")]
		internal static extern bool GetJapaneseEraStartDate(int era, out int startYear, out int startMonth, out int startDay);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_ChangeCase")]
		internal unsafe static extern void ChangeCase(char* src, int srcLen, char* dstBuffer, int dstBufferCapacity, bool bToUpper);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_ChangeCaseInvariant")]
		internal unsafe static extern void ChangeCaseInvariant(char* src, int srcLen, char* dstBuffer, int dstBufferCapacity, bool bToUpper);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_ChangeCaseTurkish")]
		internal unsafe static extern void ChangeCaseTurkish(char* src, int srcLen, char* dstBuffer, int dstBufferCapacity, bool bToUpper);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_InitOrdinalCasingPage")]
		internal unsafe static extern void InitOrdinalCasingPage(int pageNumber, char* pTarget);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Ansi, EntryPoint = "GlobalizationNative_GetSortHandle")]
		internal static extern ResultCode GetSortHandle(string localeName, out IntPtr sortHandle);

		[DllImport("System.Globalization.Native", EntryPoint = "GlobalizationNative_CloseSortHandle")]
		internal static extern void CloseSortHandle(IntPtr handle);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_CompareString")]
		internal unsafe static extern int CompareString(IntPtr sortHandle, char* lpStr1, int cwStr1Len, char* lpStr2, int cwStr2Len, CompareOptions options);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_IndexOf")]
		internal unsafe static extern int IndexOf(IntPtr sortHandle, char* target, int cwTargetLength, char* pSource, int cwSourceLength, CompareOptions options, int* matchLengthPtr);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_LastIndexOf")]
		internal unsafe static extern int LastIndexOf(IntPtr sortHandle, char* target, int cwTargetLength, char* pSource, int cwSourceLength, CompareOptions options, int* matchLengthPtr);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_StartsWith")]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal unsafe static extern bool StartsWith(IntPtr sortHandle, char* target, int cwTargetLength, char* source, int cwSourceLength, CompareOptions options, int* matchedLength);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_EndsWith")]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal unsafe static extern bool EndsWith(IntPtr sortHandle, char* target, int cwTargetLength, char* source, int cwSourceLength, CompareOptions options, int* matchedLength);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetSortKey")]
		internal unsafe static extern int GetSortKey(IntPtr sortHandle, char* str, int strLength, byte* sortKey, int sortKeyLength, CompareOptions options);

		[DllImport("System.Globalization.Native", EntryPoint = "GlobalizationNative_GetSortVersion")]
		internal static extern int GetSortVersion(IntPtr sortHandle);

		[DllImport("System.Globalization.Native", EntryPoint = "GlobalizationNative_LoadICU")]
		internal static extern int LoadICU();

		internal static void InitICUFunctions(IntPtr icuuc, IntPtr icuin, ReadOnlySpan<char> version, ReadOnlySpan<char> suffix)
		{
			InitICUFunctions(icuuc, icuin, version.ToString(), (suffix.Length > 0) ? suffix.ToString() : null);
		}

		[DllImport("System.Globalization.Native", EntryPoint = "GlobalizationNative_InitICUFunctions")]
		internal static extern void InitICUFunctions(IntPtr icuuc, IntPtr icuin, string version, string suffix);

		[DllImport("System.Globalization.Native", EntryPoint = "GlobalizationNative_GetICUVersion")]
		internal static extern int GetICUVersion();

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_ToAscii")]
		internal unsafe static extern int ToAscii(uint flags, char* src, int srcLen, char* dstBuffer, int dstBufferCapacity);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_ToUnicode")]
		internal unsafe static extern int ToUnicode(uint flags, char* src, int srcLen, char* dstBuffer, int dstBufferCapacity);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetLocaleName")]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal unsafe static extern bool GetLocaleName(string localeName, char* value, int valueLength);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetLocaleInfoString")]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal unsafe static extern bool GetLocaleInfoString(string localeName, uint localeStringData, char* value, int valueLength, string uiLocaleName = null);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_IsPredefinedLocale")]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool IsPredefinedLocale(string localeName);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetLocaleTimeFormat")]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal unsafe static extern bool GetLocaleTimeFormat(string localeName, bool shortFormat, char* value, int valueLength);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetLocaleInfoInt")]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool GetLocaleInfoInt(string localeName, uint localeNumberData, ref int value);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetLocaleInfoGroupingSizes")]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool GetLocaleInfoGroupingSizes(string localeName, uint localeGroupingData, ref int primaryGroupSize, ref int secondaryGroupSize);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_GetLocales")]
		internal static extern int GetLocales([Out] char[] value, int valueLength);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_IsNormalized")]
		internal unsafe static extern int IsNormalized(NormalizationForm normalizationForm, char* src, int srcLen);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_NormalizeString")]
		internal unsafe static extern int NormalizeString(NormalizationForm normalizationForm, char* src, int srcLen, char* dstBuffer, int dstBufferCapacity);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_WindowsIdToIanaId")]
		internal unsafe static extern int WindowsIdToIanaId(string windowsId, IntPtr region, char* ianaId, int ianaIdLength);

		[DllImport("System.Globalization.Native", CharSet = CharSet.Unicode, EntryPoint = "GlobalizationNative_IanaIdToWindowsId")]
		internal unsafe static extern int IanaIdToWindowsId(string ianaId, char* windowsId, int windowsIdLength);
	}

	internal enum BOOL
	{
		FALSE,
		TRUE
	}

	internal static class Kernel32
	{
		internal struct NlsVersionInfoEx
		{
			internal int dwNLSVersionInfoSize;

			internal int dwNLSVersion;

			internal int dwDefinedVersion;

			internal int dwEffectiveId;

			internal Guid guidCustomVersion;
		}

		internal struct CONDITION_VARIABLE
		{
			private IntPtr Ptr;
		}

		internal struct CRITICAL_SECTION
		{
			private IntPtr DebugInfo;

			private int LockCount;

			private int RecursionCount;

			private IntPtr OwningThread;

			private IntPtr LockSemaphore;

			private UIntPtr SpinCount;
		}

		internal struct FILE_BASIC_INFO
		{
			internal long CreationTime;

			internal long LastAccessTime;

			internal long LastWriteTime;

			internal long ChangeTime;

			internal uint FileAttributes;
		}

		internal struct FILE_ALLOCATION_INFO
		{
			internal long AllocationSize;
		}

		internal struct FILE_END_OF_FILE_INFO
		{
			internal long EndOfFile;
		}

		internal struct FILE_STANDARD_INFO
		{
			internal long AllocationSize;

			internal long EndOfFile;

			internal uint NumberOfLinks;

			internal BOOL DeletePending;

			internal BOOL Directory;
		}

		internal struct FILE_TIME
		{
			internal uint dwLowDateTime;

			internal uint dwHighDateTime;

			internal long ToTicks()
			{
				return (long)(((ulong)dwHighDateTime << 32) + dwLowDateTime);
			}

			internal DateTimeOffset ToDateTimeOffset()
			{
				return DateTimeOffset.FromFileTime(ToTicks());
			}
		}

		internal enum FINDEX_INFO_LEVELS : uint
		{
			FindExInfoStandard,
			FindExInfoBasic,
			FindExInfoMaxInfoLevel
		}

		internal enum FINDEX_SEARCH_OPS : uint
		{
			FindExSearchNameMatch,
			FindExSearchLimitToDirectories,
			FindExSearchLimitToDevices,
			FindExSearchMaxSearchOp
		}

		internal enum GET_FILEEX_INFO_LEVELS : uint
		{
			GetFileExInfoStandard,
			GetFileExMaxInfoLevel
		}

		internal struct CPINFO
		{
			internal int MaxCharSize;

			internal unsafe fixed byte DefaultChar[2];

			internal unsafe fixed byte LeadByte[12];
		}

		internal struct PROCESS_MEMORY_COUNTERS
		{
			public uint cb;

			public uint PageFaultCount;

			public UIntPtr PeakWorkingSetSize;

			public UIntPtr WorkingSetSize;

			public UIntPtr QuotaPeakPagedPoolUsage;

			public UIntPtr QuotaPagedPoolUsage;

			public UIntPtr QuotaPeakNonPagedPoolUsage;

			public UIntPtr QuotaNonPagedPoolUsage;

			public UIntPtr PagefileUsage;

			public UIntPtr PeakPagefileUsage;
		}

		internal struct MEMORY_BASIC_INFORMATION
		{
			internal unsafe void* BaseAddress;

			internal unsafe void* AllocationBase;

			internal uint AllocationProtect;

			internal UIntPtr RegionSize;

			internal uint State;

			internal uint Protect;

			internal uint Type;
		}

		internal struct MEMORYSTATUSEX
		{
			internal uint dwLength;

			internal uint dwMemoryLoad;

			internal ulong ullTotalPhys;

			internal ulong ullAvailPhys;

			internal ulong ullTotalPageFile;

			internal ulong ullAvailPageFile;

			internal ulong ullTotalVirtual;

			internal ulong ullAvailVirtual;

			internal ulong ullAvailExtendedVirtual;
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		internal struct OSVERSIONINFOEX
		{
			public int dwOSVersionInfoSize;

			public int dwMajorVersion;

			public int dwMinorVersion;

			public int dwBuildNumber;

			public int dwPlatformId;

			public unsafe fixed char szCSDVersion[128];

			public ushort wServicePackMajor;

			public ushort wServicePackMinor;

			public ushort wSuiteMask;

			public byte wProductType;

			public byte wReserved;
		}

		internal struct SymbolicLinkReparseBuffer
		{
			internal uint ReparseTag;

			internal ushort ReparseDataLength;

			internal ushort Reserved;

			internal ushort SubstituteNameOffset;

			internal ushort SubstituteNameLength;

			internal ushort PrintNameOffset;

			internal ushort PrintNameLength;

			internal uint Flags;
		}

		internal struct MountPointReparseBuffer
		{
			public uint ReparseTag;

			public ushort ReparseDataLength;

			public ushort Reserved;

			public ushort SubstituteNameOffset;

			public ushort SubstituteNameLength;

			public ushort PrintNameOffset;

			public ushort PrintNameLength;
		}

		internal struct SECURITY_ATTRIBUTES
		{
			internal uint nLength;

			internal IntPtr lpSecurityDescriptor;

			internal BOOL bInheritHandle;
		}

		internal struct SYSTEM_INFO
		{
			internal ushort wProcessorArchitecture;

			internal ushort wReserved;

			internal int dwPageSize;

			internal IntPtr lpMinimumApplicationAddress;

			internal IntPtr lpMaximumApplicationAddress;

			internal IntPtr dwActiveProcessorMask;

			internal int dwNumberOfProcessors;

			internal int dwProcessorType;

			internal int dwAllocationGranularity;

			internal short wProcessorLevel;

			internal short wProcessorRevision;
		}

		internal struct SYSTEMTIME
		{
			internal ushort Year;

			internal ushort Month;

			internal ushort DayOfWeek;

			internal ushort Day;

			internal ushort Hour;

			internal ushort Minute;

			internal ushort Second;

			internal ushort Milliseconds;

			internal bool Equals(in SYSTEMTIME other)
			{
				if (Year == other.Year && Month == other.Month && DayOfWeek == other.DayOfWeek && Day == other.Day && Hour == other.Hour && Minute == other.Minute && Second == other.Second)
				{
					return Milliseconds == other.Milliseconds;
				}
				return false;
			}
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		internal struct TIME_DYNAMIC_ZONE_INFORMATION
		{
			internal int Bias;

			internal unsafe fixed char StandardName[32];

			internal SYSTEMTIME StandardDate;

			internal int StandardBias;

			internal unsafe fixed char DaylightName[32];

			internal SYSTEMTIME DaylightDate;

			internal int DaylightBias;

			internal unsafe fixed char TimeZoneKeyName[128];

			internal byte DynamicDaylightTimeDisabled;

			internal unsafe string GetTimeZoneKeyName()
			{
				fixed (char* value = TimeZoneKeyName)
				{
					return new string(value);
				}
			}
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		internal struct TIME_ZONE_INFORMATION
		{
			internal int Bias;

			internal unsafe fixed char StandardName[32];

			internal SYSTEMTIME StandardDate;

			internal int StandardBias;

			internal unsafe fixed char DaylightName[32];

			internal SYSTEMTIME DaylightDate;

			internal int DaylightBias;

			internal unsafe TIME_ZONE_INFORMATION(in TIME_DYNAMIC_ZONE_INFORMATION dtzi)
			{
				fixed (TIME_ZONE_INFORMATION* ptr = &this)
				{
					fixed (TIME_DYNAMIC_ZONE_INFORMATION* ptr2 = &dtzi)
					{
						*ptr = *(TIME_ZONE_INFORMATION*)ptr2;
					}
				}
			}

			internal unsafe string GetStandardName()
			{
				fixed (char* value = StandardName)
				{
					return new string(value);
				}
			}

			internal unsafe string GetDaylightName()
			{
				fixed (char* value = DaylightName)
				{
					return new string(value);
				}
			}
		}

		internal struct REG_TZI_FORMAT
		{
			internal int Bias;

			internal int StandardBias;

			internal int DaylightBias;

			internal SYSTEMTIME StandardDate;

			internal SYSTEMTIME DaylightDate;

			internal REG_TZI_FORMAT(in TIME_ZONE_INFORMATION tzi)
			{
				Bias = tzi.Bias;
				StandardDate = tzi.StandardDate;
				StandardBias = tzi.StandardBias;
				DaylightDate = tzi.DaylightDate;
				DaylightBias = tzi.DaylightBias;
			}
		}

		internal struct WIN32_FILE_ATTRIBUTE_DATA
		{
			internal int dwFileAttributes;

			internal FILE_TIME ftCreationTime;

			internal FILE_TIME ftLastAccessTime;

			internal FILE_TIME ftLastWriteTime;

			internal uint nFileSizeHigh;

			internal uint nFileSizeLow;

			internal void PopulateFrom(ref WIN32_FIND_DATA findData)
			{
				dwFileAttributes = (int)findData.dwFileAttributes;
				ftCreationTime = findData.ftCreationTime;
				ftLastAccessTime = findData.ftLastAccessTime;
				ftLastWriteTime = findData.ftLastWriteTime;
				nFileSizeHigh = findData.nFileSizeHigh;
				nFileSizeLow = findData.nFileSizeLow;
			}
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		internal struct WIN32_FIND_DATA
		{
			internal uint dwFileAttributes;

			internal FILE_TIME ftCreationTime;

			internal FILE_TIME ftLastAccessTime;

			internal FILE_TIME ftLastWriteTime;

			internal uint nFileSizeHigh;

			internal uint nFileSizeLow;

			internal uint dwReserved0;

			internal uint dwReserved1;

			private unsafe fixed char _cFileName[260];

			private unsafe fixed char _cAlternateFileName[14];

			internal unsafe ReadOnlySpan<char> cFileName
			{
				get
				{
					fixed (char* pointer = _cFileName)
					{
						return new ReadOnlySpan<char>(pointer, 260);
					}
				}
			}
		}

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern int LCIDToLocaleName(int locale, char* pLocaleName, int cchName, uint dwFlags);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal static extern int LocaleNameToLCID(string lpName, uint dwFlags);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		internal unsafe static extern int LCMapStringEx(string lpLocaleName, uint dwMapFlags, char* lpSrcStr, int cchSrc, void* lpDestStr, int cchDest, void* lpVersionInformation, void* lpReserved, IntPtr sortHandle);

		[DllImport("kernel32.dll")]
		internal unsafe static extern int FindNLSStringEx(char* lpLocaleName, uint dwFindNLSStringFlags, char* lpStringSource, int cchSource, char* lpStringValue, int cchValue, int* pcchFound, void* lpVersionInformation, void* lpReserved, IntPtr sortHandle);

		[DllImport("kernel32.dll")]
		internal unsafe static extern int CompareStringEx(char* lpLocaleName, uint dwCmpFlags, char* lpString1, int cchCount1, char* lpString2, int cchCount2, void* lpVersionInformation, void* lpReserved, IntPtr lParam);

		[DllImport("kernel32.dll")]
		internal unsafe static extern int CompareStringOrdinal(char* lpString1, int cchCount1, char* lpString2, int cchCount2, bool bIgnoreCase);

		[DllImport("kernel32.dll")]
		internal unsafe static extern int FindStringOrdinal(uint dwFindStringOrdinalFlags, char* lpStringSource, int cchSource, char* lpStringValue, int cchValue, BOOL bIgnoreCase);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern bool IsNLSDefinedString(int Function, uint dwFlags, IntPtr lpVersionInformation, char* lpString, int cchStr);

		[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
		internal unsafe static extern BOOL GetUserPreferredUILanguages(uint dwFlags, uint* pulNumLanguages, char* pwszLanguagesBuffer, uint* pcchLanguagesBuffer);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern int GetLocaleInfoEx(string lpLocaleName, uint LCType, void* lpLCData, int cchData);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern bool EnumSystemLocalesEx(delegate* unmanaged<char*, uint, void*, BOOL> lpLocaleEnumProcEx, uint dwFlags, void* lParam, IntPtr reserved);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern bool EnumTimeFormatsEx(delegate* unmanaged<char*, void*, BOOL> lpTimeFmtEnumProcEx, string lpLocaleName, uint dwFlags, void* lParam);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal static extern int GetCalendarInfoEx(string lpLocaleName, uint Calendar, IntPtr lpReserved, uint CalType, IntPtr lpCalData, int cchData, out int lpValue);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal static extern int GetCalendarInfoEx(string lpLocaleName, uint Calendar, IntPtr lpReserved, uint CalType, IntPtr lpCalData, int cchData, IntPtr lpValue);

		[DllImport("kernel32.dll")]
		internal static extern int GetUserGeoID(int geoClass);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern int GetGeoInfo(int location, int geoType, char* lpGeoData, int cchData, int LangId);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern bool EnumCalendarInfoExEx(delegate* unmanaged<char*, uint, IntPtr, void*, BOOL> pCalInfoEnumProcExEx, string lpLocaleName, uint Calendar, string lpReserved, uint CalType, void* lParam);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern bool GetNLSVersionEx(int function, string localeName, NlsVersionInfoEx* lpVersionInformation);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern int ResolveLocaleName(string lpNameToResolve, char* lpLocaleName, int cchLocaleName);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern bool CancelIoEx(SafeHandle handle, NativeOverlapped* lpOverlapped);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern IntPtr CreateIoCompletionPort(IntPtr FileHandle, IntPtr ExistingCompletionPort, UIntPtr CompletionKey, int NumberOfConcurrentThreads);

		[DllImport("kernel32.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool PostQueuedCompletionStatus(IntPtr CompletionPort, int dwNumberOfBytesTransferred, UIntPtr CompletionKey, IntPtr lpOverlapped);

		[DllImport("kernel32.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool GetQueuedCompletionStatus(IntPtr CompletionPort, out int lpNumberOfBytes, out UIntPtr CompletionKey, out IntPtr lpOverlapped, int dwMilliseconds);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern void InitializeConditionVariable(CONDITION_VARIABLE* ConditionVariable);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern void WakeConditionVariable(CONDITION_VARIABLE* ConditionVariable);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern bool SleepConditionVariableCS(CONDITION_VARIABLE* ConditionVariable, CRITICAL_SECTION* CriticalSection, int dwMilliseconds);

		internal static int CopyFile(string src, string dst, bool failIfExists)
		{
			int flags = (failIfExists ? 1 : 0);
			int cancel = 0;
			if (!CopyFileEx(src, dst, IntPtr.Zero, IntPtr.Zero, ref cancel, flags))
			{
				return Marshal.GetLastWin32Error();
			}
			return 0;
		}

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "CopyFileExW", SetLastError = true)]
		private static extern bool CopyFileExPrivate(string src, string dst, IntPtr progressRoutine, IntPtr progressData, ref int cancel, int flags);

		internal static bool CopyFileEx(string src, string dst, IntPtr progressRoutine, IntPtr progressData, ref int cancel, int flags)
		{
			src = PathInternal.EnsureExtendedPrefixIfNeeded(src);
			dst = PathInternal.EnsureExtendedPrefixIfNeeded(dst);
			return CopyFileExPrivate(src, dst, progressRoutine, progressData, ref cancel, flags);
		}

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "CreateDirectoryW", SetLastError = true)]
		private static extern bool CreateDirectoryPrivate(string path, ref SECURITY_ATTRIBUTES lpSecurityAttributes);

		internal static bool CreateDirectory(string path, ref SECURITY_ATTRIBUTES lpSecurityAttributes)
		{
			path = PathInternal.EnsureExtendedPrefix(path);
			return CreateDirectoryPrivate(path, ref lpSecurityAttributes);
		}

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "CreateFileW", ExactSpelling = true, SetLastError = true)]
		private unsafe static extern SafeFileHandle CreateFilePrivate(string lpFileName, int dwDesiredAccess, FileShare dwShareMode, SECURITY_ATTRIBUTES* lpSecurityAttributes, FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile);

		internal unsafe static SafeFileHandle CreateFile(string lpFileName, int dwDesiredAccess, FileShare dwShareMode, SECURITY_ATTRIBUTES* lpSecurityAttributes, FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile)
		{
			lpFileName = PathInternal.EnsureExtendedPrefixIfNeeded(lpFileName);
			return CreateFilePrivate(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
		}

		internal unsafe static SafeFileHandle CreateFile(string lpFileName, int dwDesiredAccess, FileShare dwShareMode, FileMode dwCreationDisposition, int dwFlagsAndAttributes)
		{
			lpFileName = PathInternal.EnsureExtendedPrefixIfNeeded(lpFileName);
			return CreateFilePrivate(lpFileName, dwDesiredAccess, dwShareMode, null, dwCreationDisposition, dwFlagsAndAttributes, IntPtr.Zero);
		}

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "DeleteFileW", SetLastError = true)]
		private static extern bool DeleteFilePrivate(string path);

		internal static bool DeleteFile(string path)
		{
			path = PathInternal.EnsureExtendedPrefixIfNeeded(path);
			return DeleteFilePrivate(path);
		}

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "DeleteVolumeMountPointW", SetLastError = true)]
		internal static extern bool DeleteVolumeMountPointPrivate(string mountPoint);

		internal static bool DeleteVolumeMountPoint(string mountPoint)
		{
			mountPoint = PathInternal.EnsureExtendedPrefixIfNeeded(mountPoint);
			return DeleteVolumeMountPointPrivate(mountPoint);
		}

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "CreateFileW", ExactSpelling = true, SetLastError = true)]
		private unsafe static extern IntPtr CreateFilePrivate_IntPtr(string lpFileName, int dwDesiredAccess, FileShare dwShareMode, SECURITY_ATTRIBUTES* lpSecurityAttributes, FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile);

		internal unsafe static IntPtr CreateFile_IntPtr(string lpFileName, int dwDesiredAccess, FileShare dwShareMode, FileMode dwCreationDisposition, int dwFlagsAndAttributes)
		{
			lpFileName = PathInternal.EnsureExtendedPrefixIfNeeded(lpFileName);
			return CreateFilePrivate_IntPtr(lpFileName, dwDesiredAccess, dwShareMode, null, dwCreationDisposition, dwFlagsAndAttributes, IntPtr.Zero);
		}

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "CreateSymbolicLinkW", ExactSpelling = true, SetLastError = true)]
		private static extern bool CreateSymbolicLinkPrivate(string lpSymlinkFileName, string lpTargetFileName, int dwFlags);

		internal static void CreateSymbolicLink(string symlinkFileName, string targetFileName, bool isDirectory)
		{
			string path = symlinkFileName;
			symlinkFileName = PathInternal.EnsureExtendedPrefixIfNeeded(symlinkFileName);
			targetFileName = PathInternal.EnsureExtendedPrefixIfNeeded(targetFileName);
			int num = 0;
			bool flag = (Environment.OSVersion.Version.Major == 10 && Environment.OSVersion.Version.Build >= 14972) || Environment.OSVersion.Version.Major >= 11;
			if (flag)
			{
				num = 2;
			}
			if (isDirectory)
			{
				num |= 1;
			}
			if (!CreateSymbolicLinkPrivate(symlinkFileName, targetFileName, num))
			{
				throw Win32Marshal.GetExceptionForLastWin32Error(path);
			}
			int lastWin32Error;
			if (!flag && (lastWin32Error = Marshal.GetLastWin32Error()) != 0)
			{
				throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, path);
			}
		}

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern void InitializeCriticalSection(CRITICAL_SECTION* lpCriticalSection);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern void EnterCriticalSection(CRITICAL_SECTION* lpCriticalSection);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern void LeaveCriticalSection(CRITICAL_SECTION* lpCriticalSection);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern void DeleteCriticalSection(CRITICAL_SECTION* lpCriticalSection);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern bool DeviceIoControl(SafeHandle hDevice, uint dwIoControlCode, IntPtr lpInBuffer, uint nInBufferSize, byte[] lpOutBuffer, uint nOutBufferSize, out uint lpBytesReturned, IntPtr lpOverlapped);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "ExpandEnvironmentStringsW", ExactSpelling = true, SetLastError = true)]
		internal static extern uint ExpandEnvironmentStrings(string lpSrc, ref char lpDst, uint nSize);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "FindNextFileW", SetLastError = true)]
		internal static extern bool FindNextFile(SafeFindHandle hndFindFile, ref WIN32_FIND_DATA lpFindFileData);

		[DllImport("kernel32.dll")]
		[SuppressGCTransition]
		internal unsafe static extern BOOL FileTimeToSystemTime(ulong* lpFileTime, SYSTEMTIME* lpSystemTime);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool FindClose(IntPtr hFindFile);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "FindFirstFileExW", ExactSpelling = true, SetLastError = true)]
		private static extern SafeFindHandle FindFirstFileExPrivate(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, ref WIN32_FIND_DATA lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, IntPtr lpSearchFilter, int dwAdditionalFlags);

		internal static SafeFindHandle FindFirstFile(string fileName, ref WIN32_FIND_DATA data)
		{
			fileName = PathInternal.EnsureExtendedPrefixIfNeeded(fileName);
			return FindFirstFileExPrivate(fileName, FINDEX_INFO_LEVELS.FindExInfoBasic, ref data, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, 0);
		}

		[DllImport("kernel32.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool FlushFileBuffers(SafeHandle hHandle);

		[DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
		internal static extern bool FreeLibrary(IntPtr hModule);

		[DllImport("kernel32.dll")]
		[SuppressGCTransition]
		internal static extern int GetLastError();

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "GetComputerNameW", ExactSpelling = true)]
		private static extern int GetComputerName(ref char lpBuffer, ref uint nSize);

		internal static string GetComputerName()
		{
			Span<char> span = stackalloc char[16];
			uint nSize = (uint)span.Length;
			if (GetComputerName(ref MemoryMarshal.GetReference(span), ref nSize) == 0)
			{
				return null;
			}
			return span.Slice(0, (int)nSize).ToString();
		}

		[DllImport("kernel32.dll")]
		internal unsafe static extern BOOL GetCPInfo(uint codePage, CPINFO* lpCpInfo);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "GetCurrentDirectoryW", ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetCurrentDirectory(uint nBufferLength, ref char lpBuffer);

		[DllImport("kernel32.dll")]
		internal static extern IntPtr GetCurrentProcess();

		[DllImport("kernel32.dll")]
		internal static extern uint GetCurrentProcessId();

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "GetFileAttributesExW", ExactSpelling = true, SetLastError = true)]
		private static extern bool GetFileAttributesExPrivate(string name, GET_FILEEX_INFO_LEVELS fileInfoLevel, ref WIN32_FILE_ATTRIBUTE_DATA lpFileInformation);

		internal static bool GetFileAttributesEx(string name, GET_FILEEX_INFO_LEVELS fileInfoLevel, ref WIN32_FILE_ATTRIBUTE_DATA lpFileInformation)
		{
			name = PathInternal.EnsureExtendedPrefixIfNeeded(name);
			return GetFileAttributesExPrivate(name, fileInfoLevel, ref lpFileInformation);
		}

		[DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
		internal unsafe static extern bool GetFileInformationByHandleEx(SafeFileHandle hFile, int FileInformationClass, void* lpFileInformation, uint dwBufferSize);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern int GetFileType(SafeHandle hFile);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "GetFinalPathNameByHandleW", ExactSpelling = true, SetLastError = true)]
		internal unsafe static extern uint GetFinalPathNameByHandle(SafeFileHandle hFile, char* lpszFilePath, uint cchFilePath, uint dwFlags);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetFullPathNameW(ref char lpFileName, uint nBufferLength, ref char lpBuffer, IntPtr lpFilePart);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern int GetLogicalDrives();

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetLongPathNameW(ref char lpszShortPath, ref char lpszLongPath, uint cchBuffer);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "GetModuleFileNameW", ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetModuleFileName(IntPtr hModule, ref char lpFilename, uint nSize);

		[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
		internal unsafe static extern bool GetOverlappedResult(SafeFileHandle hFile, NativeOverlapped* lpOverlapped, ref int lpNumberOfBytesTransferred, bool bWait);

		[DllImport("kernel32.dll", EntryPoint = "K32GetProcessMemoryInfo")]
		internal static extern bool GetProcessMemoryInfo(IntPtr Process, ref PROCESS_MEMORY_COUNTERS ppsmemCounters, uint cb);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool GetProcessTimes(IntPtr handleProcess, out long creation, out long exit, out long kernel, out long user);

		[DllImport("kernel32.dll")]
		[SuppressGCTransition]
		internal static extern IntPtr GetStdHandle(int nStdHandle);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetSystemDirectoryW(ref char lpBuffer, uint uSize);

		[DllImport("kernel32.dll")]
		internal static extern void GetSystemInfo(out SYSTEM_INFO lpSystemInfo);

		[DllImport("kernel32.dll")]
		[SuppressGCTransition]
		internal unsafe static extern void GetSystemTime(SYSTEMTIME* lpSystemTime);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool GetSystemTimes(out long idle, out long kernel, out long user);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetTempFileNameW(ref char lpPathName, string lpPrefixString, uint uUnique, ref char lpTempFileName);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, ExactSpelling = true)]
		internal static extern uint GetTempPathW(int bufferLen, ref char buffer);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "GetVolumeInformationW", SetLastError = true)]
		internal unsafe static extern bool GetVolumeInformation(string drive, char* volumeName, int volumeNameBufLen, int* volSerialNumber, int* maxFileNameLen, out int fileSystemFlags, char* fileSystemName, int fileSystemNameBufLen);

		[DllImport("kernel32.dll")]
		internal unsafe static extern BOOL GlobalMemoryStatusEx(MEMORYSTATUSEX* lpBuffer);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool IsWow64Process(IntPtr hProcess, out bool Wow64Process);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "LoadLibraryExW", ExactSpelling = true, SetLastError = true)]
		internal static extern IntPtr LoadLibraryEx(string libFilename, IntPtr reserved, int flags);

		[DllImport("kernel32.dll")]
		internal static extern IntPtr LocalAlloc(uint uFlags, nuint uBytes);

		[DllImport("kernel32.dll")]
		internal static extern IntPtr LocalReAlloc(IntPtr hMem, nuint uBytes, uint uFlags);

		[DllImport("kernel32.dll")]
		internal static extern IntPtr LocalFree(IntPtr hMem);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool LockFile(SafeFileHandle handle, int offsetLow, int offsetHigh, int countLow, int countHigh);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool UnlockFile(SafeFileHandle handle, int offsetLow, int offsetHigh, int countLow, int countHigh);

		[DllImport("kernel32.dll")]
		internal unsafe static extern int MultiByteToWideChar(uint CodePage, uint dwFlags, byte* lpMultiByteStr, int cbMultiByte, char* lpWideCharStr, int cchWideChar);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "MoveFileExW", SetLastError = true)]
		private static extern bool MoveFileExPrivate(string src, string dst, uint flags);

		internal static bool MoveFile(string src, string dst, bool overwrite)
		{
			src = PathInternal.EnsureExtendedPrefixIfNeeded(src);
			dst = PathInternal.EnsureExtendedPrefixIfNeeded(dst);
			uint num = 2u;
			if (overwrite)
			{
				num |= 1u;
			}
			return MoveFileExPrivate(src, dst, num);
		}

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "OutputDebugStringW", ExactSpelling = true)]
		internal static extern void OutputDebugString(string message);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		[SuppressGCTransition]
		internal unsafe static extern BOOL QueryPerformanceCounter(long* lpPerformanceCount);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern BOOL QueryPerformanceFrequency(long* lpFrequency);

		[DllImport("kernel32.dll")]
		internal static extern bool QueryUnbiasedInterruptTime(out ulong UnbiasedTime);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern int ReadFile(SafeHandle handle, byte* bytes, int numBytesToRead, IntPtr numBytesRead_mustBeZero, NativeOverlapped* overlapped);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern int ReadFile(SafeHandle handle, byte* bytes, int numBytesToRead, out int numBytesRead, NativeOverlapped* overlapped);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern int ReadFileScatter(SafeHandle hFile, long* aSegmentArray, int nNumberOfBytesToRead, IntPtr lpReserved, NativeOverlapped* lpOverlapped);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern int WriteFileGather(SafeHandle hFile, long* aSegmentArray, int nNumberOfBytesToWrite, IntPtr lpReserved, NativeOverlapped* lpOverlapped);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RemoveDirectoryW", SetLastError = true)]
		private static extern bool RemoveDirectoryPrivate(string path);

		internal static bool RemoveDirectory(string path)
		{
			path = PathInternal.EnsureExtendedPrefixIfNeeded(path);
			return RemoveDirectoryPrivate(path);
		}

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "ReplaceFileW", SetLastError = true)]
		private static extern bool ReplaceFilePrivate(string replacedFileName, string replacementFileName, string backupFileName, int dwReplaceFlags, IntPtr lpExclude, IntPtr lpReserved);

		internal static bool ReplaceFile(string replacedFileName, string replacementFileName, string backupFileName, int dwReplaceFlags, IntPtr lpExclude, IntPtr lpReserved)
		{
			replacedFileName = PathInternal.EnsureExtendedPrefixIfNeeded(replacedFileName);
			replacementFileName = PathInternal.EnsureExtendedPrefixIfNeeded(replacementFileName);
			backupFileName = PathInternal.EnsureExtendedPrefixIfNeeded(backupFileName);
			return ReplaceFilePrivate(replacedFileName, replacementFileName, backupFileName, dwReplaceFlags, lpExclude, lpReserved);
		}

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern bool SetConsoleCtrlHandler(delegate* unmanaged<int, BOOL> HandlerRoutine, bool Add);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "SetCurrentDirectoryW", ExactSpelling = true, SetLastError = true)]
		internal static extern bool SetCurrentDirectory(string path);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "SetFileAttributesW", SetLastError = true)]
		private static extern bool SetFileAttributesPrivate(string name, int attr);

		internal static bool SetFileAttributes(string name, int attr)
		{
			name = PathInternal.EnsureExtendedPrefixIfNeeded(name);
			return SetFileAttributesPrivate(name, attr);
		}

		[DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
		internal unsafe static extern bool SetFileInformationByHandle(SafeFileHandle hFile, int FileInformationClass, void* lpFileInformation, uint dwBufferSize);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool SetFilePointerEx(SafeFileHandle hFile, long liDistanceToMove, out long lpNewFilePointer, uint dwMoveMethod);

		[DllImport("kernel32.dll")]
		[SuppressGCTransition]
		internal static extern void SetLastError(int errorCode);

		[DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
		[SuppressGCTransition]
		internal static extern bool SetThreadErrorMode(uint dwNewMode, out uint lpOldMode);

		[DllImport("kernel32.dll")]
		[SuppressGCTransition]
		internal unsafe static extern BOOL SystemTimeToFileTime(SYSTEMTIME* lpSystemTime, ulong* lpFileTime);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetDynamicTimeZoneInformation(out TIME_DYNAMIC_ZONE_INFORMATION pTimeZoneInformation);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetTimeZoneInformation(out TIME_ZONE_INFORMATION lpTimeZoneInformation);

		[DllImport("kernel32.dll")]
		internal unsafe static extern BOOL TzSpecificLocalTimeToSystemTime(IntPtr lpTimeZoneInformation, SYSTEMTIME* lpLocalTime, SYSTEMTIME* lpUniversalTime);

		[DllImport("kernel32.dll")]
		internal static extern bool VerifyVersionInfoW(ref OSVERSIONINFOEX lpVersionInfo, uint dwTypeMask, ulong dwlConditionMask);

		[DllImport("kernel32.dll")]
		internal static extern ulong VerSetConditionMask(ulong ConditionMask, uint TypeMask, byte Condition);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern void* VirtualAlloc(void* lpAddress, UIntPtr dwSize, int flAllocationType, int flProtect);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern bool VirtualFree(void* lpAddress, UIntPtr dwSize, int dwFreeType);

		[DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
		internal unsafe static extern UIntPtr VirtualQuery(void* lpAddress, ref MEMORY_BASIC_INFORMATION lpBuffer, UIntPtr dwLength);

		[DllImport("kernel32.dll")]
		internal unsafe static extern int WideCharToMultiByte(uint CodePage, uint dwFlags, char* lpWideCharStr, int cchWideChar, byte* lpMultiByteStr, int cbMultiByte, IntPtr lpDefaultChar, IntPtr lpUsedDefaultChar);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern int WriteFile(SafeHandle handle, byte* bytes, int numBytesToWrite, IntPtr numBytesWritten_mustBeZero, NativeOverlapped* lpOverlapped);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern int WriteFile(SafeHandle handle, byte* bytes, int numBytesToWrite, out int numBytesWritten, NativeOverlapped* lpOverlapped);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool CloseHandle(IntPtr handle);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool SetEvent(SafeWaitHandle handle);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool ResetEvent(SafeWaitHandle handle);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "CreateEventExW", ExactSpelling = true, SetLastError = true)]
		internal static extern SafeWaitHandle CreateEventEx(IntPtr lpSecurityAttributes, string name, uint flags, uint desiredAccess);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "OpenEventW", ExactSpelling = true, SetLastError = true)]
		internal static extern SafeWaitHandle OpenEvent(uint desiredAccess, bool inheritHandle, string name);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "GetEnvironmentVariableW", ExactSpelling = true, SetLastError = true)]
		internal static extern uint GetEnvironmentVariable(string lpName, ref char lpBuffer, uint nSize);

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern char* GetEnvironmentStringsW();

		[DllImport("kernel32.dll", ExactSpelling = true)]
		internal unsafe static extern BOOL FreeEnvironmentStringsW(char* lpszEnvironmentBlock);

		[DllImport("kernel32.dll", BestFitMapping = true, CharSet = CharSet.Unicode, EntryPoint = "FormatMessageW", ExactSpelling = true, SetLastError = true)]
		private unsafe static extern int FormatMessage(int dwFlags, IntPtr lpSource, uint dwMessageId, int dwLanguageId, void* lpBuffer, int nSize, IntPtr arguments);

		internal static string GetMessage(int errorCode)
		{
			return GetMessage(errorCode, IntPtr.Zero);
		}

		internal unsafe static string GetMessage(int errorCode, IntPtr moduleHandle)
		{
			int num = 12800;
			if (moduleHandle != IntPtr.Zero)
			{
				num |= 0x800;
			}
			Span<char> span = stackalloc char[256];
			fixed (char* lpBuffer = span)
			{
				int num2 = FormatMessage(num, moduleHandle, (uint)errorCode, 0, lpBuffer, span.Length, IntPtr.Zero);
				if (num2 > 0)
				{
					return GetAndTrimString(span.Slice(0, num2));
				}
			}
			if (Marshal.GetLastWin32Error() == 122)
			{
				IntPtr intPtr = default(IntPtr);
				try
				{
					int num3 = FormatMessage(num | 0x100, moduleHandle, (uint)errorCode, 0, &intPtr, 0, IntPtr.Zero);
					if (num3 > 0)
					{
						return GetAndTrimString(new Span<char>((void*)intPtr, num3));
					}
				}
				finally
				{
					Marshal.FreeHGlobal(intPtr);
				}
			}
			return $"Unknown error (0x{errorCode:x})";
		}

		private static string GetAndTrimString(Span<char> buffer)
		{
			int num = buffer.Length;
			while (num > 0 && buffer[num - 1] <= ' ')
			{
				num--;
			}
			return buffer.Slice(0, num).ToString();
		}

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "OpenMutexW", ExactSpelling = true, SetLastError = true)]
		internal static extern SafeWaitHandle OpenMutex(uint desiredAccess, bool inheritHandle, string name);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "CreateMutexExW", ExactSpelling = true, SetLastError = true)]
		internal static extern SafeWaitHandle CreateMutexEx(IntPtr lpMutexAttributes, string name, uint flags, uint desiredAccess);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool ReleaseMutex(SafeWaitHandle handle);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "OpenSemaphoreW", ExactSpelling = true, SetLastError = true)]
		internal static extern SafeWaitHandle OpenSemaphore(uint desiredAccess, bool inheritHandle, string name);

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, EntryPoint = "CreateSemaphoreExW", ExactSpelling = true, SetLastError = true)]
		internal static extern SafeWaitHandle CreateSemaphoreEx(IntPtr lpSecurityAttributes, int initialCount, int maximumCount, string name, uint flags, uint desiredAccess);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal static extern bool ReleaseSemaphore(SafeWaitHandle handle, int releaseCount, out int previousCount);

		[DllImport("kernel32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "SetEnvironmentVariableW", ExactSpelling = true, SetLastError = true)]
		internal static extern bool SetEnvironmentVariable(string lpName, string lpValue);

		[DllImport("kernel32.dll", SetLastError = true)]
		internal unsafe static extern int WriteFile(IntPtr handle, byte* bytes, int numBytesToWrite, out int numBytesWritten, IntPtr mustBeZero);
	}

	internal static class Normaliz
	{
		[DllImport("Normaliz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		internal unsafe static extern int IdnToAscii(uint dwFlags, char* lpUnicodeCharStr, int cchUnicodeChar, char* lpASCIICharStr, int cchASCIIChar);

		[DllImport("Normaliz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		internal unsafe static extern int IdnToUnicode(uint dwFlags, char* lpASCIICharStr, int cchASCIIChar, char* lpUnicodeCharStr, int cchUnicodeChar);

		[DllImport("Normaliz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		internal unsafe static extern BOOL IsNormalizedString(NormalizationForm normForm, char* source, int length);

		[DllImport("Normaliz.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		internal unsafe static extern int NormalizeString(NormalizationForm normForm, char* source, int sourceLength, char* destination, int destinationLength);
	}

	internal static class HostPolicy
	{
		[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Auto)]
		internal delegate void corehost_resolve_component_dependencies_result_fn(string assemblyPaths, string nativeSearchPaths, string resourceSearchPaths);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Auto)]
		internal delegate void corehost_error_writer_fn(string message);

		[DllImport("hostpolicy.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)]
		internal static extern int corehost_resolve_component_dependencies(string componentMainAssemblyPath, corehost_resolve_component_dependencies_result_fn result);

		[DllImport("hostpolicy.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Auto)]
		internal static extern IntPtr corehost_set_error_writer(IntPtr errorWriter);
	}

	internal static class Advapi32
	{
		internal enum ActivityControl : uint
		{
			EVENT_ACTIVITY_CTRL_GET_ID = 1u,
			EVENT_ACTIVITY_CTRL_SET_ID,
			EVENT_ACTIVITY_CTRL_CREATE_ID,
			EVENT_ACTIVITY_CTRL_GET_SET_ID,
			EVENT_ACTIVITY_CTRL_CREATE_SET_ID
		}

		internal struct EVENT_FILTER_DESCRIPTOR
		{
			public long Ptr;

			public int Size;

			public int Type;
		}

		internal unsafe delegate void EtwEnableCallback(in Guid sourceId, int isEnabled, byte level, long matchAnyKeywords, long matchAllKeywords, EVENT_FILTER_DESCRIPTOR* filterData, void* callbackContext);

		internal enum EVENT_INFO_CLASS
		{
			BinaryTrackInfo,
			SetEnableAllKeywords,
			SetTraits
		}

		internal enum TRACE_QUERY_INFO_CLASS
		{
			TraceGuidQueryList,
			TraceGuidQueryInfo,
			TraceGuidQueryProcess,
			TraceStackTracingInfo,
			MaxTraceSetInfoClass
		}

		internal struct TRACE_GUID_INFO
		{
			public int InstanceCount;

			public int Reserved;
		}

		internal struct TRACE_PROVIDER_INSTANCE_INFO
		{
			public int NextOffset;

			public int EnableCount;

			public int Pid;

			public int Flags;
		}

		internal struct TRACE_ENABLE_INFO
		{
			public int IsEnabled;

			public byte Level;

			public byte Reserved1;

			public ushort LoggerId;

			public int EnableProperty;

			public int Reserved2;

			public long MatchAnyKeyword;

			public long MatchAllKeyword;
		}

		[DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "EncryptFileW", SetLastError = true)]
		private static extern bool EncryptFilePrivate(string lpFileName);

		internal static bool EncryptFile(string path)
		{
			path = PathInternal.EnsureExtendedPrefixIfNeeded(path);
			return EncryptFilePrivate(path);
		}

		[DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "DecryptFileW", SetLastError = true)]
		private static extern bool DecryptFileFilePrivate(string lpFileName, int dwReserved);

		internal static bool DecryptFile(string path)
		{
			path = PathInternal.EnsureExtendedPrefixIfNeeded(path);
			return DecryptFileFilePrivate(path, 0);
		}

		[DllImport("advapi32.dll", ExactSpelling = true)]
		internal static extern int EventActivityIdControl(ActivityControl ControlCode, ref Guid ActivityId);

		[DllImport("advapi32.dll", ExactSpelling = true)]
		internal unsafe static extern uint EventRegister(in Guid providerId, EtwEnableCallback enableCallback, void* callbackContext, ref long registrationHandle);

		[DllImport("advapi32.dll", ExactSpelling = true)]
		internal unsafe static extern int EventSetInformation(long registrationHandle, EVENT_INFO_CLASS informationClass, void* eventInformation, uint informationLength);

		[DllImport("advapi32.dll", ExactSpelling = true)]
		internal unsafe static extern int EnumerateTraceGuidsEx(TRACE_QUERY_INFO_CLASS TraceQueryInfoClass, void* InBuffer, int InBufferSize, void* OutBuffer, int OutBufferSize, out int ReturnLength);

		[DllImport("advapi32.dll", ExactSpelling = true)]
		internal static extern uint EventUnregister(long registrationHandle);

		internal unsafe static int EventWriteTransfer(long registrationHandle, in EventDescriptor eventDescriptor, Guid* activityId, Guid* relatedActivityId, int userDataCount, EventProvider.EventData* userData)
		{
			int num = EventWriteTransfer_PInvoke(registrationHandle, in eventDescriptor, activityId, relatedActivityId, userDataCount, userData);
			if (num == 87 && relatedActivityId == null)
			{
				Guid empty = Guid.Empty;
				num = EventWriteTransfer_PInvoke(registrationHandle, in eventDescriptor, activityId, &empty, userDataCount, userData);
			}
			return num;
		}

		[DllImport("advapi32.dll", EntryPoint = "EventWriteTransfer", ExactSpelling = true)]
		private unsafe static extern int EventWriteTransfer_PInvoke(long registrationHandle, in EventDescriptor eventDescriptor, Guid* activityId, Guid* relatedActivityId, int userDataCount, EventProvider.EventData* userData);

		[DllImport("advapi32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern bool LookupAccountNameW(string lpSystemName, ref char lpAccountName, ref byte Sid, ref uint cbSid, ref char ReferencedDomainName, ref uint cchReferencedDomainName, out uint peUse);

		[DllImport("advapi32.dll")]
		internal static extern int RegCloseKey(IntPtr hKey);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegDeleteValueW", ExactSpelling = true)]
		internal static extern int RegDeleteValue(SafeRegistryHandle hKey, string lpValueName);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegEnumKeyExW", ExactSpelling = true)]
		internal static extern int RegEnumKeyEx(SafeRegistryHandle hKey, int dwIndex, char[] lpName, ref int lpcbName, int[] lpReserved, [Out] char[] lpClass, int[] lpcbClass, long[] lpftLastWriteTime);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegEnumValueW", ExactSpelling = true)]
		internal static extern int RegEnumValue(SafeRegistryHandle hKey, int dwIndex, char[] lpValueName, ref int lpcbValueName, IntPtr lpReserved_MustBeZero, int[] lpType, byte[] lpData, int[] lpcbData);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegOpenKeyExW", ExactSpelling = true)]
		internal static extern int RegOpenKeyEx(SafeRegistryHandle hKey, string lpSubKey, int ulOptions, int samDesired, out SafeRegistryHandle hkResult);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegQueryValueExW", ExactSpelling = true)]
		internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, string lpValueName, int[] lpReserved, ref int lpType, [Out] byte[] lpData, ref int lpcbData);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegQueryValueExW", ExactSpelling = true)]
		internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, string lpValueName, int[] lpReserved, ref int lpType, ref int lpData, ref int lpcbData);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegQueryValueExW", ExactSpelling = true)]
		internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, string lpValueName, int[] lpReserved, ref int lpType, ref long lpData, ref int lpcbData);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegQueryValueExW", ExactSpelling = true)]
		internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, string lpValueName, int[] lpReserved, ref int lpType, [Out] char[] lpData, ref int lpcbData);

		[DllImport("advapi32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, EntryPoint = "RegSetValueExW", ExactSpelling = true)]
		internal static extern int RegSetValueEx(SafeRegistryHandle hKey, string lpValueName, int Reserved, int dwType, string lpData, int cbData);
	}

	internal static class BCrypt
	{
		internal enum NTSTATUS : uint
		{
			STATUS_SUCCESS = 0u,
			STATUS_NOT_FOUND = 3221226021u,
			STATUS_INVALID_PARAMETER = 3221225485u,
			STATUS_NO_MEMORY = 3221225495u,
			STATUS_AUTH_TAG_MISMATCH = 3221266434u
		}

		[DllImport("BCrypt.dll", CharSet = CharSet.Unicode)]
		internal unsafe static extern NTSTATUS BCryptGenRandom(IntPtr hAlgorithm, byte* pbBuffer, int cbBuffer, int dwFlags);
	}

	internal static class Crypt32
	{
		[DllImport("crypt32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		internal static extern bool CryptProtectMemory(SafeBuffer pData, uint cbData, uint dwFlags);

		[DllImport("crypt32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		internal static extern bool CryptUnprotectMemory(SafeBuffer pData, uint cbData, uint dwFlags);
	}

	internal enum BOOLEAN : byte
	{
		FALSE,
		TRUE
	}

	internal static class NtDll
	{
		public enum CreateDisposition : uint
		{
			FILE_SUPERSEDE,
			FILE_OPEN,
			FILE_CREATE,
			FILE_OPEN_IF,
			FILE_OVERWRITE,
			FILE_OVERWRITE_IF
		}

		public enum CreateOptions : uint
		{
			FILE_DIRECTORY_FILE = 1u,
			FILE_WRITE_THROUGH = 2u,
			FILE_SEQUENTIAL_ONLY = 4u,
			FILE_NO_INTERMEDIATE_BUFFERING = 8u,
			FILE_SYNCHRONOUS_IO_ALERT = 0x10u,
			FILE_SYNCHRONOUS_IO_NONALERT = 0x20u,
			FILE_NON_DIRECTORY_FILE = 0x40u,
			FILE_CREATE_TREE_CONNECTION = 0x80u,
			FILE_COMPLETE_IF_OPLOCKED = 0x100u,
			FILE_NO_EA_KNOWLEDGE = 0x200u,
			FILE_RANDOM_ACCESS = 0x800u,
			FILE_DELETE_ON_CLOSE = 0x1000u,
			FILE_OPEN_BY_FILE_ID = 0x2000u,
			FILE_OPEN_FOR_BACKUP_INTENT = 0x4000u,
			FILE_NO_COMPRESSION = 0x8000u,
			FILE_OPEN_REQUIRING_OPLOCK = 0x10000u,
			FILE_DISALLOW_EXCLUSIVE = 0x20000u,
			FILE_SESSION_AWARE = 0x40000u,
			FILE_RESERVE_OPFILTER = 0x100000u,
			FILE_OPEN_REPARSE_POINT = 0x200000u,
			FILE_OPEN_NO_RECALL = 0x400000u
		}

		[Flags]
		public enum DesiredAccess : uint
		{
			FILE_READ_DATA = 1u,
			FILE_LIST_DIRECTORY = 1u,
			FILE_WRITE_DATA = 2u,
			FILE_ADD_FILE = 2u,
			FILE_APPEND_DATA = 4u,
			FILE_ADD_SUBDIRECTORY = 4u,
			FILE_CREATE_PIPE_INSTANCE = 4u,
			FILE_READ_EA = 8u,
			FILE_WRITE_EA = 0x10u,
			FILE_EXECUTE = 0x20u,
			FILE_TRAVERSE = 0x20u,
			FILE_DELETE_CHILD = 0x40u,
			FILE_READ_ATTRIBUTES = 0x80u,
			FILE_WRITE_ATTRIBUTES = 0x100u,
			FILE_ALL_ACCESS = 0xF01FFu,
			DELETE = 0x10000u,
			READ_CONTROL = 0x20000u,
			WRITE_DAC = 0x40000u,
			WRITE_OWNER = 0x80000u,
			SYNCHRONIZE = 0x100000u,
			STANDARD_RIGHTS_READ = 0x20000u,
			STANDARD_RIGHTS_WRITE = 0x20000u,
			STANDARD_RIGHTS_EXECUTE = 0x20000u,
			FILE_GENERIC_READ = 0x80000000u,
			FILE_GENERIC_WRITE = 0x40000000u,
			FILE_GENERIC_EXECUTE = 0x20000000u
		}

		public struct IO_STATUS_BLOCK
		{
			[StructLayout(LayoutKind.Explicit)]
			public struct IO_STATUS
			{
				[FieldOffset(0)]
				public uint Status;

				[FieldOffset(0)]
				public IntPtr Pointer;
			}

			public IO_STATUS Status;

			public IntPtr Information;
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		public struct FILE_FULL_DIR_INFORMATION
		{
			public uint NextEntryOffset;

			public uint FileIndex;

			public LongFileTime CreationTime;

			public LongFileTime LastAccessTime;

			public LongFileTime LastWriteTime;

			public LongFileTime ChangeTime;

			public long EndOfFile;

			public long AllocationSize;

			public FileAttributes FileAttributes;

			public uint FileNameLength;

			public uint EaSize;

			private char _fileName;

			public unsafe ReadOnlySpan<char> FileName
			{
				get
				{
					fixed (char* pointer = &_fileName)
					{
						return new ReadOnlySpan<char>(pointer, (int)FileNameLength / 2);
					}
				}
			}

			public unsafe static FILE_FULL_DIR_INFORMATION* GetNextInfo(FILE_FULL_DIR_INFORMATION* info)
			{
				if (info == null)
				{
					return null;
				}
				uint nextEntryOffset = info->NextEntryOffset;
				if (nextEntryOffset == 0)
				{
					return null;
				}
				return (FILE_FULL_DIR_INFORMATION*)((byte*)info + nextEntryOffset);
			}
		}

		public enum FILE_INFORMATION_CLASS : uint
		{
			FileDirectoryInformation = 1u,
			FileFullDirectoryInformation,
			FileBothDirectoryInformation,
			FileBasicInformation,
			FileStandardInformation,
			FileInternalInformation,
			FileEaInformation,
			FileAccessInformation,
			FileNameInformation,
			FileRenameInformation,
			FileLinkInformation,
			FileNamesInformation,
			FileDispositionInformation,
			FilePositionInformation,
			FileFullEaInformation,
			FileModeInformation,
			FileAlignmentInformation,
			FileAllInformation,
			FileAllocationInformation,
			FileEndOfFileInformation,
			FileAlternateNameInformation,
			FileStreamInformation,
			FilePipeInformation,
			FilePipeLocalInformation,
			FilePipeRemoteInformation,
			FileMailslotQueryInformation,
			FileMailslotSetInformation,
			FileCompressionInformation,
			FileObjectIdInformation,
			FileCompletionInformation,
			FileMoveClusterInformation,
			FileQuotaInformation,
			FileReparsePointInformation,
			FileNetworkOpenInformation,
			FileAttributeTagInformation,
			FileTrackingInformation,
			FileIdBothDirectoryInformation,
			FileIdFullDirectoryInformation,
			FileValidDataLengthInformation,
			FileShortNameInformation,
			FileIoCompletionNotificationInformation,
			FileIoStatusBlockRangeInformation,
			FileIoPriorityHintInformation,
			FileSfioReserveInformation,
			FileSfioVolumeInformation,
			FileHardLinkInformation,
			FileProcessIdsUsingFileInformation,
			FileNormalizedNameInformation,
			FileNetworkPhysicalNameInformation,
			FileIdGlobalTxDirectoryInformation,
			FileIsRemoteDeviceInformation,
			FileUnusedInformation,
			FileNumaNodeInformation,
			FileStandardLinkInformation,
			FileRemoteProtocolInformation,
			FileRenameInformationBypassAccessCheck,
			FileLinkInformationBypassAccessCheck,
			FileVolumeNameInformation,
			FileIdInformation,
			FileIdExtdDirectoryInformation,
			FileReplaceCompletionInformation,
			FileHardLinkFullIdInformation,
			FileIdExtdBothDirectoryInformation,
			FileDispositionInformationEx,
			FileRenameInformationEx,
			FileRenameInformationExBypassAccessCheck,
			FileDesiredStorageClassInformation,
			FileStatInformation
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		internal struct RTL_OSVERSIONINFOEX
		{
			internal uint dwOSVersionInfoSize;

			internal uint dwMajorVersion;

			internal uint dwMinorVersion;

			internal uint dwBuildNumber;

			internal uint dwPlatformId;

			internal unsafe fixed char szCSDVersion[128];
		}

		internal struct SYSTEM_LEAP_SECOND_INFORMATION
		{
			public BOOLEAN Enabled;

			public uint Flags;
		}

		[DllImport("ntdll.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
		private unsafe static extern uint NtCreateFile(IntPtr* FileHandle, DesiredAccess DesiredAccess, OBJECT_ATTRIBUTES* ObjectAttributes, IO_STATUS_BLOCK* IoStatusBlock, long* AllocationSize, FileAttributes FileAttributes, FileShare ShareAccess, CreateDisposition CreateDisposition, CreateOptions CreateOptions, void* EaBuffer, uint EaLength);

		internal unsafe static (uint status, IntPtr handle) CreateFile(ReadOnlySpan<char> path, IntPtr rootDirectory, CreateDisposition createDisposition, DesiredAccess desiredAccess = DesiredAccess.SYNCHRONIZE | DesiredAccess.FILE_GENERIC_READ, FileShare shareAccess = FileShare.ReadWrite | FileShare.Delete, FileAttributes fileAttributes = (FileAttributes)0, CreateOptions createOptions = CreateOptions.FILE_SYNCHRONOUS_IO_NONALERT, ObjectAttributes objectAttributes = ObjectAttributes.OBJ_CASE_INSENSITIVE, void* eaBuffer = null, uint eaLength = 0u, long* preallocationSize = null, SECURITY_QUALITY_OF_SERVICE* securityQualityOfService = null)
		{
			checked
			{
				fixed (char* ptr = &MemoryMarshal.GetReference(path))
				{
					UNICODE_STRING uNICODE_STRING = default(UNICODE_STRING);
					uNICODE_STRING.Length = (ushort)(path.Length * 2);
					uNICODE_STRING.MaximumLength = (ushort)(path.Length * 2);
					uNICODE_STRING.Buffer = (IntPtr)ptr;
					UNICODE_STRING uNICODE_STRING2 = uNICODE_STRING;
					OBJECT_ATTRIBUTES oBJECT_ATTRIBUTES = new OBJECT_ATTRIBUTES(&uNICODE_STRING2, objectAttributes, rootDirectory, securityQualityOfService);
					System.Runtime.CompilerServices.Unsafe.SkipInit(out IntPtr item);
					System.Runtime.CompilerServices.Unsafe.SkipInit(out IO_STATUS_BLOCK iO_STATUS_BLOCK);
					uint item2 = NtCreateFile(&item, desiredAccess, &oBJECT_ATTRIBUTES, &iO_STATUS_BLOCK, preallocationSize, fileAttributes, shareAccess, createDisposition, createOptions, eaBuffer, eaLength);
					return (item2, item);
				}
			}
		}

		[DllImport("ntdll.dll", ExactSpelling = true)]
		public static extern uint RtlNtStatusToDosError(int Status);

		[DllImport("ntdll.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
		public unsafe static extern int NtQueryDirectoryFile(IntPtr FileHandle, IntPtr Event, IntPtr ApcRoutine, IntPtr ApcContext, IO_STATUS_BLOCK* IoStatusBlock, IntPtr FileInformation, uint Length, FILE_INFORMATION_CLASS FileInformationClass, BOOLEAN ReturnSingleEntry, UNICODE_STRING* FileName, BOOLEAN RestartScan);

		[DllImport("ntdll.dll", ExactSpelling = true)]
		internal unsafe static extern int NtQueryInformationFile(SafeFileHandle FileHandle, out IO_STATUS_BLOCK IoStatusBlock, void* FileInformation, uint Length, uint FileInformationClass);

		[DllImport("ntdll.dll", ExactSpelling = true)]
		internal unsafe static extern uint NtQuerySystemInformation(int SystemInformationClass, void* SystemInformation, uint SystemInformationLength, uint* ReturnLength);

		[DllImport("ntdll.dll", ExactSpelling = true)]
		private static extern int RtlGetVersion(ref RTL_OSVERSIONINFOEX lpVersionInformation);

		internal unsafe static int RtlGetVersionEx(out RTL_OSVERSIONINFOEX osvi)
		{
			osvi = default(RTL_OSVERSIONINFOEX);
			osvi.dwOSVersionInfoSize = (uint)sizeof(RTL_OSVERSIONINFOEX);
			return RtlGetVersion(ref osvi);
		}
	}

	internal struct UNICODE_STRING
	{
		internal ushort Length;

		internal ushort MaximumLength;

		internal IntPtr Buffer;
	}

	internal struct SECURITY_QUALITY_OF_SERVICE
	{
		public uint Length;

		public ImpersonationLevel ImpersonationLevel;

		public ContextTrackingMode ContextTrackingMode;

		public BOOLEAN EffectiveOnly;
	}

	public enum ImpersonationLevel : uint
	{
		Anonymous,
		Identification,
		Impersonation,
		Delegation
	}

	public enum ContextTrackingMode : byte
	{
		Static,
		Dynamic
	}

	internal struct OBJECT_ATTRIBUTES
	{
		public uint Length;

		public IntPtr RootDirectory;

		public unsafe UNICODE_STRING* ObjectName;

		public ObjectAttributes Attributes;

		public unsafe void* SecurityDescriptor;

		public unsafe SECURITY_QUALITY_OF_SERVICE* SecurityQualityOfService;

		public unsafe OBJECT_ATTRIBUTES(UNICODE_STRING* objectName, ObjectAttributes attributes, IntPtr rootDirectory, SECURITY_QUALITY_OF_SERVICE* securityQualityOfService = null)
		{
			Length = (uint)sizeof(OBJECT_ATTRIBUTES);
			RootDirectory = rootDirectory;
			ObjectName = objectName;
			Attributes = attributes;
			SecurityDescriptor = null;
			SecurityQualityOfService = securityQualityOfService;
		}
	}

	[Flags]
	public enum ObjectAttributes : uint
	{
		OBJ_INHERIT = 2u,
		OBJ_PERMANENT = 0x10u,
		OBJ_EXCLUSIVE = 0x20u,
		OBJ_CASE_INSENSITIVE = 0x40u,
		OBJ_OPENIF = 0x80u,
		OBJ_OPENLINK = 0x100u
	}

	internal static class Ole32
	{
		[DllImport("ole32.dll", CharSet = CharSet.Unicode)]
		internal static extern int CLSIDFromProgID(string lpszProgID, out Guid lpclsid);

		[DllImport("ole32.dll")]
		internal static extern int CoCreateGuid(out Guid guid);

		[DllImport("ole32.dll")]
		internal static extern int CoGetStandardMarshal(ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags, out IntPtr ppMarshal);

		[DllImport("ole32.dll")]
		internal static extern IntPtr CoTaskMemAlloc(nuint cb);

		[DllImport("ole32.dll")]
		internal static extern IntPtr CoTaskMemRealloc(IntPtr pv, nuint cb);

		[DllImport("ole32.dll")]
		internal static extern void CoTaskMemFree(IntPtr ptr);
	}

	internal static class Secur32
	{
		[DllImport("secur32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		internal static extern BOOLEAN GetUserNameExW(int NameFormat, ref char lpNameBuffer, ref uint lpnSize);
	}

	internal static class Shell32
	{
		[DllImport("shell32.dll", BestFitMapping = false, CharSet = CharSet.Unicode, ExactSpelling = true)]
		internal static extern int SHGetKnownFolderPath([MarshalAs(UnmanagedType.LPStruct)] Guid rfid, uint dwFlags, IntPtr hToken, out string ppszPath);
	}

	internal static class Ucrtbase
	{
		[DllImport("ucrtbase.dll", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
		internal unsafe static extern void* _aligned_malloc(nuint size, nuint alignment);

		[DllImport("ucrtbase.dll", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
		internal unsafe static extern void _aligned_free(void* ptr);

		[DllImport("ucrtbase.dll", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
		internal unsafe static extern void* _aligned_realloc(void* ptr, nuint size, nuint alignment);

		[DllImport("ucrtbase.dll", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
		internal unsafe static extern void* calloc(nuint num, nuint size);

		[DllImport("ucrtbase.dll", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
		internal unsafe static extern void free(void* ptr);

		[DllImport("ucrtbase.dll", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
		internal unsafe static extern void* malloc(nuint size);

		[DllImport("ucrtbase.dll", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
		internal unsafe static extern void* realloc(void* ptr, nuint new_size);
	}

	internal static class User32
	{
		internal struct USEROBJECTFLAGS
		{
			public int fInherit;

			public int fReserved;

			public int dwFlags;
		}

		[DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "LoadStringW", ExactSpelling = true, SetLastError = true)]
		internal unsafe static extern int LoadString(IntPtr hInstance, uint uID, char* lpBuffer, int cchBufferMax);

		[DllImport("user32.dll", EntryPoint = "SendMessageTimeoutW")]
		public static extern IntPtr SendMessageTimeout(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam, int flags, int timeout, out IntPtr pdwResult);

		[DllImport("user32.dll", ExactSpelling = true)]
		internal static extern IntPtr GetProcessWindowStation();

		[DllImport("user32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
		public unsafe static extern bool GetUserObjectInformationW(IntPtr hObj, int nIndex, void* pvBuffer, uint nLength, ref uint lpnLengthNeeded);
	}

	internal struct LongFileTime
	{
		internal long TicksSince1601;

		internal DateTimeOffset ToDateTimeOffset()
		{
			return new DateTimeOffset(DateTime.FromFileTimeUtc(TicksSince1601));
		}
	}

	internal static bool CallStringMethod<TArg1, TArg2, TArg3>(SpanFunc<char, TArg1, TArg2, TArg3, Globalization.ResultCode> interopCall, TArg1 arg1, TArg2 arg2, TArg3 arg3, out string result)
	{
		Span<char> span = stackalloc char[256];
		switch (interopCall(span, arg1, arg2, arg3))
		{
		case Globalization.ResultCode.Success:
			result = span.Slice(0, span.IndexOf('\0')).ToString();
			return true;
		case Globalization.ResultCode.InsufficentBuffer:
			span = new char[1280];
			if (interopCall(span, arg1, arg2, arg3) == Globalization.ResultCode.Success)
			{
				result = span.Slice(0, span.IndexOf('\0')).ToString();
				return true;
			}
			break;
		}
		result = null;
		return false;
	}

	internal unsafe static void GetRandomBytes(byte* buffer, int length)
	{
		switch (BCrypt.BCryptGenRandom(IntPtr.Zero, buffer, length, 2))
		{
		case BCrypt.NTSTATUS.STATUS_NO_MEMORY:
			throw new OutOfMemoryException();
		default:
			throw new InvalidOperationException();
		case BCrypt.NTSTATUS.STATUS_SUCCESS:
			break;
		}
	}
}
namespace Microsoft.Win32
{
	internal static class OAVariantLib
	{
		internal static readonly Type[] ClassTypes = new Type[23]
		{
			typeof(Empty),
			typeof(void),
			typeof(bool),
			typeof(char),
			typeof(sbyte),
			typeof(byte),
			typeof(short),
			typeof(ushort),
			typeof(int),
			typeof(uint),
			typeof(long),
			typeof(ulong),
			typeof(float),
			typeof(double),
			typeof(string),
			typeof(void),
			typeof(DateTime),
			typeof(TimeSpan),
			typeof(object),
			typeof(decimal),
			null,
			typeof(Missing),
			typeof(DBNull)
		};

		internal static System.Variant ChangeType(System.Variant source, Type targetClass, short options, CultureInfo culture)
		{
			if (targetClass == null)
			{
				throw new ArgumentNullException("targetClass");
			}
			if (culture == null)
			{
				throw new ArgumentNullException("culture");
			}
			System.Variant result = default(System.Variant);
			ChangeTypeEx(ref result, ref source, culture.LCID, targetClass.TypeHandle.Value, GetCVTypeFromClass(targetClass), options);
			return result;
		}

		private static int GetCVTypeFromClass(Type ctype)
		{
			int num = -1;
			for (int i = 0; i < ClassTypes.Length; i++)
			{
				if (ctype.Equals(ClassTypes[i]))
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				num = 18;
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void ChangeTypeEx(ref System.Variant result, ref System.Variant source, int lcid, IntPtr typeHandle, int cvType, short flags);
	}
}
namespace Microsoft.Win32.SafeHandles
{
	public abstract class CriticalHandleMinusOneIsInvalid : CriticalHandle
	{
		public override bool IsInvalid => handle == new IntPtr(-1);

		protected CriticalHandleMinusOneIsInvalid()
			: base(new IntPtr(-1))
		{
		}
	}
	public abstract class CriticalHandleZeroOrMinusOneIsInvalid : CriticalHandle
	{
		public override bool IsInvalid
		{
			get
			{
				if (!(handle == IntPtr.Zero))
				{
					return handle == new IntPtr(-1);
				}
				return true;
			}
		}

		protected CriticalHandleZeroOrMinusOneIsInvalid()
			: base(IntPtr.Zero)
		{
		}
	}
	public abstract class SafeHandleMinusOneIsInvalid : SafeHandle
	{
		public override bool IsInvalid => handle == new IntPtr(-1);

		protected SafeHandleMinusOneIsInvalid(bool ownsHandle)
			: base(new IntPtr(-1), ownsHandle)
		{
		}
	}
	public abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle
	{
		public override bool IsInvalid
		{
			get
			{
				if (!(handle == IntPtr.Zero))
				{
					return handle == new IntPtr(-1);
				}
				return true;
			}
		}

		protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle)
			: base(IntPtr.Zero, ownsHandle)
		{
		}
	}
	public sealed class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		internal sealed class ThreadPoolValueTaskSource : IThreadPoolWorkItem, IValueTaskSource<int>, IValueTaskSource<long>, IValueTaskSource
		{
			private enum Operation : byte
			{
				None,
				Read,
				Write,
				ReadScatter,
				WriteGather
			}

			private readonly SafeFileHandle _fileHandle;

			private ManualResetValueTaskSourceCore<long> _source;

			private Operation _operation;

			private ExecutionContext _context;

			private OSFileStreamStrategy _strategy;

			private long _fileOffset;

			private CancellationToken _cancellationToken;

			private ReadOnlyMemory<byte> _singleSegment;

			private IReadOnlyList<Memory<byte>> _readScatterBuffers;

			private IReadOnlyList<ReadOnlyMemory<byte>> _writeGatherBuffers;

			internal ThreadPoolValueTaskSource(SafeFileHandle fileHandle)
			{
				_fileHandle = fileHandle;
			}

			public ValueTaskSourceStatus GetStatus(short token)
			{
				return _source.GetStatus(token);
			}

			public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				_source.OnCompleted(continuation, state, token, flags);
			}

			void IValueTaskSource.GetResult(short token)
			{
				GetResult(token);
			}

			int IValueTaskSource<int>.GetResult(short token)
			{
				return (int)GetResult(token);
			}

			public long GetResult(short token)
			{
				try
				{
					return _source.GetResult(token);
				}
				finally
				{
					_source.Reset();
					Volatile.Write(ref _fileHandle._reusableThreadPoolValueTaskSource, this);
				}
			}

			private void ExecuteInternal()
			{
				long num = 0L;
				Exception ex = null;
				try
				{
					if (_cancellationToken.IsCancellationRequested)
					{
						ex = new OperationCanceledException(_cancellationToken);
					}
					else
					{
						switch (_operation)
						{
						case Operation.Read:
						{
							Memory<byte> memory = MemoryMarshal.AsMemory(_singleSegment);
							num = RandomAccess.ReadAtOffset(_fileHandle, memory.Span, _fileOffset);
							break;
						}
						case Operation.Write:
							RandomAccess.WriteAtOffset(_fileHandle, _singleSegment.Span, _fileOffset);
							break;
						case Operation.ReadScatter:
							num = RandomAccess.ReadScatterAtOffset(_fileHandle, _readScatterBuffers, _fileOffset);
							break;
						case Operation.WriteGather:
							RandomAccess.WriteGatherAtOffset(_fileHandle, _writeGatherBuffers, _fileOffset);
							break;
						}
					}
				}
				catch (Exception ex2)
				{
					ex = ex2;
				}
				finally
				{
					if (_strategy != null)
					{
						if (ex != null)
						{
							_strategy.OnIncompleteOperation(_singleSegment.Length, 0);
						}
						else if (_operation == Operation.Read && num != _singleSegment.Length)
						{
							_strategy.OnIncompleteOperation(_singleSegment.Length, (int)num);
						}
					}
					_operation = Operation.None;
					_context = null;
					_strategy = null;
					_cancellationToken = default(CancellationToken);
					_singleSegment = default(ReadOnlyMemory<byte>);
					_readScatterBuffers = null;
					_writeGatherBuffers = null;
				}
				if (ex == null)
				{
					_source.SetResult(num);
				}
				else
				{
					_source.SetException(ex);
				}
			}

			void IThreadPoolWorkItem.Execute()
			{
				if (_context == null || _context.IsDefault)
				{
					ExecuteInternal();
					return;
				}
				ExecutionContext.RunForThreadPoolUnsafe(_context, delegate(ThreadPoolValueTaskSource x)
				{
					x.ExecuteInternal();
				}, in this);
			}

			private void QueueToThreadPool()
			{
				_context = ExecutionContext.Capture();
				ThreadPool.UnsafeQueueUserWorkItem(this, preferLocal: true);
			}

			public ValueTask<int> QueueRead(Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy strategy)
			{
				_operation = Operation.Read;
				_singleSegment = buffer;
				_fileOffset = fileOffset;
				_cancellationToken = cancellationToken;
				_strategy = strategy;
				QueueToThreadPool();
				return new ValueTask<int>(this, _source.Version);
			}

			public ValueTask QueueWrite(ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy strategy)
			{
				_operation = Operation.Write;
				_singleSegment = buffer;
				_fileOffset = fileOffset;
				_cancellationToken = cancellationToken;
				_strategy = strategy;
				QueueToThreadPool();
				return new ValueTask(this, _source.Version);
			}

			public ValueTask<long> QueueReadScatter(IReadOnlyList<Memory<byte>> buffers, long fileOffset, CancellationToken cancellationToken)
			{
				_operation = Operation.ReadScatter;
				_readScatterBuffers = buffers;
				_fileOffset = fileOffset;
				_cancellationToken = cancellationToken;
				QueueToThreadPool();
				return new ValueTask<long>(this, _source.Version);
			}

			public ValueTask QueueWriteGather(IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset, CancellationToken cancellationToken)
			{
				_operation = Operation.WriteGather;
				_writeGatherBuffers = buffers;
				_fileOffset = fileOffset;
				_cancellationToken = cancellationToken;
				QueueToThreadPool();
				return new ValueTask(this, _source.Version);
			}
		}

		internal sealed class OverlappedValueTaskSource : IValueTaskSource<int>, IValueTaskSource
		{
			internal unsafe static readonly IOCompletionCallback s_ioCallback = IOCallback;

			internal readonly PreAllocatedOverlapped _preallocatedOverlapped;

			internal readonly SafeFileHandle _fileHandle;

			private OSFileStreamStrategy _strategy;

			internal MemoryHandle _memoryHandle;

			private int _bufferSize;

			internal ManualResetValueTaskSourceCore<int> _source;

			private unsafe NativeOverlapped* _overlapped;

			private CancellationTokenRegistration _cancellationRegistration;

			internal ulong _result;

			internal short Version => _source.Version;

			internal OverlappedValueTaskSource(SafeFileHandle fileHandle)
			{
				_fileHandle = fileHandle;
				_source.RunContinuationsAsynchronously = true;
				_preallocatedOverlapped = PreAllocatedOverlapped.UnsafeCreate(s_ioCallback, this, null);
			}

			internal void Dispose()
			{
				ReleaseResources();
				_preallocatedOverlapped.Dispose();
			}

			internal static Exception GetIOError(int errorCode, string path)
			{
				if (errorCode != 38)
				{
					return Win32Marshal.GetExceptionForWin32Error(errorCode, path);
				}
				return ThrowHelper.CreateEndOfFileException();
			}

			internal unsafe NativeOverlapped* PrepareForOperation(ReadOnlyMemory<byte> memory, long fileOffset, OSFileStreamStrategy strategy = null)
			{
				_result = 0uL;
				_strategy = strategy;
				_bufferSize = memory.Length;
				_memoryHandle = memory.Pin();
				_overlapped = _fileHandle.ThreadPoolBinding.AllocateNativeOverlapped(_preallocatedOverlapped);
				if (_fileHandle.CanSeek)
				{
					_overlapped->OffsetLow = (int)fileOffset;
					_overlapped->OffsetHigh = (int)(fileOffset >> 32);
				}
				return _overlapped;
			}

			public ValueTaskSourceStatus GetStatus(short token)
			{
				return _source.GetStatus(token);
			}

			public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				_source.OnCompleted(continuation, state, token, flags);
			}

			void IValueTaskSource.GetResult(short token)
			{
				GetResult(token);
			}

			public int GetResult(short token)
			{
				try
				{
					return _source.GetResult(token);
				}
				finally
				{
					_fileHandle.TryToReuse(this);
				}
			}

			internal unsafe void RegisterForCancellation(CancellationToken cancellationToken)
			{
				if (!cancellationToken.CanBeCanceled)
				{
					return;
				}
				try
				{
					_cancellationRegistration = cancellationToken.UnsafeRegister(delegate(object s, CancellationToken token)
					{
						OverlappedValueTaskSource overlappedValueTaskSource = (OverlappedValueTaskSource)s;
						if (!overlappedValueTaskSource._fileHandle.IsInvalid)
						{
							try
							{
								Interop.Kernel32.CancelIoEx(overlappedValueTaskSource._fileHandle, overlappedValueTaskSource._overlapped);
							}
							catch (ObjectDisposedException)
							{
							}
						}
					}, this);
				}
				catch (OutOfMemoryException)
				{
				}
			}

			private unsafe void ReleaseResources()
			{
				_strategy = null;
				_cancellationRegistration.Dispose();
				_memoryHandle.Dispose();
				if (_overlapped != null)
				{
					_fileHandle.ThreadPoolBinding.FreeNativeOverlapped(_overlapped);
					_overlapped = null;
				}
			}

			internal void FinishedScheduling()
			{
				ulong num = Interlocked.Exchange(ref _result, 1uL);
				if (num != 0L)
				{
					Complete((uint)num, (uint)(int)(num >> 32) & 0x7FFFFFFFu);
				}
			}

			private unsafe static void IOCallback(uint errorCode, uint numBytes, NativeOverlapped* pOverlapped)
			{
				OverlappedValueTaskSource overlappedValueTaskSource = (OverlappedValueTaskSource)ThreadPoolBoundHandle.GetNativeOverlappedState(pOverlapped);
				if (Interlocked.Exchange(ref overlappedValueTaskSource._result, 0x8000000000000000uL | ((ulong)numBytes << 32) | errorCode) != 0L)
				{
					overlappedValueTaskSource.Complete(errorCode, numBytes);
				}
			}

			internal void Complete(uint errorCode, uint numBytes)
			{
				OSFileStreamStrategy strategy = _strategy;
				ReleaseResources();
				switch (errorCode)
				{
				case 0u:
				case 38u:
				case 109u:
				case 232u:
					if (_bufferSize != numBytes)
					{
						strategy?.OnIncompleteOperation(_bufferSize, (int)numBytes);
					}
					_source.SetResult((int)numBytes);
					break;
				case 995u:
				{
					strategy?.OnIncompleteOperation(_bufferSize, 0);
					CancellationToken token = _cancellationRegistration.Token;
					_source.SetException(token.IsCancellationRequested ? new OperationCanceledException(token) : new OperationCanceledException());
					break;
				}
				default:
					strategy?.OnIncompleteOperation(_bufferSize, 0);
					_source.SetException(Win32Marshal.GetExceptionForWin32Error((int)errorCode));
					break;
				}
			}
		}

		private string _path;

		private ThreadPoolValueTaskSource _reusableThreadPoolValueTaskSource;

		private volatile FileOptions _fileOptions = (FileOptions)(-1);

		private volatile int _fileType = -1;

		private OverlappedValueTaskSource _reusableOverlappedValueTaskSource;

		internal string? Path => _path;

		public bool IsAsync => (GetFileOptions() & FileOptions.Asynchronous) != 0;

		internal bool CanSeek
		{
			get
			{
				if (!base.IsClosed)
				{
					return GetFileType() == 1;
				}
				return false;
			}
		}

		internal ThreadPoolBoundHandle? ThreadPoolBinding { get; set; }

		public SafeFileHandle(IntPtr preexistingHandle, bool ownsHandle)
			: base(ownsHandle)
		{
			SetHandle(preexistingHandle);
		}

		internal ThreadPoolValueTaskSource GetThreadPoolValueTaskSource()
		{
			return Interlocked.Exchange(ref _reusableThreadPoolValueTaskSource, null) ?? new ThreadPoolValueTaskSource(this);
		}

		public SafeFileHandle()
			: base(ownsHandle: true)
		{
		}

		internal static SafeFileHandle Open(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
		{
			using (DisableMediaInsertionPrompt.Create())
			{
				SafeFileHandle safeFileHandle = CreateFile(fullPath, mode, access, share, options);
				if (preallocationSize > 0)
				{
					Preallocate(fullPath, preallocationSize, safeFileHandle);
				}
				if ((options & FileOptions.Asynchronous) != 0)
				{
					safeFileHandle.InitThreadPoolBinding();
				}
				return safeFileHandle;
			}
		}

		private unsafe static SafeFileHandle CreateFile(string fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options)
		{
			Interop.Kernel32.SECURITY_ATTRIBUTES sECURITY_ATTRIBUTES = default(Interop.Kernel32.SECURITY_ATTRIBUTES);
			if ((share & FileShare.Inheritable) != 0)
			{
				Interop.Kernel32.SECURITY_ATTRIBUTES sECURITY_ATTRIBUTES2 = default(Interop.Kernel32.SECURITY_ATTRIBUTES);
				sECURITY_ATTRIBUTES2.nLength = (uint)sizeof(Interop.Kernel32.SECURITY_ATTRIBUTES);
				sECURITY_ATTRIBUTES2.bInheritHandle = Interop.BOOL.TRUE;
				sECURITY_ATTRIBUTES = sECURITY_ATTRIBUTES2;
			}
			int dwDesiredAccess = (((access & FileAccess.Read) == FileAccess.Read) ? int.MinValue : 0) | (((access & FileAccess.Write) == FileAccess.Write) ? 1073741824 : 0);
			share &= ~FileShare.Inheritable;
			if (mode == FileMode.Append)
			{
				mode = FileMode.OpenOrCreate;
			}
			int num = (int)options;
			num |= 0x100000;
			SafeFileHandle safeFileHandle = Interop.Kernel32.CreateFile(fullPath, dwDesiredAccess, share, &sECURITY_ATTRIBUTES, mode, num, IntPtr.Zero);
			if (safeFileHandle.IsInvalid)
			{
				int num2 = Marshal.GetLastPInvokeError();
				if (num2 == 3 && fullPath.Length == PathInternal.GetRootLength(fullPath))
				{
					num2 = 5;
				}
				throw Win32Marshal.GetExceptionForWin32Error(num2, fullPath);
			}
			safeFileHandle._path = fullPath;
			safeFileHandle._fileOptions = options;
			return safeFileHandle;
		}

		private unsafe static void Preallocate(string fullPath, long preallocationSize, SafeFileHandle fileHandle)
		{
			Interop.Kernel32.FILE_ALLOCATION_INFO fILE_ALLOCATION_INFO = default(Interop.Kernel32.FILE_ALLOCATION_INFO);
			fILE_ALLOCATION_INFO.AllocationSize = preallocationSize;
			Interop.Kernel32.FILE_ALLOCATION_INFO fILE_ALLOCATION_INFO2 = fILE_ALLOCATION_INFO;
			if (!Interop.Kernel32.SetFileInformationByHandle(fileHandle, 5, &fILE_ALLOCATION_INFO2, (uint)sizeof(Interop.Kernel32.FILE_ALLOCATION_INFO)))
			{
				int lastPInvokeError = Marshal.GetLastPInvokeError();
				if (lastPInvokeError == 112 || lastPInvokeError == 223)
				{
					fileHandle.Dispose();
					Interop.Kernel32.DeleteFile(fullPath);
					throw new IOException(SR.Format((lastPInvokeError == 112) ? SR.IO_DiskFull_Path_AllocationSize : SR.IO_FileTooLarge_Path_AllocationSize, fullPath, preallocationSize));
				}
			}
		}

		internal void EnsureThreadPoolBindingInitialized()
		{
			if (IsAsync && ThreadPoolBinding == null)
			{
				Init();
			}
			void Init()
			{
				lock (this)
				{
					if (ThreadPoolBinding == null)
					{
						InitThreadPoolBinding();
					}
				}
			}
		}

		private void InitThreadPoolBinding()
		{
			try
			{
				ThreadPoolBinding = ThreadPoolBoundHandle.BindHandle(this);
			}
			catch (ArgumentException innerException)
			{
				if (base.OwnsHandle)
				{
					Dispose();
				}
				throw new IOException(SR.IO_BindHandleFailed, innerException);
			}
		}

		internal unsafe FileOptions GetFileOptions()
		{
			FileOptions fileOptions = _fileOptions;
			if (fileOptions != (FileOptions)(-1))
			{
				return fileOptions;
			}
			Interop.NtDll.IO_STATUS_BLOCK IoStatusBlock;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.NtDll.CreateOptions createOptions);
			int num = Interop.NtDll.NtQueryInformationFile(this, out IoStatusBlock, &createOptions, 4u, 16u);
			if (num != 0L)
			{
				int errorCode = (int)Interop.NtDll.RtlNtStatusToDosError(num);
				throw Win32Marshal.GetExceptionForWin32Error(errorCode);
			}
			FileOptions fileOptions2 = FileOptions.None;
			if ((createOptions & (Interop.NtDll.CreateOptions)48u) == 0)
			{
				fileOptions2 |= FileOptions.Asynchronous;
			}
			if ((createOptions & Interop.NtDll.CreateOptions.FILE_WRITE_THROUGH) != 0)
			{
				fileOptions2 |= FileOptions.WriteThrough;
			}
			if ((createOptions & Interop.NtDll.CreateOptions.FILE_RANDOM_ACCESS) != 0)
			{
				fileOptions2 |= FileOptions.RandomAccess;
			}
			if ((createOptions & Interop.NtDll.CreateOptions.FILE_SEQUENTIAL_ONLY) != 0)
			{
				fileOptions2 |= FileOptions.SequentialScan;
			}
			if ((createOptions & Interop.NtDll.CreateOptions.FILE_DELETE_ON_CLOSE) != 0)
			{
				fileOptions2 |= FileOptions.DeleteOnClose;
			}
			if ((createOptions & Interop.NtDll.CreateOptions.FILE_NO_INTERMEDIATE_BUFFERING) != 0)
			{
				fileOptions2 |= (FileOptions)536870912;
			}
			return _fileOptions = fileOptions2;
		}

		internal int GetFileType()
		{
			int num = _fileType;
			if (num == -1)
			{
				num = (_fileType = Interop.Kernel32.GetFileType(this));
			}
			return num;
		}

		internal OverlappedValueTaskSource GetOverlappedValueTaskSource()
		{
			return Interlocked.Exchange(ref _reusableOverlappedValueTaskSource, null) ?? new OverlappedValueTaskSource(this);
		}

		protected override bool ReleaseHandle()
		{
			bool result = Interop.Kernel32.CloseHandle(handle);
			Interlocked.Exchange(ref _reusableOverlappedValueTaskSource, null)?.Dispose();
			return result;
		}

		private void TryToReuse(OverlappedValueTaskSource source)
		{
			source._source.Reset();
			if (Interlocked.CompareExchange(ref _reusableOverlappedValueTaskSource, source, null) != null)
			{
				source._preallocatedOverlapped.Dispose();
			}
		}
	}
	public sealed class SafeWaitHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		public SafeWaitHandle()
			: base(ownsHandle: true)
		{
		}

		public SafeWaitHandle(IntPtr existingHandle, bool ownsHandle)
			: base(ownsHandle)
		{
			SetHandle(existingHandle);
		}

		protected override bool ReleaseHandle()
		{
			return Interop.Kernel32.CloseHandle(handle);
		}
	}
	internal sealed class SafeFindHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		public SafeFindHandle()
			: base(ownsHandle: true)
		{
		}

		protected override bool ReleaseHandle()
		{
			return Interop.Kernel32.FindClose(handle);
		}
	}
}
namespace System
{
	[ClassInterface(ClassInterfaceType.None)]
	[ComVisible(true)]
	internal class __Canon
	{
	}
	public ref struct ArgIterator
	{
		private IntPtr ArgCookie;

		private IntPtr sigPtr;

		private IntPtr sigPtrLen;

		private IntPtr ArgPtr;

		private int RemainingArgs;

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern ArgIterator(IntPtr arglist);

		public ArgIterator(RuntimeArgumentHandle arglist)
			: this(arglist.Value)
		{
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe extern ArgIterator(IntPtr arglist, void* ptr);

		[CLSCompliant(false)]
		public unsafe ArgIterator(RuntimeArgumentHandle arglist, void* ptr)
			: this(arglist.Value, ptr)
		{
		}

		[CLSCompliant(false)]
		public unsafe TypedReference GetNextArg()
		{
			TypedReference result = default(TypedReference);
			FCallGetNextArg(&result);
			return result;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe extern void FCallGetNextArg(void* result);

		[CLSCompliant(false)]
		public unsafe TypedReference GetNextArg(RuntimeTypeHandle rth)
		{
			if (sigPtr != IntPtr.Zero)
			{
				return GetNextArg();
			}
			if (ArgPtr == IntPtr.Zero)
			{
				throw new ArgumentNullException();
			}
			TypedReference result = default(TypedReference);
			InternalGetNextArg(&result, rth.GetRuntimeType());
			return result;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe extern void InternalGetNextArg(void* result, RuntimeType rt);

		public void End()
		{
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern int GetRemainingCount();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe extern void* _GetNextArgType();

		public unsafe RuntimeTypeHandle GetNextArgType()
		{
			return new RuntimeTypeHandle(Type.GetTypeFromHandleUnsafe((IntPtr)_GetNextArgType()));
		}

		public override int GetHashCode()
		{
			return ValueType.GetHashCodeOfPtr(ArgCookie);
		}

		public override bool Equals(object? o)
		{
			throw new NotSupportedException(SR.NotSupported_NYI);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public abstract class Array : ICloneable, IList, ICollection, System.Collections.IEnumerable, IStructuralComparable, IStructuralEquatable
	{
		private static class EmptyArray<T>
		{
			internal static readonly T[] Value = new T[0];
		}

		private readonly struct SorterObjectArray
		{
			private readonly object[] keys;

			private readonly object[] items;

			private readonly IComparer comparer;

			internal SorterObjectArray(object[] keys, object[] items, IComparer comparer)
			{
				this.keys = keys;
				this.items = items;
				this.comparer = comparer;
			}

			internal void SwapIfGreater(int a, int b)
			{
				if (a != b && comparer.Compare(keys[a], keys[b]) > 0)
				{
					object obj = keys[a];
					keys[a] = keys[b];
					keys[b] = obj;
					if (items != null)
					{
						object obj2 = items[a];
						items[a] = items[b];
						items[b] = obj2;
					}
				}
			}

			private void Swap(int i, int j)
			{
				object obj = keys[i];
				keys[i] = keys[j];
				keys[j] = obj;
				if (items != null)
				{
					object obj2 = items[i];
					items[i] = items[j];
					items[j] = obj2;
				}
			}

			internal void Sort(int left, int length)
			{
				IntrospectiveSort(left, length);
			}

			private void IntrospectiveSort(int left, int length)
			{
				if (length < 2)
				{
					return;
				}
				try
				{
					IntroSort(left, length + left - 1, 2 * (BitOperations.Log2((uint)length) + 1));
				}
				catch (IndexOutOfRangeException)
				{
					ThrowHelper.ThrowArgumentException_BadComparer(comparer);
				}
				catch (Exception e)
				{
					ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
				}
			}

			private void IntroSort(int lo, int hi, int depthLimit)
			{
				while (hi > lo)
				{
					int num = hi - lo + 1;
					if (num <= 16)
					{
						switch (num)
						{
						case 2:
							SwapIfGreater(lo, hi);
							break;
						case 3:
							SwapIfGreater(lo, hi - 1);
							SwapIfGreater(lo, hi);
							SwapIfGreater(hi - 1, hi);
							break;
						default:
							InsertionSort(lo, hi);
							break;
						}
						break;
					}
					if (depthLimit == 0)
					{
						Heapsort(lo, hi);
						break;
					}
					depthLimit--;
					int num2 = PickPivotAndPartition(lo, hi);
					IntroSort(num2 + 1, hi, depthLimit);
					hi = num2 - 1;
				}
			}

			private int PickPivotAndPartition(int lo, int hi)
			{
				int num = lo + (hi - lo) / 2;
				SwapIfGreater(lo, num);
				SwapIfGreater(lo, hi);
				SwapIfGreater(num, hi);
				object obj = keys[num];
				Swap(num, hi - 1);
				int num2 = lo;
				int num3 = hi - 1;
				while (num2 < num3)
				{
					while (comparer.Compare(keys[++num2], obj) < 0)
					{
					}
					while (comparer.Compare(obj, keys[--num3]) < 0)
					{
					}
					if (num2 >= num3)
					{
						break;
					}
					Swap(num2, num3);
				}
				if (num2 != hi - 1)
				{
					Swap(num2, hi - 1);
				}
				return num2;
			}

			private void Heapsort(int lo, int hi)
			{
				int num = hi - lo + 1;
				for (int num2 = num / 2; num2 >= 1; num2--)
				{
					DownHeap(num2, num, lo);
				}
				for (int num3 = num; num3 > 1; num3--)
				{
					Swap(lo, lo + num3 - 1);
					DownHeap(1, num3 - 1, lo);
				}
			}

			private void DownHeap(int i, int n, int lo)
			{
				object obj = keys[lo + i - 1];
				object[] array = items;
				object obj2 = ((array != null) ? array[lo + i - 1] : null);
				while (i <= n / 2)
				{
					int num = 2 * i;
					if (num < n && comparer.Compare(keys[lo + num - 1], keys[lo + num]) < 0)
					{
						num++;
					}
					if (comparer.Compare(obj, keys[lo + num - 1]) >= 0)
					{
						break;
					}
					keys[lo + i - 1] = keys[lo + num - 1];
					if (items != null)
					{
						items[lo + i - 1] = items[lo + num - 1];
					}
					i = num;
				}
				keys[lo + i - 1] = obj;
				if (items != null)
				{
					items[lo + i - 1] = obj2;
				}
			}

			private void InsertionSort(int lo, int hi)
			{
				for (int i = lo; i < hi; i++)
				{
					int num = i;
					object obj = keys[i + 1];
					object[] array = items;
					object obj2 = ((array != null) ? array[i + 1] : null);
					while (num >= lo && comparer.Compare(obj, keys[num]) < 0)
					{
						keys[num + 1] = keys[num];
						if (items != null)
						{
							items[num + 1] = items[num];
						}
						num--;
					}
					keys[num + 1] = obj;
					if (items != null)
					{
						items[num + 1] = obj2;
					}
				}
			}
		}

		private readonly struct SorterGenericArray
		{
			private readonly Array keys;

			private readonly Array items;

			private readonly IComparer comparer;

			internal SorterGenericArray(Array keys, Array items, IComparer comparer)
			{
				this.keys = keys;
				this.items = items;
				this.comparer = comparer;
			}

			internal void SwapIfGreater(int a, int b)
			{
				if (a != b && comparer.Compare(keys.GetValue(a), keys.GetValue(b)) > 0)
				{
					object value = keys.GetValue(a);
					keys.SetValue(keys.GetValue(b), a);
					keys.SetValue(value, b);
					if (items != null)
					{
						object value2 = items.GetValue(a);
						items.SetValue(items.GetValue(b), a);
						items.SetValue(value2, b);
					}
				}
			}

			private void Swap(int i, int j)
			{
				object value = keys.GetValue(i);
				keys.SetValue(keys.GetValue(j), i);
				keys.SetValue(value, j);
				if (items != null)
				{
					object value2 = items.GetValue(i);
					items.SetValue(items.GetValue(j), i);
					items.SetValue(value2, j);
				}
			}

			internal void Sort(int left, int length)
			{
				IntrospectiveSort(left, length);
			}

			private void IntrospectiveSort(int left, int length)
			{
				if (length < 2)
				{
					return;
				}
				try
				{
					IntroSort(left, length + left - 1, 2 * (BitOperations.Log2((uint)length) + 1));
				}
				catch (IndexOutOfRangeException)
				{
					ThrowHelper.ThrowArgumentException_BadComparer(comparer);
				}
				catch (Exception e)
				{
					ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
				}
			}

			private void IntroSort(int lo, int hi, int depthLimit)
			{
				while (hi > lo)
				{
					int num = hi - lo + 1;
					if (num <= 16)
					{
						switch (num)
						{
						case 2:
							SwapIfGreater(lo, hi);
							break;
						case 3:
							SwapIfGreater(lo, hi - 1);
							SwapIfGreater(lo, hi);
							SwapIfGreater(hi - 1, hi);
							break;
						default:
							InsertionSort(lo, hi);
							break;
						}
						break;
					}
					if (depthLimit == 0)
					{
						Heapsort(lo, hi);
						break;
					}
					depthLimit--;
					int num2 = PickPivotAndPartition(lo, hi);
					IntroSort(num2 + 1, hi, depthLimit);
					hi = num2 - 1;
				}
			}

			private int PickPivotAndPartition(int lo, int hi)
			{
				int num = lo + (hi - lo) / 2;
				SwapIfGreater(lo, num);
				SwapIfGreater(lo, hi);
				SwapIfGreater(num, hi);
				object value = keys.GetValue(num);
				Swap(num, hi - 1);
				int num2 = lo;
				int num3 = hi - 1;
				while (num2 < num3)
				{
					while (comparer.Compare(keys.GetValue(++num2), value) < 0)
					{
					}
					while (comparer.Compare(value, keys.GetValue(--num3)) < 0)
					{
					}
					if (num2 >= num3)
					{
						break;
					}
					Swap(num2, num3);
				}
				if (num2 != hi - 1)
				{
					Swap(num2, hi - 1);
				}
				return num2;
			}

			private void Heapsort(int lo, int hi)
			{
				int num = hi - lo + 1;
				for (int num2 = num / 2; num2 >= 1; num2--)
				{
					DownHeap(num2, num, lo);
				}
				for (int num3 = num; num3 > 1; num3--)
				{
					Swap(lo, lo + num3 - 1);
					DownHeap(1, num3 - 1, lo);
				}
			}

			private void DownHeap(int i, int n, int lo)
			{
				object value = keys.GetValue(lo + i - 1);
				object value2 = items?.GetValue(lo + i - 1);
				while (i <= n / 2)
				{
					int num = 2 * i;
					if (num < n && comparer.Compare(keys.GetValue(lo + num - 1), keys.GetValue(lo + num)) < 0)
					{
						num++;
					}
					if (comparer.Compare(value, keys.GetValue(lo + num - 1)) >= 0)
					{
						break;
					}
					keys.SetValue(keys.GetValue(lo + num - 1), lo + i - 1);
					if (items != null)
					{
						items.SetValue(items.GetValue(lo + num - 1), lo + i - 1);
					}
					i = num;
				}
				keys.SetValue(value, lo + i - 1);
				if (items != null)
				{
					items.SetValue(value2, lo + i - 1);
				}
			}

			private void InsertionSort(int lo, int hi)
			{
				for (int i = lo; i < hi; i++)
				{
					int num = i;
					object value = keys.GetValue(i + 1);
					object value2 = items?.GetValue(i + 1);
					while (num >= lo && comparer.Compare(value, keys.GetValue(num)) < 0)
					{
						keys.SetValue(keys.GetValue(num), num + 1);
						if (items != null)
						{
							items.SetValue(items.GetValue(num), num + 1);
						}
						num--;
					}
					keys.SetValue(value, num + 1);
					if (items != null)
					{
						items.SetValue(value2, num + 1);
					}
				}
			}
		}

		public int Length => checked((int)Unsafe.As<RawArrayData>(this).Length);

		internal nuint NativeLength => Unsafe.As<RawArrayData>(this).Length;

		public long LongLength => (long)NativeLength;

		public int Rank
		{
			get
			{
				int multiDimensionalArrayRank = RuntimeHelpers.GetMultiDimensionalArrayRank(this);
				if (multiDimensionalArrayRank == 0)
				{
					return 1;
				}
				return multiDimensionalArrayRank;
			}
		}

		int ICollection.Count => Length;

		public object SyncRoot => this;

		public bool IsReadOnly => false;

		public bool IsFixedSize => true;

		public bool IsSynchronized => false;

		object? IList.this[int index]
		{
			get
			{
				return GetValue(index);
			}
			set
			{
				SetValue(value, index);
			}
		}

		public static int MaxLength => 2147483591;

		public unsafe static Array CreateInstance(Type elementType, int length)
		{
			if ((object)elementType == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.elementType);
			}
			if (length < 0)
			{
				ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
			}
			RuntimeType runtimeType = elementType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_MustBeType, ExceptionArgument.elementType);
			}
			return InternalCreate((void*)runtimeType.TypeHandle.Value, 1, &length, null);
		}

		public unsafe static Array CreateInstance(Type elementType, int length1, int length2)
		{
			if ((object)elementType == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.elementType);
			}
			if (length1 < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length1, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (length2 < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length2, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			RuntimeType runtimeType = elementType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_MustBeType, ExceptionArgument.elementType);
			}
			int* ptr = stackalloc int[2];
			*ptr = length1;
			ptr[1] = length2;
			return InternalCreate((void*)runtimeType.TypeHandle.Value, 2, ptr, null);
		}

		public unsafe static Array CreateInstance(Type elementType, int length1, int length2, int length3)
		{
			if ((object)elementType == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.elementType);
			}
			if (length1 < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length1, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (length2 < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length2, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (length3 < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length3, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			RuntimeType runtimeType = elementType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_MustBeType, ExceptionArgument.elementType);
			}
			int* ptr = stackalloc int[3];
			*ptr = length1;
			ptr[1] = length2;
			ptr[2] = length3;
			return InternalCreate((void*)runtimeType.TypeHandle.Value, 3, ptr, null);
		}

		public unsafe static Array CreateInstance(Type elementType, params int[] lengths)
		{
			if ((object)elementType == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.elementType);
			}
			if (lengths == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.lengths);
			}
			if (lengths.Length == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NeedAtLeast1Rank);
			}
			RuntimeType runtimeType = elementType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_MustBeType, ExceptionArgument.elementType);
			}
			for (int i = 0; i < lengths.Length; i++)
			{
				if (lengths[i] < 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.lengths, i, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
				}
			}
			fixed (int* pLengths = &lengths[0])
			{
				return InternalCreate((void*)runtimeType.TypeHandle.Value, lengths.Length, pLengths, null);
			}
		}

		public unsafe static Array CreateInstance(Type elementType, int[] lengths, int[] lowerBounds)
		{
			if (elementType == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.elementType);
			}
			if (lengths == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.lengths);
			}
			if (lowerBounds == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.lowerBounds);
			}
			if (lengths.Length != lowerBounds.Length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RanksAndBounds);
			}
			if (lengths.Length == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NeedAtLeast1Rank);
			}
			RuntimeType runtimeType = elementType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_MustBeType, ExceptionArgument.elementType);
			}
			for (int i = 0; i < lengths.Length; i++)
			{
				if (lengths[i] < 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.lengths, i, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
				}
			}
			fixed (int* pLengths = &lengths[0])
			{
				fixed (int* pLowerBounds = &lowerBounds[0])
				{
					return InternalCreate((void*)runtimeType.TypeHandle.Value, lengths.Length, pLengths, pLowerBounds);
				}
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern Array InternalCreate(void* elementType, int rank, int* pLengths, int* pLowerBounds);

		public unsafe static void Copy(Array sourceArray, Array destinationArray, int length)
		{
			if (sourceArray == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.sourceArray);
			}
			if (destinationArray == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.destinationArray);
			}
			MethodTable* methodTable = RuntimeHelpers.GetMethodTable(sourceArray);
			if (methodTable == RuntimeHelpers.GetMethodTable(destinationArray) && !methodTable->IsMultiDimensionalArray && (uint)length <= sourceArray.NativeLength && (uint)length <= destinationArray.NativeLength)
			{
				nuint num = (nuint)(uint)length * (nuint)methodTable->ComponentSize;
				ref byte data = ref Unsafe.As<RawArrayData>(sourceArray).Data;
				ref byte data2 = ref Unsafe.As<RawArrayData>(destinationArray).Data;
				if (methodTable->ContainsGCPointers)
				{
					Buffer.BulkMoveWithWriteBarrier(ref data2, ref data, num);
				}
				else
				{
					Buffer.Memmove(ref data2, ref data, num);
				}
			}
			else
			{
				Copy(sourceArray, sourceArray.GetLowerBound(0), destinationArray, destinationArray.GetLowerBound(0), length, reliable: false);
			}
		}

		public unsafe static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
		{
			if (sourceArray != null && destinationArray != null)
			{
				MethodTable* methodTable = RuntimeHelpers.GetMethodTable(sourceArray);
				if (methodTable == RuntimeHelpers.GetMethodTable(destinationArray) && !methodTable->IsMultiDimensionalArray && length >= 0 && sourceIndex >= 0 && destinationIndex >= 0 && (uint)(sourceIndex + length) <= sourceArray.NativeLength && (uint)(destinationIndex + length) <= destinationArray.NativeLength)
				{
					nuint num = methodTable->ComponentSize;
					nuint num2 = (uint)length * num;
					ref byte reference = ref Unsafe.AddByteOffset(ref Unsafe.As<RawArrayData>(sourceArray).Data, (uint)sourceIndex * num);
					ref byte reference2 = ref Unsafe.AddByteOffset(ref Unsafe.As<RawArrayData>(destinationArray).Data, (uint)destinationIndex * num);
					if (methodTable->ContainsGCPointers)
					{
						Buffer.BulkMoveWithWriteBarrier(ref reference2, ref reference, num2);
					}
					else
					{
						Buffer.Memmove(ref reference2, ref reference, num2);
					}
					return;
				}
			}
			Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length, reliable: false);
		}

		private unsafe static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length, bool reliable)
		{
			if (sourceArray == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.sourceArray);
			}
			if (destinationArray == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.destinationArray);
			}
			if (sourceArray.GetType() != destinationArray.GetType() && sourceArray.Rank != destinationArray.Rank)
			{
				throw new RankException(SR.Rank_MustMatch);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			int lowerBound = sourceArray.GetLowerBound(0);
			if (sourceIndex < lowerBound || sourceIndex - lowerBound < 0)
			{
				throw new ArgumentOutOfRangeException("sourceIndex", SR.ArgumentOutOfRange_ArrayLB);
			}
			sourceIndex -= lowerBound;
			int lowerBound2 = destinationArray.GetLowerBound(0);
			if (destinationIndex < lowerBound2 || destinationIndex - lowerBound2 < 0)
			{
				throw new ArgumentOutOfRangeException("destinationIndex", SR.ArgumentOutOfRange_ArrayLB);
			}
			destinationIndex -= lowerBound2;
			if ((uint)(sourceIndex + length) > sourceArray.NativeLength)
			{
				throw new ArgumentException(SR.Arg_LongerThanSrcArray, "sourceArray");
			}
			if ((uint)(destinationIndex + length) > destinationArray.NativeLength)
			{
				throw new ArgumentException(SR.Arg_LongerThanDestArray, "destinationArray");
			}
			if (sourceArray.GetType() == destinationArray.GetType() || IsSimpleCopy(sourceArray, destinationArray))
			{
				MethodTable* methodTable = RuntimeHelpers.GetMethodTable(sourceArray);
				nuint num = methodTable->ComponentSize;
				nuint num2 = (uint)length * num;
				ref byte reference = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(sourceArray), (uint)sourceIndex * num);
				ref byte reference2 = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(destinationArray), (uint)destinationIndex * num);
				if (methodTable->ContainsGCPointers)
				{
					Buffer.BulkMoveWithWriteBarrier(ref reference2, ref reference, num2);
				}
				else
				{
					Buffer.Memmove(ref reference2, ref reference, num2);
				}
			}
			else
			{
				if (reliable)
				{
					throw new ArrayTypeMismatchException(SR.ArrayTypeMismatch_ConstrainedCopy);
				}
				CopySlow(sourceArray, sourceIndex, destinationArray, destinationIndex, length);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool IsSimpleCopy(Array sourceArray, Array destinationArray);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void CopySlow(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);

		public static void ConstrainedCopy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)
		{
			Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length, reliable: true);
		}

		public unsafe static void Clear(Array array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			MethodTable* methodTable = RuntimeHelpers.GetMethodTable(array);
			nuint num = methodTable->ComponentSize * array.NativeLength;
			ref byte arrayDataReference = ref MemoryMarshal.GetArrayDataReference(array);
			if (!methodTable->ContainsGCPointers)
			{
				SpanHelpers.ClearWithoutReferences(ref arrayDataReference, num);
			}
			else
			{
				SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, IntPtr>(ref arrayDataReference), num / (nuint)sizeof(IntPtr));
			}
		}

		public unsafe static void Clear(Array array, int index, int length)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			ref byte source = ref Unsafe.As<RawArrayData>(array).Data;
			int num = 0;
			MethodTable* methodTable = RuntimeHelpers.GetMethodTable(array);
			if (methodTable->IsMultiDimensionalArray)
			{
				int multiDimensionalArrayRank = methodTable->MultiDimensionalArrayRank;
				num = Unsafe.Add(ref Unsafe.As<byte, int>(ref source), multiDimensionalArrayRank);
				source = ref Unsafe.Add(ref source, 8 * multiDimensionalArrayRank);
			}
			int num2 = index - num;
			if (index < num || num2 < 0 || length < 0 || (uint)(num2 + length) > array.NativeLength)
			{
				ThrowHelper.ThrowIndexOutOfRangeException();
			}
			nuint num3 = methodTable->ComponentSize;
			ref byte reference = ref Unsafe.AddByteOffset(ref source, (uint)num2 * num3);
			nuint num4 = (uint)length * num3;
			if (methodTable->ContainsGCPointers)
			{
				SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, IntPtr>(ref reference), num4 / (uint)sizeof(IntPtr));
			}
			else
			{
				SpanHelpers.ClearWithoutReferences(ref reference, num4);
			}
		}

		private unsafe nint GetFlattenedIndex(ReadOnlySpan<int> indices)
		{
			if (RuntimeHelpers.GetMethodTable(this)->IsMultiDimensionalArray)
			{
				ref int multiDimensionalArrayBounds = ref RuntimeHelpers.GetMultiDimensionalArrayBounds(this);
				nint num = 0;
				for (int i = 0; i < indices.Length; i++)
				{
					int num2 = indices[i] - Unsafe.Add(ref multiDimensionalArrayBounds, indices.Length + i);
					int num3 = Unsafe.Add(ref multiDimensionalArrayBounds, i);
					if ((uint)num2 >= (uint)num3)
					{
						ThrowHelper.ThrowIndexOutOfRangeException();
					}
					num = num3 * num + num2;
				}
				return num;
			}
			int num4 = indices[0];
			if ((uint)num4 >= (uint)LongLength)
			{
				ThrowHelper.ThrowIndexOutOfRangeException();
			}
			return num4;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern object InternalGetValue(nint flattenedIndex);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void InternalSetValue(object value, nint flattenedIndex);

		public int GetLength(int dimension)
		{
			int multiDimensionalArrayRank = RuntimeHelpers.GetMultiDimensionalArrayRank(this);
			if (multiDimensionalArrayRank == 0 && dimension == 0)
			{
				return Length;
			}
			if ((uint)dimension >= (uint)multiDimensionalArrayRank)
			{
				throw new IndexOutOfRangeException(SR.IndexOutOfRange_ArrayRankIndex);
			}
			return Unsafe.Add(ref RuntimeHelpers.GetMultiDimensionalArrayBounds(this), dimension);
		}

		public int GetUpperBound(int dimension)
		{
			int multiDimensionalArrayRank = RuntimeHelpers.GetMultiDimensionalArrayRank(this);
			if (multiDimensionalArrayRank == 0 && dimension == 0)
			{
				return Length - 1;
			}
			if ((uint)dimension >= (uint)multiDimensionalArrayRank)
			{
				throw new IndexOutOfRangeException(SR.IndexOutOfRange_ArrayRankIndex);
			}
			ref int multiDimensionalArrayBounds = ref RuntimeHelpers.GetMultiDimensionalArrayBounds(this);
			return Unsafe.Add(ref multiDimensionalArrayBounds, dimension) + Unsafe.Add(ref multiDimensionalArrayBounds, multiDimensionalArrayRank + dimension) - 1;
		}

		public int GetLowerBound(int dimension)
		{
			int multiDimensionalArrayRank = RuntimeHelpers.GetMultiDimensionalArrayRank(this);
			if (multiDimensionalArrayRank == 0 && dimension == 0)
			{
				return 0;
			}
			if ((uint)dimension >= (uint)multiDimensionalArrayRank)
			{
				throw new IndexOutOfRangeException(SR.IndexOutOfRange_ArrayRankIndex);
			}
			return Unsafe.Add(ref RuntimeHelpers.GetMultiDimensionalArrayBounds(this), multiDimensionalArrayRank + dimension);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern CorElementType GetCorElementTypeOfElementType();

		private unsafe bool IsValueOfElementType(object value)
		{
			MethodTable* methodTable = RuntimeHelpers.GetMethodTable(this);
			return (IntPtr)methodTable->ElementType == (IntPtr)RuntimeHelpers.GetMethodTable(value);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void Initialize();

		private protected Array()
		{
		}

		public static ReadOnlyCollection<T> AsReadOnly<T>(T[] array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return new ReadOnlyCollection<T>(array);
		}

		public static void Resize<T>([NotNull] ref T[]? array, int newSize)
		{
			if (newSize < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.newSize, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			T[] array2 = array;
			if (array2 == null)
			{
				array = new T[newSize];
			}
			else if (array2.Length != newSize)
			{
				T[] array3 = new T[newSize];
				Buffer.Memmove(ref MemoryMarshal.GetArrayDataReference(array3), ref MemoryMarshal.GetArrayDataReference(array2), (uint)Math.Min(newSize, array2.Length));
				array = array3;
			}
		}

		public static Array CreateInstance(Type elementType, params long[] lengths)
		{
			if (lengths == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.lengths);
			}
			if (lengths.Length == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NeedAtLeast1Rank);
			}
			int[] array = new int[lengths.Length];
			for (int i = 0; i < lengths.Length; i++)
			{
				long num = lengths[i];
				int num2 = (int)num;
				if (num != num2)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.len, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
				}
				array[i] = num2;
			}
			return CreateInstance(elementType, array);
		}

		public static void Copy(Array sourceArray, Array destinationArray, long length)
		{
			int num = (int)length;
			if (length != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			Copy(sourceArray, destinationArray, num);
		}

		public static void Copy(Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length)
		{
			int num = (int)sourceIndex;
			int num2 = (int)destinationIndex;
			int num3 = (int)length;
			if (sourceIndex != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.sourceIndex, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			if (destinationIndex != num2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.destinationIndex, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			if (length != num3)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			Copy(sourceArray, num, destinationArray, num2, num3);
		}

		public object? GetValue(params int[] indices)
		{
			if (indices == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.indices);
			}
			if (Rank != indices.Length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankIndices);
			}
			return InternalGetValue(GetFlattenedIndex(new ReadOnlySpan<int>(indices)));
		}

		public unsafe object? GetValue(int index)
		{
			if (Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need1DArray);
			}
			return InternalGetValue(GetFlattenedIndex(new ReadOnlySpan<int>(&index, 1)));
		}

		public object? GetValue(int index1, int index2)
		{
			if (Rank != 2)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need2DArray);
			}
			Span<int> span = stackalloc int[2] { index1, index2 };
			return InternalGetValue(GetFlattenedIndex(span));
		}

		public object? GetValue(int index1, int index2, int index3)
		{
			if (Rank != 3)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need3DArray);
			}
			Span<int> span = stackalloc int[3] { index1, index2, index3 };
			return InternalGetValue(GetFlattenedIndex(span));
		}

		public unsafe void SetValue(object? value, int index)
		{
			if (Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need1DArray);
			}
			InternalSetValue(value, GetFlattenedIndex(new ReadOnlySpan<int>(&index, 1)));
		}

		public void SetValue(object? value, int index1, int index2)
		{
			if (Rank != 2)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need2DArray);
			}
			Span<int> span = stackalloc int[2] { index1, index2 };
			InternalSetValue(value, GetFlattenedIndex(span));
		}

		public void SetValue(object? value, int index1, int index2, int index3)
		{
			if (Rank != 3)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need3DArray);
			}
			Span<int> span = stackalloc int[3] { index1, index2, index3 };
			InternalSetValue(value, GetFlattenedIndex(span));
		}

		public void SetValue(object? value, params int[] indices)
		{
			if (indices == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.indices);
			}
			if (Rank != indices.Length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankIndices);
			}
			InternalSetValue(value, GetFlattenedIndex(new ReadOnlySpan<int>(indices)));
		}

		public object? GetValue(long index)
		{
			int num = (int)index;
			if (index != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			return GetValue(num);
		}

		public object? GetValue(long index1, long index2)
		{
			int num = (int)index1;
			int num2 = (int)index2;
			if (index1 != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index1, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			if (index2 != num2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index2, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			return GetValue(num, num2);
		}

		public object? GetValue(long index1, long index2, long index3)
		{
			int num = (int)index1;
			int num2 = (int)index2;
			int num3 = (int)index3;
			if (index1 != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index1, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			if (index2 != num2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index2, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			if (index3 != num3)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index3, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			return GetValue(num, num2, num3);
		}

		public object? GetValue(params long[] indices)
		{
			if (indices == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.indices);
			}
			if (Rank != indices.Length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankIndices);
			}
			int[] array = new int[indices.Length];
			for (int i = 0; i < indices.Length; i++)
			{
				long num = indices[i];
				int num2 = (int)num;
				if (num != num2)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
				}
				array[i] = num2;
			}
			return GetValue(array);
		}

		public void SetValue(object? value, long index)
		{
			int num = (int)index;
			if (index != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			SetValue(value, num);
		}

		public void SetValue(object? value, long index1, long index2)
		{
			int num = (int)index1;
			int num2 = (int)index2;
			if (index1 != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index1, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			if (index2 != num2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index2, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			SetValue(value, num, num2);
		}

		public void SetValue(object? value, long index1, long index2, long index3)
		{
			int num = (int)index1;
			int num2 = (int)index2;
			int num3 = (int)index3;
			if (index1 != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index1, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			if (index2 != num2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index2, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			if (index3 != num3)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index3, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			SetValue(value, num, num2, num3);
		}

		public void SetValue(object? value, params long[] indices)
		{
			if (indices == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.indices);
			}
			if (Rank != indices.Length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankIndices);
			}
			int[] array = new int[indices.Length];
			for (int i = 0; i < indices.Length; i++)
			{
				long num = indices[i];
				int num2 = (int)num;
				if (num != num2)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
				}
				array[i] = num2;
			}
			SetValue(value, array);
		}

		private static int GetMedian(int low, int hi)
		{
			return low + (hi - low >> 1);
		}

		public long GetLongLength(int dimension)
		{
			return GetLength(dimension);
		}

		int IList.Add(object value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
			return 0;
		}

		bool IList.Contains(object value)
		{
			return IndexOf(this, value) >= GetLowerBound(0);
		}

		void IList.Clear()
		{
			Clear(this);
		}

		int IList.IndexOf(object value)
		{
			return IndexOf(this, value);
		}

		void IList.Insert(int index, object value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
		}

		void IList.Remove(object value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
		}

		void IList.RemoveAt(int index)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
		}

		[Intrinsic]
		public object Clone()
		{
			return MemberwiseClone();
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			Array array = other as Array;
			if (array == null || Length != array.Length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.ArgumentException_OtherNotArrayOfCorrectLength, ExceptionArgument.other);
			}
			int i = 0;
			int num = 0;
			for (; i < array.Length; i++)
			{
				if (num != 0)
				{
					break;
				}
				object value = GetValue(i);
				object value2 = array.GetValue(i);
				num = comparer.Compare(value, value2);
			}
			return num;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (this == other)
			{
				return true;
			}
			if (!(other is Array array) || array.Length != Length)
			{
				return false;
			}
			for (int i = 0; i < array.Length; i++)
			{
				object value = GetValue(i);
				object value2 = array.GetValue(i);
				if (!comparer.Equals(value, value2))
				{
					return false;
				}
			}
			return true;
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			if (comparer == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparer);
			}
			HashCode hashCode = default(HashCode);
			for (int i = ((Length >= 8) ? (Length - 8) : 0); i < Length; i++)
			{
				hashCode.Add(comparer.GetHashCode(GetValue(i)));
			}
			return hashCode.ToHashCode();
		}

		public static int BinarySearch(Array array, object? value)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return BinarySearch(array, array.GetLowerBound(0), array.Length, value, null);
		}

		public static int BinarySearch(Array array, int index, int length, object? value)
		{
			return BinarySearch(array, index, length, value, null);
		}

		public static int BinarySearch(Array array, object? value, IComparer? comparer)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return BinarySearch(array, array.GetLowerBound(0), array.Length, value, comparer);
		}

		public static int BinarySearch(Array array, int index, int length, object? value, IComparer? comparer)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			int lowerBound = array.GetLowerBound(0);
			if (index < lowerBound)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (length < 0)
			{
				ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
			}
			if (array.Length - (index - lowerBound) < length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowRankException(ExceptionResource.Rank_MultiDimNotSupported);
			}
			if (comparer == null)
			{
				comparer = Comparer.Default;
			}
			int num = index;
			int num2 = index + length - 1;
			if (array is object[] array2)
			{
				while (num <= num2)
				{
					int median = GetMedian(num, num2);
					int num3;
					try
					{
						num3 = comparer.Compare(array2[median], value);
					}
					catch (Exception e)
					{
						ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
						return 0;
					}
					if (num3 == 0)
					{
						return median;
					}
					if (num3 < 0)
					{
						num = median + 1;
					}
					else
					{
						num2 = median - 1;
					}
				}
				return ~num;
			}
			if (comparer == Comparer.Default)
			{
				CorElementType corElementTypeOfElementType = array.GetCorElementTypeOfElementType();
				if (corElementTypeOfElementType.IsPrimitiveType())
				{
					if (value == null)
					{
						return ~index;
					}
					if (array.IsValueOfElementType(value))
					{
						int adjustedIndex2 = index - lowerBound;
						int num4 = -1;
						switch (corElementTypeOfElementType)
						{
						case CorElementType.ELEMENT_TYPE_I1:
							num4 = GenericBinarySearch<sbyte>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_BOOLEAN:
						case CorElementType.ELEMENT_TYPE_U1:
							num4 = GenericBinarySearch<byte>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_I2:
							num4 = GenericBinarySearch<short>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_CHAR:
						case CorElementType.ELEMENT_TYPE_U2:
							num4 = GenericBinarySearch<ushort>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_I4:
						case CorElementType.ELEMENT_TYPE_I:
							num4 = GenericBinarySearch<int>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_U4:
						case CorElementType.ELEMENT_TYPE_U:
							num4 = GenericBinarySearch<uint>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_I8:
							num4 = GenericBinarySearch<long>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_U8:
							num4 = GenericBinarySearch<ulong>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_R4:
							num4 = GenericBinarySearch<float>(array, adjustedIndex2, length, value);
							break;
						case CorElementType.ELEMENT_TYPE_R8:
							num4 = GenericBinarySearch<double>(array, adjustedIndex2, length, value);
							break;
						}
						if (num4 < 0)
						{
							return ~(index + ~num4);
						}
						return index + num4;
					}
				}
			}
			while (num <= num2)
			{
				int median2 = GetMedian(num, num2);
				int num5;
				try
				{
					num5 = comparer.Compare(array.GetValue(median2), value);
				}
				catch (Exception e2)
				{
					ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e2);
					return 0;
				}
				if (num5 == 0)
				{
					return median2;
				}
				if (num5 < 0)
				{
					num = median2 + 1;
				}
				else
				{
					num2 = median2 - 1;
				}
			}
			return ~num;
			static int GenericBinarySearch<T>(Array array, int adjustedIndex, int length, object value) where T : struct, IComparable<T>
			{
				return UnsafeArrayAsSpan<T>(array, adjustedIndex, length).BinarySearch(Unsafe.As<byte, T>(ref value.GetRawData()));
			}
		}

		public static int BinarySearch<T>(T[] array, T value)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return BinarySearch(array, 0, array.Length, value, null);
		}

		public static int BinarySearch<T>(T[] array, T value, IComparer<T>? comparer)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return BinarySearch(array, 0, array.Length, value, comparer);
		}

		public static int BinarySearch<T>(T[] array, int index, int length, T value)
		{
			return BinarySearch(array, index, length, value, null);
		}

		public static int BinarySearch<T>(T[] array, int index, int length, T value, IComparer<T>? comparer)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (length < 0)
			{
				ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
			}
			if (array.Length - index < length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			return ArraySortHelper<T>.Default.BinarySearch(array, index, length, value, comparer);
		}

		public static TOutput[] ConvertAll<TInput, TOutput>(TInput[] array, Converter<TInput, TOutput> converter)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (converter == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.converter);
			}
			TOutput[] array2 = new TOutput[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array2[i] = converter(array[i]);
			}
			return array2;
		}

		public void CopyTo(Array array, int index)
		{
			if (array != null && array.Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
			}
			Copy(this, GetLowerBound(0), array, index, Length);
		}

		public void CopyTo(Array array, long index)
		{
			int num = (int)index;
			if (index != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
			}
			CopyTo(array, num);
		}

		public static T[] Empty<T>()
		{
			return EmptyArray<T>.Value;
		}

		public static bool Exists<T>(T[] array, Predicate<T> match)
		{
			return FindIndex(array, match) != -1;
		}

		public static void Fill<T>(T[] array, T value)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = value;
				}
			}
			else
			{
				new Span<T>(array).Fill(value);
			}
		}

		public static void Fill<T>(T[] array, T value, int startIndex, int count)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if ((uint)startIndex > (uint)array.Length)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if ((uint)count > (uint)(array.Length - startIndex))
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				for (int i = startIndex; i < startIndex + count; i++)
				{
					array[i] = value;
				}
			}
			else
			{
				new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)startIndex), count).Fill(value);
			}
		}

		public static T? Find<T>(T[] array, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (match(array[i]))
				{
					return array[i];
				}
			}
			return default(T);
		}

		public static T[] FindAll<T>(T[] array, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			List<T> list = new List<T>();
			for (int i = 0; i < array.Length; i++)
			{
				if (match(array[i]))
				{
					list.Add(array[i]);
				}
			}
			return list.ToArray();
		}

		public static int FindIndex<T>(T[] array, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return FindIndex(array, 0, array.Length, match);
		}

		public static int FindIndex<T>(T[] array, int startIndex, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return FindIndex(array, startIndex, array.Length - startIndex, match);
		}

		public static int FindIndex<T>(T[] array, int startIndex, int count, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (startIndex < 0 || startIndex > array.Length)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0 || startIndex > array.Length - count)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			int num = startIndex + count;
			for (int i = startIndex; i < num; i++)
			{
				if (match(array[i]))
				{
					return i;
				}
			}
			return -1;
		}

		public static T? FindLast<T>(T[] array, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int num = array.Length - 1; num >= 0; num--)
			{
				if (match(array[num]))
				{
					return array[num];
				}
			}
			return default(T);
		}

		public static int FindLastIndex<T>(T[] array, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return FindLastIndex(array, array.Length - 1, array.Length, match);
		}

		public static int FindLastIndex<T>(T[] array, int startIndex, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return FindLastIndex(array, startIndex, startIndex + 1, match);
		}

		public static int FindLastIndex<T>(T[] array, int startIndex, int count, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			if (array.Length == 0)
			{
				if (startIndex != -1)
				{
					ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
				}
			}
			else if (startIndex < 0 || startIndex >= array.Length)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0 || startIndex - count + 1 < 0)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			int num = startIndex - count;
			for (int num2 = startIndex; num2 > num; num2--)
			{
				if (match(array[num2]))
				{
					return num2;
				}
			}
			return -1;
		}

		public static void ForEach<T>(T[] array, Action<T> action)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (action == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action);
			}
			for (int i = 0; i < array.Length; i++)
			{
				action(array[i]);
			}
		}

		public static int IndexOf(Array array, object? value)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return IndexOf(array, value, array.GetLowerBound(0), array.Length);
		}

		public static int IndexOf(Array array, object? value, int startIndex)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			int lowerBound = array.GetLowerBound(0);
			return IndexOf(array, value, startIndex, array.Length - startIndex + lowerBound);
		}

		public static int IndexOf(Array array, object? value, int startIndex, int count)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowRankException(ExceptionResource.Rank_MultiDimNotSupported);
			}
			int lowerBound = array.GetLowerBound(0);
			if (startIndex < lowerBound || startIndex > array.Length + lowerBound)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0 || count > array.Length - startIndex + lowerBound)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			int num = startIndex + count;
			if (array is object[] array2)
			{
				if (value == null)
				{
					for (int i = startIndex; i < num; i++)
					{
						if (array2[i] == null)
						{
							return i;
						}
					}
				}
				else
				{
					for (int j = startIndex; j < num; j++)
					{
						object obj = array2[j];
						if (obj != null && obj.Equals(value))
						{
							return j;
						}
					}
				}
				return -1;
			}
			CorElementType corElementTypeOfElementType = array.GetCorElementTypeOfElementType();
			if (corElementTypeOfElementType.IsPrimitiveType())
			{
				if (value == null)
				{
					return lowerBound - 1;
				}
				if (array.IsValueOfElementType(value))
				{
					int adjustedIndex2 = startIndex - lowerBound;
					int num2 = -1;
					switch (corElementTypeOfElementType)
					{
					case CorElementType.ELEMENT_TYPE_BOOLEAN:
					case CorElementType.ELEMENT_TYPE_I1:
					case CorElementType.ELEMENT_TYPE_U1:
						num2 = GenericIndexOf<byte>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_CHAR:
					case CorElementType.ELEMENT_TYPE_I2:
					case CorElementType.ELEMENT_TYPE_U2:
						num2 = GenericIndexOf<char>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_I4:
					case CorElementType.ELEMENT_TYPE_U4:
					case CorElementType.ELEMENT_TYPE_I:
					case CorElementType.ELEMENT_TYPE_U:
						num2 = GenericIndexOf<int>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_I8:
					case CorElementType.ELEMENT_TYPE_U8:
						num2 = GenericIndexOf<long>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_R4:
						num2 = GenericIndexOf<float>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_R8:
						num2 = GenericIndexOf<double>(array, value, adjustedIndex2, count);
						break;
					}
					return ((num2 >= 0) ? startIndex : lowerBound) + num2;
				}
			}
			for (int k = startIndex; k < num; k++)
			{
				object value2 = array.GetValue(k);
				if (value2 == null)
				{
					if (value == null)
					{
						return k;
					}
				}
				else if (value2.Equals(value))
				{
					return k;
				}
			}
			return lowerBound - 1;
			static int GenericIndexOf<T>(Array array, object value, int adjustedIndex, int length) where T : struct, IEquatable<T>
			{
				return UnsafeArrayAsSpan<T>(array, adjustedIndex, length).IndexOf(Unsafe.As<byte, T>(ref value.GetRawData()));
			}
		}

		public static int IndexOf<T>(T[] array, T value)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return IndexOf(array, value, 0, array.Length);
		}

		public static int IndexOf<T>(T[] array, T value, int startIndex)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return IndexOf(array, value, startIndex, array.Length - startIndex);
		}

		public static int IndexOf<T>(T[] array, T value, int startIndex, int count)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if ((uint)startIndex > (uint)array.Length)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if ((uint)count > (uint)(array.Length - startIndex))
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					int num = SpanHelpers.IndexOf(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<byte[]>(array)), startIndex), Unsafe.As<T, byte>(ref value), count);
					return ((num >= 0) ? startIndex : 0) + num;
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					int num2 = SpanHelpers.IndexOf(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<char[]>(array)), startIndex), Unsafe.As<T, char>(ref value), count);
					return ((num2 >= 0) ? startIndex : 0) + num2;
				}
				if (Unsafe.SizeOf<T>() == 4)
				{
					int num3 = SpanHelpers.IndexOf(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<int[]>(array)), startIndex), Unsafe.As<T, int>(ref value), count);
					return ((num3 >= 0) ? startIndex : 0) + num3;
				}
				if (Unsafe.SizeOf<T>() == 8)
				{
					int num4 = SpanHelpers.IndexOf(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<long[]>(array)), startIndex), Unsafe.As<T, long>(ref value), count);
					return ((num4 >= 0) ? startIndex : 0) + num4;
				}
			}
			return EqualityComparer<T>.Default.IndexOf(array, value, startIndex, count);
		}

		public static int LastIndexOf(Array array, object? value)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			int lowerBound = array.GetLowerBound(0);
			return LastIndexOf(array, value, array.Length - 1 + lowerBound, array.Length);
		}

		public static int LastIndexOf(Array array, object? value, int startIndex)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			int lowerBound = array.GetLowerBound(0);
			return LastIndexOf(array, value, startIndex, startIndex + 1 - lowerBound);
		}

		public static int LastIndexOf(Array array, object? value, int startIndex, int count)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			int lowerBound = array.GetLowerBound(0);
			if (array.Length == 0)
			{
				return lowerBound - 1;
			}
			if (startIndex < lowerBound || startIndex >= array.Length + lowerBound)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			if (count > startIndex - lowerBound + 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.endIndex, ExceptionResource.ArgumentOutOfRange_EndIndexStartIndex);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowRankException(ExceptionResource.Rank_MultiDimNotSupported);
			}
			int num = startIndex - count + 1;
			if (array is object[] array2)
			{
				if (value == null)
				{
					for (int num2 = startIndex; num2 >= num; num2--)
					{
						if (array2[num2] == null)
						{
							return num2;
						}
					}
				}
				else
				{
					for (int num3 = startIndex; num3 >= num; num3--)
					{
						object obj = array2[num3];
						if (obj != null && obj.Equals(value))
						{
							return num3;
						}
					}
				}
				return -1;
			}
			CorElementType corElementTypeOfElementType = array.GetCorElementTypeOfElementType();
			if (corElementTypeOfElementType.IsPrimitiveType())
			{
				if (value == null)
				{
					return lowerBound - 1;
				}
				if (array.IsValueOfElementType(value))
				{
					int adjustedIndex2 = num - lowerBound;
					int num4 = -1;
					switch (corElementTypeOfElementType)
					{
					case CorElementType.ELEMENT_TYPE_BOOLEAN:
					case CorElementType.ELEMENT_TYPE_I1:
					case CorElementType.ELEMENT_TYPE_U1:
						num4 = GenericLastIndexOf<byte>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_CHAR:
					case CorElementType.ELEMENT_TYPE_I2:
					case CorElementType.ELEMENT_TYPE_U2:
						num4 = GenericLastIndexOf<char>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_I4:
					case CorElementType.ELEMENT_TYPE_U4:
					case CorElementType.ELEMENT_TYPE_I:
					case CorElementType.ELEMENT_TYPE_U:
						num4 = GenericLastIndexOf<int>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_I8:
					case CorElementType.ELEMENT_TYPE_U8:
						num4 = GenericLastIndexOf<long>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_R4:
						num4 = GenericLastIndexOf<float>(array, value, adjustedIndex2, count);
						break;
					case CorElementType.ELEMENT_TYPE_R8:
						num4 = GenericLastIndexOf<double>(array, value, adjustedIndex2, count);
						break;
					}
					return ((num4 >= 0) ? num : lowerBound) + num4;
				}
			}
			for (int num5 = startIndex; num5 >= num; num5--)
			{
				object value2 = array.GetValue(num5);
				if (value2 == null)
				{
					if (value == null)
					{
						return num5;
					}
				}
				else if (value2.Equals(value))
				{
					return num5;
				}
			}
			return lowerBound - 1;
			static int GenericLastIndexOf<T>(Array array, object value, int adjustedIndex, int length) where T : struct, IEquatable<T>
			{
				return UnsafeArrayAsSpan<T>(array, adjustedIndex, length).LastIndexOf(Unsafe.As<byte, T>(ref value.GetRawData()));
			}
		}

		public static int LastIndexOf<T>(T[] array, T value)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return LastIndexOf(array, value, array.Length - 1, array.Length);
		}

		public static int LastIndexOf<T>(T[] array, T value, int startIndex)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			return LastIndexOf(array, value, startIndex, (array.Length != 0) ? (startIndex + 1) : 0);
		}

		public static int LastIndexOf<T>(T[] array, T value, int startIndex, int count)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (array.Length == 0)
			{
				if (startIndex != -1 && startIndex != 0)
				{
					ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
				}
				if (count != 0)
				{
					ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
				}
				return -1;
			}
			if ((uint)startIndex >= (uint)array.Length)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0 || startIndex - count + 1 < 0)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					int num = startIndex - count + 1;
					int num2 = SpanHelpers.LastIndexOf(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<byte[]>(array)), num), Unsafe.As<T, byte>(ref value), count);
					return ((num2 >= 0) ? num : 0) + num2;
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					int num3 = startIndex - count + 1;
					int num4 = SpanHelpers.LastIndexOf(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<char[]>(array)), num3), Unsafe.As<T, char>(ref value), count);
					return ((num4 >= 0) ? num3 : 0) + num4;
				}
				if (Unsafe.SizeOf<T>() == 4)
				{
					int num5 = startIndex - count + 1;
					int num6 = SpanHelpers.LastIndexOf(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<int[]>(array)), num5), Unsafe.As<T, int>(ref value), count);
					return ((num6 >= 0) ? num5 : 0) + num6;
				}
				if (Unsafe.SizeOf<T>() == 8)
				{
					int num7 = startIndex - count + 1;
					int num8 = SpanHelpers.LastIndexOf(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<long[]>(array)), num7), Unsafe.As<T, long>(ref value), count);
					return ((num8 >= 0) ? num7 : 0) + num8;
				}
			}
			return EqualityComparer<T>.Default.LastIndexOf(array, value, startIndex, count);
		}

		public static void Reverse(Array array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			Reverse(array, array.GetLowerBound(0), array.Length);
		}

		public static void Reverse(Array array, int index, int length)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			int lowerBound = array.GetLowerBound(0);
			if (index < lowerBound)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (length < 0)
			{
				ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
			}
			if (array.Length - (index - lowerBound) < length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowRankException(ExceptionResource.Rank_MultiDimNotSupported);
			}
			if (length <= 1)
			{
				return;
			}
			int adjustedIndex = index - lowerBound;
			switch (array.GetCorElementTypeOfElementType())
			{
			case CorElementType.ELEMENT_TYPE_BOOLEAN:
			case CorElementType.ELEMENT_TYPE_I1:
			case CorElementType.ELEMENT_TYPE_U1:
				UnsafeArrayAsSpan<byte>(array, adjustedIndex, length).Reverse();
				return;
			case CorElementType.ELEMENT_TYPE_CHAR:
			case CorElementType.ELEMENT_TYPE_I2:
			case CorElementType.ELEMENT_TYPE_U2:
				UnsafeArrayAsSpan<short>(array, adjustedIndex, length).Reverse();
				return;
			case CorElementType.ELEMENT_TYPE_I4:
			case CorElementType.ELEMENT_TYPE_U4:
			case CorElementType.ELEMENT_TYPE_R4:
			case CorElementType.ELEMENT_TYPE_I:
			case CorElementType.ELEMENT_TYPE_U:
				UnsafeArrayAsSpan<int>(array, adjustedIndex, length).Reverse();
				return;
			case CorElementType.ELEMENT_TYPE_I8:
			case CorElementType.ELEMENT_TYPE_U8:
			case CorElementType.ELEMENT_TYPE_R8:
				UnsafeArrayAsSpan<long>(array, adjustedIndex, length).Reverse();
				return;
			case CorElementType.ELEMENT_TYPE_ARRAY:
			case CorElementType.ELEMENT_TYPE_OBJECT:
			case CorElementType.ELEMENT_TYPE_SZARRAY:
				UnsafeArrayAsSpan<object>(array, adjustedIndex, length).Reverse();
				return;
			}
			int num = index;
			int num2 = index + length - 1;
			while (num < num2)
			{
				object value = array.GetValue(num);
				array.SetValue(array.GetValue(num2), num);
				array.SetValue(value, num2);
				num++;
				num2--;
			}
		}

		public static void Reverse<T>(T[] array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			Reverse(array, 0, array.Length);
		}

		public static void Reverse<T>(T[] array, int index, int length)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (length < 0)
			{
				ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
			}
			if (array.Length - index < length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (length > 1)
			{
				ref T reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index);
				ref T reference2 = ref Unsafe.Add(ref Unsafe.Add(ref reference, length), -1);
				do
				{
					T val = reference;
					reference = reference2;
					reference2 = val;
					reference = ref Unsafe.Add(ref reference, 1);
					reference2 = ref Unsafe.Add(ref reference2, -1);
				}
				while (Unsafe.IsAddressLessThan(ref reference, ref reference2));
			}
		}

		public static void Sort(Array array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			Sort(array, null, array.GetLowerBound(0), array.Length, null);
		}

		public static void Sort(Array keys, Array? items)
		{
			if (keys == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
			}
			Sort(keys, items, keys.GetLowerBound(0), keys.Length, null);
		}

		public static void Sort(Array array, int index, int length)
		{
			Sort(array, null, index, length, null);
		}

		public static void Sort(Array keys, Array? items, int index, int length)
		{
			Sort(keys, items, index, length, null);
		}

		public static void Sort(Array array, IComparer? comparer)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			Sort(array, null, array.GetLowerBound(0), array.Length, comparer);
		}

		public static void Sort(Array keys, Array? items, IComparer? comparer)
		{
			if (keys == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
			}
			Sort(keys, items, keys.GetLowerBound(0), keys.Length, comparer);
		}

		public static void Sort(Array array, int index, int length, IComparer? comparer)
		{
			Sort(array, null, index, length, comparer);
		}

		public static void Sort(Array keys, Array? items, int index, int length, IComparer? comparer)
		{
			if (keys == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
			}
			if (keys.Rank != 1 || (items != null && items.Rank != 1))
			{
				ThrowHelper.ThrowRankException(ExceptionResource.Rank_MultiDimNotSupported);
			}
			int lowerBound = keys.GetLowerBound(0);
			if (items != null && lowerBound != items.GetLowerBound(0))
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_LowerBoundsMustMatch);
			}
			if (index < lowerBound)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (length < 0)
			{
				ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
			}
			if (keys.Length - (index - lowerBound) < length || (items != null && index - lowerBound > items.Length - length))
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (length <= 1)
			{
				return;
			}
			if (comparer == null)
			{
				comparer = Comparer.Default;
			}
			if (keys is object[] keys2)
			{
				object[] array = items as object[];
				if (items == null || array != null)
				{
					new SorterObjectArray(keys2, array, comparer).Sort(index, length);
					return;
				}
			}
			if (comparer == Comparer.Default)
			{
				CorElementType corElementTypeOfElementType = keys.GetCorElementTypeOfElementType();
				if (items == null || items.GetCorElementTypeOfElementType() == corElementTypeOfElementType)
				{
					int adjustedIndex2 = index - lowerBound;
					switch (corElementTypeOfElementType)
					{
					case CorElementType.ELEMENT_TYPE_I1:
						GenericSort<sbyte>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_BOOLEAN:
					case CorElementType.ELEMENT_TYPE_U1:
						GenericSort<byte>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_I2:
						GenericSort<short>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_CHAR:
					case CorElementType.ELEMENT_TYPE_U2:
						GenericSort<ushort>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_I4:
					case CorElementType.ELEMENT_TYPE_I:
						GenericSort<int>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_U4:
					case CorElementType.ELEMENT_TYPE_U:
						GenericSort<uint>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_I8:
						GenericSort<long>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_U8:
						GenericSort<ulong>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_R4:
						GenericSort<float>(keys, items, adjustedIndex2, length);
						return;
					case CorElementType.ELEMENT_TYPE_R8:
						GenericSort<double>(keys, items, adjustedIndex2, length);
						return;
					}
				}
			}
			new SorterGenericArray(keys, items, comparer).Sort(index, length);
			static void GenericSort<T>(Array keys, Array items, int adjustedIndex, int length) where T : struct
			{
				Span<T> span = UnsafeArrayAsSpan<T>(keys, adjustedIndex, length);
				if (items != null)
				{
					span.Sort(UnsafeArrayAsSpan<T>(items, adjustedIndex, length));
				}
				else
				{
					span.Sort();
				}
			}
		}

		public static void Sort<T>(T[] array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (array.Length > 1)
			{
				Span<T> keys = new Span<T>(ref MemoryMarshal.GetArrayDataReference(array), array.Length);
				ArraySortHelper<T>.Default.Sort(keys, null);
			}
		}

		public static void Sort<TKey, TValue>(TKey[] keys, TValue[]? items)
		{
			if (keys == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
			}
			Sort(keys, items, 0, keys.Length, null);
		}

		public static void Sort<T>(T[] array, int index, int length)
		{
			Sort(array, index, length, null);
		}

		public static void Sort<TKey, TValue>(TKey[] keys, TValue[]? items, int index, int length)
		{
			Sort(keys, items, index, length, null);
		}

		public static void Sort<T>(T[] array, IComparer<T>? comparer)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			Sort(array, 0, array.Length, comparer);
		}

		public static void Sort<TKey, TValue>(TKey[] keys, TValue[]? items, IComparer<TKey>? comparer)
		{
			if (keys == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
			}
			Sort(keys, items, 0, keys.Length, comparer);
		}

		public static void Sort<T>(T[] array, int index, int length, IComparer<T>? comparer)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (length < 0)
			{
				ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
			}
			if (array.Length - index < length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (length > 1)
			{
				Span<T> keys = new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index), length);
				ArraySortHelper<T>.Default.Sort(keys, comparer);
			}
		}

		public static void Sort<TKey, TValue>(TKey[] keys, TValue[]? items, int index, int length, IComparer<TKey>? comparer)
		{
			if (keys == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keys);
			}
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (length < 0)
			{
				ThrowHelper.ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum();
			}
			if (keys.Length - index < length || (items != null && index > items.Length - length))
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (length > 1)
			{
				if (items == null)
				{
					Sort(keys, index, length, comparer);
					return;
				}
				Span<TKey> keys2 = new Span<TKey>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(keys), index), length);
				Span<TValue> values = new Span<TValue>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(items), index), length);
				ArraySortHelper<TKey, TValue>.Default.Sort(keys2, values, comparer);
			}
		}

		public static void Sort<T>(T[] array, Comparison<T> comparison)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (comparison == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparison);
			}
			Span<T> keys = new Span<T>(ref MemoryMarshal.GetArrayDataReference(array), array.Length);
			ArraySortHelper<T>.Sort(keys, comparison);
		}

		public static bool TrueForAll<T>(T[] array, Predicate<T> match)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (!match(array[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static Span<T> UnsafeArrayAsSpan<T>(Array array, int adjustedIndex, int length)
		{
			return new Span<T>(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), array.Length).Slice(adjustedIndex, length);
		}

		public System.Collections.IEnumerator GetEnumerator()
		{
			return new ArrayEnumerator(this);
		}
	}
	internal sealed class SZArrayHelper
	{
		private SZArrayHelper()
		{
		}

		internal IEnumerator<T> GetEnumerator<T>()
		{
			T[] array = Unsafe.As<T[]>(this);
			if (array.Length != 0)
			{
				return new SZGenericArrayEnumerator<T>(array);
			}
			return SZGenericArrayEnumerator<T>.Empty;
		}

		private void CopyTo<T>(T[] array, int index)
		{
			T[] array2 = Unsafe.As<T[]>(this);
			Array.Copy(array2, 0, array, index, array2.Length);
		}

		internal int get_Count<T>()
		{
			T[] array = Unsafe.As<T[]>(this);
			return array.Length;
		}

		internal T get_Item<T>(int index)
		{
			T[] array = Unsafe.As<T[]>(this);
			if ((uint)index >= (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return array[index];
		}

		internal void set_Item<T>(int index, T value)
		{
			T[] array = Unsafe.As<T[]>(this);
			if ((uint)index >= (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			array[index] = value;
		}

		private void Add<T>(T value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
		}

		private bool Contains<T>(T value)
		{
			T[] array = Unsafe.As<T[]>(this);
			return Array.IndexOf(array, value, 0, array.Length) >= 0;
		}

		private bool get_IsReadOnly<T>()
		{
			return true;
		}

		private void Clear<T>()
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}

		private int IndexOf<T>(T value)
		{
			T[] array = Unsafe.As<T[]>(this);
			return Array.IndexOf(array, value, 0, array.Length);
		}

		private void Insert<T>(int index, T value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
		}

		private bool Remove<T>(T value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
			return false;
		}

		private void RemoveAt<T>(int index)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
		}
	}
	[Serializable]
	[AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = false)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public abstract class Attribute
	{
		public virtual object TypeId => GetType();

		private static Attribute[] InternalGetCustomAttributes(PropertyInfo element, Type type, bool inherit)
		{
			Attribute[] array = (Attribute[])element.GetCustomAttributes(type, inherit);
			if (!inherit)
			{
				return array;
			}
			Type[] indexParameterTypes = GetIndexParameterTypes(element);
			PropertyInfo parentDefinition = GetParentDefinition(element, indexParameterTypes);
			if (parentDefinition == null)
			{
				return array;
			}
			Dictionary<Type, AttributeUsageAttribute> types = new Dictionary<Type, AttributeUsageAttribute>(11);
			List<Attribute> list = new List<Attribute>();
			CopyToAttributeList(list, array, types);
			do
			{
				array = GetCustomAttributes(parentDefinition, type, inherit: false);
				AddAttributesToList(list, array, types);
				parentDefinition = GetParentDefinition(parentDefinition, indexParameterTypes);
			}
			while (parentDefinition != null);
			Attribute[] array2 = CreateAttributeArrayHelper(type, list.Count);
			list.CopyTo(array2, 0);
			return array2;
		}

		private static bool InternalIsDefined(PropertyInfo element, Type attributeType, bool inherit)
		{
			if (element.IsDefined(attributeType, inherit))
			{
				return true;
			}
			if (inherit)
			{
				AttributeUsageAttribute attributeUsageAttribute = InternalGetAttributeUsage(attributeType);
				if (!attributeUsageAttribute.Inherited)
				{
					return false;
				}
				Type[] indexParameterTypes = GetIndexParameterTypes(element);
				PropertyInfo parentDefinition = GetParentDefinition(element, indexParameterTypes);
				while (parentDefinition != null)
				{
					if (parentDefinition.IsDefined(attributeType, inherit: false))
					{
						return true;
					}
					parentDefinition = GetParentDefinition(parentDefinition, indexParameterTypes);
				}
			}
			return false;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "rtPropAccessor.DeclaringType is guaranteed to have the specified property because rtPropAccessor.GetParentDefinition() returned a non-null MethodInfo.")]
		private static PropertyInfo GetParentDefinition(PropertyInfo property, Type[] propertyParameters)
		{
			MethodInfo methodInfo = property.GetGetMethod(nonPublic: true) ?? property.GetSetMethod(nonPublic: true);
			RuntimeMethodInfo runtimeMethodInfo = methodInfo as RuntimeMethodInfo;
			if (runtimeMethodInfo != null)
			{
				runtimeMethodInfo = runtimeMethodInfo.GetParentDefinition();
				if (runtimeMethodInfo != null)
				{
					return runtimeMethodInfo.DeclaringType.GetProperty(property.Name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, property.PropertyType, propertyParameters, null);
				}
			}
			return null;
		}

		private static Attribute[] InternalGetCustomAttributes(EventInfo element, Type type, bool inherit)
		{
			Attribute[] array = (Attribute[])element.GetCustomAttributes(type, inherit);
			if (!inherit)
			{
				return array;
			}
			EventInfo parentDefinition = GetParentDefinition(element);
			if (parentDefinition == null)
			{
				return array;
			}
			Dictionary<Type, AttributeUsageAttribute> types = new Dictionary<Type, AttributeUsageAttribute>(11);
			List<Attribute> list = new List<Attribute>();
			CopyToAttributeList(list, array, types);
			do
			{
				array = GetCustomAttributes(parentDefinition, type, inherit: false);
				AddAttributesToList(list, array, types);
				parentDefinition = GetParentDefinition(parentDefinition);
			}
			while (parentDefinition != null);
			Attribute[] array2 = CreateAttributeArrayHelper(type, list.Count);
			list.CopyTo(array2, 0);
			return array2;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "rtAdd.DeclaringType is guaranteed to have the specified event because rtAdd.GetParentDefinition() returned a non-null MethodInfo.")]
		private static EventInfo GetParentDefinition(EventInfo ev)
		{
			MethodInfo addMethod = ev.GetAddMethod(nonPublic: true);
			RuntimeMethodInfo runtimeMethodInfo = addMethod as RuntimeMethodInfo;
			if (runtimeMethodInfo != null)
			{
				runtimeMethodInfo = runtimeMethodInfo.GetParentDefinition();
				if (runtimeMethodInfo != null)
				{
					return runtimeMethodInfo.DeclaringType.GetEvent(ev.Name);
				}
			}
			return null;
		}

		private static bool InternalIsDefined(EventInfo element, Type attributeType, bool inherit)
		{
			if (element.IsDefined(attributeType, inherit))
			{
				return true;
			}
			if (inherit)
			{
				AttributeUsageAttribute attributeUsageAttribute = InternalGetAttributeUsage(attributeType);
				if (!attributeUsageAttribute.Inherited)
				{
					return false;
				}
				EventInfo parentDefinition = GetParentDefinition(element);
				while (parentDefinition != null)
				{
					if (parentDefinition.IsDefined(attributeType, inherit: false))
					{
						return true;
					}
					parentDefinition = GetParentDefinition(parentDefinition);
				}
			}
			return false;
		}

		private static ParameterInfo GetParentDefinition(ParameterInfo param)
		{
			RuntimeMethodInfo runtimeMethodInfo = param.Member as RuntimeMethodInfo;
			if (runtimeMethodInfo != null)
			{
				runtimeMethodInfo = runtimeMethodInfo.GetParentDefinition();
				if (runtimeMethodInfo != null)
				{
					int position = param.Position;
					if (position == -1)
					{
						return runtimeMethodInfo.ReturnParameter;
					}
					ParameterInfo[] parameters = runtimeMethodInfo.GetParameters();
					return parameters[position];
				}
			}
			return null;
		}

		private static Attribute[] InternalParamGetCustomAttributes(ParameterInfo param, Type type, bool inherit)
		{
			List<Type> list = new List<Type>();
			if ((object)type == null)
			{
				type = typeof(Attribute);
			}
			object[] customAttributes = param.GetCustomAttributes(type, inherit: false);
			for (int i = 0; i < customAttributes.Length; i++)
			{
				Type type2 = customAttributes[i].GetType();
				AttributeUsageAttribute attributeUsageAttribute = InternalGetAttributeUsage(type2);
				if (!attributeUsageAttribute.AllowMultiple)
				{
					list.Add(type2);
				}
			}
			Attribute[] array = ((customAttributes.Length != 0) ? ((Attribute[])customAttributes) : CreateAttributeArrayHelper(type, 0));
			if ((object)param.Member.DeclaringType == null)
			{
				return array;
			}
			if (!inherit)
			{
				return array;
			}
			for (ParameterInfo parentDefinition = GetParentDefinition(param); parentDefinition != null; parentDefinition = GetParentDefinition(parentDefinition))
			{
				customAttributes = parentDefinition.GetCustomAttributes(type, inherit: false);
				int num = 0;
				for (int j = 0; j < customAttributes.Length; j++)
				{
					Type type3 = customAttributes[j].GetType();
					AttributeUsageAttribute attributeUsageAttribute2 = InternalGetAttributeUsage(type3);
					if (attributeUsageAttribute2.Inherited && !list.Contains(type3))
					{
						if (!attributeUsageAttribute2.AllowMultiple)
						{
							list.Add(type3);
						}
						num++;
					}
					else
					{
						customAttributes[j] = null;
					}
				}
				Attribute[] array2 = CreateAttributeArrayHelper(type, num);
				num = 0;
				foreach (object obj in customAttributes)
				{
					if (obj != null)
					{
						array2[num] = (Attribute)obj;
						num++;
					}
				}
				Attribute[] array3 = array;
				array = CreateAttributeArrayHelper(type, array3.Length + num);
				Array.Copy(array3, array, array3.Length);
				int num2 = array3.Length;
				for (int l = 0; l < array2.Length; l++)
				{
					array[num2 + l] = array2[l];
				}
			}
			return array;
		}

		private static bool InternalParamIsDefined(ParameterInfo param, Type type, bool inherit)
		{
			if (param.IsDefined(type, inherit: false))
			{
				return true;
			}
			if ((object)param.Member.DeclaringType == null || !inherit)
			{
				return false;
			}
			for (ParameterInfo parentDefinition = GetParentDefinition(param); parentDefinition != null; parentDefinition = GetParentDefinition(parentDefinition))
			{
				object[] customAttributes = parentDefinition.GetCustomAttributes(type, inherit: false);
				for (int i = 0; i < customAttributes.Length; i++)
				{
					Type type2 = customAttributes[i].GetType();
					AttributeUsageAttribute attributeUsageAttribute = InternalGetAttributeUsage(type2);
					if (customAttributes[i] is Attribute && attributeUsageAttribute.Inherited)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static void CopyToAttributeList(List<Attribute> attributeList, Attribute[] attributes, Dictionary<Type, AttributeUsageAttribute> types)
		{
			for (int i = 0; i < attributes.Length; i++)
			{
				attributeList.Add(attributes[i]);
				Type type = attributes[i].GetType();
				if (!types.ContainsKey(type))
				{
					types[type] = InternalGetAttributeUsage(type);
				}
			}
		}

		private static Type[] GetIndexParameterTypes(PropertyInfo element)
		{
			ParameterInfo[] indexParameters = element.GetIndexParameters();
			if (indexParameters.Length != 0)
			{
				Type[] array = new Type[indexParameters.Length];
				for (int i = 0; i < indexParameters.Length; i++)
				{
					array[i] = indexParameters[i].ParameterType;
				}
				return array;
			}
			return Type.EmptyTypes;
		}

		private static void AddAttributesToList(List<Attribute> attributeList, Attribute[] attributes, Dictionary<Type, AttributeUsageAttribute> types)
		{
			for (int i = 0; i < attributes.Length; i++)
			{
				Type type = attributes[i].GetType();
				types.TryGetValue(type, out var value);
				if (value == null)
				{
					value = (types[type] = InternalGetAttributeUsage(type));
					if (value.Inherited)
					{
						attributeList.Add(attributes[i]);
					}
				}
				else if (value.Inherited && value.AllowMultiple)
				{
					attributeList.Add(attributes[i]);
				}
			}
		}

		private static AttributeUsageAttribute InternalGetAttributeUsage(Type type)
		{
			object[] customAttributes = type.GetCustomAttributes(typeof(AttributeUsageAttribute), inherit: false);
			if (customAttributes.Length == 1)
			{
				return (AttributeUsageAttribute)customAttributes[0];
			}
			if (customAttributes.Length == 0)
			{
				return AttributeUsageAttribute.Default;
			}
			throw new FormatException(SR.Format(SR.Format_AttributeUsage, type));
		}

		private static Attribute[] CreateAttributeArrayHelper(Type elementType, int elementCount)
		{
			return (Attribute[])Array.CreateInstance(elementType, elementCount);
		}

		public static Attribute[] GetCustomAttributes(MemberInfo element, Type attributeType)
		{
			return GetCustomAttributes(element, attributeType, inherit: true);
		}

		public static Attribute[] GetCustomAttributes(MemberInfo element, Type attributeType, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
			{
				throw new ArgumentException(SR.Argument_MustHaveAttributeBaseClass);
			}
			return element.MemberType switch
			{
				MemberTypes.Property => InternalGetCustomAttributes((PropertyInfo)element, attributeType, inherit), 
				MemberTypes.Event => InternalGetCustomAttributes((EventInfo)element, attributeType, inherit), 
				_ => element.GetCustomAttributes(attributeType, inherit) as Attribute[], 
			};
		}

		public static Attribute[] GetCustomAttributes(MemberInfo element)
		{
			return GetCustomAttributes(element, inherit: true);
		}

		public static Attribute[] GetCustomAttributes(MemberInfo element, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			return element.MemberType switch
			{
				MemberTypes.Property => InternalGetCustomAttributes((PropertyInfo)element, typeof(Attribute), inherit), 
				MemberTypes.Event => InternalGetCustomAttributes((EventInfo)element, typeof(Attribute), inherit), 
				_ => element.GetCustomAttributes(typeof(Attribute), inherit) as Attribute[], 
			};
		}

		public static bool IsDefined(MemberInfo element, Type attributeType)
		{
			return IsDefined(element, attributeType, inherit: true);
		}

		public static bool IsDefined(MemberInfo element, Type attributeType, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
			{
				throw new ArgumentException(SR.Argument_MustHaveAttributeBaseClass);
			}
			return element.MemberType switch
			{
				MemberTypes.Property => InternalIsDefined((PropertyInfo)element, attributeType, inherit), 
				MemberTypes.Event => InternalIsDefined((EventInfo)element, attributeType, inherit), 
				_ => element.IsDefined(attributeType, inherit), 
			};
		}

		public static Attribute? GetCustomAttribute(MemberInfo element, Type attributeType)
		{
			return GetCustomAttribute(element, attributeType, inherit: true);
		}

		public static Attribute? GetCustomAttribute(MemberInfo element, Type attributeType, bool inherit)
		{
			Attribute[] customAttributes = GetCustomAttributes(element, attributeType, inherit);
			if (customAttributes == null || customAttributes.Length == 0)
			{
				return null;
			}
			if (customAttributes.Length == 1)
			{
				return customAttributes[0];
			}
			throw new AmbiguousMatchException(SR.RFLCT_AmbigCust);
		}

		public static Attribute[] GetCustomAttributes(ParameterInfo element)
		{
			return GetCustomAttributes(element, inherit: true);
		}

		public static Attribute[] GetCustomAttributes(ParameterInfo element, Type attributeType)
		{
			return GetCustomAttributes(element, attributeType, inherit: true);
		}

		public static Attribute[] GetCustomAttributes(ParameterInfo element, Type attributeType, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
			{
				throw new ArgumentException(SR.Argument_MustHaveAttributeBaseClass);
			}
			if (element.Member == null)
			{
				throw new ArgumentException(SR.Argument_InvalidParameterInfo, "element");
			}
			MemberInfo member = element.Member;
			if (member.MemberType == MemberTypes.Method && inherit)
			{
				return InternalParamGetCustomAttributes(element, attributeType, inherit);
			}
			return element.GetCustomAttributes(attributeType, inherit) as Attribute[];
		}

		public static Attribute[] GetCustomAttributes(ParameterInfo element, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (element.Member == null)
			{
				throw new ArgumentException(SR.Argument_InvalidParameterInfo, "element");
			}
			MemberInfo member = element.Member;
			if (member.MemberType == MemberTypes.Method && inherit)
			{
				return InternalParamGetCustomAttributes(element, null, inherit);
			}
			return element.GetCustomAttributes(typeof(Attribute), inherit) as Attribute[];
		}

		public static bool IsDefined(ParameterInfo element, Type attributeType)
		{
			return IsDefined(element, attributeType, inherit: true);
		}

		public static bool IsDefined(ParameterInfo element, Type attributeType, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
			{
				throw new ArgumentException(SR.Argument_MustHaveAttributeBaseClass);
			}
			MemberInfo member = element.Member;
			return member.MemberType switch
			{
				MemberTypes.Method => InternalParamIsDefined(element, attributeType, inherit), 
				MemberTypes.Constructor => element.IsDefined(attributeType, inherit: false), 
				MemberTypes.Property => element.IsDefined(attributeType, inherit: false), 
				_ => throw new ArgumentException(SR.Argument_InvalidParamInfo), 
			};
		}

		public static Attribute? GetCustomAttribute(ParameterInfo element, Type attributeType)
		{
			return GetCustomAttribute(element, attributeType, inherit: true);
		}

		public static Attribute? GetCustomAttribute(ParameterInfo element, Type attributeType, bool inherit)
		{
			Attribute[] customAttributes = GetCustomAttributes(element, attributeType, inherit);
			if (customAttributes == null || customAttributes.Length == 0)
			{
				return null;
			}
			if (customAttributes.Length == 0)
			{
				return null;
			}
			if (customAttributes.Length == 1)
			{
				return customAttributes[0];
			}
			throw new AmbiguousMatchException(SR.RFLCT_AmbigCust);
		}

		public static Attribute[] GetCustomAttributes(Module element, Type attributeType)
		{
			return GetCustomAttributes(element, attributeType, inherit: true);
		}

		public static Attribute[] GetCustomAttributes(Module element)
		{
			return GetCustomAttributes(element, inherit: true);
		}

		public static Attribute[] GetCustomAttributes(Module element, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			return (Attribute[])element.GetCustomAttributes(typeof(Attribute), inherit);
		}

		public static Attribute[] GetCustomAttributes(Module element, Type attributeType, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
			{
				throw new ArgumentException(SR.Argument_MustHaveAttributeBaseClass);
			}
			return (Attribute[])element.GetCustomAttributes(attributeType, inherit);
		}

		public static bool IsDefined(Module element, Type attributeType)
		{
			return IsDefined(element, attributeType, inherit: false);
		}

		public static bool IsDefined(Module element, Type attributeType, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
			{
				throw new ArgumentException(SR.Argument_MustHaveAttributeBaseClass);
			}
			return element.IsDefined(attributeType, inherit: false);
		}

		public static Attribute? GetCustomAttribute(Module element, Type attributeType)
		{
			return GetCustomAttribute(element, attributeType, inherit: true);
		}

		public static Attribute? GetCustomAttribute(Module element, Type attributeType, bool inherit)
		{
			Attribute[] customAttributes = GetCustomAttributes(element, attributeType, inherit);
			if (customAttributes == null || customAttributes.Length == 0)
			{
				return null;
			}
			if (customAttributes.Length == 1)
			{
				return customAttributes[0];
			}
			throw new AmbiguousMatchException(SR.RFLCT_AmbigCust);
		}

		public static Attribute[] GetCustomAttributes(Assembly element, Type attributeType)
		{
			return GetCustomAttributes(element, attributeType, inherit: true);
		}

		public static Attribute[] GetCustomAttributes(Assembly element, Type attributeType, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
			{
				throw new ArgumentException(SR.Argument_MustHaveAttributeBaseClass);
			}
			return (Attribute[])element.GetCustomAttributes(attributeType, inherit);
		}

		public static Attribute[] GetCustomAttributes(Assembly element)
		{
			return GetCustomAttributes(element, inherit: true);
		}

		public static Attribute[] GetCustomAttributes(Assembly element, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			return (Attribute[])element.GetCustomAttributes(typeof(Attribute), inherit);
		}

		public static bool IsDefined(Assembly element, Type attributeType)
		{
			return IsDefined(element, attributeType, inherit: true);
		}

		public static bool IsDefined(Assembly element, Type attributeType, bool inherit)
		{
			if (element == null)
			{
				throw new ArgumentNullException("element");
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (!attributeType.IsSubclassOf(typeof(Attribute)) && attributeType != typeof(Attribute))
			{
				throw new ArgumentException(SR.Argument_MustHaveAttributeBaseClass);
			}
			return element.IsDefined(attributeType, inherit: false);
		}

		public static Attribute? GetCustomAttribute(Assembly element, Type attributeType)
		{
			return GetCustomAttribute(element, attributeType, inherit: true);
		}

		public static Attribute? GetCustomAttribute(Assembly element, Type attributeType, bool inherit)
		{
			Attribute[] customAttributes = GetCustomAttributes(element, attributeType, inherit);
			if (customAttributes == null || customAttributes.Length == 0)
			{
				return null;
			}
			if (customAttributes.Length == 1)
			{
				return customAttributes[0];
			}
			throw new AmbiguousMatchException(SR.RFLCT_AmbigCust);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "Unused fields don't make a difference for equality")]
		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (GetType() != obj.GetType())
			{
				return false;
			}
			Type type = GetType();
			while (type != typeof(Attribute))
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				for (int i = 0; i < fields.Length; i++)
				{
					object value = fields[i].GetValue(this);
					object value2 = fields[i].GetValue(obj);
					if (!AreFieldValuesEqual(value, value2))
					{
						return false;
					}
				}
				type = type.BaseType;
			}
			return true;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "Unused fields don't make a difference for hashcode quality")]
		public override int GetHashCode()
		{
			Type type = GetType();
			while (type != typeof(Attribute))
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				object obj = null;
				for (int i = 0; i < fields.Length; i++)
				{
					object value = fields[i].GetValue(this);
					if (value != null && !value.GetType().IsArray)
					{
						obj = value;
					}
					if (obj != null)
					{
						break;
					}
				}
				if (obj != null)
				{
					return obj.GetHashCode();
				}
				type = type.BaseType;
			}
			return type.GetHashCode();
		}

		private static bool AreFieldValuesEqual(object thisValue, object thatValue)
		{
			if (thisValue == null && thatValue == null)
			{
				return true;
			}
			if (thisValue == null || thatValue == null)
			{
				return false;
			}
			Type type = thisValue.GetType();
			if (type.IsArray)
			{
				if (!type.Equals(thatValue.GetType()))
				{
					return false;
				}
				Array array = (Array)thisValue;
				Array array2 = (Array)thatValue;
				if (array.Length != array2.Length)
				{
					return false;
				}
				for (int i = 0; i < array.Length; i++)
				{
					if (!AreFieldValuesEqual(array.GetValue(i), array2.GetValue(i)))
					{
						return false;
					}
				}
			}
			else if (!thisValue.Equals(thatValue))
			{
				return false;
			}
			return true;
		}

		public virtual bool Match(object? obj)
		{
			return Equals(obj);
		}

		public virtual bool IsDefaultAttribute()
		{
			return false;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class BadImageFormatException : SystemException
	{
		private readonly string _fileName;

		private readonly string _fusionLog;

		public override string Message
		{
			get
			{
				SetMessageField();
				return _message;
			}
		}

		public string? FileName => _fileName;

		public string? FusionLog => _fusionLog;

		private BadImageFormatException(string fileName, int hResult)
			: base(null)
		{
			base.HResult = hResult;
			_fileName = fileName;
			SetMessageField();
		}

		public BadImageFormatException()
			: base(SR.Arg_BadImageFormatException)
		{
			base.HResult = -2147024885;
		}

		public BadImageFormatException(string? message)
			: base(message)
		{
			base.HResult = -2147024885;
		}

		public BadImageFormatException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147024885;
		}

		public BadImageFormatException(string? message, string? fileName)
			: base(message)
		{
			base.HResult = -2147024885;
			_fileName = fileName;
		}

		public BadImageFormatException(string? message, string? fileName, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147024885;
			_fileName = fileName;
		}

		protected BadImageFormatException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_fileName = info.GetString("BadImageFormat_FileName");
			_fusionLog = info.GetString("BadImageFormat_FusionLog");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("BadImageFormat_FileName", _fileName, typeof(string));
			info.AddValue("BadImageFormat_FusionLog", _fusionLog, typeof(string));
		}

		private void SetMessageField()
		{
			if (_message == null)
			{
				if (_fileName == null && base.HResult == -2146233088)
				{
					_message = SR.Arg_BadImageFormatException;
				}
				else
				{
					_message = FileLoadException.FormatFileLoadExceptionMessage(_fileName, base.HResult);
				}
			}
		}

		public override string ToString()
		{
			string text = GetType().ToString() + ": " + Message;
			if (!string.IsNullOrEmpty(_fileName))
			{
				text = text + "\r\n" + SR.Format(SR.IO_FileName_Name, _fileName);
			}
			if (base.InnerException != null)
			{
				text = text + " ---> " + base.InnerException.ToString();
			}
			if (StackTrace != null)
			{
				text = text + "\r\n" + StackTrace;
			}
			if (_fusionLog != null)
			{
				if (text == null)
				{
					text = " ";
				}
				text = text + "\r\n\r\n" + _fusionLog;
			}
			return text;
		}
	}
	public static class Buffer
	{
		[StructLayout(LayoutKind.Sequential, Size = 16)]
		private struct Block16
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 64)]
		private struct Block64
		{
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal unsafe static void _ZeroMemory(ref byte b, nuint byteLength)
		{
			fixed (byte* b2 = &b)
			{
				__ZeroMemory(b2, byteLength);
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void __ZeroMemory(void* b, nuint byteLength);

		internal static void BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount)
		{
			if (byteCount <= 16384)
			{
				__BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
			}
			else
			{
				_BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void _BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount)
		{
			if (Unsafe.AreSame(ref source, ref destination))
			{
				return;
			}
			if ((nuint)(nint)Unsafe.ByteOffset(ref source, ref destination) >= byteCount)
			{
				do
				{
					byteCount -= 16384;
					__BulkMoveWithWriteBarrier(ref destination, ref source, 16384u);
					destination = ref Unsafe.AddByteOffset(ref destination, 16384u);
					source = ref Unsafe.AddByteOffset(ref source, 16384u);
				}
				while (byteCount > 16384);
			}
			else
			{
				do
				{
					byteCount -= 16384;
					__BulkMoveWithWriteBarrier(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), 16384u);
				}
				while (byteCount > 16384);
			}
			__BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void __BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void __Memmove(byte* dest, byte* src, nuint len);

		internal unsafe static void Memcpy(byte* dest, byte* src, int len)
		{
			Memmove(ref *dest, ref *src, (uint)len);
		}

		internal unsafe static void Memcpy(byte* pDest, int destIndex, byte[] src, int srcIndex, int len)
		{
			Memmove(ref pDest[(uint)destIndex], ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(src), (nint)(uint)srcIndex), (uint)len);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Memmove<T>(ref T destination, ref T source, nuint elementCount)
		{
			if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				Memmove(ref Unsafe.As<T, byte>(ref destination), ref Unsafe.As<T, byte>(ref source), elementCount * (nuint)Unsafe.SizeOf<T>());
			}
			else
			{
				BulkMoveWithWriteBarrier(ref Unsafe.As<T, byte>(ref destination), ref Unsafe.As<T, byte>(ref source), elementCount * (nuint)Unsafe.SizeOf<T>());
			}
		}

		public static void BlockCopy(Array src, int srcOffset, Array dst, int dstOffset, int count)
		{
			if (src == null)
			{
				throw new ArgumentNullException("src");
			}
			if (dst == null)
			{
				throw new ArgumentNullException("dst");
			}
			nuint num = src.NativeLength;
			if (src.GetType() != typeof(byte[]))
			{
				if (!src.GetCorElementTypeOfElementType().IsPrimitiveType())
				{
					throw new ArgumentException(SR.Arg_MustBePrimArray, "src");
				}
				num *= src.GetElementSize();
			}
			nuint num2 = num;
			if (src != dst)
			{
				num2 = dst.NativeLength;
				if (dst.GetType() != typeof(byte[]))
				{
					if (!dst.GetCorElementTypeOfElementType().IsPrimitiveType())
					{
						throw new ArgumentException(SR.Arg_MustBePrimArray, "dst");
					}
					num2 *= dst.GetElementSize();
				}
			}
			if (srcOffset < 0)
			{
				throw new ArgumentOutOfRangeException("srcOffset", SR.ArgumentOutOfRange_MustBeNonNegInt32);
			}
			if (dstOffset < 0)
			{
				throw new ArgumentOutOfRangeException("dstOffset", SR.ArgumentOutOfRange_MustBeNonNegInt32);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_MustBeNonNegInt32);
			}
			nuint num3 = (nuint)count;
			nuint num4 = (nuint)srcOffset;
			nuint num5 = (nuint)dstOffset;
			if (num < num4 + num3 || num2 < num5 + num3)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			Memmove(ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(dst), num5), ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(src), num4), num3);
		}

		public static int ByteLength(Array array)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (!array.GetCorElementTypeOfElementType().IsPrimitiveType())
			{
				throw new ArgumentException(SR.Arg_MustBePrimArray, "array");
			}
			nuint num = array.NativeLength * array.GetElementSize();
			return checked((int)num);
		}

		public static byte GetByte(Array array, int index)
		{
			if ((uint)index >= (uint)ByteLength(array))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index);
		}

		public static void SetByte(Array array, int index, byte value)
		{
			if ((uint)index >= (uint)ByteLength(array))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index) = value;
		}

		internal unsafe static void ZeroMemory(byte* dest, nuint len)
		{
			SpanHelpers.ClearWithoutReferences(ref *dest, len);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public unsafe static void MemoryCopy(void* source, void* destination, long destinationSizeInBytes, long sourceBytesToCopy)
		{
			if (sourceBytesToCopy > destinationSizeInBytes)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.sourceBytesToCopy);
			}
			Memmove(ref *(byte*)destination, ref *(byte*)source, checked((nuint)sourceBytesToCopy));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public unsafe static void MemoryCopy(void* source, void* destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy)
		{
			if (sourceBytesToCopy > destinationSizeInBytes)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.sourceBytesToCopy);
			}
			Memmove(ref *(byte*)destination, ref *(byte*)source, checked((nuint)sourceBytesToCopy));
		}

		internal static void Memmove(ref byte dest, ref byte src, nuint len)
		{
			if ((nuint)(nint)Unsafe.ByteOffset(ref src, ref dest) >= len && (nuint)(nint)Unsafe.ByteOffset(ref dest, ref src) >= len)
			{
				ref byte source = ref Unsafe.Add(ref src, (nint)len);
				ref byte source2 = ref Unsafe.Add(ref dest, (nint)len);
				if (len > 16)
				{
					if (len > 64)
					{
						if (len > 2048)
						{
							goto IL_0211;
						}
						nuint num = len >> 6;
						do
						{
							Unsafe.As<byte, Block64>(ref dest) = Unsafe.As<byte, Block64>(ref src);
							dest = ref Unsafe.Add(ref dest, 64);
							src = ref Unsafe.Add(ref src, 64);
							num--;
						}
						while (num != 0);
						len %= 64;
						if (len <= 16)
						{
							Unsafe.As<byte, Block16>(ref Unsafe.Add(ref source2, -16)) = Unsafe.As<byte, Block16>(ref Unsafe.Add(ref source, -16));
							return;
						}
					}
					Unsafe.As<byte, Block16>(ref dest) = Unsafe.As<byte, Block16>(ref src);
					if (len > 32)
					{
						Unsafe.As<byte, Block16>(ref Unsafe.Add(ref dest, 16)) = Unsafe.As<byte, Block16>(ref Unsafe.Add(ref src, 16));
						if (len > 48)
						{
							Unsafe.As<byte, Block16>(ref Unsafe.Add(ref dest, 32)) = Unsafe.As<byte, Block16>(ref Unsafe.Add(ref src, 32));
						}
					}
					Unsafe.As<byte, Block16>(ref Unsafe.Add(ref source2, -16)) = Unsafe.As<byte, Block16>(ref Unsafe.Add(ref source, -16));
				}
				else if ((len & 0x18) != 0)
				{
					Unsafe.As<byte, int>(ref dest) = Unsafe.As<byte, int>(ref src);
					Unsafe.As<byte, int>(ref Unsafe.Add(ref dest, 4)) = Unsafe.As<byte, int>(ref Unsafe.Add(ref src, 4));
					Unsafe.As<byte, int>(ref Unsafe.Add(ref source2, -8)) = Unsafe.As<byte, int>(ref Unsafe.Add(ref source, -8));
					Unsafe.As<byte, int>(ref Unsafe.Add(ref source2, -4)) = Unsafe.As<byte, int>(ref Unsafe.Add(ref source, -4));
				}
				else if ((len & 4) != 0)
				{
					Unsafe.As<byte, int>(ref dest) = Unsafe.As<byte, int>(ref src);
					Unsafe.As<byte, int>(ref Unsafe.Add(ref source2, -4)) = Unsafe.As<byte, int>(ref Unsafe.Add(ref source, -4));
				}
				else if (len != 0)
				{
					dest = src;
					if ((len & 2) != 0)
					{
						Unsafe.As<byte, short>(ref Unsafe.Add(ref source2, -2)) = Unsafe.As<byte, short>(ref Unsafe.Add(ref source, -2));
					}
				}
				return;
			}
			if (Unsafe.AreSame(ref dest, ref src))
			{
				return;
			}
			goto IL_0211;
			IL_0211:
			_Memmove(ref dest, ref src, len);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe static void _Memmove(ref byte dest, ref byte src, nuint len)
		{
			fixed (byte* dest2 = &dest)
			{
				fixed (byte* src2 = &src)
				{
					__Memmove(dest2, src2, len);
				}
			}
		}
	}
	internal struct Currency
	{
		internal long m_value;

		public Currency(decimal value)
		{
			m_value = decimal.ToOACurrency(value);
		}
	}
	[Serializable]
	[NonVersionable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Decimal : ISpanFormattable, IFormattable, IComparable, IConvertible, IComparable<decimal>, IEquatable<decimal>, ISerializable, IDeserializationCallback, IMinMaxValue<decimal>, ISignedNumber<decimal>, INumber<decimal>, IAdditionOperators<decimal, decimal, decimal>, IAdditiveIdentity<decimal, decimal>, IComparisonOperators<decimal, decimal>, IEqualityOperators<decimal, decimal>, IDecrementOperators<decimal>, IDivisionOperators<decimal, decimal, decimal>, IIncrementOperators<decimal>, IModulusOperators<decimal, decimal, decimal>, IMultiplicativeIdentity<decimal, decimal>, IMultiplyOperators<decimal, decimal, decimal>, ISpanParseable<decimal>, IParseable<decimal>, ISubtractionOperators<decimal, decimal, decimal>, IUnaryNegationOperators<decimal, decimal>, IUnaryPlusOperators<decimal, decimal>
	{
		[StructLayout(LayoutKind.Explicit)]
		private struct DecCalc
		{
			private struct PowerOvfl
			{
				public readonly uint Hi;

				public readonly ulong MidLo;

				public PowerOvfl(uint hi, uint mid, uint lo)
				{
					Hi = hi;
					MidLo = ((ulong)mid << 32) + lo;
				}
			}

			[StructLayout(LayoutKind.Explicit)]
			private struct Buf12
			{
				[FieldOffset(0)]
				public uint U0;

				[FieldOffset(4)]
				public uint U1;

				[FieldOffset(8)]
				public uint U2;

				[FieldOffset(0)]
				private ulong ulo64LE;

				[FieldOffset(4)]
				private ulong uhigh64LE;

				public ulong Low64
				{
					get
					{
						return ulo64LE;
					}
					set
					{
						ulo64LE = value;
					}
				}

				public ulong High64
				{
					get
					{
						return uhigh64LE;
					}
					set
					{
						uhigh64LE = value;
					}
				}
			}

			[StructLayout(LayoutKind.Explicit)]
			private struct Buf16
			{
				[FieldOffset(0)]
				public uint U0;

				[FieldOffset(4)]
				public uint U1;

				[FieldOffset(8)]
				public uint U2;

				[FieldOffset(12)]
				public uint U3;

				[FieldOffset(0)]
				private ulong ulo64LE;

				[FieldOffset(8)]
				private ulong uhigh64LE;

				public ulong Low64
				{
					get
					{
						return ulo64LE;
					}
					set
					{
						ulo64LE = value;
					}
				}

				public ulong High64
				{
					get
					{
						return uhigh64LE;
					}
					set
					{
						uhigh64LE = value;
					}
				}
			}

			[StructLayout(LayoutKind.Explicit)]
			private struct Buf24
			{
				[FieldOffset(0)]
				public uint U0;

				[FieldOffset(4)]
				public uint U1;

				[FieldOffset(8)]
				public uint U2;

				[FieldOffset(12)]
				public uint U3;

				[FieldOffset(16)]
				public uint U4;

				[FieldOffset(20)]
				public uint U5;

				[FieldOffset(0)]
				private ulong ulo64LE;

				[FieldOffset(8)]
				private ulong umid64LE;

				[FieldOffset(16)]
				private ulong uhigh64LE;

				public ulong Low64
				{
					get
					{
						return ulo64LE;
					}
					set
					{
						ulo64LE = value;
					}
				}

				public ulong Mid64
				{
					set
					{
						umid64LE = value;
					}
				}

				public ulong High64
				{
					set
					{
						uhigh64LE = value;
					}
				}
			}

			private struct Buf28
			{
				public Buf24 Buf24;

				public uint U6;
			}

			[FieldOffset(0)]
			private uint uflags;

			[FieldOffset(4)]
			private uint uhi;

			[FieldOffset(8)]
			private uint ulo;

			[FieldOffset(12)]
			private uint umid;

			[FieldOffset(8)]
			private ulong ulomid;

			private static readonly uint[] s_powers10 = new uint[10] { 1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u, 10000000u, 100000000u, 1000000000u };

			private static readonly ulong[] s_ulongPowers10 = new ulong[19]
			{
				10uL, 100uL, 1000uL, 10000uL, 100000uL, 1000000uL, 10000000uL, 100000000uL, 1000000000uL, 10000000000uL,
				100000000000uL, 1000000000000uL, 10000000000000uL, 100000000000000uL, 1000000000000000uL, 10000000000000000uL, 100000000000000000uL, 1000000000000000000uL, 10000000000000000000uL
			};

			private static readonly double[] s_doublePowers10 = new double[81]
			{
				1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
				10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 1E+17, 1E+18, 1E+19,
				1E+20, 1E+21, 1E+22, 1E+23, 1E+24, 1E+25, 1E+26, 1E+27, 1E+28, 1E+29,
				1E+30, 1E+31, 1E+32, 1E+33, 1E+34, 1E+35, 1E+36, 1E+37, 1E+38, 1E+39,
				1E+40, 1E+41, 1E+42, 1E+43, 1E+44, 1E+45, 1E+46, 1E+47, 1E+48, 1E+49,
				1E+50, 1E+51, 1E+52, 1E+53, 1E+54, 1E+55, 1E+56, 1E+57, 1E+58, 1E+59,
				1E+60, 1E+61, 1E+62, 1E+63, 1E+64, 1E+65, 1E+66, 1E+67, 1E+68, 1E+69,
				1E+70, 1E+71, 1E+72, 1E+73, 1E+74, 1E+75, 1E+76, 1E+77, 1E+78, 1E+79,
				1E+80
			};

			private static readonly PowerOvfl[] PowerOvflValues = new PowerOvfl[8]
			{
				new PowerOvfl(429496729u, 2576980377u, 2576980377u),
				new PowerOvfl(42949672u, 4123168604u, 687194767u),
				new PowerOvfl(4294967u, 1271310319u, 2645699854u),
				new PowerOvfl(429496u, 3133608139u, 694066715u),
				new PowerOvfl(42949u, 2890341191u, 2216890319u),
				new PowerOvfl(4294u, 4154504685u, 2369172679u),
				new PowerOvfl(429u, 2133437386u, 4102387834u),
				new PowerOvfl(42u, 4078814305u, 410238783u)
			};

			private uint High
			{
				get
				{
					return uhi;
				}
				set
				{
					uhi = value;
				}
			}

			private uint Low
			{
				get
				{
					return ulo;
				}
				set
				{
					ulo = value;
				}
			}

			private uint Mid
			{
				get
				{
					return umid;
				}
				set
				{
					umid = value;
				}
			}

			private bool IsNegative => (int)uflags < 0;

			private int Scale => (byte)(uflags >> 16);

			private ulong Low64
			{
				get
				{
					return ulomid;
				}
				set
				{
					ulomid = value;
				}
			}

			private unsafe static uint GetExponent(float f)
			{
				return (byte)(*(uint*)(&f) >> 23);
			}

			private unsafe static uint GetExponent(double d)
			{
				return (uint)(int)((ulong)(*(long*)(&d)) >> 52) & 0x7FFu;
			}

			private static ulong UInt32x32To64(uint a, uint b)
			{
				return (ulong)a * (ulong)b;
			}

			private static void UInt64x64To128(ulong a, ulong b, ref DecCalc result)
			{
				ulong num = UInt32x32To64((uint)a, (uint)b);
				ulong num2 = UInt32x32To64((uint)a, (uint)(b >> 32));
				ulong num3 = UInt32x32To64((uint)(a >> 32), (uint)(b >> 32));
				num3 += num2 >> 32;
				num += (num2 <<= 32);
				if (num < num2)
				{
					num3++;
				}
				num2 = UInt32x32To64((uint)(a >> 32), (uint)b);
				num3 += num2 >> 32;
				num += (num2 <<= 32);
				if (num < num2)
				{
					num3++;
				}
				if (num3 > uint.MaxValue)
				{
					Number.ThrowOverflowException(TypeCode.Decimal);
				}
				result.Low64 = num;
				result.High = (uint)num3;
			}

			private static uint Div96By32(ref Buf12 bufNum, uint den)
			{
				ulong high;
				ulong num2;
				if (bufNum.U2 != 0)
				{
					high = bufNum.High64;
					num2 = (bufNum.High64 = high / den);
					high = (high - (uint)((int)num2 * (int)den) << 32) | bufNum.U0;
					if (high == 0L)
					{
						return 0u;
					}
					return (uint)(int)high - (bufNum.U0 = (uint)(high / den)) * den;
				}
				high = bufNum.Low64;
				if (high == 0L)
				{
					return 0u;
				}
				num2 = (bufNum.Low64 = high / den);
				return (uint)(high - num2 * den);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static bool Div96ByConst(ref ulong high64, ref uint low, uint pow)
			{
				if (high64 <= uint.MaxValue)
				{
					uint num = (uint)high64;
					uint num2 = num / pow;
					num = num - num2 * pow << 16;
					num += low >> 16;
					uint num3 = num / pow;
					num = num - num3 * pow << 16;
					num += (ushort)low;
					uint num4 = num / pow;
					if (num == num4 * pow)
					{
						high64 = num2;
						low = (num3 << 16) + num4;
						return true;
					}
				}
				else
				{
					uint num = (uint)(high64 >> 32);
					uint num5 = num / pow;
					num = num - num5 * pow << 16;
					num += (uint)high64 >> 16;
					uint num2 = num / pow;
					num = num - num2 * pow << 16;
					num += (ushort)high64;
					uint num4 = num / pow;
					num = num - num4 * pow << 16;
					num2 = num4 + (num2 << 16);
					num += low >> 16;
					uint num3 = num / pow;
					num = num - num3 * pow << 16;
					num += (ushort)low;
					num4 = num / pow;
					if (num == num4 * pow)
					{
						high64 = ((ulong)num5 << 32) | num2;
						low = (num3 << 16) + num4;
						return true;
					}
				}
				return false;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static void Unscale(ref uint low, ref ulong high64, ref int scale)
			{
				while ((low & 0xF) == 0 && scale >= 4 && Div96ByConst(ref high64, ref low, 10000u))
				{
					scale -= 4;
				}
				if ((low & 3) == 0 && scale >= 2 && Div96ByConst(ref high64, ref low, 100u))
				{
					scale -= 2;
				}
				if ((low & 1) == 0 && scale >= 1 && Div96ByConst(ref high64, ref low, 10u))
				{
					scale--;
				}
			}

			private static uint Div96By64(ref Buf12 bufNum, ulong den)
			{
				uint u = bufNum.U2;
				uint num;
				ulong low;
				if (u == 0)
				{
					low = bufNum.Low64;
					if (low < den)
					{
						return 0u;
					}
					num = (uint)(low / den);
					low -= num * den;
					bufNum.Low64 = low;
					return num;
				}
				uint num2 = (uint)(den >> 32);
				if (u >= num2)
				{
					low = bufNum.Low64;
					low -= den << 32;
					num = 0u;
					do
					{
						num--;
						low += den;
					}
					while (low >= den);
					bufNum.Low64 = low;
					return num;
				}
				ulong high = bufNum.High64;
				if (high < num2)
				{
					return 0u;
				}
				num = (uint)(high / num2);
				low = bufNum.U0 | (high - num * num2 << 32);
				ulong num3 = UInt32x32To64(num, (uint)den);
				low -= num3;
				if (low > ~num3)
				{
					do
					{
						num--;
						low += den;
					}
					while (low >= den);
				}
				bufNum.Low64 = low;
				return num;
			}

			private static uint Div128By96(ref Buf16 bufNum, ref Buf12 bufDen)
			{
				ulong high = bufNum.High64;
				uint u = bufDen.U2;
				if (high < u)
				{
					return 0u;
				}
				uint num = (uint)(high / u);
				uint num2 = (uint)(int)high - num * u;
				ulong num3 = UInt32x32To64(num, bufDen.U0);
				ulong num4 = UInt32x32To64(num, bufDen.U1);
				num4 += num3 >> 32;
				num3 = (uint)num3 | (num4 << 32);
				num4 >>= 32;
				ulong low = bufNum.Low64;
				low -= num3;
				num2 -= (uint)(int)num4;
				if (low > ~num3)
				{
					num2--;
					if (num2 >= (uint)(~num4))
					{
						goto IL_008b;
					}
				}
				else if (num2 > (uint)(~num4))
				{
					goto IL_008b;
				}
				goto IL_00b4;
				IL_008b:
				num3 = bufDen.Low64;
				do
				{
					num--;
					low += num3;
					num2 += u;
				}
				while ((low >= num3 || num2++ >= u) && num2 >= u);
				goto IL_00b4;
				IL_00b4:
				bufNum.Low64 = low;
				bufNum.U2 = num2;
				return num;
			}

			private static uint IncreaseScale(ref Buf12 bufNum, uint power)
			{
				ulong num = UInt32x32To64(bufNum.U0, power);
				bufNum.U0 = (uint)num;
				num >>= 32;
				num += UInt32x32To64(bufNum.U1, power);
				bufNum.U1 = (uint)num;
				num >>= 32;
				num += UInt32x32To64(bufNum.U2, power);
				bufNum.U2 = (uint)num;
				return (uint)(num >> 32);
			}

			private static void IncreaseScale64(ref Buf12 bufNum, uint power)
			{
				ulong num = UInt32x32To64(bufNum.U0, power);
				bufNum.U0 = (uint)num;
				num >>= 32;
				num += UInt32x32To64(bufNum.U1, power);
				bufNum.High64 = num;
			}

			private unsafe static int ScaleResult(Buf24* bufRes, uint hiRes, int scale)
			{
				int num = 0;
				if (hiRes > 2)
				{
					num = (int)(hiRes * 32 - 64 - 1);
					num -= BitOperations.LeadingZeroCount(*(uint*)((byte*)bufRes + (long)hiRes * 4L));
					num = (num * 77 >> 8) + 1;
					if (num > scale)
					{
						goto IL_014e;
					}
				}
				if (num < scale - 28)
				{
					num = scale - 28;
				}
				if (num == 0)
				{
					goto IL_014c;
				}
				scale -= num;
				uint num2 = 0u;
				uint remainder = 0u;
				while (true)
				{
					num2 |= remainder;
					uint num3 = num switch
					{
						1 => DivByConst((uint*)bufRes, hiRes, out var quotient, out remainder, 10u), 
						2 => DivByConst((uint*)bufRes, hiRes, out quotient, out remainder, 100u), 
						3 => DivByConst((uint*)bufRes, hiRes, out quotient, out remainder, 1000u), 
						_ => DivByConst((uint*)bufRes, hiRes, out quotient, out remainder, 10000u), 
					};
					*(uint*)((byte*)bufRes + (long)hiRes * 4L) = quotient;
					if (quotient == 0 && hiRes != 0)
					{
						hiRes--;
					}
					num -= 4;
					if (num > 0)
					{
						continue;
					}
					if (hiRes > 2)
					{
						if (scale == 0)
						{
							break;
						}
						num = 1;
						scale--;
						continue;
					}
					num3 >>= 1;
					if (num3 <= remainder && (num3 < remainder || ((*(uint*)bufRes & (true ? 1u : 0u)) | num2) != 0) && ++(*(int*)bufRes) == 0)
					{
						uint num4 = 0u;
						while (++(*(int*)((byte*)bufRes + (long)(++num4) * 4L)) == 0)
						{
						}
						if (num4 > 2)
						{
							if (scale == 0)
							{
								break;
							}
							hiRes = num4;
							num2 = 0u;
							remainder = 0u;
							num = 1;
							scale--;
							continue;
						}
					}
					goto IL_014c;
				}
				goto IL_014e;
				IL_014c:
				return scale;
				IL_014e:
				Number.ThrowOverflowException(TypeCode.Decimal);
				return 0;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private unsafe static uint DivByConst(uint* result, uint hiRes, out uint quotient, out uint remainder, uint power)
			{
				uint num = result[hiRes];
				remainder = num - (quotient = num / power) * power;
				uint num2 = hiRes - 1;
				while ((int)num2 >= 0)
				{
					uint num3 = *(ushort*)((byte*)result + num2 * 4 + 2) + (remainder << 16);
					uint num4 = num3 / power;
					remainder = num3 - num4 * power;
					*(ushort*)((byte*)result + num2 * 4 + 2) = (ushort)num4;
					num3 = *(ushort*)((byte*)result + num2 * 4) + (remainder << 16);
					num4 = num3 / power;
					remainder = num3 - num4 * power;
					*(ushort*)((byte*)result + num2 * 4) = (ushort)num4;
					num2--;
				}
				return power;
			}

			private static int OverflowUnscale(ref Buf12 bufQuo, int scale, bool sticky)
			{
				if (--scale < 0)
				{
					Number.ThrowOverflowException(TypeCode.Decimal);
				}
				bufQuo.U2 = 429496729u;
				ulong num = 25769803776uL + (ulong)bufQuo.U1;
				num = (num - (bufQuo.U1 = (uint)(num / 10)) * 10 << 32) + bufQuo.U0;
				uint num2 = (uint)(num - (bufQuo.U0 = (uint)(num / 10)) * 10);
				if (num2 > 5 || (num2 == 5 && (sticky || (bufQuo.U0 & (true ? 1u : 0u)) != 0)))
				{
					Add32To96(ref bufQuo, 1u);
				}
				return scale;
			}

			private static int SearchScale(ref Buf12 bufQuo, int scale)
			{
				uint u = bufQuo.U2;
				ulong low = bufQuo.Low64;
				int num = 0;
				if (u <= 429496729)
				{
					PowerOvfl[] powerOvflValues = PowerOvflValues;
					if (scale > 19)
					{
						num = 28 - scale;
						if (u < powerOvflValues[num - 1].Hi)
						{
							goto IL_00d1;
						}
					}
					else if (u < 4 || (u == 4 && low <= 5441186219426131129L))
					{
						return 9;
					}
					if (u > 42949)
					{
						if (u > 4294967)
						{
							num = 2;
							if (u > 42949672)
							{
								num--;
							}
						}
						else
						{
							num = 4;
							if (u > 429496)
							{
								num--;
							}
						}
					}
					else if (u > 429)
					{
						num = 6;
						if (u > 4294)
						{
							num--;
						}
					}
					else
					{
						num = 8;
						if (u > 42)
						{
							num--;
						}
					}
					if (u == powerOvflValues[num - 1].Hi && low > powerOvflValues[num - 1].MidLo)
					{
						num--;
					}
				}
				goto IL_00d1;
				IL_00d1:
				if (num + scale < 0)
				{
					Number.ThrowOverflowException(TypeCode.Decimal);
				}
				return num;
			}

			private static bool Add32To96(ref Buf12 bufNum, uint value)
			{
				if ((bufNum.Low64 += value) < value && ++bufNum.U2 == 0)
				{
					return false;
				}
				return true;
			}

			internal unsafe static void DecAddSub(ref DecCalc d1, ref DecCalc d2, bool sign)
			{
				ulong num = d1.Low64;
				uint num2 = d1.High;
				uint num3 = d1.uflags;
				uint num4 = d2.uflags;
				uint num5 = num4 ^ num3;
				sign ^= (num5 & 0x80000000u) != 0;
				int num7;
				if ((num5 & 0xFF0000u) != 0)
				{
					uint num6 = num3;
					num3 = (num4 & 0xFF0000u) | (num3 & 0x80000000u);
					num7 = (int)(num3 - num6) >> 16;
					if (num7 < 0)
					{
						num7 = -num7;
						num3 = num6;
						if (sign)
						{
							num3 ^= 0x80000000u;
						}
						num = d2.Low64;
						num2 = d2.High;
						d2 = d1;
					}
					if (num2 != 0)
					{
						goto IL_015f;
					}
					if (num > uint.MaxValue)
					{
						goto IL_0106;
					}
					if ((int)num == 0)
					{
						uint num8 = num3 & 0x80000000u;
						if (sign)
						{
							num8 ^= 0x80000000u;
						}
						d1 = d2;
						d1.uflags = (d2.uflags & 0xFF0000u) | num8;
						return;
					}
					while (num7 > 9)
					{
						num7 -= 9;
						num = UInt32x32To64((uint)num, 1000000000u);
						if (num <= uint.MaxValue)
						{
							continue;
						}
						goto IL_0106;
					}
					num = UInt32x32To64((uint)num, s_powers10[num7]);
				}
				goto IL_0450;
				IL_03b1:
				if ((num3 & 0xFF0000) == 0)
				{
					Number.ThrowOverflowException(TypeCode.Decimal);
				}
				num3 -= 65536;
				ulong num9 = (ulong)num2 + 4294967296uL;
				num2 = (uint)(num9 / 10);
				num9 = (num9 - num2 * 10 << 32) + (num >> 32);
				uint num10 = (uint)(num9 / 10);
				num9 = (num9 - num10 * 10 << 32) + (uint)num;
				num = num10;
				num <<= 32;
				num10 = (uint)(num9 / 10);
				num += num10;
				num10 = (uint)(int)num9 - num10 * 10;
				if (num10 >= 5 && (num10 > 5 || (num & 1) != 0L) && ++num == 0L)
				{
					num2++;
				}
				goto IL_04b9;
				IL_0350:
				Buf24 value;
				value.Low64 = num;
				value.U2 = num2;
				uint num11;
				num7 = ScaleResult(&value, num11, (byte)(num3 >> 16));
				num3 = (num3 & 0xFF00FFFFu) | (uint)(num7 << 16);
				num = value.Low64;
				num2 = value.U2;
				goto IL_04b9;
				IL_0106:
				ulong num13;
				while (true)
				{
					uint b = 1000000000u;
					if (num7 < 9)
					{
						b = s_powers10[num7];
					}
					ulong num12 = UInt32x32To64((uint)num, b);
					num13 = UInt32x32To64((uint)(num >> 32), b) + (num12 >> 32);
					num = (uint)num12 + (num13 << 32);
					num2 = (uint)(num13 >> 32);
					if ((num7 -= 9) <= 0)
					{
						break;
					}
					if (num2 == 0)
					{
						continue;
					}
					goto IL_015f;
				}
				goto IL_0450;
				IL_0312:
				uint* ptr = (uint*)(&value);
				uint num14 = 3u;
				while (++ptr[num14++] == 0)
				{
					if (num11 < num14)
					{
						ptr[num14] = 1u;
						num11 = num14;
						break;
					}
				}
				goto IL_0350;
				IL_015f:
				while (true)
				{
					uint b = 1000000000u;
					if (num7 < 9)
					{
						b = s_powers10[num7];
					}
					ulong num12 = UInt32x32To64((uint)num, b);
					num13 = UInt32x32To64((uint)(num >> 32), b) + (num12 >> 32);
					num = (uint)num12 + (num13 << 32);
					num13 >>= 32;
					num13 += UInt32x32To64(num2, b);
					num7 -= 9;
					if (num13 > uint.MaxValue)
					{
						break;
					}
					num2 = (uint)num13;
					if (num7 > 0)
					{
						continue;
					}
					goto IL_0450;
				}
				Unsafe.SkipInit<Buf24>(out value);
				value.Low64 = num;
				value.Mid64 = num13;
				num11 = 3u;
				while (num7 > 0)
				{
					uint b = 1000000000u;
					if (num7 < 9)
					{
						b = s_powers10[num7];
					}
					num13 = 0uL;
					uint* ptr2 = (uint*)(&value);
					uint num15 = 0u;
					do
					{
						num13 += UInt32x32To64(ptr2[num15], b);
						ptr2[num15] = (uint)num13;
						num15++;
						num13 >>= 32;
					}
					while (num15 <= num11);
					if ((uint)num13 != 0)
					{
						ptr2[++num11] = (uint)num13;
					}
					num7 -= 9;
				}
				num13 = value.Low64;
				num = d2.Low64;
				uint u = value.U2;
				num2 = d2.High;
				if (sign)
				{
					num = num13 - num;
					num2 = u - num2;
					if (num > num13)
					{
						num2--;
						if (num2 >= u)
						{
							goto IL_02b3;
						}
					}
					else if (num2 > u)
					{
						goto IL_02b3;
					}
				}
				else
				{
					num += num13;
					num2 += u;
					if (num < num13)
					{
						num2++;
						if (num2 <= u)
						{
							goto IL_0312;
						}
					}
					else if (num2 < u)
					{
						goto IL_0312;
					}
				}
				goto IL_0350;
				IL_0394:
				num3 ^= 0x80000000u;
				num2 = ~num2;
				num = 0L - num;
				if (num == 0L)
				{
					num2++;
				}
				goto IL_04b9;
				IL_0450:
				ulong num16 = num;
				uint num17 = num2;
				if (sign)
				{
					num = num16 - d2.Low64;
					num2 = num17 - d2.High;
					if (num > num16)
					{
						num2--;
						if (num2 >= num17)
						{
							goto IL_0394;
						}
					}
					else if (num2 > num17)
					{
						goto IL_0394;
					}
				}
				else
				{
					num = num16 + d2.Low64;
					num2 = num17 + d2.High;
					if (num < num16)
					{
						num2++;
						if (num2 <= num17)
						{
							goto IL_03b1;
						}
					}
					else if (num2 < num17)
					{
						goto IL_03b1;
					}
				}
				goto IL_04b9;
				IL_04b9:
				d1.uflags = num3;
				d1.High = num2;
				d1.Low64 = num;
				return;
				IL_02b3:
				uint* ptr3 = (uint*)(&value);
				uint num18 = 3u;
				while (ptr3[num18++]-- == 0)
				{
				}
				if (ptr3[num11] != 0 || --num11 > 2)
				{
					goto IL_0350;
				}
				goto IL_04b9;
			}

			internal static long VarCyFromDec(ref DecCalc pdecIn)
			{
				int num = pdecIn.Scale - 4;
				long num4;
				if (num < 0)
				{
					if (pdecIn.High == 0)
					{
						uint a = s_powers10[-num];
						ulong num2 = UInt32x32To64(a, pdecIn.Mid);
						if (num2 <= uint.MaxValue)
						{
							ulong num3 = UInt32x32To64(a, pdecIn.Low);
							num3 += (num2 <<= 32);
							if (num3 >= num2)
							{
								num4 = (long)num3;
								goto IL_006d;
							}
						}
					}
				}
				else
				{
					if (num != 0)
					{
						InternalRound(ref pdecIn, (uint)num, MidpointRounding.ToEven);
					}
					if (pdecIn.High == 0)
					{
						num4 = (long)pdecIn.Low64;
						goto IL_006d;
					}
				}
				goto IL_0093;
				IL_006d:
				if (num4 >= 0 || (num4 == long.MinValue && pdecIn.IsNegative))
				{
					if (pdecIn.IsNegative)
					{
						num4 = -num4;
					}
					return num4;
				}
				goto IL_0093;
				IL_0093:
				throw new OverflowException(SR.Overflow_Currency);
			}

			internal static int VarDecCmp(in decimal d1, in decimal d2)
			{
				if ((d2.Low64 | d2.High) == 0L)
				{
					if ((d1.Low64 | d1.High) == 0L)
					{
						return 0;
					}
					return (d1._flags >> 31) | 1;
				}
				if ((d1.Low64 | d1.High) == 0L)
				{
					return -((d2._flags >> 31) | 1);
				}
				int num = (d1._flags >> 31) - (d2._flags >> 31);
				if (num != 0)
				{
					return num;
				}
				return VarDecCmpSub(in d1, in d2);
			}

			private static int VarDecCmpSub(in decimal d1, in decimal d2)
			{
				int flags = d2._flags;
				int num = (flags >> 31) | 1;
				int num2 = flags - d1._flags;
				ulong num3 = d1.Low64;
				uint num4 = d1.High;
				ulong num5 = d2.Low64;
				uint num6 = d2.High;
				if (num2 != 0)
				{
					num2 >>= 16;
					if (num2 < 0)
					{
						num2 = -num2;
						num = -num;
						ulong num7 = num3;
						num3 = num5;
						num5 = num7;
						uint num8 = num4;
						num4 = num6;
						num6 = num8;
					}
					do
					{
						uint b = ((num2 >= 9) ? 1000000000u : s_powers10[num2]);
						ulong num9 = UInt32x32To64((uint)num3, b);
						ulong num10 = UInt32x32To64((uint)(num3 >> 32), b) + (num9 >> 32);
						num3 = (uint)num9 + (num10 << 32);
						num10 >>= 32;
						num10 += UInt32x32To64(num4, b);
						if (num10 > uint.MaxValue)
						{
							return num;
						}
						num4 = (uint)num10;
					}
					while ((num2 -= 9) > 0);
				}
				uint num11 = num4 - num6;
				if (num11 != 0)
				{
					if (num11 > num4)
					{
						num = -num;
					}
					return num;
				}
				ulong num12 = num3 - num5;
				if (num12 == 0L)
				{
					num = 0;
				}
				else if (num12 > num3)
				{
					num = -num;
				}
				return num;
			}

			internal unsafe static void VarDecMul(ref DecCalc d1, ref DecCalc d2)
			{
				int num = (byte)(d1.uflags + d2.uflags >> 16);
				Unsafe.SkipInit<Buf24>(out var value);
				uint num6;
				if ((d1.High | d1.Mid) == 0)
				{
					ulong num4;
					if ((d2.High | d2.Mid) == 0)
					{
						ulong num2 = UInt32x32To64(d1.Low, d2.Low);
						if (num > 28)
						{
							if (num > 47)
							{
								goto IL_03b4;
							}
							num -= 29;
							ulong num3 = s_ulongPowers10[num];
							num4 = num2 / num3;
							ulong num5 = num2 - num4 * num3;
							num2 = num4;
							num3 >>= 1;
							if (num5 >= num3 && (num5 > num3 || ((uint)(int)num2 & (true ? 1u : 0u)) != 0))
							{
								num2++;
							}
							num = 28;
						}
						d1.Low64 = num2;
						d1.uflags = ((d2.uflags ^ d1.uflags) & 0x80000000u) | (uint)(num << 16);
						return;
					}
					num4 = UInt32x32To64(d1.Low, d2.Low);
					value.U0 = (uint)num4;
					num4 = UInt32x32To64(d1.Low, d2.Mid) + (num4 >> 32);
					value.U1 = (uint)num4;
					num4 >>= 32;
					if (d2.High != 0)
					{
						num4 += UInt32x32To64(d1.Low, d2.High);
						if (num4 > uint.MaxValue)
						{
							value.Mid64 = num4;
							num6 = 3u;
							goto IL_0368;
						}
					}
					value.U2 = (uint)num4;
					num6 = 2u;
				}
				else if ((d2.High | d2.Mid) == 0)
				{
					ulong num4 = UInt32x32To64(d2.Low, d1.Low);
					value.U0 = (uint)num4;
					num4 = UInt32x32To64(d2.Low, d1.Mid) + (num4 >> 32);
					value.U1 = (uint)num4;
					num4 >>= 32;
					if (d1.High != 0)
					{
						num4 += UInt32x32To64(d2.Low, d1.High);
						if (num4 > uint.MaxValue)
						{
							value.Mid64 = num4;
							num6 = 3u;
							goto IL_0368;
						}
					}
					value.U2 = (uint)num4;
					num6 = 2u;
				}
				else
				{
					ulong num4 = UInt32x32To64(d1.Low, d2.Low);
					value.U0 = (uint)num4;
					ulong num7 = UInt32x32To64(d1.Low, d2.Mid) + (num4 >> 32);
					num4 = UInt32x32To64(d1.Mid, d2.Low);
					num4 += num7;
					value.U1 = (uint)num4;
					num7 = ((num4 >= num7) ? (num4 >> 32) : ((num4 >> 32) | 0x100000000uL));
					num4 = UInt32x32To64(d1.Mid, d2.Mid) + num7;
					if ((d1.High | d2.High) != 0)
					{
						num7 = UInt32x32To64(d1.Low, d2.High);
						num4 += num7;
						uint num8 = 0u;
						if (num4 < num7)
						{
							num8 = 1u;
						}
						num7 = UInt32x32To64(d1.High, d2.Low);
						num4 += num7;
						value.U2 = (uint)num4;
						if (num4 < num7)
						{
							num8++;
						}
						num7 = ((ulong)num8 << 32) | (num4 >> 32);
						num4 = UInt32x32To64(d1.Mid, d2.High);
						num4 += num7;
						num8 = 0u;
						if (num4 < num7)
						{
							num8 = 1u;
						}
						num7 = UInt32x32To64(d1.High, d2.Mid);
						num4 += num7;
						value.U3 = (uint)num4;
						if (num4 < num7)
						{
							num8++;
						}
						num4 = ((ulong)num8 << 32) | (num4 >> 32);
						value.High64 = UInt32x32To64(d1.High, d2.High) + num4;
						num6 = 5u;
					}
					else
					{
						value.Mid64 = num4;
						num6 = 3u;
					}
				}
				uint* ptr = (uint*)(&value);
				while (ptr[(int)num6] == 0)
				{
					if (num6 != 0)
					{
						num6--;
						continue;
					}
					goto IL_03b4;
				}
				goto IL_0368;
				IL_0368:
				if (num6 > 2 || num > 28)
				{
					num = ScaleResult(&value, num6, num);
				}
				d1.Low64 = value.Low64;
				d1.High = value.U2;
				d1.uflags = ((d2.uflags ^ d1.uflags) & 0x80000000u) | (uint)(num << 16);
				return;
				IL_03b4:
				d1 = default(DecCalc);
			}

			internal static void VarDecFromR4(float input, out DecCalc result)
			{
				result = default(DecCalc);
				int num = (int)(GetExponent(input) - 126);
				if (num < -94)
				{
					return;
				}
				if (num > 96)
				{
					Number.ThrowOverflowException(TypeCode.Decimal);
				}
				uint num2 = 0u;
				if (input < 0f)
				{
					input = 0f - input;
					num2 = 2147483648u;
				}
				double num3 = input;
				int num4 = 6 - (num * 19728 >> 16);
				if (num4 >= 0)
				{
					if (num4 > 28)
					{
						num4 = 28;
					}
					num3 *= s_doublePowers10[num4];
				}
				else if (num4 != -1 || num3 >= 10000000.0)
				{
					num3 /= s_doublePowers10[-num4];
				}
				else
				{
					num4 = 0;
				}
				if (num3 < 1000000.0 && num4 < 28)
				{
					num3 *= 10.0;
					num4++;
				}
				uint num5;
				if (Sse41.IsSupported)
				{
					num5 = (uint)(int)Math.Round(num3);
				}
				else
				{
					num5 = (uint)(int)num3;
					num3 -= (double)(int)num5;
					if (num3 > 0.5 || (num3 == 0.5 && (num5 & (true ? 1u : 0u)) != 0))
					{
						num5++;
					}
				}
				if (num5 == 0)
				{
					return;
				}
				if (num4 < 0)
				{
					num4 = -num4;
					if (num4 < 10)
					{
						result.Low64 = UInt32x32To64(num5, s_powers10[num4]);
					}
					else if (num4 > 18)
					{
						ulong a = UInt32x32To64(num5, s_powers10[num4 - 18]);
						UInt64x64To128(a, 1000000000000000000uL, ref result);
					}
					else
					{
						ulong num6 = UInt32x32To64(num5, s_powers10[num4 - 9]);
						ulong num7 = UInt32x32To64(1000000000u, (uint)(num6 >> 32));
						num6 = UInt32x32To64(1000000000u, (uint)num6);
						result.Low = (uint)num6;
						num7 += num6 >> 32;
						result.Mid = (uint)num7;
						num7 >>= 32;
						result.High = (uint)num7;
					}
				}
				else
				{
					int num8 = num4;
					if (num8 > 6)
					{
						num8 = 6;
					}
					if ((num5 & 0xF) == 0 && num8 >= 4)
					{
						uint num9 = num5 / 10000;
						if (num5 == num9 * 10000)
						{
							num5 = num9;
							num4 -= 4;
							num8 -= 4;
						}
					}
					if ((num5 & 3) == 0 && num8 >= 2)
					{
						uint num10 = num5 / 100;
						if (num5 == num10 * 100)
						{
							num5 = num10;
							num4 -= 2;
							num8 -= 2;
						}
					}
					if ((num5 & 1) == 0 && num8 >= 1)
					{
						uint num11 = num5 / 10;
						if (num5 == num11 * 10)
						{
							num5 = num11;
							num4--;
						}
					}
					num2 |= (uint)(num4 << 16);
					result.Low = num5;
				}
				result.uflags = num2;
			}

			internal static void VarDecFromR8(double input, out DecCalc result)
			{
				result = default(DecCalc);
				int num = (int)(GetExponent(input) - 1022);
				if (num < -94)
				{
					return;
				}
				if (num > 96)
				{
					Number.ThrowOverflowException(TypeCode.Decimal);
				}
				uint num2 = 0u;
				if (input < 0.0)
				{
					input = 0.0 - input;
					num2 = 2147483648u;
				}
				double num3 = input;
				int num4 = 14 - (num * 19728 >> 16);
				if (num4 >= 0)
				{
					if (num4 > 28)
					{
						num4 = 28;
					}
					num3 *= s_doublePowers10[num4];
				}
				else if (num4 != -1 || num3 >= 1000000000000000.0)
				{
					num3 /= s_doublePowers10[-num4];
				}
				else
				{
					num4 = 0;
				}
				if (num3 < 100000000000000.0 && num4 < 28)
				{
					num3 *= 10.0;
					num4++;
				}
				ulong num5;
				if (Sse41.IsSupported)
				{
					num5 = (ulong)(long)Math.Round(num3);
				}
				else
				{
					num5 = (ulong)(long)num3;
					num3 -= (double)(long)num5;
					if (num3 > 0.5 || (num3 == 0.5 && (num5 & 1) != 0L))
					{
						num5++;
					}
				}
				if (num5 == 0L)
				{
					return;
				}
				if (num4 < 0)
				{
					num4 = -num4;
					if (num4 < 10)
					{
						uint b = s_powers10[num4];
						ulong num6 = UInt32x32To64((uint)num5, b);
						ulong num7 = UInt32x32To64((uint)(num5 >> 32), b);
						result.Low = (uint)num6;
						num7 += num6 >> 32;
						result.Mid = (uint)num7;
						num7 >>= 32;
						result.High = (uint)num7;
					}
					else
					{
						UInt64x64To128(num5, s_ulongPowers10[num4 - 1], ref result);
					}
				}
				else
				{
					int num8 = num4;
					if (num8 > 14)
					{
						num8 = 14;
					}
					if ((byte)num5 == 0 && num8 >= 8)
					{
						ulong num9 = num5 / 100000000;
						if ((uint)num5 == (uint)(num9 * 100000000))
						{
							num5 = num9;
							num4 -= 8;
							num8 -= 8;
						}
					}
					if (((int)num5 & 0xF) == 0 && num8 >= 4)
					{
						ulong num10 = num5 / 10000;
						if ((uint)num5 == (uint)(num10 * 10000))
						{
							num5 = num10;
							num4 -= 4;
							num8 -= 4;
						}
					}
					if (((int)num5 & 3) == 0 && num8 >= 2)
					{
						ulong num11 = num5 / 100;
						if ((uint)num5 == (uint)(num11 * 100))
						{
							num5 = num11;
							num4 -= 2;
							num8 -= 2;
						}
					}
					if (((int)num5 & 1) == 0 && num8 >= 1)
					{
						ulong num12 = num5 / 10;
						if ((uint)num5 == (uint)(num12 * 10))
						{
							num5 = num12;
							num4--;
						}
					}
					num2 |= (uint)(num4 << 16);
					result.Low64 = num5;
				}
				result.uflags = num2;
			}

			internal static float VarR4FromDec(in decimal value)
			{
				return (float)VarR8FromDec(in value);
			}

			internal static double VarR8FromDec(in decimal value)
			{
				double num = ((double)value.Low64 + (double)value.High * 1.8446744073709552E+19) / s_doublePowers10[value.Scale];
				if (value.IsNegative)
				{
					num = 0.0 - num;
				}
				return num;
			}

			internal static int GetHashCode(in decimal d)
			{
				if ((d.Low64 | d.High) == 0L)
				{
					return 0;
				}
				uint flags = (uint)d._flags;
				if ((flags & 0xFF0000) == 0 || (d.Low & (true ? 1u : 0u)) != 0)
				{
					return (int)(flags ^ d.High ^ d.Mid ^ d.Low);
				}
				int scale = (byte)(flags >> 16);
				uint low = d.Low;
				ulong high = ((ulong)d.High << 32) | d.Mid;
				Unscale(ref low, ref high, ref scale);
				flags = (flags & 0xFF00FFFFu) | (uint)(scale << 16);
				return (int)flags ^ (int)(high >> 32) ^ (int)high ^ (int)low;
			}

			internal unsafe static void VarDecDiv(ref DecCalc d1, ref DecCalc d2)
			{
				Unsafe.SkipInit<Buf12>(out var value);
				int scale = (sbyte)(d1.uflags - d2.uflags >> 16);
				bool flag = false;
				uint low;
				uint num;
				Buf16 value2;
				ulong num7;
				Buf12 value3;
				uint num6;
				if ((d2.High | d2.Mid) == 0)
				{
					low = d2.Low;
					if (low == 0)
					{
						throw new DivideByZeroException();
					}
					value.Low64 = d1.Low64;
					value.U2 = d1.High;
					num = Div96By32(ref value, low);
					while (true)
					{
						int num2;
						if (num == 0)
						{
							if (scale >= 0)
							{
								break;
							}
							num2 = Math.Min(9, -scale);
						}
						else
						{
							flag = true;
							if (scale == 28 || (num2 = SearchScale(ref value, scale)) == 0)
							{
								goto IL_0090;
							}
						}
						uint num3 = s_powers10[num2];
						scale += num2;
						if (IncreaseScale(ref value, num3) == 0)
						{
							ulong num4 = UInt32x32To64(num, num3);
							uint num5 = (uint)(num4 / low);
							num = (uint)(int)num4 - num5 * low;
							if (!Add32To96(ref value, num5))
							{
								scale = OverflowUnscale(ref value, scale, num != 0);
								break;
							}
							continue;
						}
						goto IL_04ab;
					}
				}
				else
				{
					num6 = d2.High;
					if (num6 == 0)
					{
						num6 = d2.Mid;
					}
					int num2 = BitOperations.LeadingZeroCount(num6);
					Unsafe.SkipInit<Buf16>(out value2);
					value2.Low64 = d1.Low64 << num2;
					value2.High64 = d1.Mid + ((ulong)d1.High << 32) >> 32 - num2;
					num7 = d2.Low64 << num2;
					if (d2.High == 0)
					{
						value.U2 = 0u;
						value.U1 = Div96By64(ref *(Buf12*)(&value2.U1), num7);
						value.U0 = Div96By64(ref *(Buf12*)(&value2), num7);
						while (true)
						{
							if (value2.Low64 == 0L)
							{
								if (scale >= 0)
								{
									break;
								}
								num2 = Math.Min(9, -scale);
							}
							else
							{
								flag = true;
								if (scale == 28 || (num2 = SearchScale(ref value, scale)) == 0)
								{
									goto IL_01e8;
								}
							}
							uint num3 = s_powers10[num2];
							scale += num2;
							if (IncreaseScale(ref value, num3) == 0)
							{
								IncreaseScale64(ref *(Buf12*)(&value2), num3);
								num6 = Div96By64(ref *(Buf12*)(&value2), num7);
								if (!Add32To96(ref value, num6))
								{
									scale = OverflowUnscale(ref value, scale, value2.Low64 != 0);
									break;
								}
								continue;
							}
							goto IL_04ab;
						}
					}
					else
					{
						Unsafe.SkipInit<Buf12>(out value3);
						value3.Low64 = num7;
						value3.U2 = (uint)(d2.Mid + ((ulong)d2.High << 32) >> 32 - num2);
						value.Low64 = Div128By96(ref value2, ref value3);
						value.U2 = 0u;
						while (true)
						{
							if ((value2.Low64 | value2.U2) == 0L)
							{
								if (scale >= 0)
								{
									break;
								}
								num2 = Math.Min(9, -scale);
							}
							else
							{
								flag = true;
								if (scale == 28 || (num2 = SearchScale(ref value, scale)) == 0)
								{
									goto IL_0302;
								}
							}
							uint num3 = s_powers10[num2];
							scale += num2;
							if (IncreaseScale(ref value, num3) == 0)
							{
								value2.U3 = IncreaseScale(ref *(Buf12*)(&value2), num3);
								num6 = Div128By96(ref value2, ref value3);
								if (!Add32To96(ref value, num6))
								{
									scale = OverflowUnscale(ref value, scale, (value2.Low64 | value2.High64) != 0);
									break;
								}
								continue;
							}
							goto IL_04ab;
						}
					}
				}
				goto IL_03f3;
				IL_01e8:
				ulong low2 = value2.Low64;
				if ((long)low2 >= 0L && (low2 <<= 1) <= num7 && (low2 != num7 || (value.U0 & 1) == 0))
				{
					goto IL_03f3;
				}
				goto IL_046a;
				IL_0090:
				num6 = num << 1;
				if (num6 >= num && (num6 < low || (num6 <= low && (value.U0 & 1) == 0)))
				{
					goto IL_03f3;
				}
				goto IL_046a;
				IL_0302:
				if ((int)value2.U2 >= 0)
				{
					num6 = value2.U1 >> 31;
					value2.Low64 <<= 1;
					value2.U2 = (value2.U2 << 1) + num6;
					if (value2.U2 <= value3.U2 && (value2.U2 != value3.U2 || (value2.Low64 <= value3.Low64 && (value2.Low64 != value3.Low64 || (value.U0 & 1) == 0))))
					{
						goto IL_03f3;
					}
				}
				goto IL_046a;
				IL_04ab:
				Number.ThrowOverflowException(TypeCode.Decimal);
				return;
				IL_046a:
				if (++value.Low64 == 0L && ++value.U2 == 0)
				{
					scale = OverflowUnscale(ref value, scale, sticky: true);
				}
				goto IL_03f3;
				IL_03f3:
				if (flag)
				{
					uint low3 = value.U0;
					ulong high = value.High64;
					Unscale(ref low3, ref high, ref scale);
					d1.Low = low3;
					d1.Mid = (uint)high;
					d1.High = (uint)(high >> 32);
				}
				else
				{
					d1.Low64 = value.Low64;
					d1.High = value.U2;
				}
				d1.uflags = ((d1.uflags ^ d2.uflags) & 0x80000000u) | (uint)(scale << 16);
			}

			internal static void VarDecMod(ref DecCalc d1, ref DecCalc d2)
			{
				if ((d2.ulo | d2.umid | d2.uhi) == 0)
				{
					throw new DivideByZeroException();
				}
				if ((d1.ulo | d1.umid | d1.uhi) == 0)
				{
					return;
				}
				d2.uflags = (d2.uflags & 0x7FFFFFFFu) | (d1.uflags & 0x80000000u);
				int num = VarDecCmpSub(in Unsafe.As<DecCalc, decimal>(ref d1), in Unsafe.As<DecCalc, decimal>(ref d2));
				if (num == 0)
				{
					d1.ulo = 0u;
					d1.umid = 0u;
					d1.uhi = 0u;
					if (d2.uflags > d1.uflags)
					{
						d1.uflags = d2.uflags;
					}
				}
				else
				{
					if ((int)((uint)num ^ (d1.uflags & 0x80000000u)) < 0)
					{
						return;
					}
					int num2 = (sbyte)(d1.uflags - d2.uflags >> 16);
					if (num2 > 0)
					{
						do
						{
							uint num3 = ((num2 >= 9) ? 1000000000u : s_powers10[num2]);
							ulong num4 = UInt32x32To64(d2.Low, num3);
							d2.Low = (uint)num4;
							num4 >>= 32;
							num4 += (d2.Mid + ((ulong)d2.High << 32)) * num3;
							d2.Mid = (uint)num4;
							d2.High = (uint)(num4 >> 32);
						}
						while ((num2 -= 9) > 0);
						num2 = 0;
					}
					do
					{
						if (num2 < 0)
						{
							d1.uflags = d2.uflags;
							Unsafe.SkipInit<Buf12>(out var value);
							value.Low64 = d1.Low64;
							value.U2 = d1.High;
							uint num6;
							do
							{
								int num5 = SearchScale(ref value, 28 + num2);
								if (num5 == 0)
								{
									break;
								}
								num6 = ((num5 >= 9) ? 1000000000u : s_powers10[num5]);
								num2 += num5;
								ulong num7 = UInt32x32To64(value.U0, num6);
								value.U0 = (uint)num7;
								num7 >>= 32;
								value.High64 = num7 + value.High64 * num6;
							}
							while (num6 == 1000000000 && num2 < 0);
							d1.Low64 = value.Low64;
							d1.High = value.U2;
						}
						if (d1.High == 0)
						{
							d1.Low64 %= d2.Low64;
							break;
						}
						if ((d2.High | d2.Mid) == 0)
						{
							uint low = d2.Low;
							ulong num8 = ((ulong)d1.High << 32) | d1.Mid;
							num8 = (num8 % low << 32) | d1.Low;
							d1.Low64 = num8 % low;
							d1.High = 0u;
							continue;
						}
						VarDecModFull(ref d1, ref d2, num2);
						break;
					}
					while (num2 < 0);
				}
			}

			private unsafe static void VarDecModFull(ref DecCalc d1, ref DecCalc d2, int scale)
			{
				uint num = d2.High;
				if (num == 0)
				{
					num = d2.Mid;
				}
				int num2 = BitOperations.LeadingZeroCount(num);
				Unsafe.SkipInit<Buf28>(out var value);
				value.Buf24.Low64 = d1.Low64 << num2;
				value.Buf24.Mid64 = d1.Mid + ((ulong)d1.High << 32) >> 32 - num2;
				uint num3 = 3u;
				while (scale < 0)
				{
					uint b = ((scale <= -9) ? 1000000000u : s_powers10[-scale]);
					uint* ptr = (uint*)(&value);
					ulong num4 = UInt32x32To64(value.Buf24.U0, b);
					value.Buf24.U0 = (uint)num4;
					for (int i = 1; i <= num3; i++)
					{
						num4 >>= 32;
						num4 += UInt32x32To64(ptr[i], b);
						ptr[i] = (uint)num4;
					}
					if (num4 > int.MaxValue)
					{
						ptr[++num3] = (uint)(num4 >> 32);
					}
					scale += 9;
				}
				if (d2.High == 0)
				{
					ulong den = d2.Low64 << num2;
					switch (num3)
					{
					case 6u:
						Div96By64(ref *(Buf12*)(&value.Buf24.U4), den);
						goto case 5u;
					case 5u:
						Div96By64(ref *(Buf12*)(&value.Buf24.U3), den);
						goto case 4u;
					case 4u:
						Div96By64(ref *(Buf12*)(&value.Buf24.U2), den);
						break;
					}
					Div96By64(ref *(Buf12*)(&value.Buf24.U1), den);
					Div96By64(ref *(Buf12*)(&value), den);
					d1.Low64 = value.Buf24.Low64 >> num2;
					d1.High = 0u;
					return;
				}
				Unsafe.SkipInit<Buf12>(out var value2);
				value2.Low64 = d2.Low64 << num2;
				value2.U2 = (uint)(d2.Mid + ((ulong)d2.High << 32) >> 32 - num2);
				switch (num3)
				{
				case 6u:
					Div128By96(ref *(Buf16*)(&value.Buf24.U3), ref value2);
					goto case 5u;
				case 5u:
					Div128By96(ref *(Buf16*)(&value.Buf24.U2), ref value2);
					goto case 4u;
				case 4u:
					Div128By96(ref *(Buf16*)(&value.Buf24.U1), ref value2);
					break;
				}
				Div128By96(ref *(Buf16*)(&value), ref value2);
				d1.Low64 = (value.Buf24.Low64 >> num2) + ((ulong)value.Buf24.U2 << 32 - num2 << 32);
				d1.High = value.Buf24.U2 >> num2;
			}

			internal static void InternalRound(ref DecCalc d, uint scale, MidpointRounding mode)
			{
				d.uflags -= scale << 16;
				uint num = 0u;
				while (true)
				{
					uint num6;
					uint num5;
					if (scale >= 9)
					{
						scale -= 9;
						uint num2 = d.uhi;
						if (num2 == 0)
						{
							ulong low = d.Low64;
							ulong num4 = (d.Low64 = low / 1000000000);
							num5 = (uint)(low - num4 * 1000000000);
						}
						else
						{
							num5 = num2 - (d.uhi = num2 / 1000000000) * 1000000000;
							num2 = d.umid;
							if ((num2 | num5) != 0)
							{
								num5 = num2 - (d.umid = (uint)((((ulong)num5 << 32) | num2) / 1000000000)) * 1000000000;
							}
							num2 = d.ulo;
							if ((num2 | num5) != 0)
							{
								num5 = num2 - (d.ulo = (uint)((((ulong)num5 << 32) | num2) / 1000000000)) * 1000000000;
							}
						}
						num6 = 1000000000u;
						if (scale != 0)
						{
							num |= num5;
							continue;
						}
					}
					else
					{
						num6 = s_powers10[scale];
						uint num7 = d.uhi;
						if (num7 == 0)
						{
							ulong low2 = d.Low64;
							if (low2 == 0L)
							{
								if (mode <= MidpointRounding.ToZero)
								{
									break;
								}
								num5 = 0u;
							}
							else
							{
								ulong num9 = (d.Low64 = low2 / num6);
								num5 = (uint)(low2 - num9 * num6);
							}
						}
						else
						{
							num5 = num7 - (d.uhi = num7 / num6) * num6;
							num7 = d.umid;
							if ((num7 | num5) != 0)
							{
								num5 = num7 - (d.umid = (uint)((((ulong)num5 << 32) | num7) / num6)) * num6;
							}
							num7 = d.ulo;
							if ((num7 | num5) != 0)
							{
								num5 = num7 - (d.ulo = (uint)((((ulong)num5 << 32) | num7) / num6)) * num6;
							}
						}
					}
					switch (mode)
					{
					case MidpointRounding.ToEven:
						num5 <<= 1;
						if ((num | (d.ulo & (true ? 1u : 0u))) != 0)
						{
							num5++;
						}
						if (num6 >= num5)
						{
							break;
						}
						goto IL_01e5;
					case MidpointRounding.AwayFromZero:
						num5 <<= 1;
						if (num6 > num5)
						{
							break;
						}
						goto IL_01e5;
					case MidpointRounding.ToNegativeInfinity:
						if ((num5 | num) == 0 || !d.IsNegative)
						{
							break;
						}
						goto IL_01e5;
					default:
						if ((num5 | num) == 0 || d.IsNegative)
						{
							break;
						}
						goto IL_01e5;
					case MidpointRounding.ToZero:
						break;
						IL_01e5:
						if (++d.Low64 == 0L)
						{
							d.uhi++;
						}
						break;
					}
					break;
				}
			}

			internal static uint DecDivMod1E9(ref DecCalc value)
			{
				ulong num = ((ulong)value.uhi << 32) + value.umid;
				ulong num2 = num / 1000000000;
				value.uhi = (uint)(num2 >> 32);
				value.umid = (uint)num2;
				ulong num3 = (num - (uint)((int)num2 * 1000000000) << 32) + value.ulo;
				return (uint)(int)num3 - (value.ulo = (uint)(num3 / 1000000000)) * 1000000000;
			}
		}

		public const decimal Zero = 0m;

		public const decimal One = 1m;

		public const decimal MinusOne = -1m;

		public const decimal MaxValue = 79228162514264337593543950335m;

		public const decimal MinValue = -79228162514264337593543950335m;

		private readonly int _flags;

		private readonly uint _hi32;

		private readonly ulong _lo64;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IAdditiveIdentity<decimal, decimal>.AdditiveIdentity => 0.0m;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IMinMaxValue<decimal>.MinValue => decimal.MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IMinMaxValue<decimal>.MaxValue => decimal.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IMultiplicativeIdentity<decimal, decimal>.MultiplicativeIdentity => 1.0m;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.One => 1.0m;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Zero => 0.0m;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal ISignedNumber<decimal>.NegativeOne => -1m;

		internal uint High => _hi32;

		internal uint Low => (uint)_lo64;

		internal uint Mid => (uint)(_lo64 >> 32);

		internal bool IsNegative => _flags < 0;

		internal int Scale => (byte)(_flags >> 16);

		private ulong Low64 => _lo64;

		internal Decimal(Currency value)
		{
			this = FromOACurrency(value.m_value);
		}

		public Decimal(int value)
		{
			if (value >= 0)
			{
				_flags = 0;
			}
			else
			{
				_flags = int.MinValue;
				value = -value;
			}
			_lo64 = (uint)value;
			_hi32 = 0u;
		}

		[CLSCompliant(false)]
		public Decimal(uint value)
		{
			_flags = 0;
			_lo64 = value;
			_hi32 = 0u;
		}

		public Decimal(long value)
		{
			if (value >= 0)
			{
				_flags = 0;
			}
			else
			{
				_flags = int.MinValue;
				value = -value;
			}
			_lo64 = (ulong)value;
			_hi32 = 0u;
		}

		[CLSCompliant(false)]
		public Decimal(ulong value)
		{
			_flags = 0;
			_lo64 = value;
			_hi32 = 0u;
		}

		public Decimal(float value)
		{
			DecCalc.VarDecFromR4(value, out AsMutable(ref this));
		}

		public Decimal(double value)
		{
			DecCalc.VarDecFromR8(value, out AsMutable(ref this));
		}

		private Decimal(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_flags = info.GetInt32("flags");
			_hi32 = (uint)info.GetInt32("hi");
			_lo64 = (ulong)((uint)info.GetInt32("lo") + ((long)info.GetInt32("mid") << 32));
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("flags", _flags);
			info.AddValue("hi", (int)High);
			info.AddValue("lo", (int)Low);
			info.AddValue("mid", (int)Mid);
		}

		public static decimal FromOACurrency(long cy)
		{
			bool isNegative = false;
			ulong num;
			if (cy < 0)
			{
				isNegative = true;
				num = (ulong)(-cy);
			}
			else
			{
				num = (ulong)cy;
			}
			int num2 = 4;
			if (num != 0L)
			{
				while (num2 != 0 && num % 10 == 0L)
				{
					num2--;
					num /= 10;
				}
			}
			return new decimal((int)num, (int)(num >> 32), 0, isNegative, (byte)num2);
		}

		public static long ToOACurrency(decimal value)
		{
			return DecCalc.VarCyFromDec(ref AsMutable(ref value));
		}

		private static bool IsValid(int flags)
		{
			if ((flags & 0x7F00FFFF) == 0)
			{
				return (uint)(flags & 0xFF0000) <= 1835008u;
			}
			return false;
		}

		public Decimal(int[] bits)
			: this((ReadOnlySpan<int>)(bits ?? throw new ArgumentNullException("bits")))
		{
		}

		public Decimal(ReadOnlySpan<int> bits)
		{
			if (bits.Length == 4)
			{
				int flags = bits[3];
				if (IsValid(flags))
				{
					_lo64 = (uint)bits[0] + ((ulong)(uint)bits[1] << 32);
					_hi32 = (uint)bits[2];
					_flags = flags;
					return;
				}
			}
			throw new ArgumentException(SR.Arg_DecBitCtor);
		}

		public Decimal(int lo, int mid, int hi, bool isNegative, byte scale)
		{
			if (scale > 28)
			{
				throw new ArgumentOutOfRangeException("scale", SR.ArgumentOutOfRange_DecimalScale);
			}
			_lo64 = (uint)lo + ((ulong)(uint)mid << 32);
			_hi32 = (uint)hi;
			_flags = scale << 16;
			if (isNegative)
			{
				_flags |= int.MinValue;
			}
		}

		void IDeserializationCallback.OnDeserialization(object sender)
		{
			if (!IsValid(_flags))
			{
				throw new SerializationException(SR.Overflow_Decimal);
			}
		}

		private Decimal(int lo, int mid, int hi, int flags)
		{
			if (IsValid(flags))
			{
				_lo64 = (uint)lo + ((ulong)(uint)mid << 32);
				_hi32 = (uint)hi;
				_flags = flags;
				return;
			}
			throw new ArgumentException(SR.Arg_DecBitCtor);
		}

		private Decimal(in decimal d, int flags)
		{
			this = d;
			_flags = flags;
		}

		internal static decimal Abs(in decimal d)
		{
			return new decimal(in d, d._flags & 0x7FFFFFFF);
		}

		public static decimal Add(decimal d1, decimal d2)
		{
			DecCalc.DecAddSub(ref AsMutable(ref d1), ref AsMutable(ref d2), sign: false);
			return d1;
		}

		public static decimal Ceiling(decimal d)
		{
			int flags = d._flags;
			if (((uint)flags & 0xFF0000u) != 0)
			{
				DecCalc.InternalRound(ref AsMutable(ref d), (byte)(flags >> 16), MidpointRounding.ToPositiveInfinity);
			}
			return d;
		}

		public static int Compare(decimal d1, decimal d2)
		{
			return DecCalc.VarDecCmp(in d1, in d2);
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is decimal d))
			{
				throw new ArgumentException(SR.Arg_MustBeDecimal);
			}
			return DecCalc.VarDecCmp(in this, in d);
		}

		public int CompareTo(decimal value)
		{
			return DecCalc.VarDecCmp(in this, in value);
		}

		public static decimal Divide(decimal d1, decimal d2)
		{
			DecCalc.VarDecDiv(ref AsMutable(ref d1), ref AsMutable(ref d2));
			return d1;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is decimal d)
			{
				return DecCalc.VarDecCmp(in this, in d) == 0;
			}
			return false;
		}

		public bool Equals(decimal value)
		{
			return DecCalc.VarDecCmp(in this, in value) == 0;
		}

		public override int GetHashCode()
		{
			return DecCalc.GetHashCode(in this);
		}

		public static bool Equals(decimal d1, decimal d2)
		{
			return DecCalc.VarDecCmp(in d1, in d2) == 0;
		}

		public static decimal Floor(decimal d)
		{
			int flags = d._flags;
			if (((uint)flags & 0xFF0000u) != 0)
			{
				DecCalc.InternalRound(ref AsMutable(ref d), (byte)(flags >> 16), MidpointRounding.ToNegativeInfinity);
			}
			return d;
		}

		public override string ToString()
		{
			return Number.FormatDecimal(this, null, NumberFormatInfo.CurrentInfo);
		}

		public string ToString(string? format)
		{
			return Number.FormatDecimal(this, format, NumberFormatInfo.CurrentInfo);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.FormatDecimal(this, null, NumberFormatInfo.GetInstance(provider));
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatDecimal(this, format, NumberFormatInfo.GetInstance(provider));
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatDecimal(this, format, NumberFormatInfo.GetInstance(provider), destination, out charsWritten);
		}

		public static decimal Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseDecimal(s, NumberStyles.Number, NumberFormatInfo.CurrentInfo);
		}

		public static decimal Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseDecimal(s, style, NumberFormatInfo.CurrentInfo);
		}

		public static decimal Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseDecimal(s, NumberStyles.Number, NumberFormatInfo.GetInstance(provider));
		}

		public static decimal Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseDecimal(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static decimal Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Number, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			return Number.ParseDecimal(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out decimal result)
		{
			if (s == null)
			{
				result = default(decimal);
				return false;
			}
			return Number.TryParseDecimal(s, NumberStyles.Number, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, out decimal result)
		{
			return Number.TryParseDecimal(s, NumberStyles.Number, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out decimal result)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				result = default(decimal);
				return false;
			}
			return Number.TryParseDecimal(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out decimal result)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			return Number.TryParseDecimal(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public static int[] GetBits(decimal d)
		{
			return new int[4]
			{
				(int)d.Low,
				(int)d.Mid,
				(int)d.High,
				d._flags
			};
		}

		public static int GetBits(decimal d, Span<int> destination)
		{
			if ((uint)destination.Length <= 3u)
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			destination[0] = (int)d.Low;
			destination[1] = (int)d.Mid;
			destination[2] = (int)d.High;
			destination[3] = d._flags;
			return 4;
		}

		public static bool TryGetBits(decimal d, Span<int> destination, out int valuesWritten)
		{
			if ((uint)destination.Length <= 3u)
			{
				valuesWritten = 0;
				return false;
			}
			destination[0] = (int)d.Low;
			destination[1] = (int)d.Mid;
			destination[2] = (int)d.High;
			destination[3] = d._flags;
			valuesWritten = 4;
			return true;
		}

		internal static void GetBytes(in decimal d, Span<byte> buffer)
		{
			BinaryPrimitives.WriteInt32LittleEndian(buffer, (int)d.Low);
			BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(4), (int)d.Mid);
			BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(8), (int)d.High);
			BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(12), d._flags);
		}

		internal static decimal ToDecimal(ReadOnlySpan<byte> span)
		{
			int lo = BinaryPrimitives.ReadInt32LittleEndian(span);
			int mid = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(4));
			int hi = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(8));
			int flags = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(12));
			return new decimal(lo, mid, hi, flags);
		}

		internal static ref readonly decimal Max(in decimal d1, in decimal d2)
		{
			if (DecCalc.VarDecCmp(in d1, in d2) < 0)
			{
				return ref d2;
			}
			return ref d1;
		}

		internal static ref readonly decimal Min(in decimal d1, in decimal d2)
		{
			if (DecCalc.VarDecCmp(in d1, in d2) >= 0)
			{
				return ref d2;
			}
			return ref d1;
		}

		public static decimal Remainder(decimal d1, decimal d2)
		{
			DecCalc.VarDecMod(ref AsMutable(ref d1), ref AsMutable(ref d2));
			return d1;
		}

		public static decimal Multiply(decimal d1, decimal d2)
		{
			DecCalc.VarDecMul(ref AsMutable(ref d1), ref AsMutable(ref d2));
			return d1;
		}

		public static decimal Negate(decimal d)
		{
			return new decimal(in d, d._flags ^ int.MinValue);
		}

		public static decimal Round(decimal d)
		{
			return Round(ref d, 0, MidpointRounding.ToEven);
		}

		public static decimal Round(decimal d, int decimals)
		{
			return Round(ref d, decimals, MidpointRounding.ToEven);
		}

		public static decimal Round(decimal d, MidpointRounding mode)
		{
			return Round(ref d, 0, mode);
		}

		public static decimal Round(decimal d, int decimals, MidpointRounding mode)
		{
			return Round(ref d, decimals, mode);
		}

		private static decimal Round(ref decimal d, int decimals, MidpointRounding mode)
		{
			if ((uint)decimals > 28u)
			{
				throw new ArgumentOutOfRangeException("decimals", SR.ArgumentOutOfRange_DecimalRound);
			}
			if ((uint)mode > 4u)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidEnumValue, mode, "MidpointRounding"), "mode");
			}
			int num = d.Scale - decimals;
			if (num > 0)
			{
				DecCalc.InternalRound(ref AsMutable(ref d), (uint)num, mode);
			}
			return d;
		}

		internal static int Sign(in decimal d)
		{
			if ((d.Low64 | d.High) != 0L)
			{
				return (d._flags >> 31) | 1;
			}
			return 0;
		}

		public static decimal Subtract(decimal d1, decimal d2)
		{
			DecCalc.DecAddSub(ref AsMutable(ref d1), ref AsMutable(ref d2), sign: true);
			return d1;
		}

		public static byte ToByte(decimal value)
		{
			uint num;
			try
			{
				num = ToUInt32(value);
			}
			catch (OverflowException)
			{
				Number.ThrowOverflowException(TypeCode.Byte);
				throw;
			}
			if (num != (byte)num)
			{
				Number.ThrowOverflowException(TypeCode.Byte);
			}
			return (byte)num;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(decimal value)
		{
			int num;
			try
			{
				num = ToInt32(value);
			}
			catch (OverflowException)
			{
				Number.ThrowOverflowException(TypeCode.SByte);
				throw;
			}
			if (num != (sbyte)num)
			{
				Number.ThrowOverflowException(TypeCode.SByte);
			}
			return (sbyte)num;
		}

		public static short ToInt16(decimal value)
		{
			int num;
			try
			{
				num = ToInt32(value);
			}
			catch (OverflowException)
			{
				Number.ThrowOverflowException(TypeCode.Int16);
				throw;
			}
			if (num != (short)num)
			{
				Number.ThrowOverflowException(TypeCode.Int16);
			}
			return (short)num;
		}

		public static double ToDouble(decimal d)
		{
			return DecCalc.VarR8FromDec(in d);
		}

		public static int ToInt32(decimal d)
		{
			Truncate(ref d);
			if ((d.High | d.Mid) == 0)
			{
				int low = (int)d.Low;
				if (!d.IsNegative)
				{
					if (low >= 0)
					{
						return low;
					}
				}
				else
				{
					low = -low;
					if (low <= 0)
					{
						return low;
					}
				}
			}
			throw new OverflowException(SR.Overflow_Int32);
		}

		public static long ToInt64(decimal d)
		{
			Truncate(ref d);
			if (d.High == 0)
			{
				long low = (long)d.Low64;
				if (!d.IsNegative)
				{
					if (low >= 0)
					{
						return low;
					}
				}
				else
				{
					low = -low;
					if (low <= 0)
					{
						return low;
					}
				}
			}
			throw new OverflowException(SR.Overflow_Int64);
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(decimal value)
		{
			uint num;
			try
			{
				num = ToUInt32(value);
			}
			catch (OverflowException)
			{
				Number.ThrowOverflowException(TypeCode.UInt16);
				throw;
			}
			if (num != (ushort)num)
			{
				Number.ThrowOverflowException(TypeCode.UInt16);
			}
			return (ushort)num;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(decimal d)
		{
			Truncate(ref d);
			if ((d.High | d.Mid) == 0)
			{
				uint low = d.Low;
				if (!d.IsNegative || low == 0)
				{
					return low;
				}
			}
			throw new OverflowException(SR.Overflow_UInt32);
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(decimal d)
		{
			Truncate(ref d);
			if (d.High == 0)
			{
				ulong low = d.Low64;
				if (!d.IsNegative || low == 0L)
				{
					return low;
				}
			}
			throw new OverflowException(SR.Overflow_UInt64);
		}

		public static float ToSingle(decimal d)
		{
			return DecCalc.VarR4FromDec(in d);
		}

		public static decimal Truncate(decimal d)
		{
			Truncate(ref d);
			return d;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void Truncate(ref decimal d)
		{
			int flags = d._flags;
			if (((uint)flags & 0xFF0000u) != 0)
			{
				DecCalc.InternalRound(ref AsMutable(ref d), (byte)(flags >> 16), MidpointRounding.ToZero);
			}
		}

		public static implicit operator decimal(byte value)
		{
			return new decimal((uint)value);
		}

		[CLSCompliant(false)]
		public static implicit operator decimal(sbyte value)
		{
			return new decimal(value);
		}

		public static implicit operator decimal(short value)
		{
			return new decimal(value);
		}

		[CLSCompliant(false)]
		public static implicit operator decimal(ushort value)
		{
			return new decimal((uint)value);
		}

		public static implicit operator decimal(char value)
		{
			return new decimal((uint)value);
		}

		public static implicit operator decimal(int value)
		{
			return new decimal(value);
		}

		[CLSCompliant(false)]
		public static implicit operator decimal(uint value)
		{
			return new decimal(value);
		}

		public static implicit operator decimal(long value)
		{
			return new decimal(value);
		}

		[CLSCompliant(false)]
		public static implicit operator decimal(ulong value)
		{
			return new decimal(value);
		}

		public static explicit operator decimal(float value)
		{
			return new decimal(value);
		}

		public static explicit operator decimal(double value)
		{
			return new decimal(value);
		}

		public static explicit operator byte(decimal value)
		{
			return ToByte(value);
		}

		[CLSCompliant(false)]
		public static explicit operator sbyte(decimal value)
		{
			return ToSByte(value);
		}

		public static explicit operator char(decimal value)
		{
			try
			{
				return (char)ToUInt16(value);
			}
			catch (OverflowException innerException)
			{
				throw new OverflowException(SR.Overflow_Char, innerException);
			}
		}

		public static explicit operator short(decimal value)
		{
			return ToInt16(value);
		}

		[CLSCompliant(false)]
		public static explicit operator ushort(decimal value)
		{
			return ToUInt16(value);
		}

		public static explicit operator int(decimal value)
		{
			return ToInt32(value);
		}

		[CLSCompliant(false)]
		public static explicit operator uint(decimal value)
		{
			return ToUInt32(value);
		}

		public static explicit operator long(decimal value)
		{
			return ToInt64(value);
		}

		[CLSCompliant(false)]
		public static explicit operator ulong(decimal value)
		{
			return ToUInt64(value);
		}

		public static explicit operator float(decimal value)
		{
			return DecCalc.VarR4FromDec(in value);
		}

		public static explicit operator double(decimal value)
		{
			return DecCalc.VarR8FromDec(in value);
		}

		public static decimal operator +(decimal d)
		{
			return d;
		}

		public static decimal operator -(decimal d)
		{
			return new decimal(in d, d._flags ^ int.MinValue);
		}

		public static decimal operator ++(decimal d)
		{
			return Add(d, 1m);
		}

		public static decimal operator --(decimal d)
		{
			return Subtract(d, 1m);
		}

		public static decimal operator +(decimal d1, decimal d2)
		{
			DecCalc.DecAddSub(ref AsMutable(ref d1), ref AsMutable(ref d2), sign: false);
			return d1;
		}

		public static decimal operator -(decimal d1, decimal d2)
		{
			DecCalc.DecAddSub(ref AsMutable(ref d1), ref AsMutable(ref d2), sign: true);
			return d1;
		}

		public static decimal operator *(decimal d1, decimal d2)
		{
			DecCalc.VarDecMul(ref AsMutable(ref d1), ref AsMutable(ref d2));
			return d1;
		}

		public static decimal operator /(decimal d1, decimal d2)
		{
			DecCalc.VarDecDiv(ref AsMutable(ref d1), ref AsMutable(ref d2));
			return d1;
		}

		public static decimal operator %(decimal d1, decimal d2)
		{
			DecCalc.VarDecMod(ref AsMutable(ref d1), ref AsMutable(ref d2));
			return d1;
		}

		public static bool operator ==(decimal d1, decimal d2)
		{
			return DecCalc.VarDecCmp(in d1, in d2) == 0;
		}

		public static bool operator !=(decimal d1, decimal d2)
		{
			return DecCalc.VarDecCmp(in d1, in d2) != 0;
		}

		public static bool operator <(decimal d1, decimal d2)
		{
			return DecCalc.VarDecCmp(in d1, in d2) < 0;
		}

		public static bool operator <=(decimal d1, decimal d2)
		{
			return DecCalc.VarDecCmp(in d1, in d2) <= 0;
		}

		public static bool operator >(decimal d1, decimal d2)
		{
			return DecCalc.VarDecCmp(in d1, in d2) > 0;
		}

		public static bool operator >=(decimal d1, decimal d2)
		{
			return DecCalc.VarDecCmp(in d1, in d2) >= 0;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Decimal;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Decimal", "Char"));
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return DecCalc.VarR4FromDec(in this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return DecCalc.VarR8FromDec(in this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return this;
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Decimal", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IAdditionOperators<decimal, decimal, decimal>.op_Addition(decimal left, decimal right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<decimal, decimal>.op_LessThan(decimal left, decimal right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<decimal, decimal>.op_LessThanOrEqual(decimal left, decimal right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<decimal, decimal>.op_GreaterThan(decimal left, decimal right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<decimal, decimal>.op_GreaterThanOrEqual(decimal left, decimal right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IDecrementOperators<decimal>.op_Decrement(decimal value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IDivisionOperators<decimal, decimal, decimal>.op_Division(decimal left, decimal right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<decimal, decimal>.op_Equality(decimal left, decimal right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<decimal, decimal>.op_Inequality(decimal left, decimal right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IIncrementOperators<decimal>.op_Increment(decimal value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IModulusOperators<decimal, decimal, decimal>.op_Modulus(decimal left, decimal right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IMultiplyOperators<decimal, decimal, decimal>.op_Multiply(decimal left, decimal right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Abs(decimal value)
		{
			return Math.Abs(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (decimal)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (long)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (decimal)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (ulong)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0m;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (decimal)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (long)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (decimal)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (ulong)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0m;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (decimal)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (long)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (decimal)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (ulong)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0m;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Clamp(decimal value, decimal min, decimal max)
		{
			return Math.Clamp(value, min, max);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (decimal Quotient, decimal Remainder) INumber<decimal>.DivRem(decimal left, decimal right)
		{
			return (left / right, left % right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Max(decimal x, decimal y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Min(decimal x, decimal y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal INumber<decimal>.Sign(decimal value)
		{
			return Math.Sign(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<decimal>.TryCreate<TOther>(TOther value, out decimal result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				result = (decimal)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				result = (decimal)(double)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				result = (short)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				result = (int)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				result = (long)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				result = (long)(IntPtr)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				result = (decimal)(float)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				result = (uint)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				result = (ulong)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				result = (ulong)(UIntPtr)(object)value;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = default(decimal);
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<decimal>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out decimal result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<decimal>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out decimal result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IParseable<decimal>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<decimal>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out decimal result)
		{
			return TryParse(s, NumberStyles.Number, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal ISpanParseable<decimal>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Number, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<decimal>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out decimal result)
		{
			return TryParse(s, NumberStyles.Number, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal ISubtractionOperators<decimal, decimal, decimal>.op_Subtraction(decimal left, decimal right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IUnaryNegationOperators<decimal, decimal>.op_UnaryNegation(decimal value)
		{
			return -value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static decimal IUnaryPlusOperators<decimal, decimal>.op_UnaryPlus(decimal value)
		{
			return value;
		}

		private static ref DecCalc AsMutable(ref decimal d)
		{
			return ref Unsafe.As<decimal, DecCalc>(ref d);
		}

		internal static uint DecDivMod1E9(ref decimal value)
		{
			return DecCalc.DecDivMod1E9(ref AsMutable(ref value));
		}
	}
	[ClassInterface(ClassInterfaceType.None)]
	[ComVisible(true)]
	public abstract class Delegate : ICloneable, ISerializable
	{
		internal object _target;

		internal object _methodBase;

		internal IntPtr _methodPtr;

		internal IntPtr _methodPtrAux;

		public object? Target => GetTarget();

		public MethodInfo Method => GetMethodImpl();

		[RequiresUnreferencedCode("The target method might be removed")]
		protected Delegate(object target, string method)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (method == null)
			{
				throw new ArgumentNullException("method");
			}
			if (!BindToMethodName(target, (RuntimeType)target.GetType(), method, (DelegateBindingFlags)10))
			{
				throw new ArgumentException(SR.Arg_DlgtTargMeth);
			}
		}

		protected Delegate([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type target, string method)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (target.ContainsGenericParameters)
			{
				throw new ArgumentException(SR.Arg_UnboundGenParam, "target");
			}
			if (method == null)
			{
				throw new ArgumentNullException("method");
			}
			if (!(target is RuntimeType methodType))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "target");
			}
			BindToMethodName(null, methodType, method, (DelegateBindingFlags)37);
		}

		protected virtual object? DynamicInvokeImpl(object?[]? args)
		{
			RuntimeMethodInfo runtimeMethodInfo = (RuntimeMethodInfo)RuntimeType.GetMethodBase(methodHandle: new RuntimeMethodHandleInternal(GetInvokeMethod()), reflectedType: (RuntimeType)GetType());
			return runtimeMethodInfo.Invoke(this, BindingFlags.Default, null, args, null);
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj == null || !InternalEqualTypes(this, obj))
			{
				return false;
			}
			Delegate @delegate = (Delegate)obj;
			if (_target == @delegate._target && _methodPtr == @delegate._methodPtr && _methodPtrAux == @delegate._methodPtrAux)
			{
				return true;
			}
			if (_methodPtrAux == IntPtr.Zero)
			{
				if (@delegate._methodPtrAux != IntPtr.Zero)
				{
					return false;
				}
				if (_target != @delegate._target)
				{
					return false;
				}
			}
			else
			{
				if (@delegate._methodPtrAux == IntPtr.Zero)
				{
					return false;
				}
				if (_methodPtrAux == @delegate._methodPtrAux)
				{
					return true;
				}
			}
			if (_methodBase == null || @delegate._methodBase == null || !(_methodBase is MethodInfo) || !(@delegate._methodBase is MethodInfo))
			{
				return InternalEqualMethodHandles(this, @delegate);
			}
			return _methodBase.Equals(@delegate._methodBase);
		}

		public override int GetHashCode()
		{
			if (_methodPtrAux == IntPtr.Zero)
			{
				return ((_target != null) ? (RuntimeHelpers.GetHashCode(_target) * 33) : 0) + GetType().GetHashCode();
			}
			return GetType().GetHashCode();
		}

		protected virtual MethodInfo GetMethodImpl()
		{
			if (_methodBase == null || !(_methodBase is MethodInfo))
			{
				IRuntimeMethodInfo runtimeMethodInfo = FindMethodHandle();
				RuntimeType runtimeType = RuntimeMethodHandle.GetDeclaringType(runtimeMethodInfo);
				if ((RuntimeTypeHandle.IsGenericTypeDefinition(runtimeType) || RuntimeTypeHandle.HasInstantiation(runtimeType)) && (RuntimeMethodHandle.GetAttributes(runtimeMethodInfo) & MethodAttributes.Static) == 0)
				{
					if (_methodPtrAux == IntPtr.Zero)
					{
						Type type = _target.GetType();
						Type genericTypeDefinition = runtimeType.GetGenericTypeDefinition();
						while (type != null)
						{
							if (type.IsGenericType && type.GetGenericTypeDefinition() == genericTypeDefinition)
							{
								runtimeType = type as RuntimeType;
								break;
							}
							type = type.BaseType;
						}
					}
					else
					{
						MethodInfo method = GetType().GetMethod("Invoke");
						runtimeType = (RuntimeType)method.GetParameters()[0].ParameterType;
					}
				}
				_methodBase = (MethodInfo)RuntimeType.GetMethodBase(runtimeType, runtimeMethodInfo);
			}
			return (MethodInfo)_methodBase;
		}

		[RequiresUnreferencedCode("The target method might be removed")]
		public static Delegate? CreateDelegate(Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (method == null)
			{
				throw new ArgumentNullException("method");
			}
			if (!(type is RuntimeType runtimeType))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "type");
			}
			if (!runtimeType.IsDelegate())
			{
				throw new ArgumentException(SR.Arg_MustBeDelegate, "type");
			}
			Delegate @delegate = InternalAlloc(runtimeType);
			if (!@delegate.BindToMethodName(target, (RuntimeType)target.GetType(), method, (DelegateBindingFlags)26 | (ignoreCase ? DelegateBindingFlags.CaselessMatching : ((DelegateBindingFlags)0))))
			{
				if (throwOnBindFailure)
				{
					throw new ArgumentException(SR.Arg_DlgtTargMeth);
				}
				return null;
			}
			return @delegate;
		}

		public static Delegate? CreateDelegate(Type type, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type target, string method, bool ignoreCase, bool throwOnBindFailure)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (target.ContainsGenericParameters)
			{
				throw new ArgumentException(SR.Arg_UnboundGenParam, "target");
			}
			if (method == null)
			{
				throw new ArgumentNullException("method");
			}
			if (!(type is RuntimeType runtimeType))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "type");
			}
			if (!(target is RuntimeType methodType))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "target");
			}
			if (!runtimeType.IsDelegate())
			{
				throw new ArgumentException(SR.Arg_MustBeDelegate, "type");
			}
			Delegate @delegate = InternalAlloc(runtimeType);
			if (!@delegate.BindToMethodName(null, methodType, method, (DelegateBindingFlags)5 | (ignoreCase ? DelegateBindingFlags.CaselessMatching : ((DelegateBindingFlags)0))))
			{
				if (throwOnBindFailure)
				{
					throw new ArgumentException(SR.Arg_DlgtTargMeth);
				}
				return null;
			}
			return @delegate;
		}

		public static Delegate? CreateDelegate(Type type, MethodInfo method, bool throwOnBindFailure)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (method == null)
			{
				throw new ArgumentNullException("method");
			}
			if (!(type is RuntimeType runtimeType))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "type");
			}
			if (!(method is RuntimeMethodInfo rtMethod))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, "method");
			}
			if (!runtimeType.IsDelegate())
			{
				throw new ArgumentException(SR.Arg_MustBeDelegate, "type");
			}
			Delegate @delegate = CreateDelegateInternal(runtimeType, rtMethod, null, (DelegateBindingFlags)68);
			if ((object)@delegate == null && throwOnBindFailure)
			{
				throw new ArgumentException(SR.Arg_DlgtTargMeth);
			}
			return @delegate;
		}

		public static Delegate? CreateDelegate(Type type, object? firstArgument, MethodInfo method, bool throwOnBindFailure)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (method == null)
			{
				throw new ArgumentNullException("method");
			}
			if (!(type is RuntimeType runtimeType))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "type");
			}
			if (!(method is RuntimeMethodInfo rtMethod))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, "method");
			}
			if (!runtimeType.IsDelegate())
			{
				throw new ArgumentException(SR.Arg_MustBeDelegate, "type");
			}
			Delegate @delegate = CreateDelegateInternal(runtimeType, rtMethod, firstArgument, DelegateBindingFlags.RelaxedSignature);
			if ((object)@delegate == null && throwOnBindFailure)
			{
				throw new ArgumentException(SR.Arg_DlgtTargMeth);
			}
			return @delegate;
		}

		internal static Delegate CreateDelegateNoSecurityCheck(Type type, object target, RuntimeMethodHandle method)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (method.IsNullHandle())
			{
				throw new ArgumentNullException("method");
			}
			if (!(type is RuntimeType runtimeType))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "type");
			}
			if (!runtimeType.IsDelegate())
			{
				throw new ArgumentException(SR.Arg_MustBeDelegate, "type");
			}
			Delegate @delegate = InternalAlloc(runtimeType);
			if (!@delegate.BindToMethodInfo(target, method.GetMethodInfo(), RuntimeMethodHandle.GetDeclaringType(method.GetMethodInfo()), DelegateBindingFlags.RelaxedSignature))
			{
				throw new ArgumentException(SR.Arg_DlgtTargMeth);
			}
			return @delegate;
		}

		internal static Delegate CreateDelegateInternal(RuntimeType rtType, RuntimeMethodInfo rtMethod, object firstArgument, DelegateBindingFlags flags)
		{
			Delegate @delegate = InternalAlloc(rtType);
			if (@delegate.BindToMethodInfo(firstArgument, rtMethod, rtMethod.GetDeclaringTypeInternal(), flags))
			{
				return @delegate;
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern bool BindToMethodName(object target, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] RuntimeType methodType, string method, DelegateBindingFlags flags);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern bool BindToMethodInfo(object target, IRuntimeMethodInfo method, RuntimeType methodType, DelegateBindingFlags flags);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern MulticastDelegate InternalAlloc(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern MulticastDelegate InternalAllocLike(Delegate d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool InternalEqualTypes(object a, object b);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void DelegateConstruct(object target, IntPtr slot);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern IntPtr GetMulticastInvoke();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern IntPtr GetInvokeMethod();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern IRuntimeMethodInfo FindMethodHandle();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool InternalEqualMethodHandles(Delegate left, Delegate right);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern IntPtr AdjustTarget(object target, IntPtr methodPtr);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern IntPtr GetCallStub(IntPtr methodPtr);

		internal virtual object GetTarget()
		{
			if (!(_methodPtrAux == IntPtr.Zero))
			{
				return null;
			}
			return _target;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool CompareUnmanagedFunctionPtrs(Delegate d1, Delegate d2);

		public virtual object Clone()
		{
			return MemberwiseClone();
		}

		[return: NotNullIfNotNull("a")]
		[return: NotNullIfNotNull("b")]
		public static Delegate? Combine(Delegate? a, Delegate? b)
		{
			if ((object)a == null)
			{
				return b;
			}
			return a.CombineImpl(b);
		}

		public static Delegate? Combine(params Delegate?[]? delegates)
		{
			if (delegates == null || delegates.Length == 0)
			{
				return null;
			}
			Delegate @delegate = delegates[0];
			for (int i = 1; i < delegates.Length; i++)
			{
				@delegate = Combine(@delegate, delegates[i]);
			}
			return @delegate;
		}

		public static Delegate CreateDelegate(Type type, object? firstArgument, MethodInfo method)
		{
			return CreateDelegate(type, firstArgument, method, throwOnBindFailure: true);
		}

		public static Delegate CreateDelegate(Type type, MethodInfo method)
		{
			return CreateDelegate(type, method, throwOnBindFailure: true);
		}

		[RequiresUnreferencedCode("The target method might be removed")]
		public static Delegate CreateDelegate(Type type, object target, string method)
		{
			return CreateDelegate(type, target, method, ignoreCase: false, throwOnBindFailure: true);
		}

		[RequiresUnreferencedCode("The target method might be removed")]
		public static Delegate CreateDelegate(Type type, object target, string method, bool ignoreCase)
		{
			return CreateDelegate(type, target, method, ignoreCase, throwOnBindFailure: true);
		}

		public static Delegate CreateDelegate(Type type, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type target, string method)
		{
			return CreateDelegate(type, target, method, ignoreCase: false, throwOnBindFailure: true);
		}

		public static Delegate CreateDelegate(Type type, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type target, string method, bool ignoreCase)
		{
			return CreateDelegate(type, target, method, ignoreCase, throwOnBindFailure: true);
		}

		protected virtual Delegate CombineImpl(Delegate? d)
		{
			throw new MulticastNotSupportedException(SR.Multicast_Combine);
		}

		protected virtual Delegate? RemoveImpl(Delegate d)
		{
			if (!d.Equals(this))
			{
				return this;
			}
			return null;
		}

		public virtual Delegate[] GetInvocationList()
		{
			return new Delegate[1] { this };
		}

		public object? DynamicInvoke(params object?[]? args)
		{
			return DynamicInvokeImpl(args);
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public static Delegate? Remove(Delegate? source, Delegate? value)
		{
			if ((object)source == null)
			{
				return null;
			}
			if ((object)value == null)
			{
				return source;
			}
			if (!InternalEqualTypes(source, value))
			{
				throw new ArgumentException(SR.Arg_DlgtTypeMis);
			}
			return source.RemoveImpl(value);
		}

		public static Delegate? RemoveAll(Delegate? source, Delegate? value)
		{
			Delegate @delegate;
			do
			{
				@delegate = source;
				source = Remove(source, value);
			}
			while (@delegate != source);
			return @delegate;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(Delegate? d1, Delegate? d2)
		{
			if ((object)d2 == null)
			{
				if ((object)d1 != null)
				{
					return false;
				}
				return true;
			}
			if ((object)d2 != d1)
			{
				return d2.Equals(d1);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator !=(Delegate? d1, Delegate? d2)
		{
			if ((object)d2 == null)
			{
				if ((object)d1 != null)
				{
					return true;
				}
				return false;
			}
			if ((object)d2 != d1)
			{
				return !d2.Equals(d1);
			}
			return false;
		}
	}
	internal enum DelegateBindingFlags
	{
		StaticMethodOnly = 1,
		InstanceMethodOnly = 2,
		OpenDelegateOnly = 4,
		ClosedDelegateOnly = 8,
		NeverCloseOverNull = 0x10,
		CaselessMatching = 0x20,
		RelaxedSignature = 0x40
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public abstract class Enum : ValueType, IComparable, IFormattable, IConvertible
	{
		internal sealed class EnumInfo
		{
			public readonly bool HasFlagsAttribute;

			public readonly ulong[] Values;

			public readonly string[] Names;

			public EnumInfo(bool hasFlagsAttribute, ulong[] values, string[] names)
			{
				HasFlagsAttribute = hasFlagsAttribute;
				Values = values;
				Names = names;
			}
		}

		private const char EnumSeparatorChar = ',';

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public override extern bool Equals([NotNullWhen(true)] object? obj);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object InternalBoxEnum(RuntimeType enumType, long value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern CorElementType InternalGetCorElementType();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeType InternalGetUnderlyingType(RuntimeType enumType);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern bool InternalHasFlag(Enum flags);

		private static EnumInfo GetEnumInfo(RuntimeType enumType, bool getNames = true)
		{
			EnumInfo enumInfo = enumType.GenericCache as EnumInfo;
			if (enumInfo == null || (getNames && enumInfo.Names == null))
			{
				ulong[] o = null;
				string[] o2 = null;
				RuntimeTypeHandle rth = enumType.GetTypeHandleInternal();
				GetEnumValuesAndNames(new QCallTypeHandle(ref rth), ObjectHandleOnStack.Create(ref o), ObjectHandleOnStack.Create(ref o2), getNames ? Interop.BOOL.TRUE : Interop.BOOL.FALSE);
				bool hasFlagsAttribute = enumType.IsDefined(typeof(FlagsAttribute), inherit: false);
				enumInfo = (EnumInfo)(enumType.GenericCache = new EnumInfo(hasFlagsAttribute, o, o2));
			}
			return enumInfo;
		}

		private string ValueToString()
		{
			ref byte rawData = ref this.GetRawData();
			return InternalGetCorElementType() switch
			{
				CorElementType.ELEMENT_TYPE_I1 => Unsafe.As<byte, sbyte>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_U1 => rawData.ToString(), 
				CorElementType.ELEMENT_TYPE_BOOLEAN => Unsafe.As<byte, bool>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_I2 => Unsafe.As<byte, short>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_U2 => Unsafe.As<byte, ushort>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_CHAR => Unsafe.As<byte, char>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_I4 => Unsafe.As<byte, int>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_U4 => Unsafe.As<byte, uint>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_R4 => Unsafe.As<byte, float>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_I8 => Unsafe.As<byte, long>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_U8 => Unsafe.As<byte, ulong>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_R8 => Unsafe.As<byte, double>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_I => Unsafe.As<byte, IntPtr>(ref rawData).ToString(), 
				CorElementType.ELEMENT_TYPE_U => Unsafe.As<byte, UIntPtr>(ref rawData).ToString(), 
				_ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType), 
			};
		}

		private string ValueToHexString()
		{
			ref byte rawData = ref this.GetRawData();
			Span<byte> destination = stackalloc byte[8];
			int length;
			switch (InternalGetCorElementType())
			{
			case CorElementType.ELEMENT_TYPE_I1:
			case CorElementType.ELEMENT_TYPE_U1:
				destination[0] = rawData;
				length = 1;
				break;
			case CorElementType.ELEMENT_TYPE_BOOLEAN:
				if (rawData == 0)
				{
					return "00";
				}
				return "01";
			case CorElementType.ELEMENT_TYPE_CHAR:
			case CorElementType.ELEMENT_TYPE_I2:
			case CorElementType.ELEMENT_TYPE_U2:
				BinaryPrimitives.WriteUInt16BigEndian(destination, Unsafe.As<byte, ushort>(ref rawData));
				length = 2;
				break;
			case CorElementType.ELEMENT_TYPE_I4:
			case CorElementType.ELEMENT_TYPE_U4:
				BinaryPrimitives.WriteUInt32BigEndian(destination, Unsafe.As<byte, uint>(ref rawData));
				length = 4;
				break;
			case CorElementType.ELEMENT_TYPE_I8:
			case CorElementType.ELEMENT_TYPE_U8:
				BinaryPrimitives.WriteUInt64BigEndian(destination, Unsafe.As<byte, ulong>(ref rawData));
				length = 8;
				break;
			default:
				throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
			}
			return HexConverter.ToString(destination.Slice(0, length));
		}

		private static string ValueToHexString(object value)
		{
			return Convert.GetTypeCode(value) switch
			{
				TypeCode.SByte => ((byte)(sbyte)value).ToString("X2", null), 
				TypeCode.Byte => ((byte)value).ToString("X2", null), 
				TypeCode.Boolean => ((bool)value) ? "01" : "00", 
				TypeCode.Int16 => ((ushort)(short)value).ToString("X4", null), 
				TypeCode.UInt16 => ((ushort)value).ToString("X4", null), 
				TypeCode.Char => ((ushort)(char)value).ToString("X4", null), 
				TypeCode.UInt32 => ((uint)value).ToString("X8", null), 
				TypeCode.Int32 => ((uint)(int)value).ToString("X8", null), 
				TypeCode.UInt64 => ((ulong)value).ToString("X16", null), 
				TypeCode.Int64 => ((ulong)(long)value).ToString("X16", null), 
				_ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType), 
			};
		}

		internal static string GetEnumName(RuntimeType enumType, ulong ulValue)
		{
			return GetEnumName(GetEnumInfo(enumType), ulValue);
		}

		private static string GetEnumName(EnumInfo enumInfo, ulong ulValue)
		{
			int num = Array.BinarySearch(enumInfo.Values, ulValue);
			if (num >= 0)
			{
				return enumInfo.Names[num];
			}
			return null;
		}

		private static string InternalFormat(RuntimeType enumType, ulong value)
		{
			EnumInfo enumInfo = GetEnumInfo(enumType);
			if (!enumInfo.HasFlagsAttribute)
			{
				return GetEnumName(enumInfo, value);
			}
			return InternalFlagsFormat(enumInfo, value);
		}

		private static string InternalFlagsFormat(RuntimeType enumType, ulong result)
		{
			return InternalFlagsFormat(GetEnumInfo(enumType), result);
		}

		private static string InternalFlagsFormat(EnumInfo enumInfo, ulong resultValue)
		{
			string[] names = enumInfo.Names;
			ulong[] values = enumInfo.Values;
			if (resultValue == 0L)
			{
				if (values.Length == 0 || values[0] != 0L)
				{
					return "0";
				}
				return names[0];
			}
			Span<int> span = stackalloc int[64];
			int num;
			for (num = values.Length - 1; num >= 0; num--)
			{
				if (values[num] == resultValue)
				{
					return names[num];
				}
				if (values[num] < resultValue)
				{
					break;
				}
			}
			int num2 = 0;
			int num3 = 0;
			while (num >= 0)
			{
				ulong num4 = values[num];
				if (num == 0 && num4 == 0L)
				{
					break;
				}
				if ((resultValue & num4) == num4)
				{
					resultValue -= num4;
					span[num3++] = num;
					num2 = checked(num2 + names[num].Length);
				}
				num--;
			}
			if (resultValue != 0L)
			{
				return null;
			}
			string text = string.FastAllocateString(checked(num2 + 2 * (num3 - 1)));
			Span<char> destination = new Span<char>(ref text.GetRawStringData(), text.Length);
			string text2 = names[span[--num3]];
			text2.CopyTo(destination);
			destination = destination.Slice(text2.Length);
			while (--num3 >= 0)
			{
				destination[0] = ',';
				destination[1] = ' ';
				destination = destination.Slice(2);
				text2 = names[span[num3]];
				text2.CopyTo(destination);
				destination = destination.Slice(text2.Length);
			}
			return text;
		}

		internal static ulong ToUInt64(object value)
		{
			return Convert.GetTypeCode(value) switch
			{
				TypeCode.SByte => (ulong)(sbyte)value, 
				TypeCode.Byte => (byte)value, 
				TypeCode.Boolean => (ulong)(((bool)value) ? 1 : 0), 
				TypeCode.Int16 => (ulong)(short)value, 
				TypeCode.UInt16 => (ushort)value, 
				TypeCode.Char => (char)value, 
				TypeCode.UInt32 => (uint)value, 
				TypeCode.Int32 => (ulong)(int)value, 
				TypeCode.UInt64 => (ulong)value, 
				TypeCode.Int64 => (ulong)(long)value, 
				_ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType), 
			};
		}

		private static ulong ToUInt64<TEnum>(TEnum value) where TEnum : struct, Enum
		{
			return Type.GetTypeCode(typeof(TEnum)) switch
			{
				TypeCode.SByte => (ulong)Unsafe.As<TEnum, sbyte>(ref value), 
				TypeCode.Byte => Unsafe.As<TEnum, byte>(ref value), 
				TypeCode.Boolean => (ulong)(Unsafe.As<TEnum, bool>(ref value) ? 1 : 0), 
				TypeCode.Int16 => (ulong)Unsafe.As<TEnum, short>(ref value), 
				TypeCode.UInt16 => Unsafe.As<TEnum, ushort>(ref value), 
				TypeCode.Char => Unsafe.As<TEnum, char>(ref value), 
				TypeCode.UInt32 => Unsafe.As<TEnum, uint>(ref value), 
				TypeCode.Int32 => (ulong)Unsafe.As<TEnum, int>(ref value), 
				TypeCode.UInt64 => Unsafe.As<TEnum, ulong>(ref value), 
				TypeCode.Int64 => (ulong)Unsafe.As<TEnum, long>(ref value), 
				_ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType), 
			};
		}

		public static string? GetName<TEnum>(TEnum value) where TEnum : struct, Enum
		{
			return GetEnumName((RuntimeType)typeof(TEnum), ToUInt64(value));
		}

		public static string? GetName(Type enumType, object value)
		{
			if ((object)enumType == null)
			{
				throw new ArgumentNullException("enumType");
			}
			return enumType.GetEnumName(value);
		}

		public static string[] GetNames<TEnum>() where TEnum : struct, Enum
		{
			return new ReadOnlySpan<string>(InternalGetNames((RuntimeType)typeof(TEnum))).ToArray();
		}

		public static string[] GetNames(Type enumType)
		{
			if ((object)enumType == null)
			{
				throw new ArgumentNullException("enumType");
			}
			return enumType.GetEnumNames();
		}

		internal static string[] InternalGetNames(RuntimeType enumType)
		{
			return GetEnumInfo(enumType).Names;
		}

		public static Type GetUnderlyingType(Type enumType)
		{
			if (enumType == null)
			{
				throw new ArgumentNullException("enumType");
			}
			return enumType.GetEnumUnderlyingType();
		}

		public static TEnum[] GetValues<TEnum>() where TEnum : struct, Enum
		{
			return (TEnum[])GetValues(typeof(TEnum));
		}

		public static Array GetValues(Type enumType)
		{
			if ((object)enumType == null)
			{
				throw new ArgumentNullException("enumType");
			}
			return enumType.GetEnumValues();
		}

		[Intrinsic]
		public bool HasFlag(Enum flag)
		{
			if (flag == null)
			{
				throw new ArgumentNullException("flag");
			}
			if (!GetType().IsEquivalentTo(flag.GetType()))
			{
				throw new ArgumentException(SR.Format(SR.Argument_EnumTypeDoesNotMatch, flag.GetType(), GetType()));
			}
			return InternalHasFlag(flag);
		}

		internal static ulong[] InternalGetValues(RuntimeType enumType)
		{
			return GetEnumInfo(enumType, getNames: false).Values;
		}

		public static bool IsDefined<TEnum>(TEnum value) where TEnum : struct, Enum
		{
			RuntimeType enumType = (RuntimeType)typeof(TEnum);
			ulong[] array = InternalGetValues(enumType);
			ulong value2 = ToUInt64(value);
			return Array.BinarySearch(array, value2) >= 0;
		}

		public static bool IsDefined(Type enumType, object value)
		{
			if ((object)enumType == null)
			{
				throw new ArgumentNullException("enumType");
			}
			return enumType.IsEnumDefined(value);
		}

		public static object Parse(Type enumType, string value)
		{
			return Parse(enumType, value, ignoreCase: false);
		}

		public static object Parse(Type enumType, ReadOnlySpan<char> value)
		{
			return Parse(enumType, value, ignoreCase: false);
		}

		public static object Parse(Type enumType, string value, bool ignoreCase)
		{
			object result;
			bool flag = TryParse(enumType, value, ignoreCase, throwOnFailure: true, out result);
			return result;
		}

		public static object Parse(Type enumType, ReadOnlySpan<char> value, bool ignoreCase)
		{
			object result;
			bool flag = TryParse(enumType, value, ignoreCase, throwOnFailure: true, out result);
			return result;
		}

		public static TEnum Parse<TEnum>(string value) where TEnum : struct
		{
			return Parse<TEnum>(value, ignoreCase: false);
		}

		public static TEnum Parse<TEnum>(ReadOnlySpan<char> value) where TEnum : struct
		{
			return Parse<TEnum>(value, ignoreCase: false);
		}

		public static TEnum Parse<TEnum>(string value, bool ignoreCase) where TEnum : struct
		{
			TEnum result;
			bool flag = TryParse<TEnum>(value, ignoreCase, throwOnFailure: true, out result);
			return result;
		}

		public static TEnum Parse<TEnum>(ReadOnlySpan<char> value, bool ignoreCase) where TEnum : struct
		{
			TEnum result;
			bool flag = TryParse<TEnum>(value, ignoreCase, throwOnFailure: true, out result);
			return result;
		}

		public static bool TryParse(Type enumType, string? value, out object? result)
		{
			return TryParse(enumType, value, ignoreCase: false, out result);
		}

		public static bool TryParse(Type enumType, ReadOnlySpan<char> value, out object? result)
		{
			return TryParse(enumType, value, ignoreCase: false, out result);
		}

		public static bool TryParse(Type enumType, string? value, bool ignoreCase, out object? result)
		{
			return TryParse(enumType, value, ignoreCase, throwOnFailure: false, out result);
		}

		public static bool TryParse(Type enumType, ReadOnlySpan<char> value, bool ignoreCase, out object? result)
		{
			return TryParse(enumType, value, ignoreCase, throwOnFailure: false, out result);
		}

		private static bool TryParse(Type enumType, string value, bool ignoreCase, bool throwOnFailure, out object result)
		{
			if (value == null)
			{
				if (throwOnFailure)
				{
					throw new ArgumentNullException("value");
				}
				result = null;
				return false;
			}
			return TryParse(enumType, value.AsSpan(), ignoreCase, throwOnFailure, out result);
		}

		private static bool TryParse(Type enumType, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, out object result)
		{
			RuntimeType runtimeType = ValidateRuntimeType(enumType);
			value = value.TrimStart();
			if (value.Length == 0)
			{
				if (throwOnFailure)
				{
					throw new ArgumentException(SR.Arg_MustContainEnumInfo, "value");
				}
				result = null;
				return false;
			}
			int result3;
			uint result4;
			switch (Type.GetTypeCode(runtimeType))
			{
			case TypeCode.SByte:
			{
				bool flag = TryParseInt32Enum(runtimeType, value, -128, 127, ignoreCase, throwOnFailure, TypeCode.SByte, out result3);
				result = (flag ? InternalBoxEnum(runtimeType, result3) : null);
				return flag;
			}
			case TypeCode.Int16:
			{
				bool flag = TryParseInt32Enum(runtimeType, value, -32768, 32767, ignoreCase, throwOnFailure, TypeCode.Int16, out result3);
				result = (flag ? InternalBoxEnum(runtimeType, result3) : null);
				return flag;
			}
			case TypeCode.Int32:
			{
				bool flag = TryParseInt32Enum(runtimeType, value, int.MinValue, int.MaxValue, ignoreCase, throwOnFailure, TypeCode.Int32, out result3);
				result = (flag ? InternalBoxEnum(runtimeType, result3) : null);
				return flag;
			}
			case TypeCode.Byte:
			{
				bool flag = TryParseUInt32Enum(runtimeType, value, 255u, ignoreCase, throwOnFailure, TypeCode.Byte, out result4);
				result = (flag ? InternalBoxEnum(runtimeType, result4) : null);
				return flag;
			}
			case TypeCode.UInt16:
			{
				bool flag = TryParseUInt32Enum(runtimeType, value, 65535u, ignoreCase, throwOnFailure, TypeCode.UInt16, out result4);
				result = (flag ? InternalBoxEnum(runtimeType, result4) : null);
				return flag;
			}
			case TypeCode.UInt32:
			{
				bool flag = TryParseUInt32Enum(runtimeType, value, uint.MaxValue, ignoreCase, throwOnFailure, TypeCode.UInt32, out result4);
				result = (flag ? InternalBoxEnum(runtimeType, result4) : null);
				return flag;
			}
			case TypeCode.Int64:
			{
				long result5;
				bool flag = TryParseInt64Enum(runtimeType, value, ignoreCase, throwOnFailure, out result5);
				result = (flag ? InternalBoxEnum(runtimeType, result5) : null);
				return flag;
			}
			case TypeCode.UInt64:
			{
				ulong result2;
				bool flag = TryParseUInt64Enum(runtimeType, value, ignoreCase, throwOnFailure, out result2);
				result = (flag ? InternalBoxEnum(runtimeType, (long)result2) : null);
				return flag;
			}
			default:
				return TryParseRareEnum(runtimeType, value, ignoreCase, throwOnFailure, out result);
			}
		}

		public static bool TryParse<TEnum>([NotNullWhen(true)] string? value, out TEnum result) where TEnum : struct
		{
			return TryParse<TEnum>(value, ignoreCase: false, out result);
		}

		public static bool TryParse<TEnum>(ReadOnlySpan<char> value, out TEnum result) where TEnum : struct
		{
			return TryParse<TEnum>(value, ignoreCase: false, out result);
		}

		public static bool TryParse<TEnum>([NotNullWhen(true)] string? value, bool ignoreCase, out TEnum result) where TEnum : struct
		{
			return TryParse<TEnum>(value, ignoreCase, throwOnFailure: false, out result);
		}

		public static bool TryParse<TEnum>(ReadOnlySpan<char> value, bool ignoreCase, out TEnum result) where TEnum : struct
		{
			return TryParse<TEnum>(value, ignoreCase, throwOnFailure: false, out result);
		}

		private static bool TryParse<TEnum>(string value, bool ignoreCase, bool throwOnFailure, out TEnum result) where TEnum : struct
		{
			if (value == null)
			{
				if (throwOnFailure)
				{
					throw new ArgumentNullException("value");
				}
				result = default(TEnum);
				return false;
			}
			return TryParse<TEnum>(value.AsSpan(), ignoreCase, throwOnFailure, out result);
		}

		private static bool TryParse<TEnum>(ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, out TEnum result) where TEnum : struct
		{
			if (!typeof(TEnum).IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "TEnum");
			}
			value = value.TrimStart();
			if (value.Length == 0)
			{
				if (throwOnFailure)
				{
					throw new ArgumentException(SR.Arg_MustContainEnumInfo, "value");
				}
				result = default(TEnum);
				return false;
			}
			RuntimeType enumType = (RuntimeType)typeof(TEnum);
			int result3;
			uint result6;
			switch (Type.GetTypeCode(typeof(TEnum)))
			{
			case TypeCode.SByte:
			{
				bool flag = TryParseInt32Enum(enumType, value, -128, 127, ignoreCase, throwOnFailure, TypeCode.SByte, out result3);
				sbyte source2 = (sbyte)result3;
				result = Unsafe.As<sbyte, TEnum>(ref source2);
				return flag;
			}
			case TypeCode.Int16:
			{
				bool flag = TryParseInt32Enum(enumType, value, -32768, 32767, ignoreCase, throwOnFailure, TypeCode.Int16, out result3);
				short source = (short)result3;
				result = Unsafe.As<short, TEnum>(ref source);
				return flag;
			}
			case TypeCode.Int32:
			{
				bool flag = TryParseInt32Enum(enumType, value, int.MinValue, int.MaxValue, ignoreCase, throwOnFailure, TypeCode.Int32, out result3);
				result = Unsafe.As<int, TEnum>(ref result3);
				return flag;
			}
			case TypeCode.Byte:
			{
				bool flag = TryParseUInt32Enum(enumType, value, 255u, ignoreCase, throwOnFailure, TypeCode.Byte, out result6);
				byte source4 = (byte)result6;
				result = Unsafe.As<byte, TEnum>(ref source4);
				return flag;
			}
			case TypeCode.UInt16:
			{
				bool flag = TryParseUInt32Enum(enumType, value, 65535u, ignoreCase, throwOnFailure, TypeCode.UInt16, out result6);
				ushort source3 = (ushort)result6;
				result = Unsafe.As<ushort, TEnum>(ref source3);
				return flag;
			}
			case TypeCode.UInt32:
			{
				bool flag = TryParseUInt32Enum(enumType, value, uint.MaxValue, ignoreCase, throwOnFailure, TypeCode.UInt32, out result6);
				result = Unsafe.As<uint, TEnum>(ref result6);
				return flag;
			}
			case TypeCode.Int64:
			{
				long result5;
				bool flag = TryParseInt64Enum(enumType, value, ignoreCase, throwOnFailure, out result5);
				result = Unsafe.As<long, TEnum>(ref result5);
				return flag;
			}
			case TypeCode.UInt64:
			{
				ulong result4;
				bool flag = TryParseUInt64Enum(enumType, value, ignoreCase, throwOnFailure, out result4);
				result = Unsafe.As<ulong, TEnum>(ref result4);
				return flag;
			}
			default:
			{
				object result2;
				bool flag = TryParseRareEnum(enumType, value, ignoreCase, throwOnFailure, out result2);
				result = (flag ? ((TEnum)result2) : default(TEnum));
				return flag;
			}
			}
		}

		private static bool TryParseInt32Enum(RuntimeType enumType, ReadOnlySpan<char> value, int minInclusive, int maxInclusive, bool ignoreCase, bool throwOnFailure, TypeCode type, out int result)
		{
			Number.ParsingStatus parsingStatus = Number.ParsingStatus.OK;
			if (StartsNumber(value[0]))
			{
				parsingStatus = Number.TryParseInt32IntegerStyle(value, NumberStyles.AllowTrailingWhite | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture.NumberFormat, out result);
				if (parsingStatus == Number.ParsingStatus.OK)
				{
					if ((uint)(result - minInclusive) <= (uint)(maxInclusive - minInclusive))
					{
						return true;
					}
					parsingStatus = Number.ParsingStatus.Overflow;
				}
			}
			ulong result2;
			if (parsingStatus == Number.ParsingStatus.Overflow)
			{
				if (throwOnFailure)
				{
					Number.ThrowOverflowException(type);
				}
			}
			else if (TryParseByName(enumType, value, ignoreCase, throwOnFailure, out result2))
			{
				result = (int)result2;
				return true;
			}
			result = 0;
			return false;
		}

		private static bool TryParseUInt32Enum(RuntimeType enumType, ReadOnlySpan<char> value, uint maxInclusive, bool ignoreCase, bool throwOnFailure, TypeCode type, out uint result)
		{
			Number.ParsingStatus parsingStatus = Number.ParsingStatus.OK;
			if (StartsNumber(value[0]))
			{
				parsingStatus = Number.TryParseUInt32IntegerStyle(value, NumberStyles.AllowTrailingWhite | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture.NumberFormat, out result);
				if (parsingStatus == Number.ParsingStatus.OK)
				{
					if (result <= maxInclusive)
					{
						return true;
					}
					parsingStatus = Number.ParsingStatus.Overflow;
				}
			}
			ulong result2;
			if (parsingStatus == Number.ParsingStatus.Overflow)
			{
				if (throwOnFailure)
				{
					Number.ThrowOverflowException(type);
				}
			}
			else if (TryParseByName(enumType, value, ignoreCase, throwOnFailure, out result2))
			{
				result = (uint)result2;
				return true;
			}
			result = 0u;
			return false;
		}

		private static bool TryParseInt64Enum(RuntimeType enumType, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, out long result)
		{
			Number.ParsingStatus parsingStatus = Number.ParsingStatus.OK;
			if (StartsNumber(value[0]))
			{
				parsingStatus = Number.TryParseInt64IntegerStyle(value, NumberStyles.AllowTrailingWhite | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture.NumberFormat, out result);
				if (parsingStatus == Number.ParsingStatus.OK)
				{
					return true;
				}
			}
			ulong result2;
			if (parsingStatus == Number.ParsingStatus.Overflow)
			{
				if (throwOnFailure)
				{
					Number.ThrowOverflowException(TypeCode.Int64);
				}
			}
			else if (TryParseByName(enumType, value, ignoreCase, throwOnFailure, out result2))
			{
				result = (long)result2;
				return true;
			}
			result = 0L;
			return false;
		}

		private static bool TryParseUInt64Enum(RuntimeType enumType, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, out ulong result)
		{
			Number.ParsingStatus parsingStatus = Number.ParsingStatus.OK;
			if (StartsNumber(value[0]))
			{
				parsingStatus = Number.TryParseUInt64IntegerStyle(value, NumberStyles.AllowTrailingWhite | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture.NumberFormat, out result);
				if (parsingStatus == Number.ParsingStatus.OK)
				{
					return true;
				}
			}
			if (parsingStatus == Number.ParsingStatus.Overflow)
			{
				if (throwOnFailure)
				{
					Number.ThrowOverflowException(TypeCode.UInt64);
				}
			}
			else if (TryParseByName(enumType, value, ignoreCase, throwOnFailure, out result))
			{
				return true;
			}
			result = 0uL;
			return false;
		}

		private static bool TryParseRareEnum(RuntimeType enumType, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, [NotNullWhen(true)] out object result)
		{
			if (StartsNumber(value[0]))
			{
				Type underlyingType = GetUnderlyingType(enumType);
				try
				{
					result = ToObject(enumType, Convert.ChangeType(value.ToString(), underlyingType, CultureInfo.InvariantCulture));
					return true;
				}
				catch (FormatException)
				{
				}
				catch when (!throwOnFailure)
				{
					result = null;
					return false;
				}
			}
			if (TryParseByName(enumType, value, ignoreCase, throwOnFailure, out var result2))
			{
				try
				{
					result = ToObject(enumType, result2);
					return true;
				}
				catch when (!throwOnFailure)
				{
				}
			}
			result = null;
			return false;
		}

		private static bool TryParseByName(RuntimeType enumType, ReadOnlySpan<char> value, bool ignoreCase, bool throwOnFailure, out ulong result)
		{
			ReadOnlySpan<char> readOnlySpan = value;
			EnumInfo enumInfo = GetEnumInfo(enumType);
			string[] names = enumInfo.Names;
			ulong[] values = enumInfo.Values;
			bool flag = true;
			ulong num = 0uL;
			while (value.Length > 0)
			{
				int num2 = value.IndexOf(',');
				ReadOnlySpan<char> span;
				if (num2 == -1)
				{
					span = value.Trim();
					value = default(ReadOnlySpan<char>);
				}
				else
				{
					if (num2 == value.Length - 1)
					{
						flag = false;
						break;
					}
					span = value.Slice(0, num2).Trim();
					value = value.Slice(num2 + 1);
				}
				bool flag2 = false;
				if (ignoreCase)
				{
					for (int i = 0; i < names.Length; i++)
					{
						if (span.EqualsOrdinalIgnoreCase(names[i]))
						{
							num |= values[i];
							flag2 = true;
							break;
						}
					}
				}
				else
				{
					for (int j = 0; j < names.Length; j++)
					{
						if (span.EqualsOrdinal(names[j]))
						{
							num |= values[j];
							flag2 = true;
							break;
						}
					}
				}
				if (!flag2)
				{
					flag = false;
					break;
				}
			}
			if (flag)
			{
				result = num;
				return true;
			}
			if (throwOnFailure)
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumValueNotFound, readOnlySpan.ToString()));
			}
			result = 0uL;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool StartsNumber(char c)
		{
			if (!char.IsInRange(c, '0', '9') && c != '-')
			{
				return c == '+';
			}
			return true;
		}

		public static object ToObject(Type enumType, object value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			return Convert.GetTypeCode(value) switch
			{
				TypeCode.Int32 => ToObject(enumType, (int)value), 
				TypeCode.SByte => ToObject(enumType, (sbyte)value), 
				TypeCode.Int16 => ToObject(enumType, (short)value), 
				TypeCode.Int64 => ToObject(enumType, (long)value), 
				TypeCode.UInt32 => ToObject(enumType, (uint)value), 
				TypeCode.Byte => ToObject(enumType, (byte)value), 
				TypeCode.UInt16 => ToObject(enumType, (ushort)value), 
				TypeCode.UInt64 => ToObject(enumType, (ulong)value), 
				TypeCode.Char => ToObject(enumType, (char)value), 
				TypeCode.Boolean => ToObject(enumType, (bool)value), 
				_ => throw new ArgumentException(SR.Arg_MustBeEnumBaseTypeOrEnum, "value"), 
			};
		}

		public static string Format(Type enumType, object value, string format)
		{
			RuntimeType enumType2 = ValidateRuntimeType(enumType);
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			Type type = value.GetType();
			if (type.IsEnum)
			{
				if (!type.IsEquivalentTo(enumType))
				{
					throw new ArgumentException(SR.Format(SR.Arg_EnumAndObjectMustBeSameType, type, enumType));
				}
				if (format.Length != 1)
				{
					throw new FormatException(SR.Format_InvalidEnumFormatSpecification);
				}
				return ((Enum)value).ToString(format);
			}
			Type underlyingType = GetUnderlyingType(enumType);
			if (type != underlyingType)
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumFormatUnderlyingTypeAndObjectMustBeSameType, type, underlyingType));
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'G':
				case 'g':
					return InternalFormat(enumType2, ToUInt64(value)) ?? value.ToString();
				case 'D':
				case 'd':
					return value.ToString();
				case 'X':
				case 'x':
					return ValueToHexString(value);
				case 'F':
				case 'f':
					return InternalFlagsFormat(enumType2, ToUInt64(value)) ?? value.ToString();
				}
			}
			throw new FormatException(SR.Format_InvalidEnumFormatSpecification);
		}

		internal object GetValue()
		{
			ref byte rawData = ref this.GetRawData();
			return InternalGetCorElementType() switch
			{
				CorElementType.ELEMENT_TYPE_I1 => Unsafe.As<byte, sbyte>(ref rawData), 
				CorElementType.ELEMENT_TYPE_U1 => rawData, 
				CorElementType.ELEMENT_TYPE_BOOLEAN => Unsafe.As<byte, bool>(ref rawData), 
				CorElementType.ELEMENT_TYPE_I2 => Unsafe.As<byte, short>(ref rawData), 
				CorElementType.ELEMENT_TYPE_U2 => Unsafe.As<byte, ushort>(ref rawData), 
				CorElementType.ELEMENT_TYPE_CHAR => Unsafe.As<byte, char>(ref rawData), 
				CorElementType.ELEMENT_TYPE_I4 => Unsafe.As<byte, int>(ref rawData), 
				CorElementType.ELEMENT_TYPE_U4 => Unsafe.As<byte, uint>(ref rawData), 
				CorElementType.ELEMENT_TYPE_R4 => Unsafe.As<byte, float>(ref rawData), 
				CorElementType.ELEMENT_TYPE_I8 => Unsafe.As<byte, long>(ref rawData), 
				CorElementType.ELEMENT_TYPE_U8 => Unsafe.As<byte, ulong>(ref rawData), 
				CorElementType.ELEMENT_TYPE_R8 => Unsafe.As<byte, double>(ref rawData), 
				CorElementType.ELEMENT_TYPE_I => Unsafe.As<byte, IntPtr>(ref rawData), 
				CorElementType.ELEMENT_TYPE_U => Unsafe.As<byte, UIntPtr>(ref rawData), 
				_ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType), 
			};
		}

		private ulong ToUInt64()
		{
			ref byte rawData = ref this.GetRawData();
			switch (InternalGetCorElementType())
			{
			case CorElementType.ELEMENT_TYPE_I1:
				return (ulong)Unsafe.As<byte, sbyte>(ref rawData);
			case CorElementType.ELEMENT_TYPE_U1:
				return rawData;
			case CorElementType.ELEMENT_TYPE_BOOLEAN:
				if (rawData == 0)
				{
					return 0uL;
				}
				return 1uL;
			case CorElementType.ELEMENT_TYPE_I2:
				return (ulong)Unsafe.As<byte, short>(ref rawData);
			case CorElementType.ELEMENT_TYPE_CHAR:
			case CorElementType.ELEMENT_TYPE_U2:
				return Unsafe.As<byte, ushort>(ref rawData);
			case CorElementType.ELEMENT_TYPE_I4:
				return (ulong)Unsafe.As<byte, int>(ref rawData);
			case CorElementType.ELEMENT_TYPE_U4:
			case CorElementType.ELEMENT_TYPE_R4:
				return Unsafe.As<byte, uint>(ref rawData);
			case CorElementType.ELEMENT_TYPE_I8:
				return (ulong)Unsafe.As<byte, long>(ref rawData);
			case CorElementType.ELEMENT_TYPE_U8:
			case CorElementType.ELEMENT_TYPE_R8:
				return Unsafe.As<byte, ulong>(ref rawData);
			case CorElementType.ELEMENT_TYPE_I:
				return (ulong)(long)Unsafe.As<byte, IntPtr>(ref rawData);
			case CorElementType.ELEMENT_TYPE_U:
				return (ulong)Unsafe.As<byte, UIntPtr>(ref rawData);
			default:
				throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
			}
		}

		public override int GetHashCode()
		{
			ref byte rawData = ref this.GetRawData();
			return InternalGetCorElementType() switch
			{
				CorElementType.ELEMENT_TYPE_I1 => Unsafe.As<byte, sbyte>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_U1 => rawData.GetHashCode(), 
				CorElementType.ELEMENT_TYPE_BOOLEAN => Unsafe.As<byte, bool>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_I2 => Unsafe.As<byte, short>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_U2 => Unsafe.As<byte, ushort>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_CHAR => Unsafe.As<byte, char>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_I4 => Unsafe.As<byte, int>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_U4 => Unsafe.As<byte, uint>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_R4 => Unsafe.As<byte, float>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_I8 => Unsafe.As<byte, long>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_U8 => Unsafe.As<byte, ulong>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_R8 => Unsafe.As<byte, double>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_I => Unsafe.As<byte, IntPtr>(ref rawData).GetHashCode(), 
				CorElementType.ELEMENT_TYPE_U => Unsafe.As<byte, UIntPtr>(ref rawData).GetHashCode(), 
				_ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType), 
			};
		}

		public override string ToString()
		{
			return InternalFormat((RuntimeType)GetType(), ToUInt64()) ?? ValueToString();
		}

		public int CompareTo(object? target)
		{
			if (target == this)
			{
				return 0;
			}
			if (target == null)
			{
				return 1;
			}
			if (GetType() != target.GetType())
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumAndObjectMustBeSameType, target.GetType(), GetType()));
			}
			ref byte rawData = ref this.GetRawData();
			ref byte rawData2 = ref target.GetRawData();
			switch (InternalGetCorElementType())
			{
			case CorElementType.ELEMENT_TYPE_I1:
				return Unsafe.As<byte, sbyte>(ref rawData).CompareTo(Unsafe.As<byte, sbyte>(ref rawData2));
			case CorElementType.ELEMENT_TYPE_BOOLEAN:
			case CorElementType.ELEMENT_TYPE_U1:
				return rawData.CompareTo(rawData2);
			case CorElementType.ELEMENT_TYPE_I2:
				return Unsafe.As<byte, short>(ref rawData).CompareTo(Unsafe.As<byte, short>(ref rawData2));
			case CorElementType.ELEMENT_TYPE_CHAR:
			case CorElementType.ELEMENT_TYPE_U2:
				return Unsafe.As<byte, ushort>(ref rawData).CompareTo(Unsafe.As<byte, ushort>(ref rawData2));
			case CorElementType.ELEMENT_TYPE_I4:
			case CorElementType.ELEMENT_TYPE_I:
				return Unsafe.As<byte, int>(ref rawData).CompareTo(Unsafe.As<byte, int>(ref rawData2));
			case CorElementType.ELEMENT_TYPE_U4:
			case CorElementType.ELEMENT_TYPE_U:
				return Unsafe.As<byte, uint>(ref rawData).CompareTo(Unsafe.As<byte, uint>(ref rawData2));
			case CorElementType.ELEMENT_TYPE_I8:
				return Unsafe.As<byte, long>(ref rawData).CompareTo(Unsafe.As<byte, long>(ref rawData2));
			case CorElementType.ELEMENT_TYPE_U8:
				return Unsafe.As<byte, ulong>(ref rawData).CompareTo(Unsafe.As<byte, ulong>(ref rawData2));
			case CorElementType.ELEMENT_TYPE_R4:
				return Unsafe.As<byte, float>(ref rawData).CompareTo(Unsafe.As<byte, float>(ref rawData2));
			case CorElementType.ELEMENT_TYPE_R8:
				return Unsafe.As<byte, double>(ref rawData).CompareTo(Unsafe.As<byte, double>(ref rawData2));
			default:
				throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
			}
		}

		[Obsolete("The provider argument is not used. Use ToString(String) instead.")]
		public string ToString(string? format, IFormatProvider? provider)
		{
			return ToString(format);
		}

		public string ToString(string? format)
		{
			if (string.IsNullOrEmpty(format))
			{
				return ToString();
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'G':
				case 'g':
					return ToString();
				case 'D':
				case 'd':
					return ValueToString();
				case 'X':
				case 'x':
					return ValueToHexString();
				case 'F':
				case 'f':
					return InternalFlagsFormat((RuntimeType)GetType(), ToUInt64()) ?? ValueToString();
				}
			}
			throw new FormatException(SR.Format_InvalidEnumFormatSpecification);
		}

		[Obsolete("The provider argument is not used. Use ToString() instead.")]
		public string ToString(IFormatProvider? provider)
		{
			return ToString();
		}

		public TypeCode GetTypeCode()
		{
			return InternalGetCorElementType() switch
			{
				CorElementType.ELEMENT_TYPE_I1 => TypeCode.SByte, 
				CorElementType.ELEMENT_TYPE_U1 => TypeCode.Byte, 
				CorElementType.ELEMENT_TYPE_BOOLEAN => TypeCode.Boolean, 
				CorElementType.ELEMENT_TYPE_I2 => TypeCode.Int16, 
				CorElementType.ELEMENT_TYPE_U2 => TypeCode.UInt16, 
				CorElementType.ELEMENT_TYPE_CHAR => TypeCode.Char, 
				CorElementType.ELEMENT_TYPE_I4 => TypeCode.Int32, 
				CorElementType.ELEMENT_TYPE_U4 => TypeCode.UInt32, 
				CorElementType.ELEMENT_TYPE_I8 => TypeCode.Int64, 
				CorElementType.ELEMENT_TYPE_U8 => TypeCode.UInt64, 
				_ => throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType), 
			};
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(GetValue());
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(GetValue());
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(GetValue());
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(GetValue());
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(GetValue());
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(GetValue());
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(GetValue());
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(GetValue());
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(GetValue());
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(GetValue());
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(GetValue());
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(GetValue());
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(GetValue());
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Enum", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[CLSCompliant(false)]
		public static object ToObject(Type enumType, sbyte value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value);
		}

		public static object ToObject(Type enumType, short value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value);
		}

		public static object ToObject(Type enumType, int value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value);
		}

		public static object ToObject(Type enumType, byte value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value);
		}

		[CLSCompliant(false)]
		public static object ToObject(Type enumType, ushort value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value);
		}

		[CLSCompliant(false)]
		public static object ToObject(Type enumType, uint value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value);
		}

		public static object ToObject(Type enumType, long value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value);
		}

		[CLSCompliant(false)]
		public static object ToObject(Type enumType, ulong value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), (long)value);
		}

		private static object ToObject(Type enumType, char value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value);
		}

		private static object ToObject(Type enumType, bool value)
		{
			return InternalBoxEnum(ValidateRuntimeType(enumType), value ? 1 : 0);
		}

		private static RuntimeType ValidateRuntimeType(Type enumType)
		{
			if (enumType == null)
			{
				throw new ArgumentNullException("enumType");
			}
			if (!enumType.IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "enumType");
			}
			if (!(enumType is RuntimeType result))
			{
				throw new ArgumentException(SR.Arg_MustBeType, "enumType");
			}
			return result;
		}
	}
	public static class Environment
	{
		public enum SpecialFolder
		{
			ApplicationData = 26,
			CommonApplicationData = 35,
			LocalApplicationData = 28,
			Cookies = 33,
			Desktop = 0,
			Favorites = 6,
			History = 34,
			InternetCache = 32,
			Programs = 2,
			MyComputer = 17,
			MyMusic = 13,
			MyPictures = 39,
			MyVideos = 14,
			Recent = 8,
			SendTo = 9,
			StartMenu = 11,
			Startup = 7,
			System = 37,
			Templates = 21,
			DesktopDirectory = 16,
			Personal = 5,
			MyDocuments = 5,
			ProgramFiles = 38,
			CommonProgramFiles = 43,
			AdminTools = 48,
			CDBurning = 59,
			CommonAdminTools = 47,
			CommonDocuments = 46,
			CommonMusic = 53,
			CommonOemLinks = 58,
			CommonPictures = 54,
			CommonStartMenu = 22,
			CommonPrograms = 23,
			CommonStartup = 24,
			CommonDesktopDirectory = 25,
			CommonTemplates = 45,
			CommonVideos = 55,
			Fonts = 20,
			NetworkShortcuts = 19,
			PrinterShortcuts = 27,
			UserProfile = 40,
			CommonProgramFilesX86 = 44,
			ProgramFilesX86 = 42,
			Resources = 56,
			LocalizedResources = 57,
			SystemX86 = 41,
			Windows = 36
		}

		public enum SpecialFolderOption
		{
			None = 0,
			Create = 32768,
			DoNotVerify = 16384
		}

		private static class WindowsVersion
		{
			internal static readonly bool IsWindows8OrAbove = GetIsWindows8OrAbove();

			private unsafe static bool GetIsWindows8OrAbove()
			{
				ulong conditionMask = Interop.Kernel32.VerSetConditionMask(0uL, 2u, 3);
				conditionMask = Interop.Kernel32.VerSetConditionMask(conditionMask, 1u, 3);
				conditionMask = Interop.Kernel32.VerSetConditionMask(conditionMask, 32u, 3);
				conditionMask = Interop.Kernel32.VerSetConditionMask(conditionMask, 16u, 3);
				Interop.Kernel32.OSVERSIONINFOEX lpVersionInfo = default(Interop.Kernel32.OSVERSIONINFOEX);
				lpVersionInfo.dwOSVersionInfoSize = sizeof(Interop.Kernel32.OSVERSIONINFOEX);
				lpVersionInfo.dwMajorVersion = 6;
				lpVersionInfo.dwMinorVersion = 2;
				lpVersionInfo.wServicePackMajor = 0;
				lpVersionInfo.wServicePackMinor = 0;
				return Interop.Kernel32.VerifyVersionInfoW(ref lpVersionInfo, 51u, conditionMask);
			}
		}

		private static string[] s_commandLineArgs;

		private static volatile int s_processId;

		private static volatile string s_processPath;

		private static volatile OperatingSystem s_osVersion;

		public static extern int CurrentManagedThreadId
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		public static extern int ExitCode
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			set;
		}

		public static extern int TickCount
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		public static extern long TickCount64
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		public static int ProcessorCount { get; } = GetProcessorCount();


		internal static bool IsSingleProcessor => ProcessorCount == 1;

		public static bool HasShutdownStarted => false;

		public static string CommandLine => PasteArguments.Paste(GetCommandLineArgs(), pasteFirstArgumentUsingArgV0Rules: true);

		public static string CurrentDirectory
		{
			get
			{
				return CurrentDirectoryCore;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value.Length == 0)
				{
					throw new ArgumentException(SR.Argument_PathEmpty, "value");
				}
				CurrentDirectoryCore = value;
			}
		}

		public static int ProcessId
		{
			get
			{
				int num = s_processId;
				if (num == 0)
				{
					Interlocked.CompareExchange(ref s_processId, GetProcessId(), 0);
					num = s_processId;
				}
				return num;
			}
		}

		public static string? ProcessPath
		{
			get
			{
				string text = s_processPath;
				if (text == null)
				{
					Interlocked.CompareExchange(ref s_processPath, GetProcessPath() ?? "", null);
					text = s_processPath;
				}
				if (text.Length == 0)
				{
					return null;
				}
				return text;
			}
		}

		public static bool Is64BitProcess => IntPtr.Size == 8;

		public static bool Is64BitOperatingSystem
		{
			get
			{
				_ = Is64BitProcess;
				return Is64BitOperatingSystemWhen32BitProcess;
			}
		}

		public static string NewLine => "\r\n";

		public static OperatingSystem OSVersion
		{
			get
			{
				OperatingSystem operatingSystem = s_osVersion;
				if (operatingSystem == null)
				{
					Interlocked.CompareExchange(ref s_osVersion, GetOSVersion(), null);
					operatingSystem = s_osVersion;
				}
				return operatingSystem;
			}
		}

		public static Version Version
		{
			get
			{
				string text = typeof(object).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion;
				ReadOnlySpan<char> readOnlySpan = text.AsSpan();
				int num = readOnlySpan.IndexOfAny('-', '+', ' ');
				if (num != -1)
				{
					readOnlySpan = readOnlySpan.Slice(0, num);
				}
				if (!System.Version.TryParse(readOnlySpan, out Version result))
				{
					return new Version();
				}
				return result;
			}
		}

		public static string StackTrace
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			get
			{
				return new StackTrace(fNeedFileInfo: true).ToString(System.Diagnostics.StackTrace.TraceFormat.Normal);
			}
		}

		internal static bool IsWindows8OrAbove => WindowsVersion.IsWindows8OrAbove;

		public static string UserName
		{
			get
			{
				Span<char> initialBuffer = stackalloc char[40];
				ValueStringBuilder builder = new ValueStringBuilder(initialBuffer);
				GetUserName(ref builder);
				ReadOnlySpan<char> span = builder.AsSpan();
				int num = span.IndexOf('\\');
				if (num != -1)
				{
					span = span.Slice(num + 1);
				}
				string result = span.ToString();
				builder.Dispose();
				return result;
			}
		}

		public static string UserDomainName
		{
			get
			{
				Span<char> initialBuffer = stackalloc char[40];
				ValueStringBuilder builder = new ValueStringBuilder(initialBuffer);
				GetUserName(ref builder);
				ReadOnlySpan<char> span = builder.AsSpan();
				int num = span.IndexOf('\\');
				if (num != -1)
				{
					builder.Length = num;
					return builder.ToString();
				}
				initialBuffer = stackalloc char[64];
				ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
				uint cchReferencedDomainName = (uint)valueStringBuilder.Capacity;
				Span<byte> span2 = stackalloc byte[68];
				uint cbSid = 68u;
				uint peUse;
				while (!Interop.Advapi32.LookupAccountNameW(null, ref builder.GetPinnableReference(), ref MemoryMarshal.GetReference(span2), ref cbSid, ref valueStringBuilder.GetPinnableReference(), ref cchReferencedDomainName, out peUse))
				{
					int lastPInvokeError = Marshal.GetLastPInvokeError();
					if (lastPInvokeError != 122)
					{
						throw new InvalidOperationException(Win32Marshal.GetMessage(lastPInvokeError));
					}
					valueStringBuilder.EnsureCapacity((int)cchReferencedDomainName);
				}
				builder.Dispose();
				valueStringBuilder.Length = (int)cchReferencedDomainName;
				return valueStringBuilder.ToString();
			}
		}

		private static string CurrentDirectoryCore
		{
			get
			{
				Span<char> initialBuffer = stackalloc char[260];
				ValueStringBuilder outputBuilder = new ValueStringBuilder(initialBuffer);
				uint currentDirectory;
				while ((currentDirectory = Interop.Kernel32.GetCurrentDirectory((uint)outputBuilder.Capacity, ref outputBuilder.GetPinnableReference())) > outputBuilder.Capacity)
				{
					outputBuilder.EnsureCapacity((int)currentDirectory);
				}
				if (currentDirectory == 0)
				{
					throw Win32Marshal.GetExceptionForLastWin32Error();
				}
				outputBuilder.Length = (int)currentDirectory;
				if (outputBuilder.AsSpan().Contains('~'))
				{
					string result = PathHelper.TryExpandShortFileName(ref outputBuilder, null);
					outputBuilder.Dispose();
					return result;
				}
				return outputBuilder.ToString();
			}
			set
			{
				if (!Interop.Kernel32.SetCurrentDirectory(value))
				{
					int lastPInvokeError = Marshal.GetLastPInvokeError();
					throw Win32Marshal.GetExceptionForWin32Error((lastPInvokeError == 2) ? 3 : lastPInvokeError, value);
				}
			}
		}

		public static int SystemPageSize
		{
			get
			{
				Interop.Kernel32.GetSystemInfo(out var lpSystemInfo);
				return lpSystemInfo.dwPageSize;
			}
		}

		private static bool Is64BitOperatingSystemWhen32BitProcess
		{
			get
			{
				bool Wow64Process;
				return Interop.Kernel32.IsWow64Process(Interop.Kernel32.GetCurrentProcess(), out Wow64Process) && Wow64Process;
			}
		}

		public static string MachineName => Interop.Kernel32.GetComputerName() ?? throw new InvalidOperationException(SR.InvalidOperation_ComputerName);

		public static string SystemDirectory
		{
			get
			{
				Span<char> initialBuffer = stackalloc char[32];
				ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
				uint systemDirectoryW;
				while ((systemDirectoryW = Interop.Kernel32.GetSystemDirectoryW(ref valueStringBuilder.GetPinnableReference(), (uint)valueStringBuilder.Capacity)) > valueStringBuilder.Capacity)
				{
					valueStringBuilder.EnsureCapacity((int)systemDirectoryW);
				}
				if (systemDirectoryW == 0)
				{
					throw Win32Marshal.GetExceptionForLastWin32Error();
				}
				valueStringBuilder.Length = (int)systemDirectoryW;
				return valueStringBuilder.ToString();
			}
		}

		public unsafe static bool UserInteractive
		{
			get
			{
				IntPtr processWindowStation = Interop.User32.GetProcessWindowStation();
				if (processWindowStation != IntPtr.Zero)
				{
					Interop.User32.USEROBJECTFLAGS uSEROBJECTFLAGS = default(Interop.User32.USEROBJECTFLAGS);
					uint lpnLengthNeeded = 0u;
					if (Interop.User32.GetUserObjectInformationW(processWindowStation, 1, &uSEROBJECTFLAGS, (uint)sizeof(Interop.User32.USEROBJECTFLAGS), ref lpnLengthNeeded))
					{
						return (uSEROBJECTFLAGS.dwFlags & 1) != 0;
					}
				}
				return true;
			}
		}

		public unsafe static long WorkingSet
		{
			get
			{
				Interop.Kernel32.PROCESS_MEMORY_COUNTERS ppsmemCounters = default(Interop.Kernel32.PROCESS_MEMORY_COUNTERS);
				ppsmemCounters.cb = (uint)sizeof(Interop.Kernel32.PROCESS_MEMORY_COUNTERS);
				if (!Interop.Kernel32.GetProcessMemoryInfo(Interop.Kernel32.GetCurrentProcess(), ref ppsmemCounters, ppsmemCounters.cb))
				{
					return 0L;
				}
				return (long)(ulong)ppsmemCounters.WorkingSetSize;
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		[DoesNotReturn]
		private static extern void _Exit(int exitCode);

		[DoesNotReturn]
		public static void Exit(int exitCode)
		{
			_Exit(exitCode);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[DoesNotReturn]
		public static extern void FailFast(string? message);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[DoesNotReturn]
		public static extern void FailFast(string? message, Exception? exception);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[DoesNotReturn]
		public static extern void FailFast(string? message, Exception? exception, string? errorMessage);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern string[] GetCommandLineArgsNative();

		public static string[] GetCommandLineArgs()
		{
			if (s_commandLineArgs == null)
			{
				return GetCommandLineArgsNative();
			}
			return (string[])s_commandLineArgs.Clone();
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetProcessorCount();

		internal static string GetResourceStringLocal(string key)
		{
			return SR.GetResourceString(key);
		}

		public static string? GetEnvironmentVariable(string variable)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			return GetEnvironmentVariableCore(variable);
		}

		public static string? GetEnvironmentVariable(string variable, EnvironmentVariableTarget target)
		{
			if (target == EnvironmentVariableTarget.Process)
			{
				return GetEnvironmentVariable(variable);
			}
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			bool fromMachine = ValidateAndConvertRegistryTarget(target);
			return GetEnvironmentVariableFromRegistry(variable, fromMachine);
		}

		public static IDictionary GetEnvironmentVariables(EnvironmentVariableTarget target)
		{
			if (target == EnvironmentVariableTarget.Process)
			{
				return GetEnvironmentVariables();
			}
			bool fromMachine = ValidateAndConvertRegistryTarget(target);
			return GetEnvironmentVariablesFromRegistry(fromMachine);
		}

		public static void SetEnvironmentVariable(string variable, string? value)
		{
			ValidateVariableAndValue(variable, ref value);
			SetEnvironmentVariableCore(variable, value);
		}

		public static void SetEnvironmentVariable(string variable, string? value, EnvironmentVariableTarget target)
		{
			if (target == EnvironmentVariableTarget.Process)
			{
				SetEnvironmentVariable(variable, value);
				return;
			}
			ValidateVariableAndValue(variable, ref value);
			bool fromMachine = ValidateAndConvertRegistryTarget(target);
			SetEnvironmentVariableFromRegistry(variable, value, fromMachine);
		}

		public static string ExpandEnvironmentVariables(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				return name;
			}
			return ExpandEnvironmentVariablesCore(name);
		}

		internal static void SetCommandLineArgs(string[] cmdLineArgs)
		{
			s_commandLineArgs = cmdLineArgs;
		}

		public static string GetFolderPath(SpecialFolder folder)
		{
			return GetFolderPath(folder, SpecialFolderOption.None);
		}

		public static string GetFolderPath(SpecialFolder folder, SpecialFolderOption option)
		{
			if (!Enum.IsDefined(typeof(SpecialFolder), folder))
			{
				throw new ArgumentOutOfRangeException("folder", folder, SR.Format(SR.Arg_EnumIllegalVal, folder));
			}
			if (option != 0 && !Enum.IsDefined(typeof(SpecialFolderOption), option))
			{
				throw new ArgumentOutOfRangeException("option", option, SR.Format(SR.Arg_EnumIllegalVal, option));
			}
			return GetFolderPathCore(folder, option);
		}

		private static bool ValidateAndConvertRegistryTarget(EnvironmentVariableTarget target)
		{
			return target switch
			{
				EnvironmentVariableTarget.Machine => true, 
				EnvironmentVariableTarget.User => false, 
				_ => throw new ArgumentOutOfRangeException("target", target, SR.Format(SR.Arg_EnumIllegalVal, target)), 
			};
		}

		private static void ValidateVariableAndValue(string variable, ref string value)
		{
			if (variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			if (variable.Length == 0)
			{
				throw new ArgumentException(SR.Argument_StringZeroLength, "variable");
			}
			if (variable[0] == '\0')
			{
				throw new ArgumentException(SR.Argument_StringFirstCharIsZero, "variable");
			}
			if (variable.Contains('='))
			{
				throw new ArgumentException(SR.Argument_IllegalEnvVarName, "variable");
			}
			if (string.IsNullOrEmpty(value) || value[0] == '\0')
			{
				value = null;
			}
		}

		private static string GetEnvironmentVariableFromRegistry(string variable, bool fromMachine)
		{
			using RegistryKey registryKey = OpenEnvironmentKeyIfExists(fromMachine, writable: false);
			return registryKey?.GetValue(variable) as string;
		}

		private unsafe static void SetEnvironmentVariableFromRegistry(string variable, string value, bool fromMachine)
		{
			if (!fromMachine && variable.Length >= 255)
			{
				throw new ArgumentException(SR.Argument_LongEnvVarValue, "variable");
			}
			using (RegistryKey registryKey = OpenEnvironmentKeyIfExists(fromMachine, writable: true))
			{
				if (registryKey != null)
				{
					if (value == null)
					{
						registryKey.DeleteValue(variable, throwOnMissingValue: false);
					}
					else
					{
						registryKey.SetValue(variable, value);
					}
				}
			}
			fixed (char* ptr = &"Environment".GetPinnableReference())
			{
				IntPtr pdwResult;
				IntPtr intPtr = Interop.User32.SendMessageTimeout(new IntPtr(65535), 26, IntPtr.Zero, (IntPtr)ptr, 0, 1000, out pdwResult);
			}
		}

		private static IDictionary GetEnvironmentVariablesFromRegistry(bool fromMachine)
		{
			Hashtable hashtable = new Hashtable();
			using (RegistryKey registryKey = OpenEnvironmentKeyIfExists(fromMachine, writable: false))
			{
				if (registryKey != null)
				{
					string[] valueNames = registryKey.GetValueNames();
					foreach (string text in valueNames)
					{
						string value = registryKey.GetValue(text, "").ToString();
						try
						{
							hashtable.Add(text, value);
						}
						catch (ArgumentException)
						{
						}
					}
				}
			}
			return hashtable;
		}

		private static RegistryKey OpenEnvironmentKeyIfExists(bool fromMachine, bool writable)
		{
			RegistryKey registryKey;
			string name;
			if (fromMachine)
			{
				registryKey = Registry.LocalMachine;
				name = "System\\CurrentControlSet\\Control\\Session Manager\\Environment";
			}
			else
			{
				registryKey = Registry.CurrentUser;
				name = "Environment";
			}
			return registryKey.OpenSubKey(name, writable);
		}

		private static void GetUserName(ref ValueStringBuilder builder)
		{
			uint lpnSize = 0u;
			while (Interop.Secur32.GetUserNameExW(2, ref builder.GetPinnableReference(), ref lpnSize) == Interop.BOOLEAN.FALSE)
			{
				if (Marshal.GetLastPInvokeError() == 234)
				{
					builder.EnsureCapacity(checked((int)lpnSize));
					continue;
				}
				builder.Length = 0;
				return;
			}
			builder.Length = (int)lpnSize;
		}

		private static string GetFolderPathCore(SpecialFolder folder, SpecialFolderOption option)
		{
			string folderGuid;
			switch (folder)
			{
			case SpecialFolder.ApplicationData:
				folderGuid = "{3EB685DB-65F9-4CF6-A03A-E3EF65729F3D}";
				break;
			case SpecialFolder.CommonApplicationData:
				folderGuid = "{62AB5D82-FDC1-4DC3-A9DD-070D1D495D97}";
				break;
			case SpecialFolder.LocalApplicationData:
				folderGuid = "{F1B32785-6FBA-4FCF-9D55-7B8E7F157091}";
				break;
			case SpecialFolder.Cookies:
				folderGuid = "{2B0F765D-C0E9-4171-908E-08A611B84FF6}";
				break;
			case SpecialFolder.Desktop:
				folderGuid = "{B4BFCC3A-DB2C-424C-B029-7FE99A87C641}";
				break;
			case SpecialFolder.Favorites:
				folderGuid = "{1777F761-68AD-4D8A-87BD-30B759FA33DD}";
				break;
			case SpecialFolder.History:
				folderGuid = "{D9DC8A3B-B784-432E-A781-5A1130A75963}";
				break;
			case SpecialFolder.InternetCache:
				folderGuid = "{352481E8-33BE-4251-BA85-6007CAEDCF9D}";
				break;
			case SpecialFolder.Programs:
				folderGuid = "{A77F5D77-2E2B-44C3-A6A2-ABA601054A51}";
				break;
			case SpecialFolder.MyComputer:
				folderGuid = "{0AC0837C-BBF8-452A-850D-79D08E667CA7}";
				break;
			case SpecialFolder.MyMusic:
				folderGuid = "{4BD8D571-6D19-48D3-BE97-422220080E43}";
				break;
			case SpecialFolder.MyPictures:
				folderGuid = "{33E28130-4E1E-4676-835A-98395C3BC3BB}";
				break;
			case SpecialFolder.MyVideos:
				folderGuid = "{18989B1D-99B5-455B-841C-AB7C74E4DDFC}";
				break;
			case SpecialFolder.Recent:
				folderGuid = "{AE50C081-EBD2-438A-8655-8A092E34987A}";
				break;
			case SpecialFolder.SendTo:
				folderGuid = "{8983036C-27C0-404B-8F08-102D10DCFD74}";
				break;
			case SpecialFolder.StartMenu:
				folderGuid = "{625B53C3-AB48-4EC1-BA1F-A1EF4146FC19}";
				break;
			case SpecialFolder.Startup:
				folderGuid = "{B97D20BB-F46A-4C97-BA10-5E3608430854}";
				break;
			case SpecialFolder.System:
				folderGuid = "{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}";
				break;
			case SpecialFolder.Templates:
				folderGuid = "{A63293E8-664E-48DB-A079-DF759E0509F7}";
				break;
			case SpecialFolder.DesktopDirectory:
				folderGuid = "{B4BFCC3A-DB2C-424C-B029-7FE99A87C641}";
				break;
			case SpecialFolder.Personal:
				folderGuid = "{FDD39AD0-238F-46AF-ADB4-6C85480369C7}";
				break;
			case SpecialFolder.ProgramFiles:
				folderGuid = "{905e63b6-c1bf-494e-b29c-65b732d3d21a}";
				break;
			case SpecialFolder.CommonProgramFiles:
				folderGuid = "{F7F1ED05-9F6D-47A2-AAAE-29D317C6F066}";
				break;
			case SpecialFolder.AdminTools:
				folderGuid = "{724EF170-A42D-4FEF-9F26-B60E846FBA4F}";
				break;
			case SpecialFolder.CDBurning:
				folderGuid = "{9E52AB10-F80D-49DF-ACB8-4330F5687855}";
				break;
			case SpecialFolder.CommonAdminTools:
				folderGuid = "{D0384E7D-BAC3-4797-8F14-CBA229B392B5}";
				break;
			case SpecialFolder.CommonDocuments:
				folderGuid = "{ED4824AF-DCE4-45A8-81E2-FC7965083634}";
				break;
			case SpecialFolder.CommonMusic:
				folderGuid = "{3214FAB5-9757-4298-BB61-92A9DEAA44FF}";
				break;
			case SpecialFolder.CommonOemLinks:
				folderGuid = "{C1BAE2D0-10DF-4334-BEDD-7AA20B227A9D}";
				break;
			case SpecialFolder.CommonPictures:
				folderGuid = "{B6EBFB86-6907-413C-9AF7-4FC2ABF07CC5}";
				break;
			case SpecialFolder.CommonStartMenu:
				folderGuid = "{A4115719-D62E-491D-AA7C-E74B8BE3B067}";
				break;
			case SpecialFolder.CommonPrograms:
				folderGuid = "{0139D44E-6AFE-49F2-8690-3DAFCAE6FFB8}";
				break;
			case SpecialFolder.CommonStartup:
				folderGuid = "{82A5EA35-D9CD-47C5-9629-E15D2F714E6E}";
				break;
			case SpecialFolder.CommonDesktopDirectory:
				folderGuid = "{C4AA340D-F20F-4863-AFEF-F87EF2E6BA25}";
				break;
			case SpecialFolder.CommonTemplates:
				folderGuid = "{B94237E7-57AC-4347-9151-B08C6C32D1F7}";
				break;
			case SpecialFolder.CommonVideos:
				folderGuid = "{2400183A-6185-49FB-A2D8-4A392A602BA3}";
				break;
			case SpecialFolder.Fonts:
				folderGuid = "{FD228CB7-AE11-4AE3-864C-16F3910AB8FE}";
				break;
			case SpecialFolder.NetworkShortcuts:
				folderGuid = "{C5ABBF53-E17F-4121-8900-86626FC2C973}";
				break;
			case SpecialFolder.PrinterShortcuts:
				folderGuid = "{76FC4E2D-D6AD-4519-A663-37BD56068185}";
				break;
			case SpecialFolder.UserProfile:
				folderGuid = "{5E6C858F-0E22-4760-9AFE-EA3317B67173}";
				break;
			case SpecialFolder.CommonProgramFilesX86:
				folderGuid = "{DE974D24-D9C6-4D3E-BF91-F4455120B917}";
				break;
			case SpecialFolder.ProgramFilesX86:
				folderGuid = "{7C5A40EF-A0FB-4BFC-874A-C0F2E0B9FA8E}";
				break;
			case SpecialFolder.Resources:
				folderGuid = "{8AD10C31-2ADB-4296-A8F7-E4701232C972}";
				break;
			case SpecialFolder.LocalizedResources:
				folderGuid = "{2A00375E-224C-49DE-B8D1-440DF7EF3DDC}";
				break;
			case SpecialFolder.SystemX86:
				folderGuid = "{D65231B0-B2F1-4857-A4CE-A8E7C6EA7D27}";
				break;
			case SpecialFolder.Windows:
				folderGuid = "{F38BF404-1D43-42F2-9305-67DE0B28FC23}";
				break;
			default:
				return string.Empty;
			}
			return GetKnownFolderPath(folderGuid, option);
		}

		private static string GetKnownFolderPath(string folderGuid, SpecialFolderOption option)
		{
			Guid rfid = new Guid(folderGuid);
			if (Interop.Shell32.SHGetKnownFolderPath(rfid, (uint)option, IntPtr.Zero, out var ppszPath) != 0)
			{
				return string.Empty;
			}
			return ppszPath;
		}

		public static string[] GetLogicalDrives()
		{
			return DriveInfoInternal.GetLogicalDrives();
		}

		private static string ExpandEnvironmentVariablesCore(string name)
		{
			Span<char> initialBuffer = stackalloc char[128];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			uint num;
			while ((num = Interop.Kernel32.ExpandEnvironmentStrings(name, ref valueStringBuilder.GetPinnableReference(), (uint)valueStringBuilder.Capacity)) > valueStringBuilder.Capacity)
			{
				valueStringBuilder.EnsureCapacity((int)num);
			}
			if (num == 0)
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
			valueStringBuilder.Length = (int)(num - 1);
			return valueStringBuilder.ToString();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static int GetProcessId()
		{
			return (int)Interop.Kernel32.GetCurrentProcessId();
		}

		private static string GetProcessPath()
		{
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			uint moduleFileName;
			while ((moduleFileName = Interop.Kernel32.GetModuleFileName(IntPtr.Zero, ref valueStringBuilder.GetPinnableReference(), (uint)valueStringBuilder.Capacity)) >= valueStringBuilder.Capacity)
			{
				valueStringBuilder.EnsureCapacity((int)moduleFileName);
			}
			if (moduleFileName == 0)
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
			valueStringBuilder.Length = (int)moduleFileName;
			return valueStringBuilder.ToString();
		}

		private unsafe static OperatingSystem GetOSVersion()
		{
			if (Interop.NtDll.RtlGetVersionEx(out var osvi) != 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_GetVersion);
			}
			Version version = new Version((int)osvi.dwMajorVersion, (int)osvi.dwMinorVersion, (int)osvi.dwBuildNumber, 0);
			if (osvi.szCSDVersion[0] == '\0')
			{
				return new OperatingSystem(PlatformID.Win32NT, version);
			}
			return new OperatingSystem(PlatformID.Win32NT, version, new string(osvi.szCSDVersion));
		}

		private static string GetEnvironmentVariableCore(string variable)
		{
			Span<char> initialBuffer = stackalloc char[128];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			uint environmentVariable;
			while ((environmentVariable = Interop.Kernel32.GetEnvironmentVariable(variable, ref valueStringBuilder.GetPinnableReference(), (uint)valueStringBuilder.Capacity)) > valueStringBuilder.Capacity)
			{
				valueStringBuilder.EnsureCapacity((int)environmentVariable);
			}
			if (environmentVariable == 0 && Marshal.GetLastPInvokeError() == 203)
			{
				valueStringBuilder.Dispose();
				return null;
			}
			valueStringBuilder.Length = (int)environmentVariable;
			return valueStringBuilder.ToString();
		}

		private static void SetEnvironmentVariableCore(string variable, string value)
		{
			if (!Interop.Kernel32.SetEnvironmentVariable(variable, value))
			{
				int lastPInvokeError = Marshal.GetLastPInvokeError();
				switch (lastPInvokeError)
				{
				case 203:
					break;
				case 206:
					throw new ArgumentException(SR.Argument_LongEnvVarValue);
				case 8:
				case 1450:
					throw new OutOfMemoryException(Interop.Kernel32.GetMessage(lastPInvokeError));
				default:
					throw new ArgumentException(Interop.Kernel32.GetMessage(lastPInvokeError));
				}
			}
		}

		public unsafe static IDictionary GetEnvironmentVariables()
		{
			char* environmentStringsW = Interop.Kernel32.GetEnvironmentStringsW();
			if (environmentStringsW == null)
			{
				throw new OutOfMemoryException();
			}
			try
			{
				Hashtable hashtable = new Hashtable();
				char* ptr = environmentStringsW;
				while (true)
				{
					ReadOnlySpan<char> span = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(ptr);
					if (span.IsEmpty)
					{
						break;
					}
					int num = span.IndexOf('=');
					if (num > 0)
					{
						string key = new string(span.Slice(0, num));
						string value = new string(span.Slice(num + 1));
						try
						{
							hashtable.Add(key, value);
						}
						catch (ArgumentException)
						{
						}
					}
					ptr += span.Length + 1;
				}
				return hashtable;
			}
			finally
			{
				Interop.BOOL bOOL = Interop.Kernel32.FreeEnvironmentStringsW(environmentStringsW);
			}
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Exception : ISerializable
	{
		internal enum ExceptionMessageKind
		{
			ThreadAbort = 1,
			ThreadInterrupted,
			OutOfMemory
		}

		internal readonly struct DispatchState
		{
			public readonly byte[] StackTrace;

			public readonly object[] DynamicMethods;

			public readonly string RemoteStackTrace;

			public readonly UIntPtr IpForWatsonBuckets;

			public readonly byte[] WatsonBuckets;

			public DispatchState(byte[] stackTrace, object[] dynamicMethods, string remoteStackTrace, UIntPtr ipForWatsonBuckets, byte[] watsonBuckets)
			{
				StackTrace = stackTrace;
				DynamicMethods = dynamicMethods;
				RemoteStackTrace = remoteStackTrace;
				IpForWatsonBuckets = ipForWatsonBuckets;
				WatsonBuckets = watsonBuckets;
			}
		}

		private MethodBase _exceptionMethod;

		internal string _message;

		private IDictionary _data;

		private readonly Exception _innerException;

		private string _helpURL;

		private byte[] _stackTrace;

		private byte[] _watsonBuckets;

		private string _stackTraceString;

		private string _remoteStackTraceString;

		private readonly object[] _dynamicMethods;

		private string _source;

		private UIntPtr _ipForWatsonBuckets;

		private readonly IntPtr _xptrs;

		private readonly int _xcode = -532462766;

		private int _HResult;

		private const int _COMPlusExceptionCode = -532462766;

		private protected const string InnerExceptionPrefix = " ---> ";

		public MethodBase? TargetSite
		{
			get
			{
				if (_exceptionMethod != null)
				{
					return _exceptionMethod;
				}
				if (_stackTrace == null)
				{
					return null;
				}
				_exceptionMethod = GetExceptionMethodFromStackTrace();
				return _exceptionMethod;
			}
		}

		private bool HasBeenThrown => _stackTrace != null;

		private object? SerializationWatsonBuckets => _watsonBuckets;

		public virtual string Message => _message ?? SR.Format(SR.Exception_WasThrown, GetClassName());

		public virtual IDictionary Data => _data ?? (_data = CreateDataContainer());

		public Exception? InnerException => _innerException;

		public virtual string? HelpLink
		{
			get
			{
				return _helpURL;
			}
			set
			{
				_helpURL = value;
			}
		}

		public virtual string? Source
		{
			get
			{
				return _source ?? (_source = CreateSourceName());
			}
			set
			{
				_source = value;
			}
		}

		public int HResult
		{
			get
			{
				return _HResult;
			}
			set
			{
				_HResult = value;
			}
		}

		public virtual string? StackTrace
		{
			get
			{
				string stackTraceString = _stackTraceString;
				string remoteStackTraceString = _remoteStackTraceString;
				if (stackTraceString != null)
				{
					return remoteStackTraceString + stackTraceString;
				}
				if (!HasBeenThrown)
				{
					return remoteStackTraceString;
				}
				return remoteStackTraceString + GetStackTrace();
			}
		}

		private string? SerializationStackTraceString
		{
			get
			{
				string text = _stackTraceString;
				if (text == null && HasBeenThrown)
				{
					text = GetStackTrace();
				}
				return text;
			}
		}

		[Obsolete("BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.", DiagnosticId = "SYSLIB0011", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		protected event EventHandler<SafeSerializationEventArgs>? SerializeObjectState
		{
			add
			{
				throw new PlatformNotSupportedException(SR.PlatformNotSupported_SecureBinarySerialization);
			}
			remove
			{
				throw new PlatformNotSupportedException(SR.PlatformNotSupported_SecureBinarySerialization);
			}
		}

		private IDictionary CreateDataContainer()
		{
			if (IsImmutableAgileException(this))
			{
				return new EmptyReadOnlyDictionaryInternal();
			}
			return new ListDictionaryInternal();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool IsImmutableAgileException(Exception e);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IRuntimeMethodInfo GetMethodFromStackTrace(object stackTrace);

		private MethodBase GetExceptionMethodFromStackTrace()
		{
			IRuntimeMethodInfo methodFromStackTrace = GetMethodFromStackTrace(_stackTrace);
			if (methodFromStackTrace == null)
			{
				return null;
			}
			return RuntimeType.GetMethodBase(methodFromStackTrace);
		}

		private string CreateSourceName()
		{
			StackTrace stackTrace = new StackTrace(this, fNeedFileInfo: false);
			if (stackTrace.FrameCount > 0)
			{
				StackFrame frame = stackTrace.GetFrame(0);
				MethodBase method = frame.GetMethod();
				Module module = method.Module;
				RuntimeModule runtimeModule = module as RuntimeModule;
				if ((object)runtimeModule == null)
				{
					if (!(module is ModuleBuilder moduleBuilder))
					{
						throw new ArgumentException(SR.Argument_MustBeRuntimeReflectionObject);
					}
					runtimeModule = moduleBuilder.InternalModule;
				}
				return runtimeModule.GetRuntimeAssembly().GetSimpleName();
			}
			return null;
		}

		[OnDeserialized]
		private void OnDeserialized(StreamingContext context)
		{
			_stackTrace = null;
			_ipForWatsonBuckets = UIntPtr.Zero;
		}

		internal void InternalPreserveStackTrace()
		{
			_ = Source;
			string stackTrace = StackTrace;
			if (!string.IsNullOrEmpty(stackTrace))
			{
				_remoteStackTraceString = stackTrace + "\r\n";
			}
			_stackTrace = null;
			_stackTraceString = null;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void PrepareForForeignExceptionRaise();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetStackTracesDeepCopy(Exception exception, out byte[] currentStackTrace, out object[] dynamicMethodArray);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void SaveStackTracesFromDeepCopy(Exception exception, byte[] currentStackTrace, object[] dynamicMethodArray);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern uint GetExceptionCount();

		internal void RestoreDispatchState(in DispatchState dispatchState)
		{
			if (!IsImmutableAgileException(this))
			{
				byte[] currentStackTrace = (byte[])dispatchState.StackTrace?.Clone();
				object[] dynamicMethodArray = (object[])dispatchState.DynamicMethods?.Clone();
				_watsonBuckets = dispatchState.WatsonBuckets;
				_ipForWatsonBuckets = dispatchState.IpForWatsonBuckets;
				_remoteStackTraceString = dispatchState.RemoteStackTrace;
				SaveStackTracesFromDeepCopy(this, currentStackTrace, dynamicMethodArray);
				_stackTraceString = null;
				PrepareForForeignExceptionRaise();
			}
		}

		internal static string GetMessageFromNativeResources(ExceptionMessageKind kind)
		{
			string s = null;
			GetMessageFromNativeResources(kind, new StringHandleOnStack(ref s));
			return s;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetMessageFromNativeResources(ExceptionMessageKind kind, StringHandleOnStack retMesg);

		internal DispatchState CaptureDispatchState()
		{
			GetStackTracesDeepCopy(this, out var currentStackTrace, out var dynamicMethodArray);
			return new DispatchState(currentStackTrace, dynamicMethodArray, _remoteStackTraceString, _ipForWatsonBuckets, _watsonBuckets);
		}

		private bool CanSetRemoteStackTrace()
		{
			if (IsImmutableAgileException(this))
			{
				return false;
			}
			if (_stackTrace != null || _stackTraceString != null || _remoteStackTraceString != null)
			{
				ThrowHelper.ThrowInvalidOperationException();
			}
			return true;
		}

		public Exception()
		{
			_HResult = -2146233088;
		}

		public Exception(string? message)
			: this()
		{
			_message = message;
		}

		public Exception(string? message, Exception? innerException)
			: this()
		{
			_message = message;
			_innerException = innerException;
		}

		protected Exception(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_message = info.GetString("Message");
			_data = (IDictionary)info.GetValueNoThrow("Data", typeof(IDictionary));
			_innerException = (Exception)info.GetValue("InnerException", typeof(Exception));
			_helpURL = info.GetString("HelpURL");
			_stackTraceString = info.GetString("StackTraceString");
			_remoteStackTraceString = info.GetString("RemoteStackTraceString");
			_HResult = info.GetInt32("HResult");
			_source = info.GetString("Source");
			RestoreRemoteStackTrace(info, context);
		}

		private string GetClassName()
		{
			return GetType().ToString();
		}

		public virtual Exception GetBaseException()
		{
			Exception innerException = InnerException;
			Exception result = this;
			while (innerException != null)
			{
				result = innerException;
				innerException = innerException.InnerException;
			}
			return result;
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			if (_source == null)
			{
				_source = Source;
			}
			info.AddValue("ClassName", GetClassName(), typeof(string));
			info.AddValue("Message", _message, typeof(string));
			info.AddValue("Data", _data, typeof(IDictionary));
			info.AddValue("InnerException", _innerException, typeof(Exception));
			info.AddValue("HelpURL", _helpURL, typeof(string));
			info.AddValue("StackTraceString", SerializationStackTraceString, typeof(string));
			info.AddValue("RemoteStackTraceString", _remoteStackTraceString, typeof(string));
			info.AddValue("RemoteStackIndex", 0, typeof(int));
			info.AddValue("ExceptionMethod", null, typeof(string));
			info.AddValue("HResult", _HResult);
			info.AddValue("Source", _source, typeof(string));
			info.AddValue("WatsonBuckets", SerializationWatsonBuckets, typeof(byte[]));
		}

		public override string ToString()
		{
			string className = GetClassName();
			string message = Message;
			string text = _innerException?.ToString() ?? "";
			string exception_EndOfInnerExceptionStack = SR.Exception_EndOfInnerExceptionStack;
			string stackTrace = StackTrace;
			int num = className.Length;
			checked
			{
				if (!string.IsNullOrEmpty(message))
				{
					num += 2 + message.Length;
				}
				if (_innerException != null)
				{
					num += "\r\n".Length + " ---> ".Length + text.Length + "\r\n".Length + 3 + exception_EndOfInnerExceptionStack.Length;
				}
				if (stackTrace != null)
				{
					num += "\r\n".Length + stackTrace.Length;
				}
				string text2 = string.FastAllocateString(num);
				Span<char> dest2 = new Span<char>(ref text2.GetRawStringData(), text2.Length);
				Write(className, ref dest2);
				if (!string.IsNullOrEmpty(message))
				{
					Write(": ", ref dest2);
					Write(message, ref dest2);
				}
				if (_innerException != null)
				{
					Write("\r\n", ref dest2);
					Write(" ---> ", ref dest2);
					Write(text, ref dest2);
					Write("\r\n", ref dest2);
					Write("   ", ref dest2);
					Write(exception_EndOfInnerExceptionStack, ref dest2);
				}
				if (stackTrace != null)
				{
					Write("\r\n", ref dest2);
					Write(stackTrace, ref dest2);
				}
				return text2;
			}
			static void Write(string source, ref Span<char> dest)
			{
				source.CopyTo(dest);
				dest = dest.Slice(source.Length);
			}
		}

		public new Type GetType()
		{
			return base.GetType();
		}

		private void RestoreRemoteStackTrace(SerializationInfo info, StreamingContext context)
		{
			_watsonBuckets = (byte[])info.GetValueNoThrow("WatsonBuckets", typeof(byte[]));
			if (context.State == StreamingContextStates.CrossAppDomain)
			{
				_remoteStackTraceString += _stackTraceString;
				_stackTraceString = null;
			}
		}

		private string GetStackTrace()
		{
			return new StackTrace(this, fNeedFileInfo: true).ToString(System.Diagnostics.StackTrace.TraceFormat.Normal);
		}

		[StackTraceHidden]
		internal void SetCurrentStackTrace()
		{
			if (CanSetRemoteStackTrace())
			{
				StringBuilder stringBuilder = new StringBuilder(256);
				new StackTrace(fNeedFileInfo: true).ToString(System.Diagnostics.StackTrace.TraceFormat.TrailingNewLine, stringBuilder);
				stringBuilder.AppendLine(SR.Exception_EndStackTraceFromPreviousThrow);
				_remoteStackTraceString = stringBuilder.ToString();
			}
		}

		internal void SetRemoteStackTrace(string stackTrace)
		{
			if (CanSetRemoteStackTrace())
			{
				_remoteStackTraceString = stackTrace + "\r\n" + SR.Exception_EndStackTraceFromPreviousThrow + "\r\n";
			}
		}
	}
	public enum GCCollectionMode
	{
		Default,
		Forced,
		Optimized
	}
	public enum GCNotificationStatus
	{
		Succeeded,
		Failed,
		Canceled,
		Timeout,
		NotApplicable
	}
	public static class GC
	{
		internal enum GC_ALLOC_FLAGS
		{
			GC_ALLOC_NO_FLAGS = 0,
			GC_ALLOC_ZEROING_OPTIONAL = 0x10,
			GC_ALLOC_PINNED_OBJECT_HEAP = 0x40
		}

		private enum StartNoGCRegionStatus
		{
			Succeeded,
			NotEnoughMemory,
			AmountTooLarge,
			AlreadyInProgress
		}

		private enum EndNoGCRegionStatus
		{
			Succeeded,
			NotInProgress,
			GCInduced,
			AllocationExceeded
		}

		public static int MaxGeneration => GetMaxGeneration();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetMemoryInfo(GCMemoryInfoData data, int kind);

		public static GCMemoryInfo GetGCMemoryInfo()
		{
			return GetGCMemoryInfo(GCKind.Any);
		}

		public static GCMemoryInfo GetGCMemoryInfo(GCKind kind)
		{
			if (kind < GCKind.Any || kind > GCKind.Background)
			{
				throw new ArgumentOutOfRangeException("kind", SR.Format(SR.ArgumentOutOfRange_Bounds_Lower_Upper, GCKind.Any, GCKind.Background));
			}
			GCMemoryInfoData data = new GCMemoryInfoData();
			GetMemoryInfo(data, (int)kind);
			return new GCMemoryInfo(data);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int _StartNoGCRegion(long totalSize, bool lohSizeKnown, long lohSize, bool disallowFullBlockingGC);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int _EndNoGCRegion();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern Array AllocateNewArray(IntPtr typeHandle, int length, GC_ALLOC_FLAGS flags);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int GetGenerationWR(IntPtr handle);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern long GetTotalMemory();

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _Collect(int generation, int mode);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int GetMaxGeneration();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int _CollectionCount(int generation, int getSpecialGCCount);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern ulong GetSegmentSize();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetLastGCPercentTimeInGC();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern ulong GetGenerationSize(int gen);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _AddMemoryPressure(ulong bytesAllocated);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _RemoveMemoryPressure(ulong bytesAllocated);

		public static void AddMemoryPressure(long bytesAllocated)
		{
			if (bytesAllocated <= 0)
			{
				throw new ArgumentOutOfRangeException("bytesAllocated", SR.ArgumentOutOfRange_NeedPosNum);
			}
			_ = 4;
			_ = IntPtr.Size;
			if (bytesAllocated > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("bytesAllocated", SR.ArgumentOutOfRange_MustBeNonNegInt32);
			}
			_AddMemoryPressure((ulong)bytesAllocated);
		}

		public static void RemoveMemoryPressure(long bytesAllocated)
		{
			if (bytesAllocated <= 0)
			{
				throw new ArgumentOutOfRangeException("bytesAllocated", SR.ArgumentOutOfRange_NeedPosNum);
			}
			_ = 4;
			_ = IntPtr.Size;
			if (bytesAllocated > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("bytesAllocated", SR.ArgumentOutOfRange_MustBeNonNegInt32);
			}
			_RemoveMemoryPressure((ulong)bytesAllocated);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern int GetGeneration(object obj);

		public static void Collect(int generation)
		{
			Collect(generation, GCCollectionMode.Default);
		}

		public static void Collect()
		{
			_Collect(-1, 2);
		}

		public static void Collect(int generation, GCCollectionMode mode)
		{
			Collect(generation, mode, blocking: true);
		}

		public static void Collect(int generation, GCCollectionMode mode, bool blocking)
		{
			Collect(generation, mode, blocking, compacting: false);
		}

		public static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting)
		{
			if (generation < 0)
			{
				throw new ArgumentOutOfRangeException("generation", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (mode < GCCollectionMode.Default || mode > GCCollectionMode.Optimized)
			{
				throw new ArgumentOutOfRangeException("mode", SR.ArgumentOutOfRange_Enum);
			}
			int num = 0;
			if (mode == GCCollectionMode.Optimized)
			{
				num |= 4;
			}
			if (compacting)
			{
				num |= 8;
			}
			if (blocking)
			{
				num |= 2;
			}
			else if (!compacting)
			{
				num |= 1;
			}
			_Collect(generation, num);
		}

		public static int CollectionCount(int generation)
		{
			if (generation < 0)
			{
				throw new ArgumentOutOfRangeException("generation", SR.ArgumentOutOfRange_GenericPositive);
			}
			return _CollectionCount(generation, 0);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[Intrinsic]
		public static void KeepAlive(object? obj)
		{
		}

		public static int GetGeneration(WeakReference wo)
		{
			int generationWR = GetGenerationWR(wo.m_handle);
			KeepAlive(wo);
			return generationWR;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _WaitForPendingFinalizers();

		public static void WaitForPendingFinalizers()
		{
			_WaitForPendingFinalizers();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _SuppressFinalize(object o);

		public static void SuppressFinalize(object obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			_SuppressFinalize(obj);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _ReRegisterForFinalize(object o);

		public static void ReRegisterForFinalize(object obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			_ReRegisterForFinalize(obj);
		}

		public static long GetTotalMemory(bool forceFullCollection)
		{
			long totalMemory = GetTotalMemory();
			if (!forceFullCollection)
			{
				return totalMemory;
			}
			int num = 20;
			long num2 = totalMemory;
			float num3;
			do
			{
				WaitForPendingFinalizers();
				Collect();
				totalMemory = num2;
				num2 = GetTotalMemory();
				num3 = (float)(num2 - totalMemory) / (float)totalMemory;
			}
			while (num-- > 0 && (!(-0.05 < (double)num3) || !((double)num3 < 0.05)));
			return num2;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern IntPtr _RegisterFrozenSegment(IntPtr sectionAddress, nint sectionSize);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _UnregisterFrozenSegment(IntPtr segmentHandle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern long GetAllocatedBytesForCurrentThread();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern long GetTotalAllocatedBytes(bool precise = false);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool _RegisterForFullGCNotification(int maxGenerationPercentage, int largeObjectHeapPercentage);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool _CancelFullGCNotification();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int _WaitForFullGCApproach(int millisecondsTimeout);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int _WaitForFullGCComplete(int millisecondsTimeout);

		public static void RegisterForFullGCNotification(int maxGenerationThreshold, int largeObjectHeapThreshold)
		{
			if (maxGenerationThreshold <= 0 || maxGenerationThreshold >= 100)
			{
				throw new ArgumentOutOfRangeException("maxGenerationThreshold", SR.Format(SR.ArgumentOutOfRange_Bounds_Lower_Upper, 1, 99));
			}
			if (largeObjectHeapThreshold <= 0 || largeObjectHeapThreshold >= 100)
			{
				throw new ArgumentOutOfRangeException("largeObjectHeapThreshold", SR.Format(SR.ArgumentOutOfRange_Bounds_Lower_Upper, 1, 99));
			}
			if (!_RegisterForFullGCNotification(maxGenerationThreshold, largeObjectHeapThreshold))
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotWithConcurrentGC);
			}
		}

		public static void CancelFullGCNotification()
		{
			if (!_CancelFullGCNotification())
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotWithConcurrentGC);
			}
		}

		public static GCNotificationStatus WaitForFullGCApproach()
		{
			return (GCNotificationStatus)_WaitForFullGCApproach(-1);
		}

		public static GCNotificationStatus WaitForFullGCApproach(int millisecondsTimeout)
		{
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			return (GCNotificationStatus)_WaitForFullGCApproach(millisecondsTimeout);
		}

		public static GCNotificationStatus WaitForFullGCComplete()
		{
			return (GCNotificationStatus)_WaitForFullGCComplete(-1);
		}

		public static GCNotificationStatus WaitForFullGCComplete(int millisecondsTimeout)
		{
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			return (GCNotificationStatus)_WaitForFullGCComplete(millisecondsTimeout);
		}

		private static bool StartNoGCRegionWorker(long totalSize, bool hasLohSize, long lohSize, bool disallowFullBlockingGC)
		{
			if (totalSize <= 0)
			{
				throw new ArgumentOutOfRangeException("totalSize", "totalSize can't be zero or negative");
			}
			if (hasLohSize)
			{
				if (lohSize <= 0)
				{
					throw new ArgumentOutOfRangeException("lohSize", "lohSize can't be zero or negative");
				}
				if (lohSize > totalSize)
				{
					throw new ArgumentOutOfRangeException("lohSize", "lohSize can't be greater than totalSize");
				}
			}
			return (StartNoGCRegionStatus)_StartNoGCRegion(totalSize, hasLohSize, lohSize, disallowFullBlockingGC) switch
			{
				StartNoGCRegionStatus.NotEnoughMemory => false, 
				StartNoGCRegionStatus.AlreadyInProgress => throw new InvalidOperationException("The NoGCRegion mode was already in progress"), 
				StartNoGCRegionStatus.AmountTooLarge => throw new ArgumentOutOfRangeException("totalSize", "totalSize is too large. For more information about setting the maximum size, see \"Latency Modes\" in https://go.microsoft.com/fwlink/?LinkId=522706"), 
				_ => true, 
			};
		}

		public static bool TryStartNoGCRegion(long totalSize)
		{
			return StartNoGCRegionWorker(totalSize, hasLohSize: false, 0L, disallowFullBlockingGC: false);
		}

		public static bool TryStartNoGCRegion(long totalSize, long lohSize)
		{
			return StartNoGCRegionWorker(totalSize, hasLohSize: true, lohSize, disallowFullBlockingGC: false);
		}

		public static bool TryStartNoGCRegion(long totalSize, bool disallowFullBlockingGC)
		{
			return StartNoGCRegionWorker(totalSize, hasLohSize: false, 0L, disallowFullBlockingGC);
		}

		public static bool TryStartNoGCRegion(long totalSize, long lohSize, bool disallowFullBlockingGC)
		{
			return StartNoGCRegionWorker(totalSize, hasLohSize: true, lohSize, disallowFullBlockingGC);
		}

		public static void EndNoGCRegion()
		{
			switch ((EndNoGCRegionStatus)_EndNoGCRegion())
			{
			case EndNoGCRegionStatus.NotInProgress:
				throw new InvalidOperationException("NoGCRegion mode must be set");
			case EndNoGCRegionStatus.GCInduced:
				throw new InvalidOperationException("Garbage collection was induced in NoGCRegion mode");
			case EndNoGCRegionStatus.AllocationExceeded:
				throw new InvalidOperationException("Allocated memory exceeds specified memory for NoGCRegion mode");
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T[] AllocateUninitializedArray<T>(int length, bool pinned = false)
		{
			if (!pinned)
			{
				if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
				{
					return new T[length];
				}
				if (length < 2048 / Unsafe.SizeOf<T>())
				{
					return new T[length];
				}
			}
			else if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			return AllocateNewUninitializedArray(length, pinned);
			static T[] AllocateNewUninitializedArray(int length, bool pinned)
			{
				GC_ALLOC_FLAGS gC_ALLOC_FLAGS = GC_ALLOC_FLAGS.GC_ALLOC_ZEROING_OPTIONAL;
				if (pinned)
				{
					gC_ALLOC_FLAGS |= GC_ALLOC_FLAGS.GC_ALLOC_PINNED_OBJECT_HEAP;
				}
				return Unsafe.As<T[]>(AllocateNewArray(typeof(T[]).TypeHandle.Value, length, gC_ALLOC_FLAGS));
			}
		}

		public static T[] AllocateArray<T>(int length, bool pinned = false)
		{
			GC_ALLOC_FLAGS flags = GC_ALLOC_FLAGS.GC_ALLOC_NO_FLAGS;
			if (pinned)
			{
				if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
				{
					ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
				}
				flags = GC_ALLOC_FLAGS.GC_ALLOC_PINNED_OBJECT_HEAP;
			}
			return Unsafe.As<T[]>(AllocateNewArray(typeof(T[]).TypeHandle.Value, length, flags));
		}
	}
	public static class Math
	{
		public const double E = 2.718281828459045;

		public const double PI = 3.141592653589793;

		public const double Tau = Math.PI * 2.0;

		private static readonly double[] roundPower10Double = new double[16]
		{
			1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
			10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0
		};

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Abs(double value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Abs(float value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Acos(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Acosh(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Asin(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Asinh(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Atan(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Atanh(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Atan2(double y, double x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Cbrt(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Ceiling(double a);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Cos(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Cosh(double value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Exp(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Floor(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double FusedMultiplyAdd(double x, double y, double z);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern int ILogB(double x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Log(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Log2(double x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Log10(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Pow(double x, double y);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Sin(double a);

		public unsafe static (double Sin, double Cos) SinCos(double x)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out double item);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out double item2);
			SinCos(x, &item, &item2);
			return (item, item2);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Sinh(double value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Sqrt(double d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Tan(double a);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern double Tanh(double value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern double ModF(double x, double* intptr);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void SinCos(double x, double* sin, double* cos);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short Abs(short value)
		{
			if (value < 0)
			{
				value = (short)(-value);
				if (value < 0)
				{
					ThrowAbsOverflow();
				}
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Abs(int value)
		{
			if (value < 0)
			{
				value = -value;
				if (value < 0)
				{
					ThrowAbsOverflow();
				}
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long Abs(long value)
		{
			if (value < 0)
			{
				value = -value;
				if (value < 0)
				{
					ThrowAbsOverflow();
				}
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static nint Abs(nint value)
		{
			if (value < 0)
			{
				value = -value;
				if (value < 0)
				{
					ThrowAbsOverflow();
				}
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static sbyte Abs(sbyte value)
		{
			if (value < 0)
			{
				value = (sbyte)(-value);
				if (value < 0)
				{
					ThrowAbsOverflow();
				}
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Abs(decimal value)
		{
			return decimal.Abs(in value);
		}

		[DoesNotReturn]
		[StackTraceHidden]
		private static void ThrowAbsOverflow()
		{
			throw new OverflowException(SR.Overflow_NegateTwosCompNum);
		}

		public static long BigMul(int a, int b)
		{
			return (long)a * (long)b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public unsafe static ulong BigMul(ulong a, ulong b, out ulong low)
		{
			if (Bmi2.X64.IsSupported)
			{
				System.Runtime.CompilerServices.Unsafe.SkipInit(out ulong num);
				ulong result = Bmi2.X64.MultiplyNoFlags(a, b, &num);
				low = num;
				return result;
			}
			if (ArmBase.Arm64.IsSupported)
			{
			}
			return SoftwareFallback(a, b, out low);
			static ulong SoftwareFallback(ulong a, ulong b, out ulong low)
			{
				uint num2 = (uint)a;
				uint num3 = (uint)(a >> 32);
				uint num4 = (uint)b;
				uint num5 = (uint)(b >> 32);
				ulong num6 = (ulong)num2 * (ulong)num4;
				ulong num7 = (ulong)((long)num3 * (long)num4) + (num6 >> 32);
				ulong num8 = (ulong)((long)num2 * (long)num5 + (uint)num7);
				low = (num8 << 32) | (uint)num6;
				return (ulong)((long)num3 * (long)num5 + (long)(num7 >> 32)) + (num8 >> 32);
			}
		}

		public static long BigMul(long a, long b, out long low)
		{
			if (ArmBase.Arm64.IsSupported)
			{
			}
			ulong low2;
			ulong num = BigMul((ulong)a, (ulong)b, out low2);
			low = (long)low2;
			return (long)num - ((a >> 63) & b) - ((b >> 63) & a);
		}

		public static double BitDecrement(double x)
		{
			long num = BitConverter.DoubleToInt64Bits(x);
			if (((num >> 32) & 0x7FF00000) >= 2146435072)
			{
				if (num != 9218868437227405312L)
				{
					return x;
				}
				return double.MaxValue;
			}
			if (num == 0L)
			{
				return -5E-324;
			}
			num += ((num < 0) ? 1 : (-1));
			return BitConverter.Int64BitsToDouble(num);
		}

		public static double BitIncrement(double x)
		{
			long num = BitConverter.DoubleToInt64Bits(x);
			if (((num >> 32) & 0x7FF00000) >= 2146435072)
			{
				if (num != -4503599627370496L)
				{
					return x;
				}
				return double.MinValue;
			}
			if (num == long.MinValue)
			{
				return double.Epsilon;
			}
			num += ((num >= 0) ? 1 : (-1));
			return BitConverter.Int64BitsToDouble(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double CopySign(double x, double y)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return VectorMath.ConditionalSelectBitwise(Vector128.CreateScalarUnsafe(-0.0), Vector128.CreateScalarUnsafe(y), Vector128.CreateScalarUnsafe(x)).ToScalar();
			}
			return SoftwareFallback(x, y);
			static double SoftwareFallback(double x, double y)
			{
				long num = BitConverter.DoubleToInt64Bits(x);
				long num2 = BitConverter.DoubleToInt64Bits(y);
				num &= 0x7FFFFFFFFFFFFFFFL;
				num2 &= long.MinValue;
				return BitConverter.Int64BitsToDouble(num | num2);
			}
		}

		public static int DivRem(int a, int b, out int result)
		{
			int num = a / b;
			result = a - num * b;
			return num;
		}

		public static long DivRem(long a, long b, out long result)
		{
			long num = a / b;
			result = a - num * b;
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		[CLSCompliant(false)]
		public static (sbyte Quotient, sbyte Remainder) DivRem(sbyte left, sbyte right)
		{
			sbyte b = (sbyte)(left / right);
			return (b, (sbyte)(left - b * right));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static (byte Quotient, byte Remainder) DivRem(byte left, byte right)
		{
			byte b = (byte)(left / right);
			return (b, (byte)(left - b * right));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static (short Quotient, short Remainder) DivRem(short left, short right)
		{
			short num = (short)(left / right);
			return (num, (short)(left - num * right));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		[CLSCompliant(false)]
		public static (ushort Quotient, ushort Remainder) DivRem(ushort left, ushort right)
		{
			ushort num = (ushort)(left / right);
			return (num, (ushort)(left - num * right));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static (int Quotient, int Remainder) DivRem(int left, int right)
		{
			int num = left / right;
			return (num, left - num * right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		[CLSCompliant(false)]
		public static (uint Quotient, uint Remainder) DivRem(uint left, uint right)
		{
			uint num = left / right;
			return (num, left - num * right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static (long Quotient, long Remainder) DivRem(long left, long right)
		{
			long num = left / right;
			return (num, left - num * right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		[CLSCompliant(false)]
		public static (ulong Quotient, ulong Remainder) DivRem(ulong left, ulong right)
		{
			ulong num = left / right;
			return (num, left - num * right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static (nint Quotient, nint Remainder) DivRem(nint left, nint right)
		{
			nint num = left / right;
			return (num, left - num * right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		[CLSCompliant(false)]
		public static (nuint Quotient, nuint Remainder) DivRem(nuint left, nuint right)
		{
			nuint num = left / right;
			return (num, left - num * right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Ceiling(decimal d)
		{
			return decimal.Ceiling(d);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte Clamp(byte value, byte min, byte max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Clamp(decimal value, decimal min, decimal max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Clamp(double value, double min, double max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short Clamp(short value, short min, short max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Clamp(int value, int min, int max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long Clamp(long value, long min, long max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static nint Clamp(nint value, nint min, nint max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static sbyte Clamp(sbyte value, sbyte min, sbyte max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Clamp(float value, float min, float max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ushort Clamp(ushort value, ushort min, ushort max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint Clamp(uint value, uint min, uint max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong Clamp(ulong value, ulong min, ulong max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static nuint Clamp(nuint value, nuint min, nuint max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Floor(decimal d)
		{
			return decimal.Floor(d);
		}

		public static double IEEERemainder(double x, double y)
		{
			if (double.IsNaN(x))
			{
				return x;
			}
			if (double.IsNaN(y))
			{
				return y;
			}
			double num = x % y;
			if (double.IsNaN(num))
			{
				return double.NaN;
			}
			if (num == 0.0 && double.IsNegative(x))
			{
				return -0.0;
			}
			double num2 = num - Abs(y) * (double)Sign(x);
			if (Abs(num2) == Abs(num))
			{
				double num3 = x / y;
				double value = Round(num3);
				if (Abs(value) > Abs(num3))
				{
					return num2;
				}
				return num;
			}
			if (Abs(num2) < Abs(num))
			{
				return num2;
			}
			return num;
		}

		public static double Log(double a, double newBase)
		{
			if (double.IsNaN(a))
			{
				return a;
			}
			if (double.IsNaN(newBase))
			{
				return newBase;
			}
			if (newBase == 1.0)
			{
				return double.NaN;
			}
			if (a != 1.0 && (newBase == 0.0 || double.IsPositiveInfinity(newBase)))
			{
				return double.NaN;
			}
			return Log(a) / Log(newBase);
		}

		[NonVersionable]
		public static byte Max(byte val1, byte val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Max(decimal val1, decimal val2)
		{
			return decimal.Max(in val1, in val2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Max(double val1, double val2)
		{
			if (val1 != val2)
			{
				if (!double.IsNaN(val1))
				{
					if (!(val2 < val1))
					{
						return val2;
					}
					return val1;
				}
				return val1;
			}
			if (!double.IsNegative(val2))
			{
				return val2;
			}
			return val1;
		}

		[NonVersionable]
		public static short Max(short val1, short val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[NonVersionable]
		public static int Max(int val1, int val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[NonVersionable]
		public static long Max(long val1, long val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[NonVersionable]
		public static nint Max(nint val1, nint val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static sbyte Max(sbyte val1, sbyte val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Max(float val1, float val2)
		{
			if (val1 != val2)
			{
				if (!float.IsNaN(val1))
				{
					if (!(val2 < val1))
					{
						return val2;
					}
					return val1;
				}
				return val1;
			}
			if (!float.IsNegative(val2))
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static ushort Max(ushort val1, ushort val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static uint Max(uint val1, uint val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static ulong Max(ulong val1, ulong val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static nuint Max(nuint val1, nuint val2)
		{
			if (val1 < val2)
			{
				return val2;
			}
			return val1;
		}

		public static double MaxMagnitude(double x, double y)
		{
			double num = Abs(x);
			double num2 = Abs(y);
			if (num > num2 || double.IsNaN(num))
			{
				return x;
			}
			if (num == num2)
			{
				if (!double.IsNegative(x))
				{
					return x;
				}
				return y;
			}
			return y;
		}

		[NonVersionable]
		public static byte Min(byte val1, byte val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Min(decimal val1, decimal val2)
		{
			return decimal.Min(in val1, in val2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Min(double val1, double val2)
		{
			if (val1 != val2 && !double.IsNaN(val1))
			{
				if (!(val1 < val2))
				{
					return val2;
				}
				return val1;
			}
			if (!double.IsNegative(val1))
			{
				return val2;
			}
			return val1;
		}

		[NonVersionable]
		public static short Min(short val1, short val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[NonVersionable]
		public static int Min(int val1, int val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[NonVersionable]
		public static long Min(long val1, long val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[NonVersionable]
		public static nint Min(nint val1, nint val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static sbyte Min(sbyte val1, sbyte val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Min(float val1, float val2)
		{
			if (val1 != val2 && !float.IsNaN(val1))
			{
				if (!(val1 < val2))
				{
					return val2;
				}
				return val1;
			}
			if (!float.IsNegative(val1))
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static ushort Min(ushort val1, ushort val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static uint Min(uint val1, uint val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static ulong Min(ulong val1, ulong val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public static nuint Min(nuint val1, nuint val2)
		{
			if (val1 > val2)
			{
				return val2;
			}
			return val1;
		}

		public static double MinMagnitude(double x, double y)
		{
			double num = Abs(x);
			double num2 = Abs(y);
			if (num < num2 || double.IsNaN(num))
			{
				return x;
			}
			if (num == num2)
			{
				if (!double.IsNegative(x))
				{
					return y;
				}
				return x;
			}
			return y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double ReciprocalEstimate(double d)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return 1.0 / d;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double ReciprocalSqrtEstimate(double d)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return 1.0 / Sqrt(d);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Round(decimal d)
		{
			return decimal.Round(d, 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Round(decimal d, int decimals)
		{
			return decimal.Round(d, decimals);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Round(decimal d, MidpointRounding mode)
		{
			return decimal.Round(d, 0, mode);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Round(decimal d, int decimals, MidpointRounding mode)
		{
			return decimal.Round(d, decimals, mode);
		}

		[Intrinsic]
		public static double Round(double a)
		{
			ulong num = BitConverter.DoubleToUInt64Bits(a);
			int num2 = double.ExtractExponentFromBits(num);
			if (num2 <= 1022)
			{
				if (num << 1 == 0L)
				{
					return a;
				}
				double x = ((num2 == 1022 && double.ExtractSignificandFromBits(num) != 0L) ? 1.0 : 0.0);
				return CopySign(x, a);
			}
			if (num2 >= 1075)
			{
				return a;
			}
			ulong num3 = (ulong)(1L << 1075 - num2);
			ulong num4 = num3 - 1;
			num += num3 >> 1;
			num = (((num & num4) != 0L) ? (num & ~num4) : (num & ~num3));
			return BitConverter.UInt64BitsToDouble(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Round(double value, int digits)
		{
			return Round(value, digits, MidpointRounding.ToEven);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Round(double value, MidpointRounding mode)
		{
			return Round(value, 0, mode);
		}

		public unsafe static double Round(double value, int digits, MidpointRounding mode)
		{
			if (digits < 0 || digits > 15)
			{
				throw new ArgumentOutOfRangeException("digits", SR.ArgumentOutOfRange_RoundingDigits);
			}
			if (mode < MidpointRounding.ToEven || mode > MidpointRounding.ToPositiveInfinity)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidEnumValue, mode, "MidpointRounding"), "mode");
			}
			if (Abs(value) < 10000000000000000.0)
			{
				double num = roundPower10Double[digits];
				value *= num;
				switch (mode)
				{
				case MidpointRounding.ToEven:
					value = Round(value);
					break;
				case MidpointRounding.AwayFromZero:
				{
					double value2 = ModF(value, &value);
					if (Abs(value2) >= 0.5)
					{
						value += (double)Sign(value2);
					}
					break;
				}
				case MidpointRounding.ToZero:
					value = Truncate(value);
					break;
				case MidpointRounding.ToNegativeInfinity:
					value = Floor(value);
					break;
				case MidpointRounding.ToPositiveInfinity:
					value = Ceiling(value);
					break;
				default:
					throw new ArgumentException(SR.Format(SR.Argument_InvalidEnumValue, mode, "MidpointRounding"), "mode");
				}
				value /= num;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Sign(decimal value)
		{
			return decimal.Sign(in value);
		}

		public static int Sign(double value)
		{
			if (value < 0.0)
			{
				return -1;
			}
			if (value > 0.0)
			{
				return 1;
			}
			if (value == 0.0)
			{
				return 0;
			}
			throw new ArithmeticException(SR.Arithmetic_NaN);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Sign(short value)
		{
			return Sign((int)value);
		}

		public static int Sign(int value)
		{
			return (value >> 31) | (-value >>> 31);
		}

		public static int Sign(long value)
		{
			return (int)((value >> 63) | (-value >>> 63));
		}

		public static int Sign(nint value)
		{
			return (int)(value >> 31) | (int)((uint)(-value) >> 31);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static int Sign(sbyte value)
		{
			return Sign((int)value);
		}

		public static int Sign(float value)
		{
			if (value < 0f)
			{
				return -1;
			}
			if (value > 0f)
			{
				return 1;
			}
			if (value == 0f)
			{
				return 0;
			}
			throw new ArithmeticException(SR.Arithmetic_NaN);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Truncate(decimal d)
		{
			return decimal.Truncate(d);
		}

		public unsafe static double Truncate(double d)
		{
			ModF(d, &d);
			return d;
		}

		[DoesNotReturn]
		private static void ThrowMinMaxException<T>(T min, T max)
		{
			throw new ArgumentException(SR.Format(SR.Argument_MinMaxValue, min, max));
		}

		public static double ScaleB(double x, int n)
		{
			double num = x;
			if (n > 1023)
			{
				num *= 8.98846567431158E+307;
				n -= 1023;
				if (n > 1023)
				{
					num *= 8.98846567431158E+307;
					n -= 1023;
					if (n > 1023)
					{
						n = 1023;
					}
				}
			}
			else if (n < -1022)
			{
				num *= 2.004168360008973E-292;
				n += 969;
				if (n < -1022)
				{
					num *= 2.004168360008973E-292;
					n += 969;
					if (n < -1022)
					{
						n = -1022;
					}
				}
			}
			double num2 = BitConverter.Int64BitsToDouble((long)(1023 + n) << 52);
			return num * num2;
		}
	}
	public static class MathF
	{
		public const float E = 2.7182817f;

		public const float PI = 3.1415927f;

		public const float Tau = (float)Math.PI * 2f;

		private static readonly float[] roundPower10Single = new float[7] { 1f, 10f, 100f, 1000f, 10000f, 100000f, 1000000f };

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Acos(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Acosh(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Asin(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Asinh(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Atan(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Atanh(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Atan2(float y, float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Cbrt(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Ceiling(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Cos(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Cosh(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Exp(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Floor(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float FusedMultiplyAdd(float x, float y, float z);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern int ILogB(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Log(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Log2(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Log10(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Pow(float x, float y);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Sin(float x);

		public unsafe static (float Sin, float Cos) SinCos(float x)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out float item);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out float item2);
			SinCos(x, &item, &item2);
			return (item, item2);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Sinh(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Sqrt(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Tan(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern float Tanh(float x);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern float ModF(float x, float* intptr);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void SinCos(float x, float* sin, float* cos);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Abs(float x)
		{
			return Math.Abs(x);
		}

		public static float BitDecrement(float x)
		{
			int num = BitConverter.SingleToInt32Bits(x);
			if ((num & 0x7F800000) >= 2139095040)
			{
				if (num != 2139095040)
				{
					return x;
				}
				return float.MaxValue;
			}
			if (num == 0)
			{
				return -1E-45f;
			}
			num += ((num < 0) ? 1 : (-1));
			return BitConverter.Int32BitsToSingle(num);
		}

		public static float BitIncrement(float x)
		{
			int num = BitConverter.SingleToInt32Bits(x);
			if ((num & 0x7F800000) >= 2139095040)
			{
				if (num != -8388608)
				{
					return x;
				}
				return float.MinValue;
			}
			if (num == int.MinValue)
			{
				return float.Epsilon;
			}
			num += ((num >= 0) ? 1 : (-1));
			return BitConverter.Int32BitsToSingle(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float CopySign(float x, float y)
		{
			if (Sse.IsSupported || AdvSimd.IsSupported)
			{
				return VectorMath.ConditionalSelectBitwise(Vector128.CreateScalarUnsafe(-0f), Vector128.CreateScalarUnsafe(y), Vector128.CreateScalarUnsafe(x)).ToScalar();
			}
			return SoftwareFallback(x, y);
			static float SoftwareFallback(float x, float y)
			{
				int num = BitConverter.SingleToInt32Bits(x);
				int num2 = BitConverter.SingleToInt32Bits(y);
				num &= 0x7FFFFFFF;
				num2 &= int.MinValue;
				return BitConverter.Int32BitsToSingle(num | num2);
			}
		}

		public static float IEEERemainder(float x, float y)
		{
			if (float.IsNaN(x))
			{
				return x;
			}
			if (float.IsNaN(y))
			{
				return y;
			}
			float num = x % y;
			if (float.IsNaN(num))
			{
				return float.NaN;
			}
			if (num == 0f && float.IsNegative(x))
			{
				return -0f;
			}
			float num2 = num - Abs(y) * (float)Sign(x);
			if (Abs(num2) == Abs(num))
			{
				float x2 = x / y;
				float x3 = Round(x2);
				if (Abs(x3) > Abs(x2))
				{
					return num2;
				}
				return num;
			}
			if (Abs(num2) < Abs(num))
			{
				return num2;
			}
			return num;
		}

		public static float Log(float x, float y)
		{
			if (float.IsNaN(x))
			{
				return x;
			}
			if (float.IsNaN(y))
			{
				return y;
			}
			if (y == 1f)
			{
				return float.NaN;
			}
			if (x != 1f && (y == 0f || float.IsPositiveInfinity(y)))
			{
				return float.NaN;
			}
			return Log(x) / Log(y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Max(float x, float y)
		{
			return Math.Max(x, y);
		}

		public static float MaxMagnitude(float x, float y)
		{
			float num = Abs(x);
			float num2 = Abs(y);
			if (num > num2 || float.IsNaN(num))
			{
				return x;
			}
			if (num == num2)
			{
				if (!float.IsNegative(x))
				{
					return x;
				}
				return y;
			}
			return y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Min(float x, float y)
		{
			return Math.Min(x, y);
		}

		public static float MinMagnitude(float x, float y)
		{
			float num = Abs(x);
			float num2 = Abs(y);
			if (num < num2 || float.IsNaN(num))
			{
				return x;
			}
			if (num == num2)
			{
				if (!float.IsNegative(x))
				{
					return y;
				}
				return x;
			}
			return y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ReciprocalEstimate(float x)
		{
			if (Sse.IsSupported)
			{
				return Sse.ReciprocalScalar(Vector128.CreateScalarUnsafe(x)).ToScalar();
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return 1f / x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ReciprocalSqrtEstimate(float x)
		{
			if (Sse.IsSupported)
			{
				return Sse.ReciprocalSqrtScalar(Vector128.CreateScalarUnsafe(x)).ToScalar();
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return 1f / Sqrt(x);
		}

		[Intrinsic]
		public static float Round(float x)
		{
			uint num = BitConverter.SingleToUInt32Bits(x);
			int num2 = float.ExtractExponentFromBits(num);
			if (num2 <= 126)
			{
				if (num << 1 == 0)
				{
					return x;
				}
				float x2 = ((num2 == 126 && float.ExtractSignificandFromBits(num) != 0) ? 1f : 0f);
				return CopySign(x2, x);
			}
			if (num2 >= 150)
			{
				return x;
			}
			uint num3 = (uint)(1 << 150 - num2);
			uint num4 = num3 - 1;
			num += num3 >> 1;
			num = (((num & num4) != 0) ? (num & ~num4) : (num & ~num3));
			return BitConverter.UInt32BitsToSingle(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Round(float x, int digits)
		{
			return Round(x, digits, MidpointRounding.ToEven);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Round(float x, MidpointRounding mode)
		{
			return Round(x, 0, mode);
		}

		public unsafe static float Round(float x, int digits, MidpointRounding mode)
		{
			if (digits < 0 || digits > 6)
			{
				throw new ArgumentOutOfRangeException("digits", SR.ArgumentOutOfRange_RoundingDigits_MathF);
			}
			if (mode < MidpointRounding.ToEven || mode > MidpointRounding.ToPositiveInfinity)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidEnumValue, mode, "MidpointRounding"), "mode");
			}
			if (Abs(x) < 100000000f)
			{
				float num = roundPower10Single[digits];
				x *= num;
				switch (mode)
				{
				case MidpointRounding.ToEven:
					x = Round(x);
					break;
				case MidpointRounding.AwayFromZero:
				{
					float x2 = ModF(x, &x);
					if (Abs(x2) >= 0.5f)
					{
						x += (float)Sign(x2);
					}
					break;
				}
				case MidpointRounding.ToZero:
					x = Truncate(x);
					break;
				case MidpointRounding.ToNegativeInfinity:
					x = Floor(x);
					break;
				case MidpointRounding.ToPositiveInfinity:
					x = Ceiling(x);
					break;
				default:
					throw new ArgumentException(SR.Format(SR.Argument_InvalidEnumValue, mode, "MidpointRounding"), "mode");
				}
				x /= num;
			}
			return x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Sign(float x)
		{
			return Math.Sign(x);
		}

		public unsafe static float Truncate(float x)
		{
			ModF(x, &x);
			return x;
		}

		public static float ScaleB(float x, int n)
		{
			float num = x;
			if (n > 127)
			{
				num *= 1.7014118E+38f;
				n -= 127;
				if (n > 127)
				{
					num *= 1.7014118E+38f;
					n -= 127;
					if (n > 127)
					{
						n = 127;
					}
				}
			}
			else if (n < -126)
			{
				num *= 1.9721523E-31f;
				n += 102;
				if (n < -126)
				{
					num *= 1.9721523E-31f;
					n += 102;
					if (n < -126)
					{
						n = -126;
					}
				}
			}
			float num2 = BitConverter.Int32BitsToSingle(127 + n << 23);
			return num * num2;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class MissingMemberException : MemberAccessException, ISerializable
	{
		protected string? ClassName;

		protected string? MemberName;

		protected byte[]? Signature;

		public override string Message
		{
			get
			{
				if (ClassName == null)
				{
					return base.Message;
				}
				return SR.Format(SR.MissingMember_Name, ClassName + "." + MemberName + ((Signature != null) ? (" " + FormatSignature(Signature)) : string.Empty));
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern string FormatSignature(byte[] signature);

		public MissingMemberException()
			: base(SR.Arg_MissingMemberException)
		{
			base.HResult = -2146233070;
		}

		public MissingMemberException(string? message)
			: base(message)
		{
			base.HResult = -2146233070;
		}

		public MissingMemberException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233070;
		}

		public MissingMemberException(string? className, string? memberName)
		{
			ClassName = className;
			MemberName = memberName;
		}

		protected MissingMemberException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			ClassName = info.GetString("MMClassName");
			MemberName = info.GetString("MMMemberName");
			Signature = (byte[])info.GetValue("MMSignature", typeof(byte[]));
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("MMClassName", ClassName, typeof(string));
			info.AddValue("MMMemberName", MemberName, typeof(string));
			info.AddValue("MMSignature", Signature, typeof(byte[]));
		}
	}
	[ClassInterface(ClassInterfaceType.None)]
	[ComVisible(true)]
	public abstract class MulticastDelegate : Delegate
	{
		private object _invocationList;

		private IntPtr _invocationCount;

		[RequiresUnreferencedCode("The target method might be removed")]
		protected MulticastDelegate(object target, string method)
			: base(target, method)
		{
		}

		protected MulticastDelegate([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type target, string method)
			: base(target, method)
		{
		}

		internal bool IsUnmanagedFunctionPtr()
		{
			return _invocationCount == (IntPtr)(-1);
		}

		internal bool InvocationListLogicallyNull()
		{
			if (_invocationList != null && !(_invocationList is LoaderAllocator))
			{
				return _invocationList is DynamicResolver;
			}
			return true;
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new SerializationException(SR.Serialization_DelegatesNotSupported);
		}

		public sealed override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (this == obj)
			{
				return true;
			}
			if (!Delegate.InternalEqualTypes(this, obj))
			{
				return false;
			}
			MulticastDelegate multicastDelegate = Unsafe.As<MulticastDelegate>(obj);
			if (_invocationCount != (IntPtr)0)
			{
				if (InvocationListLogicallyNull())
				{
					if (IsUnmanagedFunctionPtr())
					{
						if (!multicastDelegate.IsUnmanagedFunctionPtr())
						{
							return false;
						}
						return Delegate.CompareUnmanagedFunctionPtrs(this, multicastDelegate);
					}
					if (multicastDelegate._invocationList is Delegate)
					{
						return Equals(multicastDelegate._invocationList);
					}
					return base.Equals(obj);
				}
				if (_invocationList is Delegate @delegate)
				{
					return @delegate.Equals(obj);
				}
				return InvocationListEquals(multicastDelegate);
			}
			if (!InvocationListLogicallyNull())
			{
				if (!_invocationList.Equals(multicastDelegate._invocationList))
				{
					return false;
				}
				return base.Equals((object?)multicastDelegate);
			}
			if (multicastDelegate._invocationList is Delegate)
			{
				return Equals(multicastDelegate._invocationList);
			}
			return base.Equals((object?)multicastDelegate);
		}

		private bool InvocationListEquals(MulticastDelegate d)
		{
			object[] array = (object[])_invocationList;
			if (d._invocationCount != _invocationCount)
			{
				return false;
			}
			int num = (int)_invocationCount;
			for (int i = 0; i < num; i++)
			{
				Delegate @delegate = (Delegate)array[i];
				object[] array2 = d._invocationList as object[];
				if (!@delegate.Equals(array2[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool TrySetSlot(object[] a, int index, object o)
		{
			if (a[index] == null && Interlocked.CompareExchange<object>(ref a[index], o, (object)null) == null)
			{
				return true;
			}
			object obj = a[index];
			if (obj != null)
			{
				MulticastDelegate multicastDelegate = (MulticastDelegate)o;
				MulticastDelegate multicastDelegate2 = (MulticastDelegate)obj;
				if (multicastDelegate2._methodPtr == multicastDelegate._methodPtr && multicastDelegate2._target == multicastDelegate._target && multicastDelegate2._methodPtrAux == multicastDelegate._methodPtrAux)
				{
					return true;
				}
			}
			return false;
		}

		private MulticastDelegate NewMulticastDelegate(object[] invocationList, int invocationCount, bool thisIsMultiCastAlready)
		{
			MulticastDelegate multicastDelegate = Delegate.InternalAllocLike(this);
			if (thisIsMultiCastAlready)
			{
				multicastDelegate._methodPtr = _methodPtr;
				multicastDelegate._methodPtrAux = _methodPtrAux;
			}
			else
			{
				multicastDelegate._methodPtr = GetMulticastInvoke();
				multicastDelegate._methodPtrAux = GetInvokeMethod();
			}
			multicastDelegate._target = multicastDelegate;
			multicastDelegate._invocationList = invocationList;
			multicastDelegate._invocationCount = (IntPtr)invocationCount;
			return multicastDelegate;
		}

		internal MulticastDelegate NewMulticastDelegate(object[] invocationList, int invocationCount)
		{
			return NewMulticastDelegate(invocationList, invocationCount, thisIsMultiCastAlready: false);
		}

		internal void StoreDynamicMethod(MethodInfo dynamicMethod)
		{
			if (_invocationCount != (IntPtr)0)
			{
				MulticastDelegate multicastDelegate = (MulticastDelegate)_invocationList;
				multicastDelegate._methodBase = dynamicMethod;
			}
			else
			{
				_methodBase = dynamicMethod;
			}
		}

		protected sealed override Delegate CombineImpl(Delegate? follow)
		{
			if ((object)follow == null)
			{
				return this;
			}
			if (!Delegate.InternalEqualTypes(this, follow))
			{
				throw new ArgumentException(SR.Arg_DlgtTypeMis);
			}
			MulticastDelegate multicastDelegate = (MulticastDelegate)follow;
			int num = 1;
			object[] array = multicastDelegate._invocationList as object[];
			if (array != null)
			{
				num = (int)multicastDelegate._invocationCount;
			}
			int num2;
			object[] array3;
			if (!(_invocationList is object[] array2))
			{
				num2 = 1 + num;
				array3 = new object[num2];
				array3[0] = this;
				if (array == null)
				{
					array3[1] = multicastDelegate;
				}
				else
				{
					for (int i = 0; i < num; i++)
					{
						array3[1 + i] = array[i];
					}
				}
				return NewMulticastDelegate(array3, num2);
			}
			int num3 = (int)_invocationCount;
			num2 = num3 + num;
			array3 = null;
			if (num2 <= array2.Length)
			{
				array3 = array2;
				if (array == null)
				{
					if (!TrySetSlot(array3, num3, multicastDelegate))
					{
						array3 = null;
					}
				}
				else
				{
					for (int j = 0; j < num; j++)
					{
						if (!TrySetSlot(array3, num3 + j, array[j]))
						{
							array3 = null;
							break;
						}
					}
				}
			}
			if (array3 == null)
			{
				int num4;
				for (num4 = array2.Length; num4 < num2; num4 *= 2)
				{
				}
				array3 = new object[num4];
				for (int k = 0; k < num3; k++)
				{
					array3[k] = array2[k];
				}
				if (array == null)
				{
					array3[num3] = multicastDelegate;
				}
				else
				{
					for (int l = 0; l < num; l++)
					{
						array3[num3 + l] = array[l];
					}
				}
			}
			return NewMulticastDelegate(array3, num2, thisIsMultiCastAlready: true);
		}

		private object[] DeleteFromInvocationList(object[] invocationList, int invocationCount, int deleteIndex, int deleteCount)
		{
			object[] array = (object[])_invocationList;
			int num = array.Length;
			while (num / 2 >= invocationCount - deleteCount)
			{
				num /= 2;
			}
			object[] array2 = new object[num];
			for (int i = 0; i < deleteIndex; i++)
			{
				array2[i] = invocationList[i];
			}
			for (int j = deleteIndex + deleteCount; j < invocationCount; j++)
			{
				array2[j - deleteCount] = invocationList[j];
			}
			return array2;
		}

		private static bool EqualInvocationLists(object[] a, object[] b, int start, int count)
		{
			for (int i = 0; i < count; i++)
			{
				if (!a[start + i].Equals(b[i]))
				{
					return false;
				}
			}
			return true;
		}

		protected sealed override Delegate? RemoveImpl(Delegate value)
		{
			if (!(value is MulticastDelegate multicastDelegate))
			{
				return this;
			}
			if (!(multicastDelegate._invocationList is object[]))
			{
				if (!(_invocationList is object[] array))
				{
					if (Equals(value))
					{
						return null;
					}
				}
				else
				{
					int num = (int)_invocationCount;
					int num2 = num;
					while (--num2 >= 0)
					{
						if (value.Equals(array[num2]))
						{
							if (num == 2)
							{
								return (Delegate)array[1 - num2];
							}
							object[] invocationList = DeleteFromInvocationList(array, num, num2, 1);
							return NewMulticastDelegate(invocationList, num - 1, thisIsMultiCastAlready: true);
						}
					}
				}
			}
			else if (_invocationList is object[] array2)
			{
				int num3 = (int)_invocationCount;
				int num4 = (int)multicastDelegate._invocationCount;
				for (int num5 = num3 - num4; num5 >= 0; num5--)
				{
					if (EqualInvocationLists(array2, multicastDelegate._invocationList as object[], num5, num4))
					{
						if (num3 - num4 == 0)
						{
							return null;
						}
						if (num3 - num4 == 1)
						{
							return (Delegate)array2[(num5 == 0) ? (num3 - 1) : 0];
						}
						object[] invocationList2 = DeleteFromInvocationList(array2, num3, num5, num4);
						return NewMulticastDelegate(invocationList2, num3 - num4, thisIsMultiCastAlready: true);
					}
				}
			}
			return this;
		}

		public sealed override Delegate[] GetInvocationList()
		{
			Delegate[] array2;
			if (!(_invocationList is object[] array))
			{
				array2 = new Delegate[1] { this };
			}
			else
			{
				array2 = new Delegate[(int)_invocationCount];
				for (int i = 0; i < array2.Length; i++)
				{
					array2[i] = (Delegate)array[i];
				}
			}
			return array2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(MulticastDelegate? d1, MulticastDelegate? d2)
		{
			if ((object)d2 == null)
			{
				if ((object)d1 != null)
				{
					return false;
				}
				return true;
			}
			if ((object)d2 != d1)
			{
				return d2.Equals(d1);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator !=(MulticastDelegate? d1, MulticastDelegate? d2)
		{
			if ((object)d2 == null)
			{
				if ((object)d1 != null)
				{
					return true;
				}
				return false;
			}
			if ((object)d2 != d1)
			{
				return !d2.Equals(d1);
			}
			return false;
		}

		public sealed override int GetHashCode()
		{
			if (IsUnmanagedFunctionPtr())
			{
				return ValueType.GetHashCodeOfPtr(_methodPtr) ^ ValueType.GetHashCodeOfPtr(_methodPtrAux);
			}
			if (_invocationCount != (IntPtr)0 && _invocationList is Delegate @delegate)
			{
				return @delegate.GetHashCode();
			}
			if (!(_invocationList is object[] array))
			{
				return base.GetHashCode();
			}
			int num = 0;
			for (int i = 0; i < (int)_invocationCount; i++)
			{
				num = num * 33 + array[i].GetHashCode();
			}
			return num;
		}

		internal override object GetTarget()
		{
			if (_invocationCount != (IntPtr)0)
			{
				if (InvocationListLogicallyNull())
				{
					return null;
				}
				if (_invocationList is object[] array)
				{
					int num = (int)_invocationCount;
					return ((Delegate)array[num - 1]).GetTarget();
				}
				if (_invocationList is Delegate @delegate)
				{
					return @delegate.GetTarget();
				}
			}
			return base.GetTarget();
		}

		protected override MethodInfo GetMethodImpl()
		{
			if (_invocationCount != (IntPtr)0 && _invocationList != null)
			{
				if (_invocationList is object[] array)
				{
					int num = (int)_invocationCount - 1;
					return ((Delegate)array[num]).Method;
				}
				if (_invocationList is MulticastDelegate multicastDelegate)
				{
					return multicastDelegate.GetMethodImpl();
				}
			}
			else if (IsUnmanagedFunctionPtr())
			{
				if (_methodBase == null || !(_methodBase is MethodInfo))
				{
					IRuntimeMethodInfo runtimeMethodInfo = FindMethodHandle();
					RuntimeType runtimeType = RuntimeMethodHandle.GetDeclaringType(runtimeMethodInfo);
					if (RuntimeTypeHandle.IsGenericTypeDefinition(runtimeType) || RuntimeTypeHandle.HasInstantiation(runtimeType))
					{
						RuntimeType runtimeType2 = (RuntimeType)GetType();
						runtimeType = runtimeType2;
					}
					_methodBase = (MethodInfo)RuntimeType.GetMethodBase(runtimeType, runtimeMethodInfo);
				}
				return (MethodInfo)_methodBase;
			}
			return base.GetMethodImpl();
		}

		[DoesNotReturn]
		[DebuggerNonUserCode]
		private static void ThrowNullThisInDelegateToInstance()
		{
			throw new ArgumentException(SR.Arg_DlgtNullInst);
		}

		[DebuggerNonUserCode]
		private void CtorClosed(object target, IntPtr methodPtr)
		{
			if (target == null)
			{
				ThrowNullThisInDelegateToInstance();
			}
			_target = target;
			_methodPtr = methodPtr;
		}

		[DebuggerNonUserCode]
		private void CtorClosedStatic(object target, IntPtr methodPtr)
		{
			_target = target;
			_methodPtr = methodPtr;
		}

		[DebuggerNonUserCode]
		private void CtorRTClosed(object target, IntPtr methodPtr)
		{
			_target = target;
			_methodPtr = AdjustTarget(target, methodPtr);
		}

		[DebuggerNonUserCode]
		private void CtorOpened(object target, IntPtr methodPtr, IntPtr shuffleThunk)
		{
			_target = this;
			_methodPtr = shuffleThunk;
			_methodPtrAux = methodPtr;
		}

		[DebuggerNonUserCode]
		private void CtorVirtualDispatch(object target, IntPtr methodPtr, IntPtr shuffleThunk)
		{
			_target = this;
			_methodPtr = shuffleThunk;
			_methodPtrAux = GetCallStub(methodPtr);
		}

		[DebuggerNonUserCode]
		private void CtorCollectibleClosedStatic(object target, IntPtr methodPtr, IntPtr gchandle)
		{
			_target = target;
			_methodPtr = methodPtr;
			_methodBase = GCHandle.InternalGet(gchandle);
		}

		[DebuggerNonUserCode]
		private void CtorCollectibleOpened(object target, IntPtr methodPtr, IntPtr shuffleThunk, IntPtr gchandle)
		{
			_target = this;
			_methodPtr = shuffleThunk;
			_methodPtrAux = methodPtr;
			_methodBase = GCHandle.InternalGet(gchandle);
		}

		[DebuggerNonUserCode]
		private void CtorCollectibleVirtualDispatch(object target, IntPtr methodPtr, IntPtr shuffleThunk, IntPtr gchandle)
		{
			_target = this;
			_methodPtr = shuffleThunk;
			_methodPtrAux = GetCallStub(methodPtr);
			_methodBase = GCHandle.InternalGet(gchandle);
		}
	}
	[Serializable]
	[ClassInterface(ClassInterfaceType.AutoDispatch)]
	[ComVisible(true)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Object
	{
		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public extern Type GetType();

		[Intrinsic]
		protected unsafe object MemberwiseClone()
		{
			object obj = RuntimeHelpers.AllocateUninitializedClone(this);
			nuint rawObjectDataSize = RuntimeHelpers.GetRawObjectDataSize(obj);
			ref byte rawData = ref this.GetRawData();
			ref byte rawData2 = ref obj.GetRawData();
			if (RuntimeHelpers.GetMethodTable(obj)->ContainsGCPointers)
			{
				Buffer.BulkMoveWithWriteBarrier(ref rawData2, ref rawData, rawObjectDataSize);
			}
			else
			{
				Buffer.Memmove(ref rawData2, ref rawData, rawObjectDataSize);
			}
			return obj;
		}

		[NonVersionable]
		public Object()
		{
		}

		[NonVersionable]
		~Object()
		{
		}

		public virtual string? ToString()
		{
			return GetType().ToString();
		}

		public virtual bool Equals(object? obj)
		{
			return RuntimeHelpers.Equals(this, obj);
		}

		public static bool Equals(object? objA, object? objB)
		{
			if (objA == objB)
			{
				return true;
			}
			if (objA == null || objB == null)
			{
				return false;
			}
			return objA.Equals(objB);
		}

		[NonVersionable]
		public static bool ReferenceEquals(object? objA, object? objB)
		{
			return objA == objB;
		}

		public virtual int GetHashCode()
		{
			return RuntimeHelpers.GetHashCode(this);
		}
	}
	public ref struct RuntimeArgumentHandle
	{
		private IntPtr m_ptr;

		internal IntPtr Value => m_ptr;
	}
	[NonVersionable]
	public struct RuntimeTypeHandle : ISerializable
	{
		internal struct IntroducedMethodEnumerator
		{
			private bool _firstCall;

			private RuntimeMethodHandleInternal _handle;

			public RuntimeMethodHandleInternal Current => _handle;

			internal IntroducedMethodEnumerator(RuntimeType type)
			{
				_handle = GetFirstIntroducedMethod(type);
				_firstCall = true;
			}

			public bool MoveNext()
			{
				if (_firstCall)
				{
					_firstCall = false;
				}
				else if (_handle.Value != IntPtr.Zero)
				{
					GetNextIntroducedMethod(ref _handle);
				}
				return !(_handle.Value == IntPtr.Zero);
			}

			public IntroducedMethodEnumerator GetEnumerator()
			{
				return this;
			}
		}

		internal RuntimeType m_type;

		public IntPtr Value
		{
			get
			{
				if (!(m_type != null))
				{
					return IntPtr.Zero;
				}
				return m_type.m_handle;
			}
		}

		internal RuntimeTypeHandle GetNativeHandle()
		{
			RuntimeType type = m_type;
			if (type == null)
			{
				throw new ArgumentNullException(null, SR.Arg_InvalidHandle);
			}
			return new RuntimeTypeHandle(type);
		}

		internal RuntimeType GetTypeChecked()
		{
			RuntimeType type = m_type;
			if (type == null)
			{
				throw new ArgumentNullException(null, SR.Arg_InvalidHandle);
			}
			return type;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsInstanceOfType(RuntimeType type, [NotNullWhen(true)] object o);

		[RequiresUnreferencedCode("MakeGenericType cannot be statically analyzed. It's not possible to guarantee the availability of requirements of the generic type.")]
		internal unsafe static Type GetTypeHelper(Type typeStart, Type[] genericArgs, IntPtr pModifiers, int cModifiers)
		{
			Type type = typeStart;
			if (genericArgs != null)
			{
				type = type.MakeGenericType(genericArgs);
			}
			if (cModifiers > 0)
			{
				int* ptr = (int*)pModifiers.ToPointer();
				for (int i = 0; i < cModifiers; i++)
				{
					type = (((byte)Marshal.ReadInt32((IntPtr)ptr, i * 4) != 15) ? (((byte)Marshal.ReadInt32((IntPtr)ptr, i * 4) != 16) ? (((byte)Marshal.ReadInt32((IntPtr)ptr, i * 4) != 29) ? type.MakeArrayType(Marshal.ReadInt32((IntPtr)ptr, ++i * 4)) : type.MakeArrayType()) : type.MakeByRefType()) : type.MakePointerType());
				}
			}
			return type;
		}

		public static bool operator ==(RuntimeTypeHandle left, object? right)
		{
			return left.Equals(right);
		}

		public static bool operator ==(object? left, RuntimeTypeHandle right)
		{
			return right.Equals(left);
		}

		public static bool operator !=(RuntimeTypeHandle left, object? right)
		{
			return !left.Equals(right);
		}

		public static bool operator !=(object? left, RuntimeTypeHandle right)
		{
			return !right.Equals(left);
		}

		public override int GetHashCode()
		{
			if (!(m_type != null))
			{
				return 0;
			}
			return m_type.GetHashCode();
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is RuntimeTypeHandle runtimeTypeHandle))
			{
				return false;
			}
			return runtimeTypeHandle.m_type == m_type;
		}

		public bool Equals(RuntimeTypeHandle handle)
		{
			return handle.m_type == m_type;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		internal static extern IntPtr GetValueInternal(RuntimeTypeHandle handle);

		internal RuntimeTypeHandle(RuntimeType type)
		{
			m_type = type;
		}

		internal static bool IsTypeDefinition(RuntimeType type)
		{
			CorElementType corElementType = GetCorElementType(type);
			if (((int)corElementType < 1 || (int)corElementType >= 15) && corElementType != CorElementType.ELEMENT_TYPE_VALUETYPE && corElementType != CorElementType.ELEMENT_TYPE_CLASS && corElementType != CorElementType.ELEMENT_TYPE_TYPEDBYREF && corElementType != CorElementType.ELEMENT_TYPE_I && corElementType != CorElementType.ELEMENT_TYPE_U && corElementType != CorElementType.ELEMENT_TYPE_OBJECT)
			{
				return false;
			}
			if (HasInstantiation(type) && !IsGenericTypeDefinition(type))
			{
				return false;
			}
			return true;
		}

		internal static bool IsPrimitive(RuntimeType type)
		{
			return GetCorElementType(type).IsPrimitiveType();
		}

		internal static bool IsByRef(RuntimeType type)
		{
			CorElementType corElementType = GetCorElementType(type);
			return corElementType == CorElementType.ELEMENT_TYPE_BYREF;
		}

		internal static bool IsPointer(RuntimeType type)
		{
			CorElementType corElementType = GetCorElementType(type);
			return corElementType == CorElementType.ELEMENT_TYPE_PTR;
		}

		internal static bool IsArray(RuntimeType type)
		{
			CorElementType corElementType = GetCorElementType(type);
			if (corElementType != CorElementType.ELEMENT_TYPE_ARRAY)
			{
				return corElementType == CorElementType.ELEMENT_TYPE_SZARRAY;
			}
			return true;
		}

		internal static bool IsSZArray(RuntimeType type)
		{
			CorElementType corElementType = GetCorElementType(type);
			return corElementType == CorElementType.ELEMENT_TYPE_SZARRAY;
		}

		internal static bool HasElementType(RuntimeType type)
		{
			CorElementType corElementType = GetCorElementType(type);
			if (corElementType != CorElementType.ELEMENT_TYPE_ARRAY && corElementType != CorElementType.ELEMENT_TYPE_SZARRAY && corElementType != CorElementType.ELEMENT_TYPE_PTR)
			{
				return corElementType == CorElementType.ELEMENT_TYPE_BYREF;
			}
			return true;
		}

		internal static IntPtr[] CopyRuntimeTypeHandles(RuntimeTypeHandle[] inHandles, out int length)
		{
			if (inHandles == null || inHandles.Length == 0)
			{
				length = 0;
				return null;
			}
			IntPtr[] array = new IntPtr[inHandles.Length];
			for (int i = 0; i < inHandles.Length; i++)
			{
				array[i] = inHandles[i].Value;
			}
			length = array.Length;
			return array;
		}

		internal static IntPtr[] CopyRuntimeTypeHandles(Type[] inHandles, out int length)
		{
			if (inHandles == null || inHandles.Length == 0)
			{
				length = 0;
				return null;
			}
			IntPtr[] array = new IntPtr[inHandles.Length];
			for (int i = 0; i < inHandles.Length; i++)
			{
				array[i] = inHandles[i].GetTypeHandleInternal().Value;
			}
			length = array.Length;
			return array;
		}

		internal unsafe static object CreateInstanceForAnotherGenericParameter([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] RuntimeType type, RuntimeType genericParameter)
		{
			object o = null;
			IntPtr value = genericParameter.GetTypeHandleInternal().Value;
			CreateInstanceForAnotherGenericParameter(new QCallTypeHandle(ref type), &value, 1, ObjectHandleOnStack.Create(ref o));
			GC.KeepAlive(genericParameter);
			return o;
		}

		internal unsafe static object CreateInstanceForAnotherGenericParameter([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] RuntimeType type, RuntimeType genericParameter1, RuntimeType genericParameter2)
		{
			object o = null;
			IntPtr* pTypeHandles = stackalloc IntPtr[2]
			{
				genericParameter1.GetTypeHandleInternal().Value,
				genericParameter2.GetTypeHandleInternal().Value
			};
			CreateInstanceForAnotherGenericParameter(new QCallTypeHandle(ref type), pTypeHandles, 2, ObjectHandleOnStack.Create(ref o));
			GC.KeepAlive(genericParameter1);
			GC.KeepAlive(genericParameter2);
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void CreateInstanceForAnotherGenericParameter(QCallTypeHandle baseType, IntPtr* pTypeHandles, int cTypeHandles, ObjectHandleOnStack instantiatedObject);

		internal unsafe static void GetActivationInfo(RuntimeType rt, out delegate*<void*, object> pfnAllocator, out void* vAllocatorFirstArg, out delegate*<object, void> pfnCtor, out bool ctorIsPublic)
		{
			delegate*<void*, object> delegate* = default(delegate*<void*, object>);
			void* ptr = default(void*);
			delegate*<object, void> delegate*2 = default(delegate*<object, void>);
			Interop.BOOL bOOL = Interop.BOOL.FALSE;
			GetActivationInfo(ObjectHandleOnStack.Create(ref rt), &delegate*, &ptr, &delegate*2, &bOOL);
			System.Runtime.CompilerServices.Unsafe.As<delegate*<void*, object>, IntPtr>(ref pfnAllocator) = (nint)delegate*;
			vAllocatorFirstArg = ptr;
			System.Runtime.CompilerServices.Unsafe.As<delegate*<object, void>, IntPtr>(ref pfnCtor) = (nint)delegate*2;
			ctorIsPublic = bOOL != Interop.BOOL.FALSE;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void GetActivationInfo(ObjectHandleOnStack pRuntimeType, delegate*<void*, object>* ppfnAllocator, void** pvAllocatorFirstArg, delegate*<object, void>* ppfnCtor, Interop.BOOL* pfCtorIsPublic);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern object AllocateComObject(void* pClassFactory);

		internal RuntimeType GetRuntimeType()
		{
			return m_type;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern CorElementType GetCorElementType(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeAssembly GetAssembly(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeModule GetModule(RuntimeType type);

		public ModuleHandle GetModuleHandle()
		{
			return new ModuleHandle(GetModule(m_type));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeType GetBaseType(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern TypeAttributes GetAttributes(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeType GetElementType(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool CompareCanonicalHandles(RuntimeType left, RuntimeType right);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetArrayRank(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetToken(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeMethodHandleInternal GetMethodAt(RuntimeType type, int slot);

		internal static IntroducedMethodEnumerator GetIntroducedMethods(RuntimeType type)
		{
			return new IntroducedMethodEnumerator(type);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern RuntimeMethodHandleInternal GetFirstIntroducedMethod(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetNextIntroducedMethod(ref RuntimeMethodHandleInternal method);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern bool GetFields(RuntimeType type, IntPtr* result, int* count);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern Type[] GetInterfaces(RuntimeType type);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types);

		internal Type[] GetConstraints()
		{
			Type[] o = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			GetConstraints(new QCallTypeHandle(ref rth), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type);

		internal IntPtr GetGCHandle(GCHandleType type)
		{
			RuntimeTypeHandle rth = GetNativeHandle();
			return GetGCHandle(new QCallTypeHandle(ref rth), type);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern IntPtr FreeGCHandle(QCallTypeHandle typeHandle, IntPtr objHandle);

		internal IntPtr FreeGCHandle(IntPtr objHandle)
		{
			RuntimeTypeHandle rth = GetNativeHandle();
			return FreeGCHandle(new QCallTypeHandle(ref rth), objHandle);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetNumVirtuals(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetNumVirtualsAndStaticVirtuals(RuntimeType type);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle);

		internal void VerifyInterfaceIsImplemented(RuntimeTypeHandle interfaceHandle)
		{
			RuntimeTypeHandle rth = GetNativeHandle();
			RuntimeTypeHandle rth2 = interfaceHandle.GetNativeHandle();
			VerifyInterfaceIsImplemented(new QCallTypeHandle(ref rth), new QCallTypeHandle(ref rth2));
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle);

		internal RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle)
		{
			RuntimeTypeHandle rth = GetNativeHandle();
			RuntimeTypeHandle rth2 = interfaceHandle.GetNativeHandle();
			return GetInterfaceMethodImplementation(new QCallTypeHandle(ref rth), new QCallTypeHandle(ref rth2), interfaceMethodHandle);
		}

		internal static bool IsComObject(RuntimeType type, bool isGenericCOM)
		{
			if (isGenericCOM)
			{
				return type.TypeHandle.Value == typeof(__ComObject).TypeHandle.Value;
			}
			return CanCastTo(type, (RuntimeType)typeof(__ComObject));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsInterface(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsByRefLike(RuntimeType type);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool _IsVisible(QCallTypeHandle typeHandle);

		internal static bool IsVisible(RuntimeType type)
		{
			return _IsVisible(new QCallTypeHandle(ref type));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsValueType(RuntimeType type);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString);

		internal string ConstructName(TypeNameFormatFlags formatFlags)
		{
			string s = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			ConstructName(new QCallTypeHandle(ref rth), formatFlags, new StringHandleOnStack(ref s));
			return s;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void* _GetUtf8Name(RuntimeType type);

		internal unsafe static MdUtf8String GetUtf8Name(RuntimeType type)
		{
			return new MdUtf8String(_GetUtf8Name(type));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool CanCastTo(RuntimeType type, RuntimeType target);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeType GetDeclaringType(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IRuntimeMethodInfo GetDeclaringMethod(RuntimeType type);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetTypeByName(string name, bool throwOnError, bool ignoreCase, StackCrawlMarkHandle stackMark, ObjectHandleOnStack assemblyLoadContext, ObjectHandleOnStack type, ObjectHandleOnStack keepalive);

		internal static RuntimeType GetTypeByName(string name, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
		{
			return GetTypeByName(name, throwOnError, ignoreCase, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext);
		}

		internal static RuntimeType GetTypeByName(string name, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark, AssemblyLoadContext assemblyLoadContext)
		{
			if (string.IsNullOrEmpty(name))
			{
				if (throwOnError)
				{
					throw new TypeLoadException(SR.Arg_TypeLoadNullStr);
				}
				return null;
			}
			RuntimeType o = null;
			object o2 = null;
			AssemblyLoadContext o3 = assemblyLoadContext;
			GetTypeByName(name, throwOnError, ignoreCase, new StackCrawlMarkHandle(ref stackMark), ObjectHandleOnStack.Create(ref o3), ObjectHandleOnStack.Create(ref o), ObjectHandleOnStack.Create(ref o2));
			GC.KeepAlive(o2);
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetTypeByNameUsingCARules(string name, QCallModule scope, ObjectHandleOnStack type);

		internal static RuntimeType GetTypeByNameUsingCARules(string name, RuntimeModule scope)
		{
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentException(null, "name");
			}
			RuntimeType o = null;
			GetTypeByNameUsingCARules(name, new QCallModule(ref scope), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray);

		internal RuntimeType[] GetInstantiationInternal()
		{
			RuntimeType[] o = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			GetInstantiation(new QCallTypeHandle(ref rth), ObjectHandleOnStack.Create(ref o), Interop.BOOL.TRUE);
			return o;
		}

		internal Type[] GetInstantiationPublic()
		{
			Type[] o = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			GetInstantiation(new QCallTypeHandle(ref rth), ObjectHandleOnStack.Create(ref o), Interop.BOOL.FALSE);
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type);

		internal unsafe RuntimeType Instantiate(RuntimeType inst)
		{
			IntPtr value = inst.TypeHandle.Value;
			RuntimeType o = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			Instantiate(new QCallTypeHandle(ref rth), &value, 1, ObjectHandleOnStack.Create(ref o));
			GC.KeepAlive(inst);
			return o;
		}

		internal unsafe RuntimeType Instantiate(Type[] inst)
		{
			int length;
			fixed (IntPtr* pInst = CopyRuntimeTypeHandles(inst, out length))
			{
				RuntimeType o = null;
				RuntimeTypeHandle rth = GetNativeHandle();
				Instantiate(new QCallTypeHandle(ref rth), pInst, length, ObjectHandleOnStack.Create(ref o));
				GC.KeepAlive(inst);
				return o;
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type);

		internal RuntimeType MakeArray(int rank)
		{
			RuntimeType o = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			MakeArray(new QCallTypeHandle(ref rth), rank, ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type);

		internal RuntimeType MakeSZArray()
		{
			RuntimeType o = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			MakeSZArray(new QCallTypeHandle(ref rth), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type);

		internal RuntimeType MakeByRef()
		{
			RuntimeType o = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			MakeByRef(new QCallTypeHandle(ref rth), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type);

		internal RuntimeType MakePointer()
		{
			RuntimeType o = null;
			RuntimeTypeHandle rth = GetNativeHandle();
			MakePointer(new QCallTypeHandle(ref rth), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern Interop.BOOL IsCollectible(QCallTypeHandle handle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool HasInstantiation(RuntimeType type);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType);

		internal static RuntimeType GetGenericTypeDefinition(RuntimeType type)
		{
			RuntimeType o = type;
			if (HasInstantiation(o) && !IsGenericTypeDefinition(o))
			{
				RuntimeTypeHandle rth = o.GetTypeHandleInternal();
				GetGenericTypeDefinition(new QCallTypeHandle(ref rth), ObjectHandleOnStack.Create(ref o));
			}
			return o;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsGenericTypeDefinition(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsGenericVariable(RuntimeType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int GetGenericVariableIndex(RuntimeType type);

		internal int GetGenericVariableIndex()
		{
			RuntimeType typeChecked = GetTypeChecked();
			if (!IsGenericVariable(typeChecked))
			{
				throw new InvalidOperationException(SR.Arg_NotGenericParameter);
			}
			return GetGenericVariableIndex(typeChecked);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool ContainsGenericVariables(RuntimeType handle);

		internal bool ContainsGenericVariables()
		{
			return ContainsGenericVariables(GetTypeChecked());
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern bool SatisfiesConstraints(RuntimeType paramType, IntPtr* pTypeContext, int typeContextLength, IntPtr* pMethodContext, int methodContextLength, RuntimeType toType);

		internal unsafe static bool SatisfiesConstraints(RuntimeType paramType, RuntimeType[] typeContext, RuntimeType[] methodContext, RuntimeType toType)
		{
			Type[] inHandles = typeContext;
			int length;
			IntPtr[] array = CopyRuntimeTypeHandles(inHandles, out length);
			inHandles = methodContext;
			int length2;
			IntPtr[] array2 = CopyRuntimeTypeHandles(inHandles, out length2);
			fixed (IntPtr* pTypeContext = array)
			{
				fixed (IntPtr* pMethodContext = array2)
				{
					bool result = SatisfiesConstraints(paramType, pTypeContext, length, pMethodContext, length2, toType);
					GC.KeepAlive(typeContext);
					GC.KeepAlive(methodContext);
					return result;
				}
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr _GetMetadataImport(RuntimeType type);

		internal static MetadataImport GetMetadataImport(RuntimeType type)
		{
			return new MetadataImport(_GetMetadataImport(type), type);
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsEquivalentTo(RuntimeType rtType1, RuntimeType rtType2);
	}
	internal struct RuntimeMethodHandleInternal
	{
		internal IntPtr m_handle;

		internal static RuntimeMethodHandleInternal EmptyHandle => default(RuntimeMethodHandleInternal);

		internal IntPtr Value => m_handle;

		internal bool IsNullHandle()
		{
			return m_handle == IntPtr.Zero;
		}

		internal RuntimeMethodHandleInternal(IntPtr value)
		{
			m_handle = value;
		}
	}
	internal sealed class RuntimeMethodInfoStub : IRuntimeMethodInfo
	{
		private readonly object m_keepalive;

		private object m_a;

		private object m_b;

		private object m_c;

		private object m_d;

		private object m_e;

		private object m_f;

		private object m_g;

		public RuntimeMethodHandleInternal m_value;

		RuntimeMethodHandleInternal IRuntimeMethodInfo.Value => m_value;

		public RuntimeMethodInfoStub(RuntimeMethodHandleInternal methodHandleValue, object keepalive)
		{
			m_keepalive = keepalive;
			m_value = methodHandleValue;
		}

		public RuntimeMethodInfoStub(IntPtr methodHandleValue, object keepalive)
		{
			m_keepalive = keepalive;
			m_value = new RuntimeMethodHandleInternal(methodHandleValue);
		}
	}
	internal interface IRuntimeMethodInfo
	{
		RuntimeMethodHandleInternal Value { get; }
	}
	[NonVersionable]
	public struct RuntimeMethodHandle : ISerializable
	{
		private readonly IRuntimeMethodInfo m_value;

		public IntPtr Value
		{
			get
			{
				if (m_value == null)
				{
					return IntPtr.Zero;
				}
				return m_value.Value.Value;
			}
		}

		internal static IRuntimeMethodInfo EnsureNonNullMethodInfo(IRuntimeMethodInfo method)
		{
			if (method == null)
			{
				throw new ArgumentNullException(null, SR.Arg_InvalidHandle);
			}
			return method;
		}

		internal RuntimeMethodHandle(IRuntimeMethodInfo method)
		{
			m_value = method;
		}

		internal IRuntimeMethodInfo GetMethodInfo()
		{
			return m_value;
		}

		private static IntPtr GetValueInternal(RuntimeMethodHandle rmh)
		{
			return rmh.Value;
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public override int GetHashCode()
		{
			return ValueType.GetHashCodeOfPtr(Value);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is RuntimeMethodHandle runtimeMethodHandle))
			{
				return false;
			}
			return runtimeMethodHandle.Value == Value;
		}

		public static bool operator ==(RuntimeMethodHandle left, RuntimeMethodHandle right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(RuntimeMethodHandle left, RuntimeMethodHandle right)
		{
			return !left.Equals(right);
		}

		public bool Equals(RuntimeMethodHandle handle)
		{
			return handle.Value == Value;
		}

		internal bool IsNullHandle()
		{
			return m_value == null;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle);

		public IntPtr GetFunctionPointer()
		{
			IntPtr functionPointer = GetFunctionPointer(EnsureNonNullMethodInfo(m_value).Value);
			GC.KeepAlive(m_value);
			return functionPointer;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern Interop.BOOL GetIsCollectible(RuntimeMethodHandleInternal handle);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern Interop.BOOL IsCAVisibleFromDecoratedType(QCallTypeHandle attrTypeHandle, RuntimeMethodHandleInternal attrCtor, QCallTypeHandle sourceTypeHandle, QCallModule sourceModule);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IRuntimeMethodInfo _GetCurrentMethod(ref StackCrawlMark stackMark);

		internal static IRuntimeMethodInfo GetCurrentMethod(ref StackCrawlMark stackMark)
		{
			return _GetCurrentMethod(ref stackMark);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern MethodAttributes GetAttributes(RuntimeMethodHandleInternal method);

		internal static MethodAttributes GetAttributes(IRuntimeMethodInfo method)
		{
			MethodAttributes attributes = GetAttributes(method.Value);
			GC.KeepAlive(method);
			return attributes;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern MethodImplAttributes GetImplAttributes(IRuntimeMethodInfo method);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString);

		internal static string ConstructInstantiation(IRuntimeMethodInfo method, TypeNameFormatFlags format)
		{
			string s = null;
			IRuntimeMethodInfo runtimeMethodInfo = EnsureNonNullMethodInfo(method);
			ConstructInstantiation(runtimeMethodInfo.Value, format, new StringHandleOnStack(ref s));
			GC.KeepAlive(runtimeMethodInfo);
			return s;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeType GetDeclaringType(RuntimeMethodHandleInternal method);

		internal static RuntimeType GetDeclaringType(IRuntimeMethodInfo method)
		{
			RuntimeType declaringType = GetDeclaringType(method.Value);
			GC.KeepAlive(method);
			return declaringType;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetSlot(RuntimeMethodHandleInternal method);

		internal static int GetSlot(IRuntimeMethodInfo method)
		{
			int slot = GetSlot(method.Value);
			GC.KeepAlive(method);
			return slot;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetMethodDef(IRuntimeMethodInfo method);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern string GetName(RuntimeMethodHandleInternal method);

		internal static string GetName(IRuntimeMethodInfo method)
		{
			string name = GetName(method.Value);
			GC.KeepAlive(method);
			return name;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void* _GetUtf8Name(RuntimeMethodHandleInternal method);

		internal unsafe static MdUtf8String GetUtf8Name(RuntimeMethodHandleInternal method)
		{
			return new MdUtf8String(_GetUtf8Name(method));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool MatchesNameHash(RuntimeMethodHandleInternal method, uint hash);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[DebuggerStepThrough]
		[DebuggerHidden]
		internal static extern object InvokeMethod(object target, in Span<object> arguments, Signature sig, bool constructor, bool wrapExceptions);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray);

		internal static RuntimeType[] GetMethodInstantiationInternal(IRuntimeMethodInfo method)
		{
			RuntimeType[] o = null;
			GetMethodInstantiation(EnsureNonNullMethodInfo(method).Value, ObjectHandleOnStack.Create(ref o), Interop.BOOL.TRUE);
			GC.KeepAlive(method);
			return o;
		}

		internal static RuntimeType[] GetMethodInstantiationInternal(RuntimeMethodHandleInternal method)
		{
			RuntimeType[] o = null;
			GetMethodInstantiation(method, ObjectHandleOnStack.Create(ref o), Interop.BOOL.TRUE);
			return o;
		}

		internal static Type[] GetMethodInstantiationPublic(IRuntimeMethodInfo method)
		{
			RuntimeType[] o = null;
			GetMethodInstantiation(EnsureNonNullMethodInfo(method).Value, ObjectHandleOnStack.Create(ref o), Interop.BOOL.FALSE);
			GC.KeepAlive(method);
			return o;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool HasMethodInstantiation(RuntimeMethodHandleInternal method);

		internal static bool HasMethodInstantiation(IRuntimeMethodInfo method)
		{
			bool result = HasMethodInstantiation(method.Value);
			GC.KeepAlive(method);
			return result;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeMethodHandleInternal GetStubIfNeeded(RuntimeMethodHandleInternal method, RuntimeType declaringType, RuntimeType[] methodInstantiation);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeMethodHandleInternal GetMethodFromCanonical(RuntimeMethodHandleInternal method, RuntimeType declaringType);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsGenericMethodDefinition(RuntimeMethodHandleInternal method);

		internal static bool IsGenericMethodDefinition(IRuntimeMethodInfo method)
		{
			bool result = IsGenericMethodDefinition(method.Value);
			GC.KeepAlive(method);
			return result;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsTypicalMethodDefinition(IRuntimeMethodInfo method);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod);

		internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo method)
		{
			if (!IsTypicalMethodDefinition(method))
			{
				GetTypicalMethodDefinition(method.Value, ObjectHandleOnStack.Create(ref method));
				GC.KeepAlive(method);
			}
			return method;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int GetGenericParameterCount(RuntimeMethodHandleInternal method);

		internal static int GetGenericParameterCount(IRuntimeMethodInfo method)
		{
			return GetGenericParameterCount(method.Value);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod);

		internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo method)
		{
			IRuntimeMethodInfo o = method;
			StripMethodInstantiation(method.Value, ObjectHandleOnStack.Create(ref o));
			GC.KeepAlive(method);
			return o;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsDynamicMethod(RuntimeMethodHandleInternal method);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void Destroy(RuntimeMethodHandleInternal method);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern Resolver GetResolver(RuntimeMethodHandleInternal method);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeMethodBody GetMethodBody(IRuntimeMethodInfo method, RuntimeType declaringType);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsConstructor(RuntimeMethodHandleInternal method);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern LoaderAllocator GetLoaderAllocator(RuntimeMethodHandleInternal method);
	}
	internal struct RuntimeFieldHandleInternal
	{
		internal IntPtr m_handle;

		internal IntPtr Value => m_handle;

		internal RuntimeFieldHandleInternal(IntPtr value)
		{
			m_handle = value;
		}
	}
	internal interface IRuntimeFieldInfo
	{
		RuntimeFieldHandleInternal Value { get; }
	}
	[StructLayout(LayoutKind.Sequential)]
	internal sealed class RuntimeFieldInfoStub : IRuntimeFieldInfo
	{
		private object m_keepalive;

		private object m_c;

		private object m_d;

		private int m_b;

		private object m_e;

		private RuntimeFieldHandleInternal m_fieldHandle;

		RuntimeFieldHandleInternal IRuntimeFieldInfo.Value => m_fieldHandle;
	}
	[NonVersionable]
	public struct RuntimeFieldHandle : ISerializable
	{
		private readonly IRuntimeFieldInfo m_ptr;

		public IntPtr Value
		{
			get
			{
				if (m_ptr == null)
				{
					return IntPtr.Zero;
				}
				return m_ptr.Value.Value;
			}
		}

		internal RuntimeFieldHandle(IRuntimeFieldInfo fieldInfo)
		{
			m_ptr = fieldInfo;
		}

		internal IRuntimeFieldInfo GetRuntimeFieldInfo()
		{
			return m_ptr;
		}

		internal bool IsNullHandle()
		{
			return m_ptr == null;
		}

		public override int GetHashCode()
		{
			return ValueType.GetHashCodeOfPtr(Value);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is RuntimeFieldHandle runtimeFieldHandle))
			{
				return false;
			}
			return runtimeFieldHandle.Value == Value;
		}

		public bool Equals(RuntimeFieldHandle handle)
		{
			return handle.Value == Value;
		}

		public static bool operator ==(RuntimeFieldHandle left, RuntimeFieldHandle right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(RuntimeFieldHandle left, RuntimeFieldHandle right)
		{
			return !left.Equals(right);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern string GetName(RtFieldInfo field);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void* _GetUtf8Name(RuntimeFieldHandleInternal field);

		internal unsafe static MdUtf8String GetUtf8Name(RuntimeFieldHandleInternal field)
		{
			return new MdUtf8String(_GetUtf8Name(field));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool MatchesNameHash(RuntimeFieldHandleInternal handle, uint hash);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern FieldAttributes GetAttributes(RuntimeFieldHandleInternal field);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeType GetApproxDeclaringType(RuntimeFieldHandleInternal field);

		internal static RuntimeType GetApproxDeclaringType(IRuntimeFieldInfo field)
		{
			RuntimeType approxDeclaringType = GetApproxDeclaringType(field.Value);
			GC.KeepAlive(field);
			return approxDeclaringType;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetToken(RtFieldInfo field);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern object GetValue(RtFieldInfo field, object instance, RuntimeType fieldType, RuntimeType declaringType, ref bool domainInitialized);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern object GetValueDirect(RtFieldInfo field, RuntimeType fieldType, void* pTypedRef, RuntimeType contextType);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void SetValue(RtFieldInfo field, object obj, object value, RuntimeType fieldType, FieldAttributes fieldAttr, RuntimeType declaringType, ref bool domainInitialized);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, void* pTypedRef, object value, RuntimeType contextType);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeFieldHandleInternal GetStaticFieldForGenericType(RuntimeFieldHandleInternal field, RuntimeType declaringType);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool AcquiresContextFromThis(RuntimeFieldHandleInternal field);

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}
	}
	public struct ModuleHandle
	{
		public static readonly ModuleHandle EmptyHandle;

		private readonly RuntimeModule m_ptr;

		public int MDStreamVersion => GetMDStreamVersion(GetRuntimeModule());

		internal ModuleHandle(RuntimeModule module)
		{
			m_ptr = module;
		}

		internal RuntimeModule GetRuntimeModule()
		{
			return m_ptr;
		}

		public override int GetHashCode()
		{
			if (!(m_ptr != null))
			{
				return 0;
			}
			return m_ptr.GetHashCode();
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is ModuleHandle moduleHandle))
			{
				return false;
			}
			return moduleHandle.m_ptr == m_ptr;
		}

		public bool Equals(ModuleHandle handle)
		{
			return handle.m_ptr == m_ptr;
		}

		public static bool operator ==(ModuleHandle left, ModuleHandle right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(ModuleHandle left, ModuleHandle right)
		{
			return !left.Equals(right);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IRuntimeMethodInfo GetDynamicMethod(DynamicMethod method, RuntimeModule module, string name, byte[] sig, Resolver resolver);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetToken(RuntimeModule module);

		private static void ValidateModulePointer(RuntimeModule module)
		{
			if ((object)module == null)
			{
				ThrowInvalidOperationException();
			}
			[StackTraceHidden]
			[DoesNotReturn]
			static void ThrowInvalidOperationException()
			{
				throw new InvalidOperationException(SR.InvalidOperation_NullModuleHandle);
			}
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public RuntimeTypeHandle GetRuntimeTypeHandleFromMetadataToken(int typeToken)
		{
			return ResolveTypeHandle(typeToken);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public RuntimeTypeHandle ResolveTypeHandle(int typeToken)
		{
			return ResolveTypeHandle(typeToken, null, null);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public unsafe RuntimeTypeHandle ResolveTypeHandle(int typeToken, RuntimeTypeHandle[]? typeInstantiationContext, RuntimeTypeHandle[]? methodInstantiationContext)
		{
			RuntimeModule module = GetRuntimeModule();
			ValidateModulePointer(module);
			IntPtr[] array = null;
			int length = 0;
			IntPtr[] array2 = null;
			int length2 = 0;
			if (typeInstantiationContext != null && typeInstantiationContext.Length != 0)
			{
				typeInstantiationContext = (RuntimeTypeHandle[])typeInstantiationContext.Clone();
				array = RuntimeTypeHandle.CopyRuntimeTypeHandles(typeInstantiationContext, out length);
			}
			if (methodInstantiationContext != null && methodInstantiationContext.Length != 0)
			{
				methodInstantiationContext = (RuntimeTypeHandle[])methodInstantiationContext.Clone();
				array2 = RuntimeTypeHandle.CopyRuntimeTypeHandles(methodInstantiationContext, out length2);
			}
			fixed (IntPtr* typeInstArgs = array)
			{
				fixed (IntPtr* methodInstArgs = array2)
				{
					try
					{
						RuntimeType o = null;
						ResolveType(new QCallModule(ref module), typeToken, typeInstArgs, length, methodInstArgs, length2, ObjectHandleOnStack.Create(ref o));
						GC.KeepAlive(typeInstantiationContext);
						GC.KeepAlive(methodInstantiationContext);
						return new RuntimeTypeHandle(o);
					}
					catch (Exception)
					{
						if (!GetMetadataImport(module).IsValidToken(typeToken))
						{
							throw new ArgumentOutOfRangeException("typeToken", SR.Format(SR.Argument_InvalidToken, typeToken, new ModuleHandle(module)));
						}
						throw;
					}
				}
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void ResolveType(QCallModule module, int typeToken, IntPtr* typeInstArgs, int typeInstCount, IntPtr* methodInstArgs, int methodInstCount, ObjectHandleOnStack type);

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public RuntimeMethodHandle GetRuntimeMethodHandleFromMetadataToken(int methodToken)
		{
			return ResolveMethodHandle(methodToken);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public RuntimeMethodHandle ResolveMethodHandle(int methodToken)
		{
			return ResolveMethodHandle(methodToken, null, null);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public RuntimeMethodHandle ResolveMethodHandle(int methodToken, RuntimeTypeHandle[]? typeInstantiationContext, RuntimeTypeHandle[]? methodInstantiationContext)
		{
			RuntimeModule runtimeModule = GetRuntimeModule();
			typeInstantiationContext = (RuntimeTypeHandle[])typeInstantiationContext?.Clone();
			methodInstantiationContext = (RuntimeTypeHandle[])methodInstantiationContext?.Clone();
			int length;
			IntPtr[] typeInstantiationContext2 = RuntimeTypeHandle.CopyRuntimeTypeHandles(typeInstantiationContext, out length);
			int length2;
			IntPtr[] methodInstantiationContext2 = RuntimeTypeHandle.CopyRuntimeTypeHandles(methodInstantiationContext, out length2);
			RuntimeMethodHandleInternal runtimeMethodHandleInternal = ResolveMethodHandleInternal(runtimeModule, methodToken, typeInstantiationContext2, length, methodInstantiationContext2, length2);
			IRuntimeMethodInfo method = new RuntimeMethodInfoStub(runtimeMethodHandleInternal, RuntimeMethodHandle.GetLoaderAllocator(runtimeMethodHandleInternal));
			GC.KeepAlive(typeInstantiationContext);
			GC.KeepAlive(methodInstantiationContext);
			return new RuntimeMethodHandle(method);
		}

		internal unsafe static RuntimeMethodHandleInternal ResolveMethodHandleInternal(RuntimeModule module, int methodToken, IntPtr[] typeInstantiationContext, int typeInstCount, IntPtr[] methodInstantiationContext, int methodInstCount)
		{
			ValidateModulePointer(module);
			try
			{
				fixed (IntPtr* typeInstArgs = typeInstantiationContext)
				{
					fixed (IntPtr* methodInstArgs = methodInstantiationContext)
					{
						return ResolveMethod(new QCallModule(ref module), methodToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount);
					}
				}
			}
			catch (Exception)
			{
				if (!GetMetadataImport(module).IsValidToken(methodToken))
				{
					throw new ArgumentOutOfRangeException("methodToken", SR.Format(SR.Argument_InvalidToken, methodToken, new ModuleHandle(module)));
				}
				throw;
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern RuntimeMethodHandleInternal ResolveMethod(QCallModule module, int methodToken, IntPtr* typeInstArgs, int typeInstCount, IntPtr* methodInstArgs, int methodInstCount);

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public RuntimeFieldHandle GetRuntimeFieldHandleFromMetadataToken(int fieldToken)
		{
			return ResolveFieldHandle(fieldToken);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public RuntimeFieldHandle ResolveFieldHandle(int fieldToken)
		{
			return ResolveFieldHandle(fieldToken, null, null);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public unsafe RuntimeFieldHandle ResolveFieldHandle(int fieldToken, RuntimeTypeHandle[]? typeInstantiationContext, RuntimeTypeHandle[]? methodInstantiationContext)
		{
			RuntimeModule module = GetRuntimeModule();
			ValidateModulePointer(module);
			IntPtr[] array = null;
			int length = 0;
			IntPtr[] array2 = null;
			int length2 = 0;
			if (typeInstantiationContext != null && typeInstantiationContext.Length != 0)
			{
				typeInstantiationContext = (RuntimeTypeHandle[])typeInstantiationContext.Clone();
				array = RuntimeTypeHandle.CopyRuntimeTypeHandles(typeInstantiationContext, out length);
			}
			if (methodInstantiationContext != null && methodInstantiationContext.Length != 0)
			{
				methodInstantiationContext = (RuntimeTypeHandle[])methodInstantiationContext.Clone();
				array2 = RuntimeTypeHandle.CopyRuntimeTypeHandles(methodInstantiationContext, out length2);
			}
			fixed (IntPtr* typeInstArgs = array)
			{
				fixed (IntPtr* methodInstArgs = array2)
				{
					try
					{
						IRuntimeFieldInfo o = null;
						ResolveField(new QCallModule(ref module), fieldToken, typeInstArgs, length, methodInstArgs, length2, ObjectHandleOnStack.Create(ref o));
						GC.KeepAlive(typeInstantiationContext);
						GC.KeepAlive(methodInstantiationContext);
						return new RuntimeFieldHandle(o);
					}
					catch (Exception)
					{
						if (!GetMetadataImport(module).IsValidToken(fieldToken))
						{
							throw new ArgumentOutOfRangeException("fieldToken", SR.Format(SR.Argument_InvalidToken, fieldToken, new ModuleHandle(module)));
						}
						throw;
					}
				}
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void ResolveField(QCallModule module, int fieldToken, IntPtr* typeInstArgs, int typeInstCount, IntPtr* methodInstArgs, int methodInstCount, ObjectHandleOnStack retField);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern Interop.BOOL _ContainsPropertyMatchingHash(QCallModule module, int propertyToken, uint hash);

		internal static bool ContainsPropertyMatchingHash(RuntimeModule module, int propertyToken, uint hash)
		{
			return _ContainsPropertyMatchingHash(new QCallModule(ref module), propertyToken, hash) != Interop.BOOL.FALSE;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void GetModuleType(QCallModule handle, ObjectHandleOnStack type);

		internal static RuntimeType GetModuleType(RuntimeModule module)
		{
			RuntimeType o = null;
			GetModuleType(new QCallModule(ref module), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void GetPEKind(QCallModule handle, int* peKind, int* machine);

		internal unsafe static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out int num);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out int num2);
			GetPEKind(new QCallModule(ref module), &num, &num2);
			peKind = (PortableExecutableKinds)num;
			machine = (ImageFileMachine)num2;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetMDStreamVersion(RuntimeModule module);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr _GetMetadataImport(RuntimeModule module);

		internal static MetadataImport GetMetadataImport(RuntimeModule module)
		{
			return new MetadataImport(_GetMetadataImport(module), module);
		}
	}
	internal class Signature
	{
		internal RuntimeType[] m_arguments;

		internal RuntimeType m_declaringType;

		internal RuntimeType m_returnTypeORfieldType;

		internal object m_keepalive;

		internal unsafe void* m_sig;

		internal int m_managedCallingConventionAndArgIteratorFlags;

		internal int m_nSizeOfArgStack;

		internal int m_csig;

		internal RuntimeMethodHandleInternal m_pMethod;

		internal CallingConventions CallingConvention => (CallingConventions)(byte)m_managedCallingConventionAndArgIteratorFlags;

		internal RuntimeType[] Arguments => m_arguments;

		internal RuntimeType ReturnType => m_returnTypeORfieldType;

		internal RuntimeType FieldType => m_returnTypeORfieldType;

		[MethodImpl(MethodImplOptions.InternalCall)]
		[MemberNotNull("m_arguments")]
		[MemberNotNull("m_returnTypeORfieldType")]
		private unsafe extern void GetSignature(void* pCorSig, int cCorSig, RuntimeFieldHandleInternal fieldHandle, IRuntimeMethodInfo methodHandle, RuntimeType declaringType);

		public unsafe Signature(IRuntimeMethodInfo method, RuntimeType[] arguments, RuntimeType returnType, CallingConventions callingConvention)
		{
			m_pMethod = method.Value;
			m_arguments = arguments;
			m_returnTypeORfieldType = returnType;
			m_managedCallingConventionAndArgIteratorFlags = (byte)callingConvention;
			GetSignature(null, 0, default(RuntimeFieldHandleInternal), method, null);
		}

		public unsafe Signature(IRuntimeMethodInfo methodHandle, RuntimeType declaringType)
		{
			GetSignature(null, 0, default(RuntimeFieldHandleInternal), methodHandle, declaringType);
		}

		public unsafe Signature(IRuntimeFieldInfo fieldHandle, RuntimeType declaringType)
		{
			GetSignature(null, 0, fieldHandle.Value, null, declaringType);
			GC.KeepAlive(fieldHandle);
		}

		public unsafe Signature(void* pCorSig, int cCorSig, RuntimeType declaringType)
		{
			GetSignature(pCorSig, cCorSig, default(RuntimeFieldHandleInternal), null, declaringType);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool CompareSig(Signature sig1, Signature sig2);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern Type[] GetCustomModifiers(int position, bool required);
	}
	internal abstract class Resolver
	{
		internal struct CORINFO_EH_CLAUSE
		{
			internal int Flags;

			internal int TryOffset;

			internal int TryLength;

			internal int HandlerOffset;

			internal int HandlerLength;

			internal int ClassTokenOrFilterOffset;
		}

		internal abstract RuntimeType GetJitContext(out int securityControlFlags);

		internal abstract byte[] GetCodeInfo(out int stackSize, out int initLocals, out int EHCount);

		internal abstract byte[] GetLocalsSignature();

		internal unsafe abstract void GetEHInfo(int EHNumber, void* exception);

		internal abstract byte[] GetRawEHInfo();

		internal abstract string GetStringLiteral(int token);

		internal abstract void ResolveToken(int token, out IntPtr typeHandle, out IntPtr methodHandle, out IntPtr fieldHandle);

		internal abstract byte[] ResolveSignature(int token, int fromMethod);

		internal abstract MethodInfo GetDynamicMethod();
	}
	internal sealed class RuntimeType : TypeInfo, ICloneable
	{
		private sealed class ActivatorCache
		{
			private unsafe readonly delegate*<void*, object> _pfnAllocator;

			private unsafe readonly void* _allocatorFirstArg;

			private unsafe readonly delegate*<object, void> _pfnCtor;

			private readonly bool _ctorIsPublic;

			internal bool CtorIsPublic => _ctorIsPublic;

			internal unsafe ActivatorCache(RuntimeType rt)
			{
				rt.CreateInstanceCheckThis();
				try
				{
					RuntimeTypeHandle.GetActivationInfo(rt, out _pfnAllocator, out _allocatorFirstArg, out _pfnCtor, out _ctorIsPublic);
				}
				catch (Exception ex)
				{
					string message = SR.Format(SR.Activator_CannotCreateInstance, rt, ex.Message);
					if (!(ex is ArgumentException))
					{
						if (!(ex is PlatformNotSupportedException))
						{
							if (!(ex is NotSupportedException))
							{
								if (!(ex is MethodAccessException))
								{
									if (!(ex is MissingMethodException))
									{
										if (ex is MemberAccessException)
										{
											throw new MemberAccessException(message);
										}
										throw;
									}
									throw new MissingMethodException(message);
								}
								throw new MethodAccessException(message);
							}
							throw new NotSupportedException(message);
						}
						throw new PlatformNotSupportedException(message);
					}
					throw new ArgumentException(message);
				}
				if (_pfnAllocator == (delegate*<void*, object>)null)
				{
					_pfnAllocator = &ReturnNull;
				}
				if (_pfnCtor == (delegate*<object, void>)null)
				{
					_pfnCtor = &CtorNoopStub;
				}
				static void CtorNoopStub(object uninitializedObject)
				{
				}
				unsafe static object ReturnNull(void* _)
				{
					return null;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal unsafe object CreateUninitializedObject(RuntimeType rt)
			{
				object result = _pfnAllocator(_allocatorFirstArg);
				GC.KeepAlive(rt);
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal unsafe void CallConstructor(object uninitializedObject)
			{
				_pfnCtor(uninitializedObject);
			}
		}

		internal enum MemberListType
		{
			All,
			CaseSensitive,
			CaseInsensitive,
			HandleToInfo
		}

		internal struct ListBuilder<T> where T : class
		{
			private T[] _items;

			private T _item;

			private int _count;

			private int _capacity;

			public T this[int index]
			{
				get
				{
					if (_items == null)
					{
						return _item;
					}
					return _items[index];
				}
			}

			public int Count => _count;

			public ListBuilder(int capacity)
			{
				_items = null;
				_item = null;
				_count = 0;
				_capacity = capacity;
			}

			public T[] ToArray()
			{
				if (_count == 0)
				{
					return Array.Empty<T>();
				}
				if (_count == 1)
				{
					return new T[1] { _item };
				}
				Array.Resize(ref _items, _count);
				_capacity = _count;
				return _items;
			}

			public void CopyTo(object[] array, int index)
			{
				if (_count != 0)
				{
					if (_count == 1)
					{
						array[index] = _item;
					}
					else
					{
						Array.Copy(_items, 0, array, index, _count);
					}
				}
			}

			public void Add(T item)
			{
				if (_count == 0)
				{
					_item = item;
				}
				else
				{
					if (_count == 1)
					{
						if (_capacity < 2)
						{
							_capacity = 4;
						}
						_items = new T[_capacity];
						_items[0] = _item;
					}
					else if (_capacity == _count)
					{
						int num = 2 * _capacity;
						Array.Resize(ref _items, num);
						_capacity = num;
					}
					_items[_count] = item;
				}
				_count++;
			}
		}

		internal sealed class RuntimeTypeCache
		{
			internal enum CacheType
			{
				Method,
				Constructor,
				Field,
				Property,
				Event,
				Interface,
				NestedType
			}

			private readonly struct Filter
			{
				private readonly MdUtf8String m_name;

				private readonly MemberListType m_listType;

				private readonly uint m_nameHash;

				public unsafe Filter(byte* pUtf8Name, int cUtf8Name, MemberListType listType)
				{
					m_name = new MdUtf8String(pUtf8Name, cUtf8Name);
					m_listType = listType;
					m_nameHash = 0u;
					if (RequiresStringComparison())
					{
						m_nameHash = m_name.HashCaseInsensitive();
					}
				}

				public bool Match(MdUtf8String name)
				{
					bool result = true;
					if (m_listType == MemberListType.CaseSensitive)
					{
						result = m_name.Equals(name);
					}
					else if (m_listType == MemberListType.CaseInsensitive)
					{
						result = m_name.EqualsCaseInsensitive(name);
					}
					return result;
				}

				public bool RequiresStringComparison()
				{
					if (m_listType != MemberListType.CaseSensitive)
					{
						return m_listType == MemberListType.CaseInsensitive;
					}
					return true;
				}

				public bool CaseSensitive()
				{
					return m_listType == MemberListType.CaseSensitive;
				}

				public uint GetHashToMatch()
				{
					return m_nameHash;
				}
			}

			private sealed class MemberInfoCache<T> where T : MemberInfo
			{
				private CerHashtable<string, T[]> m_csMemberInfos;

				private CerHashtable<string, T[]> m_cisMemberInfos;

				private T[] m_allMembers;

				private bool m_cacheComplete;

				private readonly RuntimeTypeCache m_runtimeTypeCache;

				internal RuntimeType ReflectedType => m_runtimeTypeCache.GetRuntimeType();

				internal MemberInfoCache(RuntimeTypeCache runtimeTypeCache)
				{
					m_runtimeTypeCache = runtimeTypeCache;
				}

				internal MethodBase AddMethod(RuntimeType declaringType, RuntimeMethodHandleInternal method, CacheType cacheType)
				{
					T[] allMembers = m_allMembers;
					if (allMembers != null)
					{
						switch (cacheType)
						{
						case CacheType.Method:
						{
							T[] array2 = allMembers;
							foreach (T val2 in array2)
							{
								if (val2 == null)
								{
									break;
								}
								if (val2 is RuntimeMethodInfo runtimeMethodInfo && runtimeMethodInfo.MethodHandle.Value == method.Value)
								{
									return runtimeMethodInfo;
								}
							}
							break;
						}
						case CacheType.Constructor:
						{
							T[] array = allMembers;
							foreach (T val in array)
							{
								if (val == null)
								{
									break;
								}
								if (val is RuntimeConstructorInfo runtimeConstructorInfo && runtimeConstructorInfo.MethodHandle.Value == method.Value)
								{
									return runtimeConstructorInfo;
								}
							}
							break;
						}
						}
					}
					T[] list = null;
					MethodAttributes attributes = RuntimeMethodHandle.GetAttributes(method);
					bool isPublic = (attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;
					bool isStatic = (attributes & MethodAttributes.Static) != 0;
					bool isInherited = declaringType != ReflectedType;
					BindingFlags bindingFlags = FilterPreCalculate(isPublic, isInherited, isStatic);
					switch (cacheType)
					{
					case CacheType.Method:
						list = (T[])(object)new RuntimeMethodInfo[1]
						{
							new RuntimeMethodInfo(method, declaringType, m_runtimeTypeCache, attributes, bindingFlags, null)
						};
						break;
					case CacheType.Constructor:
						list = (T[])(object)new RuntimeConstructorInfo[1]
						{
							new RuntimeConstructorInfo(method, declaringType, m_runtimeTypeCache, attributes, bindingFlags)
						};
						break;
					}
					Insert(ref list, null, MemberListType.HandleToInfo);
					return (MethodBase)(object)list[0];
				}

				internal FieldInfo AddField(RuntimeFieldHandleInternal field)
				{
					T[] allMembers = m_allMembers;
					if (allMembers != null)
					{
						T[] array = allMembers;
						foreach (T val in array)
						{
							if (val == null)
							{
								break;
							}
							if (val is RtFieldInfo rtFieldInfo && rtFieldInfo.GetFieldHandle() == field.Value)
							{
								return rtFieldInfo;
							}
						}
					}
					FieldAttributes attributes = RuntimeFieldHandle.GetAttributes(field);
					bool isPublic = (attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Public;
					bool isStatic = (attributes & FieldAttributes.Static) != 0;
					RuntimeType approxDeclaringType = RuntimeFieldHandle.GetApproxDeclaringType(field);
					bool isInherited = (RuntimeFieldHandle.AcquiresContextFromThis(field) ? (!RuntimeTypeHandle.CompareCanonicalHandles(approxDeclaringType, ReflectedType)) : (approxDeclaringType != ReflectedType));
					BindingFlags bindingFlags = FilterPreCalculate(isPublic, isInherited, isStatic);
					T[] list = (T[])(object)new RuntimeFieldInfo[1]
					{
						new RtFieldInfo(field, ReflectedType, m_runtimeTypeCache, bindingFlags)
					};
					Insert(ref list, null, MemberListType.HandleToInfo);
					return (FieldInfo)(object)list[0];
				}

				private unsafe T[] Populate(string name, MemberListType listType, CacheType cacheType)
				{
					T[] list;
					if (string.IsNullOrEmpty(name) || (cacheType == CacheType.Constructor && name[0] != '.' && name[0] != '*'))
					{
						list = GetListByName(null, 0, null, 0, listType, cacheType);
					}
					else
					{
						int length = name.Length;
						fixed (char* ptr = name)
						{
							int byteCount = Encoding.UTF8.GetByteCount(ptr, length);
							if (byteCount > 1024)
							{
								byte[] array = new byte[byteCount];
								fixed (byte* pUtf8Name = &array[0])
								{
									list = GetListByName(ptr, length, pUtf8Name, byteCount, listType, cacheType);
								}
							}
							else
							{
								byte* pUtf8Name2 = stackalloc byte[(int)(uint)byteCount];
								list = GetListByName(ptr, length, pUtf8Name2, byteCount, listType, cacheType);
							}
						}
					}
					Insert(ref list, name, listType);
					return list;
				}

				private unsafe T[] GetListByName(char* pName, int cNameLen, byte* pUtf8Name, int cUtf8Name, MemberListType listType, CacheType cacheType)
				{
					if (cNameLen != 0)
					{
						Encoding.UTF8.GetBytes(pName, cNameLen, pUtf8Name, cUtf8Name);
					}
					Filter filter = new Filter(pUtf8Name, cUtf8Name, listType);
					object obj = null;
					switch (cacheType)
					{
					case CacheType.Method:
						obj = PopulateMethods(filter);
						break;
					case CacheType.Field:
						obj = PopulateFields(filter);
						break;
					case CacheType.Constructor:
						obj = PopulateConstructors(filter);
						break;
					case CacheType.Property:
						obj = PopulateProperties(filter);
						break;
					case CacheType.Event:
						obj = PopulateEvents(filter);
						break;
					case CacheType.NestedType:
						obj = PopulateNestedClasses(filter);
						break;
					case CacheType.Interface:
						obj = PopulateInterfaces(filter);
						break;
					}
					return (T[])obj;
				}

				internal void Insert(ref T[] list, string name, MemberListType listType)
				{
					bool lockTaken = false;
					try
					{
						Monitor.Enter(this, ref lockTaken);
						switch (listType)
						{
						case MemberListType.CaseSensitive:
						{
							T[] array = m_csMemberInfos[name];
							if (array == null)
							{
								MergeWithGlobalList(list);
								m_csMemberInfos[name] = list;
							}
							else
							{
								list = array;
							}
							break;
						}
						case MemberListType.CaseInsensitive:
						{
							T[] array2 = m_cisMemberInfos[name];
							if (array2 == null)
							{
								MergeWithGlobalList(list);
								m_cisMemberInfos[name] = list;
							}
							else
							{
								list = array2;
							}
							break;
						}
						case MemberListType.All:
							if (!m_cacheComplete)
							{
								MergeWithGlobalList(list);
								int num = m_allMembers.Length;
								while (num > 0 && !((MemberInfo?)m_allMembers[num - 1] != (MemberInfo?)null))
								{
									num--;
								}
								Array.Resize(ref m_allMembers, num);
								Volatile.Write(ref m_cacheComplete, value: true);
							}
							list = m_allMembers;
							break;
						default:
							MergeWithGlobalList(list);
							break;
						}
					}
					finally
					{
						if (lockTaken)
						{
							Monitor.Exit(this);
						}
					}
				}

				private void MergeWithGlobalList(T[] list)
				{
					T[] array = m_allMembers;
					if (array == null)
					{
						m_allMembers = list;
						return;
					}
					int num = array.Length;
					int num2 = 0;
					for (int i = 0; i < list.Length; i++)
					{
						T val = list[i];
						bool flag = false;
						int j;
						for (j = 0; j < num; j++)
						{
							T val2 = array[j];
							if ((MemberInfo?)val2 == (MemberInfo?)null)
							{
								break;
							}
							if (val.CacheEquals(val2))
							{
								list[i] = val2;
								flag = true;
								break;
							}
						}
						if (!flag)
						{
							if (num2 == 0)
							{
								num2 = j;
							}
							if (num2 >= array.Length)
							{
								int newSize = ((!m_cacheComplete) ? Math.Max(Math.Max(4, 2 * array.Length), list.Length) : (array.Length + 1));
								T[] array2 = array;
								Array.Resize(ref array2, newSize);
								array = array2;
							}
							Volatile.Write(ref array[num2], val);
							num2++;
						}
					}
					m_allMembers = array;
				}

				private unsafe RuntimeMethodInfo[] PopulateMethods(Filter filter)
				{
					ListBuilder<RuntimeMethodInfo> listBuilder = default(ListBuilder<RuntimeMethodInfo>);
					RuntimeType runtimeType = ReflectedType;
					if (RuntimeTypeHandle.IsInterface(runtimeType))
					{
						RuntimeTypeHandle.IntroducedMethodEnumerator enumerator = RuntimeTypeHandle.GetIntroducedMethods(runtimeType).GetEnumerator();
						while (enumerator.MoveNext())
						{
							RuntimeMethodHandleInternal current = enumerator.Current;
							if (!filter.RequiresStringComparison() || (RuntimeMethodHandle.MatchesNameHash(current, filter.GetHashToMatch()) && filter.Match(RuntimeMethodHandle.GetUtf8Name(current))))
							{
								MethodAttributes attributes = RuntimeMethodHandle.GetAttributes(current);
								if ((attributes & MethodAttributes.RTSpecialName) == 0)
								{
									bool isPublic = (attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;
									bool isStatic = (attributes & MethodAttributes.Static) != 0;
									BindingFlags bindingFlags = FilterPreCalculate(isPublic, isInherited: false, isStatic);
									RuntimeMethodHandleInternal stubIfNeeded = RuntimeMethodHandle.GetStubIfNeeded(current, runtimeType, null);
									RuntimeMethodInfo item = new RuntimeMethodInfo(stubIfNeeded, runtimeType, m_runtimeTypeCache, attributes, bindingFlags, null);
									listBuilder.Add(item);
								}
							}
						}
					}
					else
					{
						while (RuntimeTypeHandle.IsGenericVariable(runtimeType))
						{
							runtimeType = runtimeType.GetBaseType();
						}
						int numVirtuals = RuntimeTypeHandle.GetNumVirtuals(runtimeType);
						bool* ptr = stackalloc bool[(int)(uint)numVirtuals];
						new Span<bool>(ptr, numVirtuals).Clear();
						bool isValueType = runtimeType.IsValueType;
						do
						{
							int numVirtuals2 = RuntimeTypeHandle.GetNumVirtuals(runtimeType);
							RuntimeTypeHandle.IntroducedMethodEnumerator enumerator2 = RuntimeTypeHandle.GetIntroducedMethods(runtimeType).GetEnumerator();
							while (enumerator2.MoveNext())
							{
								RuntimeMethodHandleInternal current2 = enumerator2.Current;
								if (filter.RequiresStringComparison() && (!RuntimeMethodHandle.MatchesNameHash(current2, filter.GetHashToMatch()) || !filter.Match(RuntimeMethodHandle.GetUtf8Name(current2))))
								{
									continue;
								}
								MethodAttributes attributes2 = RuntimeMethodHandle.GetAttributes(current2);
								MethodAttributes methodAttributes = attributes2 & MethodAttributes.MemberAccessMask;
								if ((attributes2 & MethodAttributes.RTSpecialName) != 0)
								{
									continue;
								}
								bool flag = false;
								int num = 0;
								if ((attributes2 & MethodAttributes.Virtual) != 0)
								{
									num = RuntimeMethodHandle.GetSlot(current2);
									flag = num < numVirtuals2;
								}
								bool flag2 = runtimeType != ReflectedType;
								bool flag3 = methodAttributes == MethodAttributes.Private;
								if (flag2 && flag3 && !flag)
								{
									continue;
								}
								if (flag)
								{
									if (ptr[num])
									{
										continue;
									}
									ptr[num] = true;
								}
								else if (isValueType && (attributes2 & (MethodAttributes.Virtual | MethodAttributes.Abstract)) != 0)
								{
									continue;
								}
								bool isPublic2 = methodAttributes == MethodAttributes.Public;
								bool isStatic2 = (attributes2 & MethodAttributes.Static) != 0;
								BindingFlags bindingFlags2 = FilterPreCalculate(isPublic2, flag2, isStatic2);
								RuntimeMethodHandleInternal stubIfNeeded2 = RuntimeMethodHandle.GetStubIfNeeded(current2, runtimeType, null);
								RuntimeMethodInfo item2 = new RuntimeMethodInfo(stubIfNeeded2, runtimeType, m_runtimeTypeCache, attributes2, bindingFlags2, null);
								listBuilder.Add(item2);
							}
							runtimeType = RuntimeTypeHandle.GetBaseType(runtimeType);
						}
						while (runtimeType != null);
					}
					return listBuilder.ToArray();
				}

				private RuntimeConstructorInfo[] PopulateConstructors(Filter filter)
				{
					if (ReflectedType.IsGenericParameter)
					{
						return Array.Empty<RuntimeConstructorInfo>();
					}
					ListBuilder<RuntimeConstructorInfo> listBuilder = default(ListBuilder<RuntimeConstructorInfo>);
					RuntimeType reflectedType = ReflectedType;
					RuntimeTypeHandle.IntroducedMethodEnumerator enumerator = RuntimeTypeHandle.GetIntroducedMethods(reflectedType).GetEnumerator();
					while (enumerator.MoveNext())
					{
						RuntimeMethodHandleInternal current = enumerator.Current;
						if (!filter.RequiresStringComparison() || (RuntimeMethodHandle.MatchesNameHash(current, filter.GetHashToMatch()) && filter.Match(RuntimeMethodHandle.GetUtf8Name(current))))
						{
							MethodAttributes attributes = RuntimeMethodHandle.GetAttributes(current);
							if ((attributes & MethodAttributes.RTSpecialName) != 0)
							{
								bool isPublic = (attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;
								bool isStatic = (attributes & MethodAttributes.Static) != 0;
								BindingFlags bindingFlags = FilterPreCalculate(isPublic, isInherited: false, isStatic);
								RuntimeMethodHandleInternal stubIfNeeded = RuntimeMethodHandle.GetStubIfNeeded(current, reflectedType, null);
								RuntimeConstructorInfo item = new RuntimeConstructorInfo(stubIfNeeded, ReflectedType, m_runtimeTypeCache, attributes, bindingFlags);
								listBuilder.Add(item);
							}
						}
					}
					return listBuilder.ToArray();
				}

				[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "Calls to GetInterfaces technically require all interfaces on ReflectedTypeBut this is not a public API to enumerate reflection items, all the public APIs which do thatshould be annotated accordingly.")]
				private RuntimeFieldInfo[] PopulateFields(Filter filter)
				{
					ListBuilder<RuntimeFieldInfo> list = default(ListBuilder<RuntimeFieldInfo>);
					RuntimeType runtimeType = ReflectedType;
					while (RuntimeTypeHandle.IsGenericVariable(runtimeType))
					{
						runtimeType = runtimeType.GetBaseType();
					}
					while (runtimeType != null)
					{
						PopulateRtFields(filter, runtimeType, ref list);
						PopulateLiteralFields(filter, runtimeType, ref list);
						runtimeType = RuntimeTypeHandle.GetBaseType(runtimeType);
					}
					if (ReflectedType.IsGenericParameter)
					{
						Type[] interfaces = ReflectedType.BaseType.GetInterfaces();
						for (int i = 0; i < interfaces.Length; i++)
						{
							PopulateLiteralFields(filter, (RuntimeType)interfaces[i], ref list);
							PopulateRtFields(filter, (RuntimeType)interfaces[i], ref list);
						}
					}
					else
					{
						Type[] interfaces2 = RuntimeTypeHandle.GetInterfaces(ReflectedType);
						if (interfaces2 != null)
						{
							for (int j = 0; j < interfaces2.Length; j++)
							{
								PopulateLiteralFields(filter, (RuntimeType)interfaces2[j], ref list);
								PopulateRtFields(filter, (RuntimeType)interfaces2[j], ref list);
							}
						}
					}
					return list.ToArray();
				}

				private unsafe void PopulateRtFields(Filter filter, RuntimeType declaringType, ref ListBuilder<RuntimeFieldInfo> list)
				{
					IntPtr* ptr = stackalloc IntPtr[64];
					int num = 64;
					if (!RuntimeTypeHandle.GetFields(declaringType, ptr, &num))
					{
						fixed (IntPtr* ptr2 = new IntPtr[num])
						{
							RuntimeTypeHandle.GetFields(declaringType, ptr2, &num);
							PopulateRtFields(filter, ptr2, num, declaringType, ref list);
						}
					}
					else if (num > 0)
					{
						PopulateRtFields(filter, ptr, num, declaringType, ref list);
					}
				}

				private unsafe void PopulateRtFields(Filter filter, IntPtr* ppFieldHandles, int count, RuntimeType declaringType, ref ListBuilder<RuntimeFieldInfo> list)
				{
					bool flag = RuntimeTypeHandle.HasInstantiation(declaringType) && !RuntimeTypeHandle.ContainsGenericVariables(declaringType);
					bool flag2 = declaringType != ReflectedType;
					for (int i = 0; i < count; i++)
					{
						RuntimeFieldHandleInternal runtimeFieldHandleInternal = new RuntimeFieldHandleInternal(ppFieldHandles[i]);
						if (filter.RequiresStringComparison() && (!RuntimeFieldHandle.MatchesNameHash(runtimeFieldHandleInternal, filter.GetHashToMatch()) || !filter.Match(RuntimeFieldHandle.GetUtf8Name(runtimeFieldHandleInternal))))
						{
							continue;
						}
						FieldAttributes attributes = RuntimeFieldHandle.GetAttributes(runtimeFieldHandleInternal);
						FieldAttributes fieldAttributes = attributes & FieldAttributes.FieldAccessMask;
						if (!flag2 || fieldAttributes != FieldAttributes.Private)
						{
							bool isPublic = fieldAttributes == FieldAttributes.Public;
							bool flag3 = (attributes & FieldAttributes.Static) != 0;
							BindingFlags bindingFlags = FilterPreCalculate(isPublic, flag2, flag3);
							if (flag && flag3)
							{
								runtimeFieldHandleInternal = RuntimeFieldHandle.GetStaticFieldForGenericType(runtimeFieldHandleInternal, declaringType);
							}
							RuntimeFieldInfo item = new RtFieldInfo(runtimeFieldHandleInternal, declaringType, m_runtimeTypeCache, bindingFlags);
							list.Add(item);
						}
					}
				}

				private void PopulateLiteralFields(Filter filter, RuntimeType declaringType, ref ListBuilder<RuntimeFieldInfo> list)
				{
					int token = RuntimeTypeHandle.GetToken(declaringType);
					if (System.Reflection.MetadataToken.IsNullToken(token))
					{
						return;
					}
					MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(declaringType);
					metadataImport.EnumFields(token, out var result);
					for (int i = 0; i < result.Length; i++)
					{
						int num = result[i];
						metadataImport.GetFieldDefProps(num, out var fieldAttributes);
						FieldAttributes fieldAttributes2 = fieldAttributes & FieldAttributes.FieldAccessMask;
						if ((fieldAttributes & FieldAttributes.Literal) == 0)
						{
							continue;
						}
						bool flag = declaringType != ReflectedType;
						if (flag && fieldAttributes2 == FieldAttributes.Private)
						{
							continue;
						}
						if (filter.RequiresStringComparison())
						{
							MdUtf8String name = metadataImport.GetName(num);
							if (!filter.Match(name))
							{
								continue;
							}
						}
						bool isPublic = fieldAttributes2 == FieldAttributes.Public;
						bool isStatic = (fieldAttributes & FieldAttributes.Static) != 0;
						BindingFlags bindingFlags = FilterPreCalculate(isPublic, flag, isStatic);
						RuntimeFieldInfo item = new MdFieldInfo(num, fieldAttributes, declaringType.GetTypeHandleInternal(), m_runtimeTypeCache, bindingFlags);
						list.Add(item);
					}
				}

				private void AddSpecialInterface(ref ListBuilder<RuntimeType> list, Filter filter, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] RuntimeType iList, bool addSubInterface)
				{
					if (!iList.IsAssignableFrom(ReflectedType))
					{
						return;
					}
					if (filter.Match(RuntimeTypeHandle.GetUtf8Name(iList)))
					{
						list.Add(iList);
					}
					if (!addSubInterface)
					{
						return;
					}
					Type[] interfaces = iList.GetInterfaces();
					for (int i = 0; i < interfaces.Length; i++)
					{
						RuntimeType runtimeType = (RuntimeType)interfaces[i];
						if (runtimeType.IsGenericType && filter.Match(RuntimeTypeHandle.GetUtf8Name(runtimeType)))
						{
							list.Add(runtimeType);
						}
					}
				}

				[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2065:UnrecognizedReflectionPattern", Justification = "Calls to GetInterfaces technically require all interfaces on ReflectedTypeBut this is not a public API to enumerate reflection items, all the public APIs which do thatshould be annotated accordingly.")]
				private RuntimeType[] PopulateInterfaces(Filter filter)
				{
					ListBuilder<RuntimeType> list = default(ListBuilder<RuntimeType>);
					RuntimeType reflectedType = ReflectedType;
					if (!RuntimeTypeHandle.IsGenericVariable(reflectedType))
					{
						Type[] interfaces = RuntimeTypeHandle.GetInterfaces(reflectedType);
						if (interfaces != null)
						{
							for (int i = 0; i < interfaces.Length; i++)
							{
								RuntimeType runtimeType = (RuntimeType)interfaces[i];
								if (!filter.RequiresStringComparison() || filter.Match(RuntimeTypeHandle.GetUtf8Name(runtimeType)))
								{
									list.Add(runtimeType);
								}
							}
						}
						if (ReflectedType.IsSZArray)
						{
							RuntimeType runtimeType2 = (RuntimeType)ReflectedType.GetElementType();
							if (!runtimeType2.IsPointer)
							{
								AddSpecialInterface(ref list, filter, (RuntimeType)typeof(IList<>).MakeGenericType(runtimeType2), addSubInterface: true);
								AddSpecialInterface(ref list, filter, (RuntimeType)typeof(IReadOnlyList<>).MakeGenericType(runtimeType2), addSubInterface: false);
								AddSpecialInterface(ref list, filter, (RuntimeType)typeof(IReadOnlyCollection<>).MakeGenericType(runtimeType2), addSubInterface: false);
							}
						}
					}
					else
					{
						HashSet<RuntimeType> hashSet = new HashSet<RuntimeType>();
						Type[] genericParameterConstraints = reflectedType.GetGenericParameterConstraints();
						for (int j = 0; j < genericParameterConstraints.Length; j++)
						{
							RuntimeType runtimeType3 = (RuntimeType)genericParameterConstraints[j];
							if (runtimeType3.IsInterface)
							{
								hashSet.Add(runtimeType3);
							}
							Type[] interfaces2 = runtimeType3.GetInterfaces();
							for (int k = 0; k < interfaces2.Length; k++)
							{
								hashSet.Add((RuntimeType)interfaces2[k]);
							}
						}
						foreach (RuntimeType item in hashSet)
						{
							if (!filter.RequiresStringComparison() || filter.Match(RuntimeTypeHandle.GetUtf8Name(item)))
							{
								list.Add(item);
							}
						}
					}
					return list.ToArray();
				}

				[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Calls to ResolveTypeHandle technically require all types to be kept But this is not a public API to enumerate reflection items, all the public APIs which do that should be annotated accordingly.")]
				private RuntimeType[] PopulateNestedClasses(Filter filter)
				{
					RuntimeType runtimeType = ReflectedType;
					while (RuntimeTypeHandle.IsGenericVariable(runtimeType))
					{
						runtimeType = runtimeType.GetBaseType();
					}
					int token = RuntimeTypeHandle.GetToken(runtimeType);
					if (System.Reflection.MetadataToken.IsNullToken(token))
					{
						return Array.Empty<RuntimeType>();
					}
					ListBuilder<RuntimeType> listBuilder = default(ListBuilder<RuntimeType>);
					ModuleHandle moduleHandle = new ModuleHandle(RuntimeTypeHandle.GetModule(runtimeType));
					ModuleHandle.GetMetadataImport(moduleHandle.GetRuntimeModule()).EnumNestedTypes(token, out var result);
					for (int i = 0; i < result.Length; i++)
					{
						RuntimeType runtimeType2;
						try
						{
							runtimeType2 = moduleHandle.ResolveTypeHandle(result[i]).GetRuntimeType();
						}
						catch (TypeLoadException)
						{
							continue;
						}
						if (!filter.RequiresStringComparison() || filter.Match(RuntimeTypeHandle.GetUtf8Name(runtimeType2)))
						{
							listBuilder.Add(runtimeType2);
						}
					}
					return listBuilder.ToArray();
				}

				private RuntimeEventInfo[] PopulateEvents(Filter filter)
				{
					Dictionary<string, RuntimeEventInfo> csEventInfos = (filter.CaseSensitive() ? null : new Dictionary<string, RuntimeEventInfo>());
					RuntimeType runtimeType = ReflectedType;
					ListBuilder<RuntimeEventInfo> list = default(ListBuilder<RuntimeEventInfo>);
					if (!RuntimeTypeHandle.IsInterface(runtimeType))
					{
						while (RuntimeTypeHandle.IsGenericVariable(runtimeType))
						{
							runtimeType = runtimeType.GetBaseType();
						}
						while (runtimeType != null)
						{
							PopulateEvents(filter, runtimeType, csEventInfos, ref list);
							runtimeType = RuntimeTypeHandle.GetBaseType(runtimeType);
						}
					}
					else
					{
						PopulateEvents(filter, runtimeType, csEventInfos, ref list);
					}
					return list.ToArray();
				}

				private void PopulateEvents(Filter filter, RuntimeType declaringType, Dictionary<string, RuntimeEventInfo> csEventInfos, ref ListBuilder<RuntimeEventInfo> list)
				{
					int token = RuntimeTypeHandle.GetToken(declaringType);
					if (System.Reflection.MetadataToken.IsNullToken(token))
					{
						return;
					}
					MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(declaringType);
					metadataImport.EnumEvents(token, out var result);
					for (int i = 0; i < result.Length; i++)
					{
						int num = result[i];
						if (filter.RequiresStringComparison())
						{
							MdUtf8String name = metadataImport.GetName(num);
							if (!filter.Match(name))
							{
								continue;
							}
						}
						bool isPrivate;
						RuntimeEventInfo runtimeEventInfo = new RuntimeEventInfo(num, declaringType, m_runtimeTypeCache, out isPrivate);
						if (declaringType != m_runtimeTypeCache.GetRuntimeType() && isPrivate)
						{
							continue;
						}
						if (csEventInfos != null)
						{
							string name2 = runtimeEventInfo.Name;
							if (csEventInfos.ContainsKey(name2))
							{
								continue;
							}
							csEventInfos[name2] = runtimeEventInfo;
						}
						else if (list.Count > 0)
						{
							break;
						}
						list.Add(runtimeEventInfo);
					}
				}

				private RuntimePropertyInfo[] PopulateProperties(Filter filter)
				{
					RuntimeType runtimeType = ReflectedType;
					ListBuilder<RuntimePropertyInfo> list = default(ListBuilder<RuntimePropertyInfo>);
					if (!RuntimeTypeHandle.IsInterface(runtimeType))
					{
						while (RuntimeTypeHandle.IsGenericVariable(runtimeType))
						{
							runtimeType = runtimeType.GetBaseType();
						}
						Dictionary<string, List<RuntimePropertyInfo>> csPropertyInfos = (filter.CaseSensitive() ? null : new Dictionary<string, List<RuntimePropertyInfo>>());
						bool[] usedSlots = new bool[RuntimeTypeHandle.GetNumVirtuals(runtimeType)];
						do
						{
							PopulateProperties(filter, runtimeType, csPropertyInfos, usedSlots, ref list);
							runtimeType = RuntimeTypeHandle.GetBaseType(runtimeType);
						}
						while (runtimeType != null);
					}
					else
					{
						PopulateProperties(filter, runtimeType, null, null, ref list);
					}
					return list.ToArray();
				}

				private void PopulateProperties(Filter filter, RuntimeType declaringType, Dictionary<string, List<RuntimePropertyInfo>> csPropertyInfos, bool[] usedSlots, ref ListBuilder<RuntimePropertyInfo> list)
				{
					int token = RuntimeTypeHandle.GetToken(declaringType);
					if (System.Reflection.MetadataToken.IsNullToken(token))
					{
						return;
					}
					RuntimeTypeHandle.GetMetadataImport(declaringType).EnumProperties(token, out var result);
					RuntimeModule module = RuntimeTypeHandle.GetModule(declaringType);
					int numVirtuals = RuntimeTypeHandle.GetNumVirtuals(declaringType);
					for (int i = 0; i < result.Length; i++)
					{
						int num = result[i];
						if (filter.RequiresStringComparison())
						{
							if (!ModuleHandle.ContainsPropertyMatchingHash(module, num, filter.GetHashToMatch()))
							{
								continue;
							}
							MdUtf8String name = declaringType.GetRuntimeModule().MetadataImport.GetName(num);
							if (!filter.Match(name))
							{
								continue;
							}
						}
						bool isPrivate;
						RuntimePropertyInfo runtimePropertyInfo = new RuntimePropertyInfo(num, declaringType, m_runtimeTypeCache, out isPrivate);
						if (usedSlots != null)
						{
							if (declaringType != ReflectedType && isPrivate)
							{
								continue;
							}
							MethodInfo methodInfo = runtimePropertyInfo.GetGetMethod() ?? runtimePropertyInfo.GetSetMethod();
							if (methodInfo != null)
							{
								int slot = RuntimeMethodHandle.GetSlot((RuntimeMethodInfo)methodInfo);
								if (slot < numVirtuals)
								{
									if (usedSlots[slot])
									{
										continue;
									}
									usedSlots[slot] = true;
								}
							}
							if (csPropertyInfos != null)
							{
								string name2 = runtimePropertyInfo.Name;
								if (!csPropertyInfos.TryGetValue(name2, out var value))
								{
									value = (csPropertyInfos[name2] = new List<RuntimePropertyInfo>(1));
								}
								for (int j = 0; j < value.Count; j++)
								{
									if (runtimePropertyInfo.EqualsSig(value[j]))
									{
										value = null;
										break;
									}
								}
								if (value == null)
								{
									continue;
								}
								value.Add(runtimePropertyInfo);
							}
							else
							{
								bool flag = false;
								for (int k = 0; k < list.Count; k++)
								{
									if (runtimePropertyInfo.EqualsSig(list[k]))
									{
										flag = true;
										break;
									}
								}
								if (flag)
								{
									continue;
								}
							}
						}
						list.Add(runtimePropertyInfo);
					}
				}

				internal T[] GetMemberList(MemberListType listType, string name, CacheType cacheType)
				{
					switch (listType)
					{
					case MemberListType.CaseSensitive:
						return m_csMemberInfos[name] ?? Populate(name, listType, cacheType);
					case MemberListType.CaseInsensitive:
						return m_cisMemberInfos[name] ?? Populate(name, listType, cacheType);
					default:
						if (Volatile.Read(ref m_cacheComplete))
						{
							return m_allMembers;
						}
						return Populate(null, listType, cacheType);
					}
				}
			}

			private readonly RuntimeType m_runtimeType;

			private RuntimeType m_enclosingType;

			private TypeCode m_typeCode;

			private string m_name;

			private string m_fullname;

			private string m_toString;

			private string m_namespace;

			private readonly bool m_isGlobal;

			private bool m_bIsDomainInitialized;

			private MemberInfoCache<RuntimeMethodInfo> m_methodInfoCache;

			private MemberInfoCache<RuntimeConstructorInfo> m_constructorInfoCache;

			private MemberInfoCache<RuntimeFieldInfo> m_fieldInfoCache;

			private MemberInfoCache<RuntimeType> m_interfaceCache;

			private MemberInfoCache<RuntimeType> m_nestedClassesCache;

			private MemberInfoCache<RuntimePropertyInfo> m_propertyInfoCache;

			private MemberInfoCache<RuntimeEventInfo> m_eventInfoCache;

			private static CerHashtable<RuntimeMethodInfo, RuntimeMethodInfo> s_methodInstantiations;

			private static object s_methodInstantiationsLock;

			private string m_defaultMemberName;

			private object m_genericCache;

			private object[] _emptyArray;

			internal object GenericCache
			{
				get
				{
					return m_genericCache;
				}
				set
				{
					m_genericCache = value;
				}
			}

			internal bool DomainInitialized
			{
				get
				{
					return m_bIsDomainInitialized;
				}
				set
				{
					m_bIsDomainInitialized = value;
				}
			}

			internal TypeCode TypeCode
			{
				get
				{
					return m_typeCode;
				}
				set
				{
					m_typeCode = value;
				}
			}

			internal bool IsGlobal => m_isGlobal;

			internal RuntimeTypeCache(RuntimeType runtimeType)
			{
				m_typeCode = TypeCode.Empty;
				m_runtimeType = runtimeType;
				m_isGlobal = RuntimeTypeHandle.GetModule(runtimeType).RuntimeType == runtimeType;
			}

			private string ConstructName([NotNull] ref string name, TypeNameFormatFlags formatFlags)
			{
				return name ?? (name = new RuntimeTypeHandle(m_runtimeType).ConstructName(formatFlags));
			}

			private T[] GetMemberList<T>(ref MemberInfoCache<T> m_cache, MemberListType listType, string name, CacheType cacheType) where T : MemberInfo
			{
				MemberInfoCache<T> memberCache = GetMemberCache(ref m_cache);
				return memberCache.GetMemberList(listType, name, cacheType);
			}

			private MemberInfoCache<T> GetMemberCache<T>(ref MemberInfoCache<T> m_cache) where T : MemberInfo
			{
				MemberInfoCache<T> memberInfoCache = m_cache;
				if (memberInfoCache == null)
				{
					MemberInfoCache<T> memberInfoCache2 = new MemberInfoCache<T>(this);
					memberInfoCache = Interlocked.CompareExchange(ref m_cache, memberInfoCache2, null);
					if (memberInfoCache == null)
					{
						memberInfoCache = memberInfoCache2;
					}
				}
				return memberInfoCache;
			}

			internal string GetName(TypeNameKind kind)
			{
				switch (kind)
				{
				case TypeNameKind.Name:
					return ConstructName(ref m_name, TypeNameFormatFlags.FormatBasic);
				case TypeNameKind.FullName:
					if (!m_runtimeType.GetRootElementType().IsGenericTypeDefinition && m_runtimeType.ContainsGenericParameters)
					{
						return null;
					}
					return ConstructName(ref m_fullname, (TypeNameFormatFlags)3);
				case TypeNameKind.ToString:
					return ConstructName(ref m_toString, TypeNameFormatFlags.FormatNamespace);
				default:
					throw new InvalidOperationException();
				}
			}

			internal string GetNameSpace()
			{
				if (m_namespace == null)
				{
					Type runtimeType = m_runtimeType;
					runtimeType = runtimeType.GetRootElementType();
					while (runtimeType.IsNested)
					{
						runtimeType = runtimeType.DeclaringType;
					}
					m_namespace = RuntimeTypeHandle.GetMetadataImport((RuntimeType)runtimeType).GetNamespace(runtimeType.MetadataToken).ToString();
				}
				return m_namespace;
			}

			internal RuntimeType GetEnclosingType()
			{
				if (m_enclosingType == null)
				{
					RuntimeType declaringType = RuntimeTypeHandle.GetDeclaringType(GetRuntimeType());
					m_enclosingType = declaringType ?? ((RuntimeType)typeof(void));
				}
				if (!(m_enclosingType == typeof(void)))
				{
					return m_enclosingType;
				}
				return null;
			}

			internal RuntimeType GetRuntimeType()
			{
				return m_runtimeType;
			}

			internal void InvalidateCachedNestedType()
			{
				m_nestedClassesCache = null;
			}

			internal string GetDefaultMemberName()
			{
				if (m_defaultMemberName == null)
				{
					CustomAttributeData customAttributeData = null;
					Type typeFromHandle = typeof(DefaultMemberAttribute);
					RuntimeType runtimeType = m_runtimeType;
					while (runtimeType != null)
					{
						IList<CustomAttributeData> customAttributes = CustomAttributeData.GetCustomAttributes(runtimeType);
						for (int i = 0; i < customAttributes.Count; i++)
						{
							if ((object)customAttributes[i].Constructor.DeclaringType == typeFromHandle)
							{
								customAttributeData = customAttributes[i];
								break;
							}
						}
						if (customAttributeData != null)
						{
							m_defaultMemberName = customAttributeData.ConstructorArguments[0].Value as string;
							break;
						}
						runtimeType = runtimeType.GetBaseType();
					}
				}
				return m_defaultMemberName;
			}

			internal object[] GetEmptyArray()
			{
				return _emptyArray ?? (_emptyArray = (object[])Array.CreateInstance(m_runtimeType, 0));
			}

			internal MethodInfo GetGenericMethodInfo(RuntimeMethodHandleInternal genericMethod)
			{
				LoaderAllocator loaderAllocator = RuntimeMethodHandle.GetLoaderAllocator(genericMethod);
				RuntimeMethodInfo runtimeMethodInfo = new RuntimeMethodInfo(genericMethod, RuntimeMethodHandle.GetDeclaringType(genericMethod), this, RuntimeMethodHandle.GetAttributes(genericMethod), (BindingFlags)(-1), loaderAllocator);
				RuntimeMethodInfo runtimeMethodInfo2 = ((loaderAllocator == null) ? s_methodInstantiations[runtimeMethodInfo] : loaderAllocator.m_methodInstantiations[runtimeMethodInfo]);
				if (runtimeMethodInfo2 != null)
				{
					return runtimeMethodInfo2;
				}
				if (s_methodInstantiationsLock == null)
				{
					Interlocked.CompareExchange(ref s_methodInstantiationsLock, new object(), null);
				}
				bool lockTaken = false;
				try
				{
					Monitor.Enter(s_methodInstantiationsLock, ref lockTaken);
					if (loaderAllocator != null)
					{
						runtimeMethodInfo2 = loaderAllocator.m_methodInstantiations[runtimeMethodInfo];
						if (runtimeMethodInfo2 != null)
						{
							return runtimeMethodInfo2;
						}
						loaderAllocator.m_methodInstantiations[runtimeMethodInfo] = runtimeMethodInfo;
					}
					else
					{
						runtimeMethodInfo2 = s_methodInstantiations[runtimeMethodInfo];
						if (runtimeMethodInfo2 != null)
						{
							return runtimeMethodInfo2;
						}
						s_methodInstantiations[runtimeMethodInfo] = runtimeMethodInfo;
					}
				}
				finally
				{
					if (lockTaken)
					{
						Monitor.Exit(s_methodInstantiationsLock);
					}
				}
				return runtimeMethodInfo;
			}

			internal RuntimeMethodInfo[] GetMethodList(MemberListType listType, string name)
			{
				return GetMemberList(ref m_methodInfoCache, listType, name, CacheType.Method);
			}

			internal RuntimeConstructorInfo[] GetConstructorList(MemberListType listType, string name)
			{
				return GetMemberList(ref m_constructorInfoCache, listType, name, CacheType.Constructor);
			}

			internal RuntimePropertyInfo[] GetPropertyList(MemberListType listType, string name)
			{
				return GetMemberList(ref m_propertyInfoCache, listType, name, CacheType.Property);
			}

			internal RuntimeEventInfo[] GetEventList(MemberListType listType, string name)
			{
				return GetMemberList(ref m_eventInfoCache, listType, name, CacheType.Event);
			}

			internal RuntimeFieldInfo[] GetFieldList(MemberListType listType, string name)
			{
				return GetMemberList(ref m_fieldInfoCache, listType, name, CacheType.Field);
			}

			internal RuntimeType[] GetInterfaceList(MemberListType listType, string name)
			{
				return GetMemberList(ref m_interfaceCache, listType, name, CacheType.Interface);
			}

			internal RuntimeType[] GetNestedTypeList(MemberListType listType, string name)
			{
				return GetMemberList(ref m_nestedClassesCache, listType, name, CacheType.NestedType);
			}

			internal MethodBase GetMethod(RuntimeType declaringType, RuntimeMethodHandleInternal method)
			{
				GetMemberCache(ref m_methodInfoCache);
				return m_methodInfoCache.AddMethod(declaringType, method, CacheType.Method);
			}

			internal MethodBase GetConstructor(RuntimeType declaringType, RuntimeMethodHandleInternal constructor)
			{
				GetMemberCache(ref m_constructorInfoCache);
				return m_constructorInfoCache.AddMethod(declaringType, constructor, CacheType.Constructor);
			}

			internal FieldInfo GetField(RuntimeFieldHandleInternal field)
			{
				GetMemberCache(ref m_fieldInfoCache);
				return m_fieldInfoCache.AddField(field);
			}
		}

		[Flags]
		private enum DispatchWrapperType
		{
			Unknown = 1,
			Dispatch = 2,
			Error = 8,
			Currency = 0x10,
			BStr = 0x20,
			SafeArray = 0x10000
		}

		private readonly object m_keepalive;

		private IntPtr m_cache;

		internal IntPtr m_handle;

		internal static readonly RuntimeType ValueType = (RuntimeType)typeof(ValueType);

		private static readonly RuntimeType ObjectType = (RuntimeType)typeof(object);

		private static readonly RuntimeType StringType = (RuntimeType)typeof(string);

		private const int GenericParameterCountAny = -1;

		private static readonly RuntimeType s_typedRef = (RuntimeType)typeof(TypedReference);

		private static OleAutBinder s_ForwardCallBinder;

		internal object GenericCache
		{
			get
			{
				return CacheIfExists?.GenericCache;
			}
			set
			{
				Cache.GenericCache = value;
			}
		}

		internal bool DomainInitialized
		{
			get
			{
				return Cache.DomainInitialized;
			}
			set
			{
				Cache.DomainInitialized = value;
			}
		}

		private RuntimeTypeCache CacheIfExists
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (m_cache != IntPtr.Zero)
				{
					object value = GCHandle.InternalGet(m_cache);
					return Unsafe.As<RuntimeTypeCache>(value);
				}
				return null;
			}
		}

		private RuntimeTypeCache Cache
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (m_cache != IntPtr.Zero)
				{
					object obj = GCHandle.InternalGet(m_cache);
					if (obj != null)
					{
						return Unsafe.As<RuntimeTypeCache>(obj);
					}
				}
				return InitializeCache();
			}
		}

		public sealed override bool IsCollectible
		{
			get
			{
				RuntimeType type = this;
				return RuntimeTypeHandle.IsCollectible(new QCallTypeHandle(ref type)) != Interop.BOOL.FALSE;
			}
		}

		public override MethodBase DeclaringMethod
		{
			get
			{
				if (!IsGenericParameter)
				{
					throw new InvalidOperationException(SR.Arg_NotGenericParameter);
				}
				IRuntimeMethodInfo declaringMethod = RuntimeTypeHandle.GetDeclaringMethod(this);
				if (declaringMethod == null)
				{
					return null;
				}
				return GetMethodBase(RuntimeMethodHandle.GetDeclaringType(declaringMethod), declaringMethod);
			}
		}

		public override string FullName => GetCachedName(TypeNameKind.FullName);

		public override string AssemblyQualifiedName
		{
			get
			{
				string fullName = FullName;
				if (fullName == null)
				{
					return null;
				}
				return Assembly.CreateQualifiedName(Assembly.FullName, fullName);
			}
		}

		public override string Namespace
		{
			get
			{
				string nameSpace = Cache.GetNameSpace();
				if (string.IsNullOrEmpty(nameSpace))
				{
					return null;
				}
				return nameSpace;
			}
		}

		public override Guid GUID
		{
			get
			{
				Guid result = default(Guid);
				GetGUID(ref result);
				return result;
			}
		}

		public override GenericParameterAttributes GenericParameterAttributes
		{
			get
			{
				if (!IsGenericParameter)
				{
					throw new InvalidOperationException(SR.Arg_NotGenericParameter);
				}
				RuntimeTypeHandle.GetMetadataImport(this).GetGenericParamProps(MetadataToken, out var attributes);
				return attributes;
			}
		}

		public sealed override bool IsSZArray => RuntimeTypeHandle.IsSZArray(this);

		public override int GenericParameterPosition
		{
			get
			{
				if (!IsGenericParameter)
				{
					throw new InvalidOperationException(SR.Arg_NotGenericParameter);
				}
				return new RuntimeTypeHandle(this).GetGenericVariableIndex();
			}
		}

		public override bool ContainsGenericParameters => GetRootElementType().GetTypeHandleInternal().ContainsGenericVariables();

		public override StructLayoutAttribute StructLayoutAttribute => PseudoCustomAttribute.GetStructLayoutCustomAttribute(this);

		public override string Name => GetCachedName(TypeNameKind.Name);

		public override Type DeclaringType => Cache.GetEnclosingType();

		private static OleAutBinder ForwardCallBinder => s_ForwardCallBinder ?? (s_ForwardCallBinder = new OleAutBinder());

		public override Assembly Assembly => RuntimeTypeHandle.GetAssembly(this);

		public override Type BaseType => GetBaseType();

		public override bool IsByRefLike => RuntimeTypeHandle.IsByRefLike(this);

		public override bool IsConstructedGenericType
		{
			get
			{
				if (IsGenericType)
				{
					return !IsGenericTypeDefinition;
				}
				return false;
			}
		}

		public override bool IsGenericType => RuntimeTypeHandle.HasInstantiation(this);

		public override bool IsGenericTypeDefinition => RuntimeTypeHandle.IsGenericTypeDefinition(this);

		public override bool IsGenericParameter => RuntimeTypeHandle.IsGenericVariable(this);

		public override bool IsTypeDefinition => RuntimeTypeHandle.IsTypeDefinition(this);

		public override bool IsSecurityCritical => true;

		public override bool IsSecuritySafeCritical => false;

		public override bool IsSecurityTransparent => false;

		public override MemberTypes MemberType
		{
			get
			{
				if (!base.IsPublic && !base.IsNotPublic)
				{
					return MemberTypes.NestedType;
				}
				return MemberTypes.TypeInfo;
			}
		}

		public override int MetadataToken => RuntimeTypeHandle.GetToken(this);

		public override Module Module => GetRuntimeModule();

		public override Type ReflectedType => DeclaringType;

		public override RuntimeTypeHandle TypeHandle => new RuntimeTypeHandle(this);

		public override Type UnderlyingSystemType => this;

		internal static RuntimeType GetType(string typeName, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
		{
			if (typeName == null)
			{
				throw new ArgumentNullException("typeName");
			}
			return RuntimeTypeHandle.GetTypeByName(typeName, throwOnError, ignoreCase, ref stackMark);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		internal static MethodBase GetMethodBase(RuntimeModule scope, int typeMetadataToken)
		{
			return GetMethodBase(new ModuleHandle(scope).ResolveMethodHandle(typeMetadataToken).GetMethodInfo());
		}

		internal static MethodBase GetMethodBase(IRuntimeMethodInfo methodHandle)
		{
			return GetMethodBase(null, methodHandle);
		}

		internal static MethodBase GetMethodBase(RuntimeType reflectedType, IRuntimeMethodInfo methodHandle)
		{
			MethodBase methodBase = GetMethodBase(reflectedType, methodHandle.Value);
			GC.KeepAlive(methodHandle);
			return methodBase;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "The code in this method looks up the method by name, but it always starts with a method handle.To get here something somwhere had to get the method handle and thus the method must exist.")]
		internal static MethodBase GetMethodBase(RuntimeType reflectedType, RuntimeMethodHandleInternal methodHandle)
		{
			if (RuntimeMethodHandle.IsDynamicMethod(methodHandle))
			{
				return RuntimeMethodHandle.GetResolver(methodHandle)?.GetDynamicMethod();
			}
			RuntimeType runtimeType = RuntimeMethodHandle.GetDeclaringType(methodHandle);
			RuntimeType[] array = null;
			if ((object)reflectedType == null)
			{
				reflectedType = runtimeType;
			}
			if (reflectedType != runtimeType && !reflectedType.IsSubclassOf(runtimeType))
			{
				if (reflectedType.IsArray)
				{
					MethodBase[] array2 = reflectedType.GetMember(RuntimeMethodHandle.GetName(methodHandle), MemberTypes.Constructor | MemberTypes.Method, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) as MethodBase[];
					bool flag = false;
					for (int i = 0; i < array2.Length; i++)
					{
						IRuntimeMethodInfo runtimeMethodInfo = (IRuntimeMethodInfo)array2[i];
						if (runtimeMethodInfo.Value.Value == methodHandle.Value)
						{
							flag = true;
						}
					}
					if (!flag)
					{
						throw new ArgumentException(SR.Format(SR.Argument_ResolveMethodHandle, reflectedType, runtimeType));
					}
				}
				else if (runtimeType.IsGenericType)
				{
					RuntimeType runtimeType2 = (RuntimeType)runtimeType.GetGenericTypeDefinition();
					RuntimeType runtimeType3 = reflectedType;
					while (runtimeType3 != null)
					{
						RuntimeType runtimeType4 = runtimeType3;
						if (runtimeType4.IsGenericType && !runtimeType3.IsGenericTypeDefinition)
						{
							runtimeType4 = (RuntimeType)runtimeType4.GetGenericTypeDefinition();
						}
						if (runtimeType4 == runtimeType2)
						{
							break;
						}
						runtimeType3 = runtimeType3.GetBaseType();
					}
					if (runtimeType3 == null)
					{
						throw new ArgumentException(SR.Format(SR.Argument_ResolveMethodHandle, reflectedType, runtimeType));
					}
					runtimeType = runtimeType3;
					if (!RuntimeMethodHandle.IsGenericMethodDefinition(methodHandle))
					{
						array = RuntimeMethodHandle.GetMethodInstantiationInternal(methodHandle);
					}
					methodHandle = RuntimeMethodHandle.GetMethodFromCanonical(methodHandle, runtimeType);
				}
				else if (!runtimeType.IsAssignableFrom(reflectedType))
				{
					throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, SR.Argument_ResolveMethodHandle, reflectedType.ToString(), runtimeType.ToString()));
				}
			}
			methodHandle = RuntimeMethodHandle.GetStubIfNeeded(methodHandle, runtimeType, array);
			MethodBase result = (RuntimeMethodHandle.IsConstructor(methodHandle) ? reflectedType.Cache.GetConstructor(runtimeType, methodHandle) : ((!RuntimeMethodHandle.HasMethodInstantiation(methodHandle) || RuntimeMethodHandle.IsGenericMethodDefinition(methodHandle)) ? reflectedType.Cache.GetMethod(runtimeType, methodHandle) : reflectedType.Cache.GetGenericMethodInfo(methodHandle)));
			GC.KeepAlive(array);
			return result;
		}

		internal static FieldInfo GetFieldInfo(IRuntimeFieldInfo fieldHandle)
		{
			return GetFieldInfo(RuntimeFieldHandle.GetApproxDeclaringType(fieldHandle), fieldHandle);
		}

		internal static FieldInfo GetFieldInfo(RuntimeType reflectedType, IRuntimeFieldInfo field)
		{
			RuntimeFieldHandleInternal value = field.Value;
			if (reflectedType == null)
			{
				reflectedType = RuntimeFieldHandle.GetApproxDeclaringType(value);
			}
			else
			{
				RuntimeType approxDeclaringType = RuntimeFieldHandle.GetApproxDeclaringType(value);
				if (reflectedType != approxDeclaringType && (!RuntimeFieldHandle.AcquiresContextFromThis(value) || !RuntimeTypeHandle.CompareCanonicalHandles(approxDeclaringType, reflectedType)))
				{
					throw new ArgumentException(SR.Format(SR.Argument_ResolveFieldHandle, reflectedType, approxDeclaringType));
				}
			}
			FieldInfo field2 = reflectedType.Cache.GetField(value);
			GC.KeepAlive(field);
			return field2;
		}

		private static PropertyInfo GetPropertyInfo(RuntimeType reflectedType, int tkProperty)
		{
			RuntimePropertyInfo[] propertyList = reflectedType.Cache.GetPropertyList(MemberListType.All, null);
			foreach (RuntimePropertyInfo runtimePropertyInfo in propertyList)
			{
				if (runtimePropertyInfo.MetadataToken == tkProperty)
				{
					return runtimePropertyInfo;
				}
			}
			throw new SystemException();
		}

		internal static void ValidateGenericArguments(MemberInfo definition, RuntimeType[] genericArguments, Exception e)
		{
			RuntimeType[] typeContext = null;
			RuntimeType[] methodContext = null;
			RuntimeType[] genericArgumentsInternal;
			if (definition is Type)
			{
				RuntimeType runtimeType = (RuntimeType)definition;
				genericArgumentsInternal = runtimeType.GetGenericArgumentsInternal();
				typeContext = genericArguments;
			}
			else
			{
				RuntimeMethodInfo runtimeMethodInfo = (RuntimeMethodInfo)definition;
				genericArgumentsInternal = runtimeMethodInfo.GetGenericArgumentsInternal();
				methodContext = genericArguments;
				RuntimeType runtimeType2 = (RuntimeType)runtimeMethodInfo.DeclaringType;
				if (runtimeType2 != null)
				{
					typeContext = runtimeType2.GetTypeHandleInternal().GetInstantiationInternal();
				}
			}
			for (int i = 0; i < genericArguments.Length; i++)
			{
				Type type = genericArguments[i];
				Type type2 = genericArgumentsInternal[i];
				if (!RuntimeTypeHandle.SatisfiesConstraints(type2.GetTypeHandleInternal().GetTypeChecked(), typeContext, methodContext, type.GetTypeHandleInternal().GetTypeChecked()))
				{
					throw new ArgumentException(SR.Format(SR.Argument_GenConstraintViolation, i.ToString(), type, definition, type2), e);
				}
			}
		}

		private static void SplitName(string fullname, out string name, out string ns)
		{
			name = null;
			ns = null;
			if (fullname == null)
			{
				return;
			}
			int num = fullname.LastIndexOf(".", StringComparison.Ordinal);
			if (num != -1)
			{
				ns = fullname.Substring(0, num);
				int num2 = fullname.Length - ns.Length - 1;
				if (num2 != 0)
				{
					name = fullname.Substring(num + 1, num2);
				}
				else
				{
					name = "";
				}
			}
			else
			{
				name = fullname;
			}
		}

		internal static BindingFlags FilterPreCalculate(bool isPublic, bool isInherited, bool isStatic)
		{
			BindingFlags bindingFlags = (isPublic ? BindingFlags.Public : BindingFlags.NonPublic);
			if (isInherited)
			{
				bindingFlags |= BindingFlags.DeclaredOnly;
				if (isStatic)
				{
					return bindingFlags | (BindingFlags.Static | BindingFlags.FlattenHierarchy);
				}
				return bindingFlags | BindingFlags.Instance;
			}
			if (isStatic)
			{
				return bindingFlags | BindingFlags.Static;
			}
			return bindingFlags | BindingFlags.Instance;
		}

		private static void FilterHelper(BindingFlags bindingFlags, ref string name, bool allowPrefixLookup, out bool prefixLookup, out bool ignoreCase, out MemberListType listType)
		{
			prefixLookup = false;
			ignoreCase = false;
			if (name != null)
			{
				if ((bindingFlags & BindingFlags.IgnoreCase) != 0)
				{
					name = name.ToLowerInvariant();
					ignoreCase = true;
					listType = MemberListType.CaseInsensitive;
				}
				else
				{
					listType = MemberListType.CaseSensitive;
				}
				if (allowPrefixLookup && name.EndsWith("*", StringComparison.Ordinal))
				{
					name = name[0..^1];
					prefixLookup = true;
					listType = MemberListType.All;
				}
			}
			else
			{
				listType = MemberListType.All;
			}
		}

		private static void FilterHelper(BindingFlags bindingFlags, ref string name, out bool ignoreCase, out MemberListType listType)
		{
			FilterHelper(bindingFlags, ref name, allowPrefixLookup: false, out var _, out ignoreCase, out listType);
		}

		private static bool FilterApplyPrefixLookup(MemberInfo memberInfo, string name, bool ignoreCase)
		{
			if (ignoreCase)
			{
				if (!memberInfo.Name.StartsWith(name, StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
			}
			else if (!memberInfo.Name.StartsWith(name, StringComparison.Ordinal))
			{
				return false;
			}
			return true;
		}

		private static bool FilterApplyBase(MemberInfo memberInfo, BindingFlags bindingFlags, bool isPublic, bool isNonProtectedInternal, bool isStatic, string name, bool prefixLookup)
		{
			if (isPublic)
			{
				if ((bindingFlags & BindingFlags.Public) == 0)
				{
					return false;
				}
			}
			else if ((bindingFlags & BindingFlags.NonPublic) == 0)
			{
				return false;
			}
			bool flag = (object)memberInfo.DeclaringType != memberInfo.ReflectedType;
			if ((bindingFlags & BindingFlags.DeclaredOnly) != 0 && flag)
			{
				return false;
			}
			if (memberInfo.MemberType != MemberTypes.TypeInfo && memberInfo.MemberType != MemberTypes.NestedType)
			{
				if (isStatic)
				{
					if ((bindingFlags & BindingFlags.FlattenHierarchy) == 0 && flag)
					{
						return false;
					}
					if ((bindingFlags & BindingFlags.Static) == 0)
					{
						return false;
					}
				}
				else if ((bindingFlags & BindingFlags.Instance) == 0)
				{
					return false;
				}
			}
			if (prefixLookup && !FilterApplyPrefixLookup(memberInfo, name, (bindingFlags & BindingFlags.IgnoreCase) != 0))
			{
				return false;
			}
			if ((bindingFlags & BindingFlags.DeclaredOnly) == 0 && flag && isNonProtectedInternal && (bindingFlags & BindingFlags.NonPublic) != 0 && !isStatic && (bindingFlags & BindingFlags.Instance) != 0)
			{
				MethodInfo methodInfo = memberInfo as MethodInfo;
				if (methodInfo == null)
				{
					return false;
				}
				if (!methodInfo.IsVirtual && !methodInfo.IsAbstract)
				{
					return false;
				}
			}
			return true;
		}

		private static bool FilterApplyType(Type type, BindingFlags bindingFlags, string name, bool prefixLookup, string ns)
		{
			bool isPublic = type.IsNestedPublic || type.IsPublic;
			if (!FilterApplyBase(type, bindingFlags, isPublic, type.IsNestedAssembly, isStatic: false, name, prefixLookup))
			{
				return false;
			}
			if (ns != null && ns != type.Namespace)
			{
				return false;
			}
			return true;
		}

		private static bool FilterApplyMethodInfo(RuntimeMethodInfo method, BindingFlags bindingFlags, CallingConventions callConv, Type[] argumentTypes)
		{
			return FilterApplyMethodBase(method, method.BindingFlags, bindingFlags, callConv, argumentTypes);
		}

		private static bool FilterApplyConstructorInfo(RuntimeConstructorInfo constructor, BindingFlags bindingFlags, CallingConventions callConv, Type[] argumentTypes)
		{
			return FilterApplyMethodBase(constructor, constructor.BindingFlags, bindingFlags, callConv, argumentTypes);
		}

		private static bool FilterApplyMethodBase(MethodBase methodBase, BindingFlags methodFlags, BindingFlags bindingFlags, CallingConventions callConv, Type[] argumentTypes)
		{
			bindingFlags ^= BindingFlags.DeclaredOnly;
			if ((bindingFlags & methodFlags) != methodFlags)
			{
				return false;
			}
			if ((callConv & CallingConventions.Any) == 0)
			{
				if ((callConv & CallingConventions.VarArgs) != 0 && (methodBase.CallingConvention & CallingConventions.VarArgs) == 0)
				{
					return false;
				}
				if ((callConv & CallingConventions.Standard) != 0 && (methodBase.CallingConvention & CallingConventions.Standard) == 0)
				{
					return false;
				}
			}
			if (argumentTypes != null)
			{
				ParameterInfo[] parametersNoCopy = methodBase.GetParametersNoCopy();
				if (argumentTypes.Length != parametersNoCopy.Length)
				{
					if ((bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.CreateInstance | BindingFlags.GetProperty | BindingFlags.SetProperty)) == 0)
					{
						return false;
					}
					bool flag = false;
					if (argumentTypes.Length > parametersNoCopy.Length)
					{
						if ((methodBase.CallingConvention & CallingConventions.VarArgs) == 0)
						{
							flag = true;
						}
					}
					else if ((bindingFlags & BindingFlags.OptionalParamBinding) == 0)
					{
						flag = true;
					}
					else if (!parametersNoCopy[argumentTypes.Length].IsOptional)
					{
						flag = true;
					}
					if (flag)
					{
						if (parametersNoCopy.Length == 0)
						{
							return false;
						}
						if (argumentTypes.Length < parametersNoCopy.Length - 1)
						{
							return false;
						}
						ParameterInfo parameterInfo = parametersNoCopy[^1];
						if (!parameterInfo.ParameterType.IsArray)
						{
							return false;
						}
						if (!parameterInfo.IsDefined(typeof(ParamArrayAttribute), inherit: false))
						{
							return false;
						}
					}
				}
				else if ((bindingFlags & BindingFlags.ExactBinding) != 0 && (bindingFlags & BindingFlags.InvokeMethod) == 0)
				{
					for (int i = 0; i < parametersNoCopy.Length; i++)
					{
						Type type = argumentTypes[i];
						if ((object)type != null && !type.MatchesParameterTypeExactly(parametersNoCopy[i]))
						{
							return false;
						}
					}
				}
			}
			return true;
		}

		internal RuntimeType()
		{
			throw new NotSupportedException();
		}

		internal IntPtr GetUnderlyingNativeHandle()
		{
			return m_handle;
		}

		internal override bool CacheEquals(object o)
		{
			if (o is RuntimeType runtimeType)
			{
				return runtimeType.m_handle == m_handle;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private RuntimeTypeCache InitializeCache()
		{
			if (m_cache == IntPtr.Zero)
			{
				RuntimeTypeHandle runtimeTypeHandle = new RuntimeTypeHandle(this);
				IntPtr gCHandle = runtimeTypeHandle.GetGCHandle(GCHandleType.WeakTrackResurrection);
				IntPtr intPtr = Interlocked.CompareExchange(ref m_cache, gCHandle, IntPtr.Zero);
				if (intPtr != IntPtr.Zero)
				{
					runtimeTypeHandle.FreeGCHandle(gCHandle);
				}
			}
			RuntimeTypeCache runtimeTypeCache = (RuntimeTypeCache)GCHandle.InternalGet(m_cache);
			if (runtimeTypeCache == null)
			{
				runtimeTypeCache = new RuntimeTypeCache(this);
				RuntimeTypeCache runtimeTypeCache2 = (RuntimeTypeCache)GCHandle.InternalCompareExchange(m_cache, runtimeTypeCache, null);
				if (runtimeTypeCache2 != null)
				{
					runtimeTypeCache = runtimeTypeCache2;
				}
			}
			return runtimeTypeCache;
		}

		internal void ClearCache()
		{
			if (!(Volatile.Read(ref m_cache) == IntPtr.Zero))
			{
				GCHandle.InternalSet(m_cache, null);
			}
		}

		private string GetDefaultMemberName()
		{
			return Cache.GetDefaultMemberName();
		}

		private ListBuilder<MethodInfo> GetMethodCandidates(string name, int genericParameterCount, BindingFlags bindingAttr, CallingConventions callConv, Type[] types, bool allowPrefixLookup)
		{
			FilterHelper(bindingAttr, ref name, allowPrefixLookup, out var prefixLookup, out var ignoreCase, out var listType);
			RuntimeMethodInfo[] methodList = Cache.GetMethodList(listType, name);
			ListBuilder<MethodInfo> result = new ListBuilder<MethodInfo>(methodList.Length);
			foreach (RuntimeMethodInfo runtimeMethodInfo in methodList)
			{
				if ((genericParameterCount == -1 || genericParameterCount == runtimeMethodInfo.GenericParameterCount) && FilterApplyMethodInfo(runtimeMethodInfo, bindingAttr, callConv, types) && (!prefixLookup || FilterApplyPrefixLookup(runtimeMethodInfo, name, ignoreCase)))
				{
					result.Add(runtimeMethodInfo);
				}
			}
			return result;
		}

		private ListBuilder<ConstructorInfo> GetConstructorCandidates(string name, BindingFlags bindingAttr, CallingConventions callConv, Type[] types, bool allowPrefixLookup)
		{
			FilterHelper(bindingAttr, ref name, allowPrefixLookup, out var prefixLookup, out var ignoreCase, out var listType);
			RuntimeConstructorInfo[] constructorList = Cache.GetConstructorList(listType, name);
			ListBuilder<ConstructorInfo> result = new ListBuilder<ConstructorInfo>(constructorList.Length);
			foreach (RuntimeConstructorInfo runtimeConstructorInfo in constructorList)
			{
				if (FilterApplyConstructorInfo(runtimeConstructorInfo, bindingAttr, callConv, types) && (!prefixLookup || FilterApplyPrefixLookup(runtimeConstructorInfo, name, ignoreCase)))
				{
					result.Add(runtimeConstructorInfo);
				}
			}
			return result;
		}

		private ListBuilder<PropertyInfo> GetPropertyCandidates(string name, BindingFlags bindingAttr, Type[] types, bool allowPrefixLookup)
		{
			FilterHelper(bindingAttr, ref name, allowPrefixLookup, out var prefixLookup, out var ignoreCase, out var listType);
			RuntimePropertyInfo[] propertyList = Cache.GetPropertyList(listType, name);
			bindingAttr ^= BindingFlags.DeclaredOnly;
			ListBuilder<PropertyInfo> result = new ListBuilder<PropertyInfo>(propertyList.Length);
			foreach (RuntimePropertyInfo runtimePropertyInfo in propertyList)
			{
				if ((bindingAttr & runtimePropertyInfo.BindingFlags) == runtimePropertyInfo.BindingFlags && (!prefixLookup || FilterApplyPrefixLookup(runtimePropertyInfo, name, ignoreCase)) && (types == null || runtimePropertyInfo.GetIndexParameters().Length == types.Length))
				{
					result.Add(runtimePropertyInfo);
				}
			}
			return result;
		}

		private ListBuilder<EventInfo> GetEventCandidates(string name, BindingFlags bindingAttr, bool allowPrefixLookup)
		{
			FilterHelper(bindingAttr, ref name, allowPrefixLookup, out var prefixLookup, out var ignoreCase, out var listType);
			RuntimeEventInfo[] eventList = Cache.GetEventList(listType, name);
			bindingAttr ^= BindingFlags.DeclaredOnly;
			ListBuilder<EventInfo> result = new ListBuilder<EventInfo>(eventList.Length);
			foreach (RuntimeEventInfo runtimeEventInfo in eventList)
			{
				if ((bindingAttr & runtimeEventInfo.BindingFlags) == runtimeEventInfo.BindingFlags && (!prefixLookup || FilterApplyPrefixLookup(runtimeEventInfo, name, ignoreCase)))
				{
					result.Add(runtimeEventInfo);
				}
			}
			return result;
		}

		private ListBuilder<FieldInfo> GetFieldCandidates(string name, BindingFlags bindingAttr, bool allowPrefixLookup)
		{
			FilterHelper(bindingAttr, ref name, allowPrefixLookup, out var prefixLookup, out var ignoreCase, out var listType);
			RuntimeFieldInfo[] fieldList = Cache.GetFieldList(listType, name);
			bindingAttr ^= BindingFlags.DeclaredOnly;
			ListBuilder<FieldInfo> result = new ListBuilder<FieldInfo>(fieldList.Length);
			foreach (RuntimeFieldInfo runtimeFieldInfo in fieldList)
			{
				if ((bindingAttr & runtimeFieldInfo.BindingFlags) == runtimeFieldInfo.BindingFlags && (!prefixLookup || FilterApplyPrefixLookup(runtimeFieldInfo, name, ignoreCase)))
				{
					result.Add(runtimeFieldInfo);
				}
			}
			return result;
		}

		private ListBuilder<Type> GetNestedTypeCandidates(string fullname, BindingFlags bindingAttr, bool allowPrefixLookup)
		{
			bindingAttr &= ~BindingFlags.Static;
			SplitName(fullname, out var name, out var ns);
			FilterHelper(bindingAttr, ref name, allowPrefixLookup, out var prefixLookup, out var _, out var listType);
			RuntimeType[] nestedTypeList = Cache.GetNestedTypeList(listType, name);
			ListBuilder<Type> result = new ListBuilder<Type>(nestedTypeList.Length);
			foreach (RuntimeType runtimeType in nestedTypeList)
			{
				if (FilterApplyType(runtimeType, bindingAttr, name, prefixLookup, ns))
				{
					result.Add(runtimeType);
				}
			}
			return result;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
		{
			return GetMethodCandidates(null, -1, bindingAttr, CallingConventions.Any, null, allowPrefixLookup: false).ToArray();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
		{
			return GetConstructorCandidates(null, bindingAttr, CallingConventions.Any, null, allowPrefixLookup: false).ToArray();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
		{
			return GetPropertyCandidates(null, bindingAttr, null, allowPrefixLookup: false).ToArray();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo[] GetEvents(BindingFlags bindingAttr)
		{
			return GetEventCandidates(null, bindingAttr, allowPrefixLookup: false).ToArray();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo[] GetFields(BindingFlags bindingAttr)
		{
			return GetFieldCandidates(null, bindingAttr, allowPrefixLookup: false).ToArray();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type[] GetInterfaces()
		{
			RuntimeType[] interfaceList = Cache.GetInterfaceList(MemberListType.All, null);
			Type[] array = interfaceList;
			return new ReadOnlySpan<Type>(array).ToArray();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type[] GetNestedTypes(BindingFlags bindingAttr)
		{
			return GetNestedTypeCandidates(null, bindingAttr, allowPrefixLookup: false).ToArray();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
		{
			ListBuilder<MethodInfo> methodCandidates = GetMethodCandidates(null, -1, bindingAttr, CallingConventions.Any, null, allowPrefixLookup: false);
			ListBuilder<ConstructorInfo> constructorCandidates = GetConstructorCandidates(null, bindingAttr, CallingConventions.Any, null, allowPrefixLookup: false);
			ListBuilder<PropertyInfo> propertyCandidates = GetPropertyCandidates(null, bindingAttr, null, allowPrefixLookup: false);
			ListBuilder<EventInfo> eventCandidates = GetEventCandidates(null, bindingAttr, allowPrefixLookup: false);
			ListBuilder<FieldInfo> fieldCandidates = GetFieldCandidates(null, bindingAttr, allowPrefixLookup: false);
			ListBuilder<Type> nestedTypeCandidates = GetNestedTypeCandidates(null, bindingAttr, allowPrefixLookup: false);
			MemberInfo[] array = new MemberInfo[methodCandidates.Count + constructorCandidates.Count + propertyCandidates.Count + eventCandidates.Count + fieldCandidates.Count + nestedTypeCandidates.Count];
			int num = 0;
			object[] array2 = array;
			methodCandidates.CopyTo(array2, num);
			num += methodCandidates.Count;
			array2 = array;
			constructorCandidates.CopyTo(array2, num);
			num += constructorCandidates.Count;
			array2 = array;
			propertyCandidates.CopyTo(array2, num);
			num += propertyCandidates.Count;
			array2 = array;
			eventCandidates.CopyTo(array2, num);
			num += eventCandidates.Count;
			array2 = array;
			fieldCandidates.CopyTo(array2, num);
			num += fieldCandidates.Count;
			array2 = array;
			nestedTypeCandidates.CopyTo(array2, num);
			num += nestedTypeCandidates.Count;
			return array;
		}

		public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type ifaceType)
		{
			if (IsGenericParameter)
			{
				throw new InvalidOperationException(SR.Arg_GenericParameter);
			}
			if ((object)ifaceType == null)
			{
				throw new ArgumentNullException("ifaceType");
			}
			RuntimeType runtimeType = ifaceType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "ifaceType");
			}
			RuntimeTypeHandle typeHandleInternal = runtimeType.GetTypeHandleInternal();
			GetTypeHandleInternal().VerifyInterfaceIsImplemented(typeHandleInternal);
			if (IsSZArray && ifaceType.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_ArrayGetInterfaceMap);
			}
			int numVirtualsAndStaticVirtuals = RuntimeTypeHandle.GetNumVirtualsAndStaticVirtuals(runtimeType);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out InterfaceMapping result);
			result.InterfaceType = ifaceType;
			result.TargetType = this;
			result.InterfaceMethods = new MethodInfo[numVirtualsAndStaticVirtuals];
			result.TargetMethods = new MethodInfo[numVirtualsAndStaticVirtuals];
			for (int i = 0; i < numVirtualsAndStaticVirtuals; i++)
			{
				RuntimeMethodHandleInternal methodAt = RuntimeTypeHandle.GetMethodAt(runtimeType, i);
				MethodBase methodBase = GetMethodBase(runtimeType, methodAt);
				result.InterfaceMethods[i] = (MethodInfo)methodBase;
				RuntimeMethodHandleInternal interfaceMethodImplementation = GetTypeHandleInternal().GetInterfaceMethodImplementation(typeHandleInternal, methodAt);
				if (!interfaceMethodImplementation.IsNullHandle())
				{
					RuntimeType runtimeType2 = RuntimeMethodHandle.GetDeclaringType(interfaceMethodImplementation);
					if (!runtimeType2.IsInterface)
					{
						runtimeType2 = this;
					}
					MethodBase methodBase2 = GetMethodBase(runtimeType2, interfaceMethodImplementation);
					result.TargetMethods[i] = (MethodInfo)methodBase2;
				}
			}
			return result;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConv, Type[] types, ParameterModifier[] modifiers)
		{
			return GetMethodImplCommon(name, -1, bindingAttr, binder, callConv, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected override MethodInfo GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, CallingConventions callConv, Type[] types, ParameterModifier[] modifiers)
		{
			return GetMethodImplCommon(name, genericParameterCount, bindingAttr, binder, callConv, types, modifiers);
		}

		private MethodInfo GetMethodImplCommon(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, CallingConventions callConv, Type[] types, ParameterModifier[] modifiers)
		{
			ListBuilder<MethodInfo> methodCandidates = GetMethodCandidates(name, genericParameterCount, bindingAttr, callConv, types, allowPrefixLookup: false);
			if (methodCandidates.Count == 0)
			{
				return null;
			}
			MethodBase[] match;
			if (types == null || types.Length == 0)
			{
				MethodInfo methodInfo = methodCandidates[0];
				if (methodCandidates.Count == 1)
				{
					return methodInfo;
				}
				if (types == null)
				{
					for (int i = 1; i < methodCandidates.Count; i++)
					{
						MethodInfo m = methodCandidates[i];
						if (!System.DefaultBinder.CompareMethodSig(m, methodInfo))
						{
							throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
						}
					}
					match = methodCandidates.ToArray();
					return System.DefaultBinder.FindMostDerivedNewSlotMeth(match, methodCandidates.Count) as MethodInfo;
				}
			}
			if (binder == null)
			{
				binder = Type.DefaultBinder;
			}
			Binder binder2 = binder;
			match = methodCandidates.ToArray();
			return binder2.SelectMethod(bindingAttr, match, types, modifiers) as MethodInfo;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			ListBuilder<ConstructorInfo> constructorCandidates = GetConstructorCandidates(null, bindingAttr, CallingConventions.Any, types, allowPrefixLookup: false);
			if (constructorCandidates.Count == 0)
			{
				return null;
			}
			if (types.Length == 0 && constructorCandidates.Count == 1)
			{
				ConstructorInfo constructorInfo = constructorCandidates[0];
				ParameterInfo[] parametersNoCopy = constructorInfo.GetParametersNoCopy();
				if (parametersNoCopy == null || parametersNoCopy.Length == 0)
				{
					return constructorInfo;
				}
			}
			MethodBase[] match;
			if ((bindingAttr & BindingFlags.ExactBinding) != 0)
			{
				match = constructorCandidates.ToArray();
				return System.DefaultBinder.ExactBinding(match, types, modifiers) as ConstructorInfo;
			}
			if (binder == null)
			{
				binder = Type.DefaultBinder;
			}
			Binder binder2 = binder;
			match = constructorCandidates.ToArray();
			return binder2.SelectMethod(bindingAttr, match, types, modifiers) as ConstructorInfo;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			ListBuilder<PropertyInfo> propertyCandidates = GetPropertyCandidates(name, bindingAttr, types, allowPrefixLookup: false);
			if (propertyCandidates.Count == 0)
			{
				return null;
			}
			if (types == null || types.Length == 0)
			{
				if (propertyCandidates.Count == 1)
				{
					PropertyInfo propertyInfo = propertyCandidates[0];
					if ((object)returnType != null && !returnType.IsEquivalentTo(propertyInfo.PropertyType))
					{
						return null;
					}
					return propertyInfo;
				}
				if ((object)returnType == null)
				{
					throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
				}
			}
			if ((bindingAttr & BindingFlags.ExactBinding) != 0)
			{
				return System.DefaultBinder.ExactPropertyBinding(propertyCandidates.ToArray(), returnType, types, modifiers);
			}
			if (binder == null)
			{
				binder = Type.DefaultBinder;
			}
			return binder.SelectProperty(bindingAttr, propertyCandidates.ToArray(), returnType, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			FilterHelper(bindingAttr, ref name, out var _, out var listType);
			RuntimeEventInfo[] eventList = Cache.GetEventList(listType, name);
			EventInfo eventInfo = null;
			bindingAttr ^= BindingFlags.DeclaredOnly;
			foreach (RuntimeEventInfo runtimeEventInfo in eventList)
			{
				if ((bindingAttr & runtimeEventInfo.BindingFlags) == runtimeEventInfo.BindingFlags)
				{
					if (eventInfo != null)
					{
						throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
					}
					eventInfo = runtimeEventInfo;
				}
			}
			return eventInfo;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo GetField(string name, BindingFlags bindingAttr)
		{
			if (name == null)
			{
				throw new ArgumentNullException();
			}
			FilterHelper(bindingAttr, ref name, out var _, out var listType);
			RuntimeFieldInfo[] fieldList = Cache.GetFieldList(listType, name);
			FieldInfo fieldInfo = null;
			bindingAttr ^= BindingFlags.DeclaredOnly;
			bool flag = false;
			foreach (RuntimeFieldInfo runtimeFieldInfo in fieldList)
			{
				if ((bindingAttr & runtimeFieldInfo.BindingFlags) != runtimeFieldInfo.BindingFlags)
				{
					continue;
				}
				if (fieldInfo != null)
				{
					if ((object)runtimeFieldInfo.DeclaringType == fieldInfo.DeclaringType)
					{
						throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
					}
					if (fieldInfo.DeclaringType.IsInterface && runtimeFieldInfo.DeclaringType.IsInterface)
					{
						flag = true;
					}
				}
				if (fieldInfo == null || runtimeFieldInfo.DeclaringType.IsSubclassOf(fieldInfo.DeclaringType) || fieldInfo.DeclaringType.IsInterface)
				{
					fieldInfo = runtimeFieldInfo;
				}
			}
			if (flag && fieldInfo.DeclaringType.IsInterface)
			{
				throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
			}
			return fieldInfo;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type GetInterface(string fullname, bool ignoreCase)
		{
			if (fullname == null)
			{
				throw new ArgumentNullException("fullname");
			}
			BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic;
			bindingFlags &= ~BindingFlags.Static;
			if (ignoreCase)
			{
				bindingFlags |= BindingFlags.IgnoreCase;
			}
			SplitName(fullname, out var name, out var ns);
			FilterHelper(bindingFlags, ref name, out var _, out var listType);
			RuntimeType[] interfaceList = Cache.GetInterfaceList(listType, name);
			RuntimeType runtimeType = null;
			foreach (RuntimeType runtimeType2 in interfaceList)
			{
				if (FilterApplyType(runtimeType2, bindingFlags, name, prefixLookup: false, ns))
				{
					if (runtimeType != null)
					{
						throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
					}
					runtimeType = runtimeType2;
				}
			}
			return runtimeType;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type GetNestedType(string fullname, BindingFlags bindingAttr)
		{
			if (fullname == null)
			{
				throw new ArgumentNullException("fullname");
			}
			bindingAttr &= ~BindingFlags.Static;
			SplitName(fullname, out var name, out var ns);
			FilterHelper(bindingAttr, ref name, out var _, out var listType);
			RuntimeType[] nestedTypeList = Cache.GetNestedTypeList(listType, name);
			RuntimeType runtimeType = null;
			foreach (RuntimeType runtimeType2 in nestedTypeList)
			{
				if (FilterApplyType(runtimeType2, bindingAttr, name, prefixLookup: false, ns))
				{
					if (runtimeType != null)
					{
						throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
					}
					runtimeType = runtimeType2;
				}
			}
			return runtimeType;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			ListBuilder<MethodInfo> listBuilder = default(ListBuilder<MethodInfo>);
			ListBuilder<ConstructorInfo> listBuilder2 = default(ListBuilder<ConstructorInfo>);
			ListBuilder<PropertyInfo> listBuilder3 = default(ListBuilder<PropertyInfo>);
			ListBuilder<EventInfo> listBuilder4 = default(ListBuilder<EventInfo>);
			ListBuilder<FieldInfo> listBuilder5 = default(ListBuilder<FieldInfo>);
			ListBuilder<Type> listBuilder6 = default(ListBuilder<Type>);
			int num = 0;
			if ((type & MemberTypes.Method) != 0)
			{
				listBuilder = GetMethodCandidates(name, -1, bindingAttr, CallingConventions.Any, null, allowPrefixLookup: true);
				if (type == MemberTypes.Method)
				{
					return listBuilder.ToArray();
				}
				num += listBuilder.Count;
			}
			if ((type & MemberTypes.Constructor) != 0)
			{
				listBuilder2 = GetConstructorCandidates(name, bindingAttr, CallingConventions.Any, null, allowPrefixLookup: true);
				if (type == MemberTypes.Constructor)
				{
					return listBuilder2.ToArray();
				}
				num += listBuilder2.Count;
			}
			if ((type & MemberTypes.Property) != 0)
			{
				listBuilder3 = GetPropertyCandidates(name, bindingAttr, null, allowPrefixLookup: true);
				if (type == MemberTypes.Property)
				{
					return listBuilder3.ToArray();
				}
				num += listBuilder3.Count;
			}
			if ((type & MemberTypes.Event) != 0)
			{
				listBuilder4 = GetEventCandidates(name, bindingAttr, allowPrefixLookup: true);
				if (type == MemberTypes.Event)
				{
					return listBuilder4.ToArray();
				}
				num += listBuilder4.Count;
			}
			if ((type & MemberTypes.Field) != 0)
			{
				listBuilder5 = GetFieldCandidates(name, bindingAttr, allowPrefixLookup: true);
				if (type == MemberTypes.Field)
				{
					return listBuilder5.ToArray();
				}
				num += listBuilder5.Count;
			}
			if ((type & (MemberTypes.TypeInfo | MemberTypes.NestedType)) != 0)
			{
				listBuilder6 = GetNestedTypeCandidates(name, bindingAttr, allowPrefixLookup: true);
				if (type == MemberTypes.NestedType || type == MemberTypes.TypeInfo)
				{
					return listBuilder6.ToArray();
				}
				num += listBuilder6.Count;
			}
			MemberInfo[] array;
			if (type != (MemberTypes.Constructor | MemberTypes.Method))
			{
				array = new MemberInfo[num];
			}
			else
			{
				MemberInfo[] array2 = new MethodBase[num];
				array = array2;
			}
			MemberInfo[] array3 = array;
			int num2 = 0;
			object[] array4 = array3;
			listBuilder.CopyTo(array4, num2);
			num2 += listBuilder.Count;
			array4 = array3;
			listBuilder2.CopyTo(array4, num2);
			num2 += listBuilder2.Count;
			array4 = array3;
			listBuilder3.CopyTo(array4, num2);
			num2 += listBuilder3.Count;
			array4 = array3;
			listBuilder4.CopyTo(array4, num2);
			num2 += listBuilder4.Count;
			array4 = array3;
			listBuilder5.CopyTo(array4, num2);
			num2 += listBuilder5.Count;
			array4 = array3;
			listBuilder6.CopyTo(array4, num2);
			num2 += listBuilder6.Count;
			return array3;
		}

		public override MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo member)
		{
			if ((object)member == null)
			{
				throw new ArgumentNullException("member");
			}
			RuntimeType runtimeType = this;
			while (runtimeType != null)
			{
				MemberInfo memberInfo = member.MemberType switch
				{
					MemberTypes.Method => GetMethodWithSameMetadataDefinitionAs(runtimeType, member), 
					MemberTypes.Constructor => GetConstructorWithSameMetadataDefinitionAs(runtimeType, member), 
					MemberTypes.Property => GetPropertyWithSameMetadataDefinitionAs(runtimeType, member), 
					MemberTypes.Field => GetFieldWithSameMetadataDefinitionAs(runtimeType, member), 
					MemberTypes.Event => GetEventWithSameMetadataDefinitionAs(runtimeType, member), 
					MemberTypes.NestedType => GetNestedTypeWithSameMetadataDefinitionAs(runtimeType, member), 
					_ => null, 
				};
				if (memberInfo != null)
				{
					return memberInfo;
				}
				runtimeType = runtimeType.GetBaseType();
			}
			throw Type.CreateGetMemberWithSameMetadataDefinitionAsNotFoundException(member);
		}

		private static MemberInfo GetMethodWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo method)
		{
			RuntimeMethodInfo[] methodList = runtimeType.Cache.GetMethodList(MemberListType.CaseSensitive, method.Name);
			foreach (RuntimeMethodInfo runtimeMethodInfo in methodList)
			{
				if (runtimeMethodInfo.HasSameMetadataDefinitionAs(method))
				{
					return runtimeMethodInfo;
				}
			}
			return null;
		}

		private static MemberInfo GetConstructorWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo constructor)
		{
			RuntimeConstructorInfo[] constructorList = runtimeType.Cache.GetConstructorList(MemberListType.CaseSensitive, constructor.Name);
			foreach (RuntimeConstructorInfo runtimeConstructorInfo in constructorList)
			{
				if (runtimeConstructorInfo.HasSameMetadataDefinitionAs(constructor))
				{
					return runtimeConstructorInfo;
				}
			}
			return null;
		}

		private static MemberInfo GetPropertyWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo property)
		{
			RuntimePropertyInfo[] propertyList = runtimeType.Cache.GetPropertyList(MemberListType.CaseSensitive, property.Name);
			foreach (RuntimePropertyInfo runtimePropertyInfo in propertyList)
			{
				if (runtimePropertyInfo.HasSameMetadataDefinitionAs(property))
				{
					return runtimePropertyInfo;
				}
			}
			return null;
		}

		private static MemberInfo GetFieldWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo field)
		{
			RuntimeFieldInfo[] fieldList = runtimeType.Cache.GetFieldList(MemberListType.CaseSensitive, field.Name);
			foreach (RuntimeFieldInfo runtimeFieldInfo in fieldList)
			{
				if (runtimeFieldInfo.HasSameMetadataDefinitionAs(field))
				{
					return runtimeFieldInfo;
				}
			}
			return null;
		}

		private static MemberInfo GetEventWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo eventInfo)
		{
			RuntimeEventInfo[] eventList = runtimeType.Cache.GetEventList(MemberListType.CaseSensitive, eventInfo.Name);
			foreach (RuntimeEventInfo runtimeEventInfo in eventList)
			{
				if (runtimeEventInfo.HasSameMetadataDefinitionAs(eventInfo))
				{
					return runtimeEventInfo;
				}
			}
			return null;
		}

		private static MemberInfo GetNestedTypeWithSameMetadataDefinitionAs(RuntimeType runtimeType, MemberInfo nestedType)
		{
			RuntimeType[] nestedTypeList = runtimeType.Cache.GetNestedTypeList(MemberListType.CaseSensitive, nestedType.Name);
			foreach (RuntimeType runtimeType2 in nestedTypeList)
			{
				if (runtimeType2.HasSameMetadataDefinitionAs(nestedType))
				{
					return runtimeType2;
				}
			}
			return null;
		}

		public override bool IsSubclassOf(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			RuntimeType runtimeType = type as RuntimeType;
			if (runtimeType == null)
			{
				return false;
			}
			RuntimeType baseType = GetBaseType();
			while (baseType != null)
			{
				if (baseType == runtimeType)
				{
					return true;
				}
				baseType = baseType.GetBaseType();
			}
			if (runtimeType == ObjectType && runtimeType != this)
			{
				return true;
			}
			return false;
		}

		public override bool IsEquivalentTo([NotNullWhen(true)] Type other)
		{
			if (!(other is RuntimeType runtimeType))
			{
				return false;
			}
			if (runtimeType == this)
			{
				return true;
			}
			return RuntimeTypeHandle.IsEquivalentTo(this, runtimeType);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void GetGUID(ref Guid result);

		internal bool IsDelegate()
		{
			return GetBaseType() == typeof(MulticastDelegate);
		}

		internal object[] GetEmptyArray()
		{
			return Cache.GetEmptyArray();
		}

		internal RuntimeType[] GetGenericArgumentsInternal()
		{
			return GetRootElementType().GetTypeHandleInternal().GetInstantiationInternal();
		}

		public override Type[] GetGenericArguments()
		{
			Type[] instantiationPublic = GetRootElementType().GetTypeHandleInternal().GetInstantiationPublic();
			return instantiationPublic ?? Type.EmptyTypes;
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public override Type MakeGenericType(params Type[] instantiation)
		{
			if (instantiation == null)
			{
				throw new ArgumentNullException("instantiation");
			}
			if (!IsGenericTypeDefinition)
			{
				throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericTypeDefinition, this));
			}
			RuntimeType[] genericArgumentsInternal = GetGenericArgumentsInternal();
			if (genericArgumentsInternal.Length != instantiation.Length)
			{
				throw new ArgumentException(SR.Argument_GenericArgsCount, "instantiation");
			}
			if (instantiation.Length == 1 && instantiation[0] is RuntimeType runtimeType)
			{
				ThrowIfTypeNeverValidGenericArgument(runtimeType);
				try
				{
					return new RuntimeTypeHandle(this).Instantiate(runtimeType);
				}
				catch (TypeLoadException e)
				{
					ValidateGenericArguments(this, new RuntimeType[1] { runtimeType }, e);
					throw;
				}
			}
			RuntimeType[] array = new RuntimeType[instantiation.Length];
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < instantiation.Length; i++)
			{
				Type type = instantiation[i];
				if (type == null)
				{
					throw new ArgumentNullException();
				}
				RuntimeType runtimeType2 = type as RuntimeType;
				if (runtimeType2 == null)
				{
					flag2 = true;
					if (type.IsSignatureType)
					{
						flag = true;
					}
				}
				array[i] = runtimeType2;
			}
			if (flag2)
			{
				if (flag)
				{
					return new SignatureConstructedGenericType(this, instantiation);
				}
				return TypeBuilderInstantiation.MakeGenericType(this, (Type[])instantiation.Clone());
			}
			SanityCheckGenericArguments(array, genericArgumentsInternal);
			try
			{
				RuntimeTypeHandle runtimeTypeHandle = new RuntimeTypeHandle(this);
				Type[] inst = array;
				return runtimeTypeHandle.Instantiate(inst);
			}
			catch (TypeLoadException e2)
			{
				ValidateGenericArguments(this, array, e2);
				throw;
			}
		}

		public override Type[] GetGenericParameterConstraints()
		{
			if (!IsGenericParameter)
			{
				throw new InvalidOperationException(SR.Arg_NotGenericParameter);
			}
			Type[] constraints = new RuntimeTypeHandle(this).GetConstraints();
			return constraints ?? Type.EmptyTypes;
		}

		public sealed override bool HasSameMetadataDefinitionAs(MemberInfo other)
		{
			return HasSameMetadataDefinitionAsCore<RuntimeType>(other);
		}

		public override Type MakePointerType()
		{
			return new RuntimeTypeHandle(this).MakePointer();
		}

		public override Type MakeByRefType()
		{
			return new RuntimeTypeHandle(this).MakeByRef();
		}

		public override Type MakeArrayType()
		{
			return new RuntimeTypeHandle(this).MakeSZArray();
		}

		public override Type MakeArrayType(int rank)
		{
			if (rank <= 0)
			{
				throw new IndexOutOfRangeException();
			}
			return new RuntimeTypeHandle(this).MakeArray(rank);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool CanValueSpecialCast(RuntimeType valueType, RuntimeType targetType);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object AllocateValueType(RuntimeType type, object value, bool fForceTypeChange);

		internal object CheckValue(object value, Binder binder, CultureInfo culture, BindingFlags invokeAttr)
		{
			if (IsInstanceOfType(value))
			{
				Type type = value.GetType();
				if ((object)type != this && RuntimeTypeHandle.IsValueType(this))
				{
					return AllocateValueType(this, value, fForceTypeChange: true);
				}
				return value;
			}
			if (base.IsByRef)
			{
				RuntimeType elementType = RuntimeTypeHandle.GetElementType(this);
				if (elementType.IsInstanceOfType(value) || value == null)
				{
					return AllocateValueType(elementType, value, fForceTypeChange: false);
				}
			}
			else
			{
				if (value == null)
				{
					return value;
				}
				if (this == s_typedRef)
				{
					return value;
				}
			}
			bool flag = base.IsPointer || IsEnum || base.IsPrimitive;
			if (flag)
			{
				Pointer pointer = value as Pointer;
				RuntimeType valueType = ((pointer == null) ? ((RuntimeType)value.GetType()) : ((RuntimeType)pointer.GetPointerType()));
				if (CanValueSpecialCast(valueType, this))
				{
					if (pointer != null)
					{
						return pointer.GetPointerValue();
					}
					return value;
				}
			}
			if ((invokeAttr & BindingFlags.ExactBinding) == BindingFlags.ExactBinding)
			{
				throw new ArgumentException(SR.Format(SR.Arg_ObjObjEx, value.GetType(), this));
			}
			return TryChangeType(value, binder, culture, flag);
		}

		private object TryChangeType(object value, Binder binder, CultureInfo culture, bool needsSpecialCast)
		{
			if (binder != null && binder != Type.DefaultBinder)
			{
				value = binder.ChangeType(value, this, culture);
				if (IsInstanceOfType(value))
				{
					return value;
				}
				if (base.IsByRef)
				{
					RuntimeType elementType = RuntimeTypeHandle.GetElementType(this);
					if (elementType.IsInstanceOfType(value) || value == null)
					{
						return AllocateValueType(elementType, value, fForceTypeChange: false);
					}
				}
				else if (value == null)
				{
					return value;
				}
				if (needsSpecialCast)
				{
					Pointer pointer = value as Pointer;
					RuntimeType valueType = ((pointer == null) ? ((RuntimeType)value.GetType()) : ((RuntimeType)pointer.GetPointerType()));
					if (CanValueSpecialCast(valueType, this))
					{
						if (pointer != null)
						{
							return pointer.GetPointerValue();
						}
						return value;
					}
				}
			}
			throw new ArgumentException(SR.Format(SR.Arg_ObjObjEx, value.GetType(), this));
		}

		public override string ToString()
		{
			return GetCachedName(TypeNameKind.ToString);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private string GetCachedName(TypeNameKind kind)
		{
			return Cache.GetName(kind);
		}

		private void CreateInstanceCheckThis()
		{
			if (ContainsGenericParameters)
			{
				throw new ArgumentException(SR.Format(SR.Acc_CreateGenericEx, this));
			}
			Type rootElementType = GetRootElementType();
			if ((object)rootElementType == typeof(ArgIterator))
			{
				throw new NotSupportedException(SR.Acc_CreateArgIterator);
			}
			if ((object)rootElementType == typeof(void))
			{
				throw new NotSupportedException(SR.Acc_CreateVoid);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2082:UnrecognizedReflectionPattern", Justification = "Implementation detail of Activator that linker intrinsically recognizes")]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2085:UnrecognizedReflectionPattern", Justification = "Implementation detail of Activator that linker intrinsically recognizes")]
		internal object CreateInstanceImpl(BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture)
		{
			CreateInstanceCheckThis();
			if (args == null)
			{
				args = Array.Empty<object>();
			}
			if (binder == null)
			{
				binder = Type.DefaultBinder;
			}
			bool publicOnly = (bindingAttr & BindingFlags.NonPublic) == 0;
			bool wrapExceptions = (bindingAttr & BindingFlags.DoNotWrapExceptions) == 0;
			object result;
			if (args.Length == 0 && (bindingAttr & BindingFlags.Public) != 0 && (bindingAttr & BindingFlags.Instance) != 0 && (IsGenericCOMObjectImpl() || base.IsValueType))
			{
				result = CreateInstanceDefaultCtor(publicOnly, wrapExceptions);
			}
			else
			{
				ConstructorInfo[] constructors = GetConstructors(bindingAttr);
				List<MethodBase> list = new List<MethodBase>(constructors.Length);
				Type[] array = new Type[args.Length];
				for (int i = 0; i < args.Length; i++)
				{
					object obj = args[i];
					if (obj != null)
					{
						array[i] = obj.GetType();
					}
				}
				for (int j = 0; j < constructors.Length; j++)
				{
					if (FilterApplyConstructorInfo((RuntimeConstructorInfo)constructors[j], bindingAttr, CallingConventions.Any, array))
					{
						list.Add(constructors[j]);
					}
				}
				if (list.Count == 0)
				{
					throw new MissingMethodException(SR.Format(SR.MissingConstructor_Name, FullName));
				}
				MethodBase[] match = list.ToArray();
				object state = null;
				MethodBase methodBase;
				try
				{
					methodBase = binder.BindToMethod(bindingAttr, match, ref args, null, culture, null, out state);
				}
				catch (MissingMethodException)
				{
					methodBase = null;
				}
				if ((object)methodBase == null)
				{
					throw new MissingMethodException(SR.Format(SR.MissingConstructor_Name, FullName));
				}
				if (methodBase.GetParametersNoCopy().Length == 0)
				{
					if (args.Length != 0)
					{
						throw new NotSupportedException(SR.NotSupported_CallToVarArg);
					}
					result = Activator.CreateInstance(this, nonPublic: true, wrapExceptions);
				}
				else
				{
					result = ((ConstructorInfo)methodBase).Invoke(bindingAttr, binder, args, culture);
					if (state != null)
					{
						binder.ReorderArgumentArray(ref args, state);
					}
				}
			}
			return result;
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		internal object CreateInstanceDefaultCtor(bool publicOnly, bool wrapExceptions)
		{
			ActivatorCache activatorCache = GenericCache as ActivatorCache;
			if (activatorCache == null)
			{
				activatorCache = (ActivatorCache)(GenericCache = new ActivatorCache(this));
			}
			if (!activatorCache.CtorIsPublic && publicOnly)
			{
				throw new MissingMethodException(SR.Format(SR.Arg_NoDefCTor, this));
			}
			object obj = activatorCache.CreateUninitializedObject(this);
			try
			{
				activatorCache.CallConstructor(obj);
				return obj;
			}
			catch (Exception inner) when (wrapExceptions)
			{
				throw new TargetInvocationException(inner);
			}
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		internal object CreateInstanceOfT()
		{
			ActivatorCache activatorCache = GenericCache as ActivatorCache;
			if (activatorCache == null)
			{
				activatorCache = (ActivatorCache)(GenericCache = new ActivatorCache(this));
			}
			if (!activatorCache.CtorIsPublic)
			{
				throw new MissingMethodException(SR.Format(SR.Arg_NoDefCTor, this));
			}
			object obj = activatorCache.CreateUninitializedObject(this);
			try
			{
				activatorCache.CallConstructor(obj);
				return obj;
			}
			catch (Exception inner)
			{
				throw new TargetInvocationException(inner);
			}
		}

		internal void InvalidateCachedNestedType()
		{
			Cache.InvalidateCachedNestedType();
		}

		internal bool IsGenericCOMObjectImpl()
		{
			return RuntimeTypeHandle.IsComObject(this, isGenericCOM: true);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object _CreateEnum(RuntimeType enumType, long value);

		internal static object CreateEnum(RuntimeType enumType, long value)
		{
			return _CreateEnum(enumType, value);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern object InvokeDispMethod(string name, BindingFlags invokeAttr, object target, object[] args, bool[] byrefModifiers, int culture, string[] namedParameters);

		[RequiresUnreferencedCode("The member might be removed")]
		private object ForwardCallToInvokeMember(string memberName, BindingFlags flags, object target, object[] aArgs, bool[] aArgsIsByRef, int[] aArgsWrapperTypes, Type[] aArgsTypes, Type retType)
		{
			if (!Marshal.IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			int num = aArgs.Length;
			ParameterModifier[] array = null;
			if (num > 0)
			{
				ParameterModifier parameterModifier = new ParameterModifier(num);
				for (int i = 0; i < num; i++)
				{
					parameterModifier[i] = aArgsIsByRef[i];
				}
				array = new ParameterModifier[1] { parameterModifier };
				if (aArgsWrapperTypes != null)
				{
					WrapArgsForInvokeCall(aArgs, aArgsWrapperTypes);
				}
			}
			flags |= BindingFlags.DoNotWrapExceptions;
			object obj = InvokeMember(memberName, flags, null, target, aArgs, array, null, null);
			for (int j = 0; j < num; j++)
			{
				if (array[0][j] && aArgs[j] != null)
				{
					Type type = aArgsTypes[j];
					if ((object)type != aArgs[j].GetType())
					{
						aArgs[j] = ForwardCallBinder.ChangeType(aArgs[j], type, null);
					}
				}
			}
			if (obj != null && (object)retType != obj.GetType())
			{
				obj = ForwardCallBinder.ChangeType(obj, retType, null);
			}
			return obj;
		}

		private static void WrapArgsForInvokeCall(object[] aArgs, int[] aArgsWrapperTypes)
		{
			int num = aArgs.Length;
			for (int i = 0; i < num; i++)
			{
				if (aArgsWrapperTypes[i] == 0)
				{
					continue;
				}
				if (((DispatchWrapperType)aArgsWrapperTypes[i]).HasFlag(DispatchWrapperType.SafeArray))
				{
					Type type = null;
					bool flag = false;
					switch ((DispatchWrapperType)(aArgsWrapperTypes[i] & -65537))
					{
					case DispatchWrapperType.Unknown:
						type = typeof(UnknownWrapper);
						break;
					case DispatchWrapperType.Dispatch:
						type = typeof(DispatchWrapper);
						break;
					case DispatchWrapperType.Error:
						type = typeof(ErrorWrapper);
						break;
					case DispatchWrapperType.Currency:
						type = typeof(CurrencyWrapper);
						break;
					case DispatchWrapperType.BStr:
						type = typeof(BStrWrapper);
						flag = true;
						break;
					}
					Array array = (Array)aArgs[i];
					int length = array.Length;
					object[] array2 = (object[])Array.CreateInstance(type, length);
					ConstructorInfo constructorInfo = ((!flag) ? type.GetConstructor(new Type[1] { typeof(object) }) : type.GetConstructor(new Type[1] { typeof(string) }));
					for (int j = 0; j < length; j++)
					{
						if (flag)
						{
							array2[j] = constructorInfo.Invoke(new object[1] { (string)array.GetValue(j) });
						}
						else
						{
							array2[j] = constructorInfo.Invoke(new object[1] { array.GetValue(j) });
						}
					}
					aArgs[i] = array2;
				}
				else
				{
					switch ((DispatchWrapperType)aArgsWrapperTypes[i])
					{
					case DispatchWrapperType.Unknown:
						aArgs[i] = new UnknownWrapper(aArgs[i]);
						break;
					case DispatchWrapperType.Dispatch:
						aArgs[i] = new DispatchWrapper(aArgs[i]);
						break;
					case DispatchWrapperType.Error:
						aArgs[i] = new ErrorWrapper(aArgs[i]);
						break;
					case DispatchWrapperType.Currency:
						aArgs[i] = new CurrencyWrapper(aArgs[i]);
						break;
					case DispatchWrapperType.BStr:
						aArgs[i] = new BStrWrapper((string)aArgs[i]);
						break;
					}
				}
			}
		}

		public object Clone()
		{
			return this;
		}

		public override bool Equals(object obj)
		{
			return obj == this;
		}

		public override int GetArrayRank()
		{
			if (!IsArrayImpl())
			{
				throw new ArgumentException(SR.Argument_HasToBeArrayClass);
			}
			return RuntimeTypeHandle.GetArrayRank(this);
		}

		protected override TypeAttributes GetAttributeFlagsImpl()
		{
			return RuntimeTypeHandle.GetAttributes(this);
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return CustomAttribute.GetCustomAttributes(this, ObjectType, inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if ((object)attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType, inherit);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)]
		public override MemberInfo[] GetDefaultMembers()
		{
			MemberInfo[] array = null;
			string defaultMemberName = GetDefaultMemberName();
			if (defaultMemberName != null)
			{
				array = GetMember(defaultMemberName);
			}
			return array ?? Array.Empty<MemberInfo>();
		}

		public override Type GetElementType()
		{
			return RuntimeTypeHandle.GetElementType(this);
		}

		public override string GetEnumName(object value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			Type type = value.GetType();
			if (!type.IsEnum && !Type.IsIntegerType(type))
			{
				throw new ArgumentException(SR.Arg_MustBeEnumBaseTypeOrEnum, "value");
			}
			ulong ulValue = Enum.ToUInt64(value);
			return Enum.GetEnumName(this, ulValue);
		}

		public override string[] GetEnumNames()
		{
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "enumType");
			}
			string[] array = Enum.InternalGetNames(this);
			return new ReadOnlySpan<string>(array).ToArray();
		}

		public override Array GetEnumValues()
		{
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "enumType");
			}
			ulong[] array = Enum.InternalGetValues(this);
			Array array2 = Array.CreateInstance(this, array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				object value = Enum.ToObject(this, array[i]);
				array2.SetValue(value, i);
			}
			return array2;
		}

		public override Type GetEnumUnderlyingType()
		{
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "enumType");
			}
			return Enum.InternalGetUnderlyingType(this);
		}

		public override Type GetGenericTypeDefinition()
		{
			if (!IsGenericType)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotGenericType);
			}
			return RuntimeTypeHandle.GetGenericTypeDefinition(this);
		}

		public override int GetHashCode()
		{
			return RuntimeHelpers.GetHashCode(this);
		}

		internal RuntimeModule GetRuntimeModule()
		{
			return RuntimeTypeHandle.GetModule(this);
		}

		protected override TypeCode GetTypeCodeImpl()
		{
			TypeCode typeCode = Cache.TypeCode;
			if (typeCode != 0)
			{
				return typeCode;
			}
			typeCode = RuntimeTypeHandle.GetCorElementType(this) switch
			{
				CorElementType.ELEMENT_TYPE_BOOLEAN => TypeCode.Boolean, 
				CorElementType.ELEMENT_TYPE_CHAR => TypeCode.Char, 
				CorElementType.ELEMENT_TYPE_I1 => TypeCode.SByte, 
				CorElementType.ELEMENT_TYPE_U1 => TypeCode.Byte, 
				CorElementType.ELEMENT_TYPE_I2 => TypeCode.Int16, 
				CorElementType.ELEMENT_TYPE_U2 => TypeCode.UInt16, 
				CorElementType.ELEMENT_TYPE_I4 => TypeCode.Int32, 
				CorElementType.ELEMENT_TYPE_U4 => TypeCode.UInt32, 
				CorElementType.ELEMENT_TYPE_I8 => TypeCode.Int64, 
				CorElementType.ELEMENT_TYPE_U8 => TypeCode.UInt64, 
				CorElementType.ELEMENT_TYPE_R4 => TypeCode.Single, 
				CorElementType.ELEMENT_TYPE_R8 => TypeCode.Double, 
				CorElementType.ELEMENT_TYPE_VALUETYPE => ((object)this != typeof(decimal)) ? (((object)this != typeof(DateTime)) ? ((!IsEnum) ? TypeCode.Object : Type.GetTypeCode(Enum.InternalGetUnderlyingType(this))) : TypeCode.DateTime) : TypeCode.Decimal, 
				_ => ((object)this != typeof(string)) ? (((object)this != typeof(DBNull)) ? TypeCode.Object : TypeCode.DBNull) : TypeCode.String, 
			};
			Cache.TypeCode = typeCode;
			return typeCode;
		}

		protected override bool HasElementTypeImpl()
		{
			return RuntimeTypeHandle.HasElementType(this);
		}

		protected override bool IsArrayImpl()
		{
			return RuntimeTypeHandle.IsArray(this);
		}

		protected override bool IsContextfulImpl()
		{
			return false;
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if ((object)attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType, inherit);
		}

		public override bool IsEnumDefined(object value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "enumType");
			}
			RuntimeType runtimeType = (RuntimeType)value.GetType();
			if (runtimeType.IsEnum)
			{
				if (!runtimeType.IsEquivalentTo(this))
				{
					throw new ArgumentException(SR.Format(SR.Arg_EnumAndObjectMustBeSameType, runtimeType, this));
				}
				runtimeType = (RuntimeType)runtimeType.GetEnumUnderlyingType();
			}
			if (runtimeType == StringType)
			{
				string[] array = Enum.InternalGetNames(this);
				object[] array2 = array;
				return Array.IndexOf(array2, value) >= 0;
			}
			if (Type.IsIntegerType(runtimeType))
			{
				RuntimeType runtimeType2 = Enum.InternalGetUnderlyingType(this);
				if (runtimeType2 != runtimeType)
				{
					throw new ArgumentException(SR.Format(SR.Arg_EnumUnderlyingTypeAndObjectMustBeSameType, runtimeType, runtimeType2));
				}
				ulong[] array3 = Enum.InternalGetValues(this);
				ulong value2 = Enum.ToUInt64(value);
				return Array.BinarySearch(array3, value2) >= 0;
			}
			throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
		}

		protected override bool IsValueTypeImpl()
		{
			if (this == typeof(ValueType) || this == typeof(Enum))
			{
				return false;
			}
			return IsSubclassOf(typeof(ValueType));
		}

		protected override bool IsByRefImpl()
		{
			return RuntimeTypeHandle.IsByRef(this);
		}

		protected override bool IsPrimitiveImpl()
		{
			return RuntimeTypeHandle.IsPrimitive(this);
		}

		protected override bool IsPointerImpl()
		{
			return RuntimeTypeHandle.IsPointer(this);
		}

		protected override bool IsCOMObjectImpl()
		{
			return RuntimeTypeHandle.IsComObject(this, isGenericCOM: false);
		}

		public override bool IsInstanceOfType([NotNullWhen(true)] object o)
		{
			return RuntimeTypeHandle.IsInstanceOfType(this, o);
		}

		public override bool IsAssignableFrom([NotNullWhen(true)] TypeInfo typeInfo)
		{
			if (typeInfo == null)
			{
				return false;
			}
			return IsAssignableFrom(typeInfo.AsType());
		}

		public override bool IsAssignableFrom([NotNullWhen(true)] Type c)
		{
			if ((object)c == null)
			{
				return false;
			}
			if ((object)c == this)
			{
				return true;
			}
			if (c.UnderlyingSystemType is RuntimeType type)
			{
				return RuntimeTypeHandle.CanCastTo(type, this);
			}
			if (c is TypeBuilder)
			{
				if (c.IsSubclassOf(this))
				{
					return true;
				}
				if (base.IsInterface)
				{
					return c.ImplementInterface(this);
				}
				if (IsGenericParameter)
				{
					Type[] genericParameterConstraints = GetGenericParameterConstraints();
					for (int i = 0; i < genericParameterConstraints.Length; i++)
					{
						if (!genericParameterConstraints[i].IsAssignableFrom(c))
						{
							return false;
						}
					}
					return true;
				}
			}
			return false;
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public override object InvokeMember(string name, BindingFlags bindingFlags, Binder binder, object target, object[] providedArgs, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParams)
		{
			if (IsGenericParameter)
			{
				throw new InvalidOperationException(SR.Arg_GenericParameter);
			}
			if ((bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.CreateInstance | BindingFlags.GetField | BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) == 0)
			{
				throw new ArgumentException(SR.Arg_NoAccessSpec, "bindingFlags");
			}
			if ((bindingFlags & (BindingFlags)255) == 0)
			{
				bindingFlags |= BindingFlags.Instance | BindingFlags.Public;
				if ((bindingFlags & BindingFlags.CreateInstance) == 0)
				{
					bindingFlags |= BindingFlags.Static;
				}
			}
			if (namedParams != null)
			{
				if (providedArgs != null)
				{
					if (namedParams.Length > providedArgs.Length)
					{
						throw new ArgumentException(SR.Arg_NamedParamTooBig, "namedParams");
					}
				}
				else if (namedParams.Length != 0)
				{
					throw new ArgumentException(SR.Arg_NamedParamTooBig, "namedParams");
				}
			}
			if (target != null && target.GetType().IsCOMObject)
			{
				if ((bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) == 0)
				{
					throw new ArgumentException(SR.Arg_COMAccess, "bindingFlags");
				}
				if ((bindingFlags & BindingFlags.GetProperty) != 0 && ((uint)(bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) & 0xFFFFEEFFu) != 0)
				{
					throw new ArgumentException(SR.Arg_PropSetGet, "bindingFlags");
				}
				if ((bindingFlags & BindingFlags.InvokeMethod) != 0 && ((uint)(bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) & 0xFFFFEEFFu) != 0)
				{
					throw new ArgumentException(SR.Arg_PropSetInvoke, "bindingFlags");
				}
				if ((bindingFlags & BindingFlags.SetProperty) != 0 && ((uint)(bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) & 0xFFFFDFFFu) != 0)
				{
					throw new ArgumentException(SR.Arg_COMPropSetPut, "bindingFlags");
				}
				if ((bindingFlags & BindingFlags.PutDispProperty) != 0 && ((uint)(bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) & 0xFFFFBFFFu) != 0)
				{
					throw new ArgumentException(SR.Arg_COMPropSetPut, "bindingFlags");
				}
				if ((bindingFlags & BindingFlags.PutRefDispProperty) != 0 && ((uint)(bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) & 0xFFFF7FFFu) != 0)
				{
					throw new ArgumentException(SR.Arg_COMPropSetPut, "bindingFlags");
				}
				if (name == null)
				{
					throw new ArgumentNullException("name");
				}
				bool[] byrefModifiers = modifiers?[0].IsByRefArray;
				int culture2 = culture?.LCID ?? 1033;
				bool flag = (bindingFlags & BindingFlags.DoNotWrapExceptions) != 0;
				try
				{
					return InvokeDispMethod(name, bindingFlags, target, providedArgs, byrefModifiers, culture2, namedParams);
				}
				catch (TargetInvocationException ex) when (flag)
				{
					throw ex.InnerException;
				}
			}
			if (namedParams != null && Array.IndexOf(namedParams, null) != -1)
			{
				throw new ArgumentException(SR.Arg_NamedParamNull, "namedParams");
			}
			int num = ((providedArgs != null) ? providedArgs.Length : 0);
			if (binder == null)
			{
				binder = Type.DefaultBinder;
			}
			if ((bindingFlags & BindingFlags.CreateInstance) != 0)
			{
				if ((bindingFlags & BindingFlags.CreateInstance) != 0 && (bindingFlags & (BindingFlags.InvokeMethod | BindingFlags.GetField | BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty)) != 0)
				{
					throw new ArgumentException(SR.Arg_CreatInstAccess, "bindingFlags");
				}
				return Activator.CreateInstance(this, bindingFlags, binder, providedArgs, culture);
			}
			if ((bindingFlags & (BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) != 0)
			{
				bindingFlags |= BindingFlags.SetProperty;
			}
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0 || name.Equals("[DISPID=0]"))
			{
				name = GetDefaultMemberName() ?? "ToString";
			}
			bool flag2 = (bindingFlags & BindingFlags.GetField) != 0;
			bool flag3 = (bindingFlags & BindingFlags.SetField) != 0;
			if (flag2 || flag3)
			{
				if (flag2)
				{
					if (flag3)
					{
						throw new ArgumentException(SR.Arg_FldSetGet, "bindingFlags");
					}
					if ((bindingFlags & BindingFlags.SetProperty) != 0)
					{
						throw new ArgumentException(SR.Arg_FldGetPropSet, "bindingFlags");
					}
				}
				else
				{
					if (providedArgs == null)
					{
						throw new ArgumentNullException("providedArgs");
					}
					if ((bindingFlags & BindingFlags.GetProperty) != 0)
					{
						throw new ArgumentException(SR.Arg_FldSetPropGet, "bindingFlags");
					}
					if ((bindingFlags & BindingFlags.InvokeMethod) != 0)
					{
						throw new ArgumentException(SR.Arg_FldSetInvoke, "bindingFlags");
					}
				}
				FieldInfo fieldInfo = null;
				FieldInfo[] array = GetMember(name, MemberTypes.Field, bindingFlags) as FieldInfo[];
				if (array.Length == 1)
				{
					fieldInfo = array[0];
				}
				else if (array.Length != 0)
				{
					fieldInfo = binder.BindToField(bindingFlags, array, flag2 ? Empty.Value : providedArgs[0], culture);
				}
				if (fieldInfo != null)
				{
					if (fieldInfo.FieldType.IsArray || (object)fieldInfo.FieldType == typeof(Array))
					{
						int num2 = (((bindingFlags & BindingFlags.GetField) == 0) ? (num - 1) : num);
						if (num2 > 0)
						{
							int[] array2 = new int[num2];
							for (int i = 0; i < num2; i++)
							{
								try
								{
									array2[i] = ((IConvertible)providedArgs[i]).ToInt32(null);
								}
								catch (InvalidCastException)
								{
									throw new ArgumentException(SR.Arg_IndexMustBeInt);
								}
							}
							Array array3 = (Array)fieldInfo.GetValue(target);
							if ((bindingFlags & BindingFlags.GetField) != 0)
							{
								return array3.GetValue(array2);
							}
							array3.SetValue(providedArgs[num2], array2);
							return null;
						}
					}
					if (flag2)
					{
						if (num != 0)
						{
							throw new ArgumentException(SR.Arg_FldGetArgErr, "bindingFlags");
						}
						return fieldInfo.GetValue(target);
					}
					if (num != 1)
					{
						throw new ArgumentException(SR.Arg_FldSetArgErr, "bindingFlags");
					}
					fieldInfo.SetValue(target, providedArgs[0], bindingFlags, binder, culture);
					return null;
				}
				if ((bindingFlags & (BindingFlags)16773888) == 0)
				{
					throw new MissingFieldException(FullName, name);
				}
			}
			bool flag4 = (bindingFlags & BindingFlags.GetProperty) != 0;
			bool flag5 = (bindingFlags & BindingFlags.SetProperty) != 0;
			if (flag4 || flag5)
			{
				if (flag4)
				{
					if (flag5)
					{
						throw new ArgumentException(SR.Arg_PropSetGet, "bindingFlags");
					}
				}
				else if ((bindingFlags & BindingFlags.InvokeMethod) != 0)
				{
					throw new ArgumentException(SR.Arg_PropSetInvoke, "bindingFlags");
				}
			}
			MethodInfo[] array4 = null;
			MethodInfo methodInfo = null;
			if ((bindingFlags & BindingFlags.InvokeMethod) != 0)
			{
				MethodInfo[] array5 = GetMember(name, MemberTypes.Method, bindingFlags) as MethodInfo[];
				List<MethodInfo> list = null;
				foreach (MethodInfo methodInfo2 in array5)
				{
					if (!FilterApplyMethodInfo((RuntimeMethodInfo)methodInfo2, bindingFlags, CallingConventions.Any, new Type[num]))
					{
						continue;
					}
					if (methodInfo == null)
					{
						methodInfo = methodInfo2;
						continue;
					}
					if (list == null)
					{
						list = new List<MethodInfo>(array5.Length) { methodInfo };
					}
					list.Add(methodInfo2);
				}
				if (list != null)
				{
					array4 = list.ToArray();
				}
			}
			if ((methodInfo == null && flag4) || flag5)
			{
				PropertyInfo[] array6 = GetMember(name, MemberTypes.Property, bindingFlags) as PropertyInfo[];
				List<MethodInfo> list2 = null;
				for (int k = 0; k < array6.Length; k++)
				{
					MethodInfo methodInfo3 = null;
					methodInfo3 = ((!flag5) ? array6[k].GetGetMethod(nonPublic: true) : array6[k].GetSetMethod(nonPublic: true));
					if (methodInfo3 == null || !FilterApplyMethodInfo((RuntimeMethodInfo)methodInfo3, bindingFlags, CallingConventions.Any, new Type[num]))
					{
						continue;
					}
					if (methodInfo == null)
					{
						methodInfo = methodInfo3;
						continue;
					}
					if (list2 == null)
					{
						list2 = new List<MethodInfo>(array6.Length) { methodInfo };
					}
					list2.Add(methodInfo3);
				}
				if (list2 != null)
				{
					array4 = list2.ToArray();
				}
			}
			if (methodInfo != null)
			{
				if (array4 == null && num == 0 && methodInfo.GetParametersNoCopy().Length == 0 && (bindingFlags & BindingFlags.OptionalParamBinding) == 0)
				{
					return methodInfo.Invoke(target, bindingFlags, binder, providedArgs, culture);
				}
				if (array4 == null)
				{
					array4 = new MethodInfo[1] { methodInfo };
				}
				if (providedArgs == null)
				{
					providedArgs = Array.Empty<object>();
				}
				object state = null;
				MethodBase methodBase = null;
				try
				{
					Binder binder2 = binder;
					BindingFlags bindingAttr = bindingFlags;
					MethodBase[] match = array4;
					methodBase = binder2.BindToMethod(bindingAttr, match, ref providedArgs, modifiers, culture, namedParams, out state);
				}
				catch (MissingMethodException)
				{
				}
				if (methodBase == null)
				{
					throw new MissingMethodException(FullName, name);
				}
				object result = ((MethodInfo)methodBase).Invoke(target, bindingFlags, binder, providedArgs, culture);
				if (state != null)
				{
					binder.ReorderArgumentArray(ref providedArgs, state);
				}
				return result;
			}
			throw new MissingMethodException(FullName, name);
		}

		private RuntimeType GetBaseType()
		{
			if (base.IsInterface)
			{
				return null;
			}
			if (RuntimeTypeHandle.IsGenericVariable(this))
			{
				Type[] genericParameterConstraints = GetGenericParameterConstraints();
				RuntimeType runtimeType = ObjectType;
				for (int i = 0; i < genericParameterConstraints.Length; i++)
				{
					RuntimeType runtimeType2 = (RuntimeType)genericParameterConstraints[i];
					if (runtimeType2.IsInterface)
					{
						continue;
					}
					if (runtimeType2.IsGenericParameter)
					{
						GenericParameterAttributes genericParameterAttributes = runtimeType2.GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask;
						if ((genericParameterAttributes & GenericParameterAttributes.ReferenceTypeConstraint) == 0 && (genericParameterAttributes & GenericParameterAttributes.NotNullableValueTypeConstraint) == 0)
						{
							continue;
						}
					}
					runtimeType = runtimeType2;
				}
				if (runtimeType == ObjectType)
				{
					GenericParameterAttributes genericParameterAttributes2 = GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask;
					if ((genericParameterAttributes2 & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0)
					{
						runtimeType = ValueType;
					}
				}
				return runtimeType;
			}
			return RuntimeTypeHandle.GetBaseType(this);
		}

		private static void ThrowIfTypeNeverValidGenericArgument(RuntimeType type)
		{
			if (type.IsPointer || type.IsByRef || type == typeof(void))
			{
				throw new ArgumentException(SR.Format(SR.Argument_NeverValidGenericArgument, type));
			}
		}

		internal static void SanityCheckGenericArguments(RuntimeType[] genericArguments, RuntimeType[] genericParameters)
		{
			if (genericArguments == null)
			{
				throw new ArgumentNullException();
			}
			for (int i = 0; i < genericArguments.Length; i++)
			{
				if (genericArguments[i] == null)
				{
					throw new ArgumentNullException();
				}
				ThrowIfTypeNeverValidGenericArgument(genericArguments[i]);
			}
			if (genericArguments.Length != genericParameters.Length)
			{
				throw new ArgumentException(SR.Format(SR.Argument_NotEnoughGenArguments, genericArguments.Length, genericParameters.Length));
			}
		}
	}
	internal enum TypeNameFormatFlags
	{
		FormatBasic = 0,
		FormatNamespace = 1,
		FormatFullInst = 2,
		FormatAssembly = 4,
		FormatSignature = 8,
		FormatNoVersion = 0x10,
		FormatAngleBrackets = 0x40,
		FormatStubInfo = 0x80,
		FormatGenericParam = 0x100
	}
	internal enum TypeNameKind
	{
		Name,
		ToString,
		FullName
	}
	internal readonly struct MdUtf8String
	{
		private unsafe readonly byte* m_pStringHeap;

		private readonly int m_StringHeapByteLength;

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern bool EqualsCaseInsensitive(void* szLhs, void* szRhs, int cSz);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern uint HashCaseInsensitive(void* sz, int cSz);

		internal unsafe MdUtf8String(void* pStringHeap)
		{
			if (pStringHeap != null)
			{
				m_StringHeapByteLength = string.strlen((byte*)pStringHeap);
			}
			else
			{
				m_StringHeapByteLength = 0;
			}
			m_pStringHeap = (byte*)pStringHeap;
		}

		internal unsafe MdUtf8String(byte* pUtf8String, int cUtf8String)
		{
			m_pStringHeap = pUtf8String;
			m_StringHeapByteLength = cUtf8String;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal unsafe bool Equals(MdUtf8String s)
		{
			if (s.m_StringHeapByteLength != m_StringHeapByteLength)
			{
				return false;
			}
			return SpanHelpers.SequenceEqual(ref *s.m_pStringHeap, ref *m_pStringHeap, (uint)m_StringHeapByteLength);
		}

		internal unsafe bool EqualsCaseInsensitive(MdUtf8String s)
		{
			if (s.m_StringHeapByteLength != m_StringHeapByteLength)
			{
				return false;
			}
			if (m_StringHeapByteLength != 0)
			{
				return EqualsCaseInsensitive(s.m_pStringHeap, m_pStringHeap, m_StringHeapByteLength);
			}
			return true;
		}

		internal unsafe uint HashCaseInsensitive()
		{
			return HashCaseInsensitive(m_pStringHeap, m_StringHeapByteLength);
		}

		public unsafe override string ToString()
		{
			return Encoding.UTF8.GetString(new ReadOnlySpan<byte>(m_pStringHeap, m_StringHeapByteLength));
		}
	}
	internal static class StartupHookProvider
	{
		private struct StartupHookNameOrPath
		{
			public AssemblyName AssemblyName;

			public string Path;
		}

		private static bool IsSupported
		{
			get
			{
				if (!AppContext.TryGetSwitch("System.StartupHookProvider.IsSupported", out var isEnabled))
				{
					return true;
				}
				return isEnabled;
			}
		}

		private static void ProcessStartupHooks()
		{
			if (!IsSupported)
			{
				return;
			}
			if (EventSource.IsSupported)
			{
				RuntimeEventSource.Initialize();
			}
			if (!(AppContext.GetData("STARTUP_HOOKS") is string text))
			{
				return;
			}
			Span<char> span = stackalloc char[4]
			{
				Path.DirectorySeparatorChar,
				Path.AltDirectorySeparatorChar,
				' ',
				','
			};
			ReadOnlySpan<char> readOnlySpan = span;
			string[] array = text.Split(Path.PathSeparator);
			StartupHookNameOrPath[] array2 = new StartupHookNameOrPath[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i];
				if (string.IsNullOrEmpty(text2))
				{
					continue;
				}
				if (Path.IsPathFullyQualified(text2))
				{
					array2[i].Path = text2;
					continue;
				}
				for (int j = 0; j < readOnlySpan.Length; j++)
				{
					if (text2.Contains(readOnlySpan[j]))
					{
						throw new ArgumentException(SR.Format(SR.Argument_InvalidStartupHookSimpleAssemblyName, text2));
					}
				}
				if (text2.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidStartupHookSimpleAssemblyName, text2));
				}
				try
				{
					array2[i].AssemblyName = new AssemblyName(text2);
				}
				catch (Exception innerException)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidStartupHookSimpleAssemblyName, text2), innerException);
				}
			}
			StartupHookNameOrPath[] array3 = array2;
			foreach (StartupHookNameOrPath startupHook in array3)
			{
				CallStartupHook(startupHook);
			}
		}

		[RequiresUnreferencedCode("The StartupHookSupport feature switch has been enabled for this app which is being trimmed. Startup hook code is not observable by the trimmer and so required assemblies, types and members may be removed")]
		private static void CallStartupHook(StartupHookNameOrPath startupHook)
		{
			Assembly assembly;
			try
			{
				if (startupHook.Path != null)
				{
					assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(startupHook.Path);
				}
				else
				{
					if (startupHook.AssemblyName == null)
					{
						return;
					}
					assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(startupHook.AssemblyName);
				}
			}
			catch (Exception innerException)
			{
				throw new ArgumentException(SR.Format(SR.Argument_StartupHookAssemblyLoadFailed, startupHook.Path ?? startupHook.AssemblyName.ToString()), innerException);
			}
			Type type = assembly.GetType("StartupHook", throwOnError: true);
			MethodInfo method = type.GetMethod("Initialize", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			bool flag = false;
			if (method == null)
			{
				try
				{
					method = type.GetMethod("Initialize", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
				catch (AmbiguousMatchException)
				{
				}
				if (!(method != null))
				{
					throw new MissingMethodException("StartupHook", "Initialize");
				}
				flag = true;
			}
			else if (method.ReturnType != typeof(void))
			{
				flag = true;
			}
			if (flag)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidStartupHookSignature, "StartupHook" + Type.Delimiter + "Initialize", startupHook.Path ?? startupHook.AssemblyName.ToString()));
			}
			method.Invoke(null, null);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class String : IComparable, System.Collections.IEnumerable, IConvertible, IEnumerable<char>, IComparable<string?>, IEquatable<string?>, ICloneable
	{
		[StructLayout(LayoutKind.Explicit, Size = 32)]
		private struct ProbabilisticMap
		{
		}

		[Intrinsic]
		public static readonly string Empty;

		[NonSerialized]
		private readonly int _stringLength;

		[NonSerialized]
		private char _firstChar;

		[IndexerName("Chars")]
		public char this[int index]
		{
			[Intrinsic]
			get
			{
				if ((uint)index >= (uint)_stringLength)
				{
					ThrowHelper.ThrowIndexOutOfRangeException();
				}
				return Unsafe.Add(ref _firstChar, (nint)(uint)index);
			}
		}

		public int Length
		{
			[Intrinsic]
			get
			{
				return _stringLength;
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern string FastAllocateString(int length);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern void SetTrailByte(byte data);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern bool TryGetTrailByte(out byte data);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern string Intern();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern string IsInterned();

		public static string Intern(string str)
		{
			if ((object)str == null)
			{
				throw new ArgumentNullException("str");
			}
			return str.Intern();
		}

		public static string? IsInterned(string str)
		{
			if ((object)str == null)
			{
				throw new ArgumentNullException("str");
			}
			return str.IsInterned();
		}

		internal unsafe static void InternalCopy(string src, IntPtr dest, int len)
		{
			if (len != 0)
			{
				Buffer.Memmove(ref *(byte*)(void*)dest, ref Unsafe.As<char, byte>(ref src.GetRawStringData()), (nuint)len);
			}
		}

		internal unsafe int GetBytesFromEncoding(byte* pbNativeBuffer, int cbNativeBuffer, Encoding encoding)
		{
			fixed (char* chars = &_firstChar)
			{
				return encoding.GetBytes(chars, Length, pbNativeBuffer, cbNativeBuffer);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool EqualsHelper(string strA, string strB)
		{
			return SpanHelpers.SequenceEqual(ref Unsafe.As<char, byte>(ref strA.GetRawStringData()), ref Unsafe.As<char, byte>(ref strB.GetRawStringData()), (uint)(strA.Length * 2));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int CompareOrdinalHelper(string strA, int indexA, int countA, string strB, int indexB, int countB)
		{
			return SpanHelpers.SequenceCompareTo(ref Unsafe.Add(ref strA.GetRawStringData(), (nint)(uint)indexA), countA, ref Unsafe.Add(ref strB.GetRawStringData(), (nint)(uint)indexB), countB);
		}

		internal static bool EqualsOrdinalIgnoreCase(string strA, string strB)
		{
			if ((object)strA == strB)
			{
				return true;
			}
			if ((object)strA == null || (object)strB == null)
			{
				return false;
			}
			if (strA.Length != strB.Length)
			{
				return false;
			}
			return EqualsOrdinalIgnoreCaseNoLengthCheck(strA, strB);
		}

		private static bool EqualsOrdinalIgnoreCaseNoLengthCheck(string strA, string strB)
		{
			return Ordinal.EqualsIgnoreCase(ref strA.GetRawStringData(), ref strB.GetRawStringData(), strB.Length);
		}

		private unsafe static int CompareOrdinalHelper(string strA, string strB)
		{
			int num = Math.Min(strA.Length, strB.Length);
			fixed (char* ptr = &strA._firstChar)
			{
				fixed (char* ptr3 = &strB._firstChar)
				{
					char* ptr2 = ptr;
					char* ptr4 = ptr3;
					if (ptr2[1] == ptr4[1])
					{
						num -= 2;
						ptr2 += 2;
						ptr4 += 2;
						while (true)
						{
							if (num >= 10)
							{
								if (*(int*)ptr2 != *(int*)ptr4)
								{
									break;
								}
								if (*(int*)(ptr2 + 2) == *(int*)(ptr4 + 2))
								{
									if (*(int*)(ptr2 + 4) == *(int*)(ptr4 + 4))
									{
										if (*(int*)(ptr2 + 6) == *(int*)(ptr4 + 6))
										{
											if (*(int*)(ptr2 + 8) == *(int*)(ptr4 + 8))
											{
												num -= 10;
												ptr2 += 10;
												ptr4 += 10;
												continue;
											}
											ptr2 += 8;
											ptr4 += 8;
											break;
										}
										ptr2 += 6;
										ptr4 += 6;
										break;
									}
									ptr2 += 2;
									ptr4 += 2;
								}
								ptr2 += 2;
								ptr4 += 2;
								break;
							}
							while (true)
							{
								if (num > 0)
								{
									if (*(int*)ptr2 != *(int*)ptr4)
									{
										break;
									}
									num -= 2;
									ptr2 += 2;
									ptr4 += 2;
									continue;
								}
								return strA.Length - strB.Length;
							}
							break;
						}
						if (*ptr2 != *ptr4)
						{
							return *ptr2 - *ptr4;
						}
					}
					return ptr2[1] - ptr4[1];
				}
			}
		}

		public static int Compare(string? strA, string? strB)
		{
			return Compare(strA, strB, StringComparison.CurrentCulture);
		}

		public static int Compare(string? strA, string? strB, bool ignoreCase)
		{
			StringComparison comparisonType = (ignoreCase ? StringComparison.CurrentCultureIgnoreCase : StringComparison.CurrentCulture);
			return Compare(strA, strB, comparisonType);
		}

		public static int Compare(string? strA, string? strB, StringComparison comparisonType)
		{
			if ((object)strA == strB)
			{
				CheckStringComparison(comparisonType);
				return 0;
			}
			if ((object)strA == null)
			{
				CheckStringComparison(comparisonType);
				return -1;
			}
			if ((object)strB == null)
			{
				CheckStringComparison(comparisonType);
				return 1;
			}
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.Compare(strA, strB, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				if (strA._firstChar != strB._firstChar)
				{
					return strA._firstChar - strB._firstChar;
				}
				return CompareOrdinalHelper(strA, strB);
			case StringComparison.OrdinalIgnoreCase:
				return Ordinal.CompareStringIgnoreCase(ref strA.GetRawStringData(), strA.Length, ref strB.GetRawStringData(), strB.Length);
			default:
				throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}

		public static int Compare(string? strA, string? strB, CultureInfo? culture, CompareOptions options)
		{
			CultureInfo cultureInfo = culture ?? CultureInfo.CurrentCulture;
			return cultureInfo.CompareInfo.Compare(strA, strB, options);
		}

		public static int Compare(string? strA, string? strB, bool ignoreCase, CultureInfo? culture)
		{
			CompareOptions options = (ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
			return Compare(strA, strB, culture, options);
		}

		public static int Compare(string? strA, int indexA, string? strB, int indexB, int length)
		{
			return Compare(strA, indexA, strB, indexB, length, ignoreCase: false);
		}

		public static int Compare(string? strA, int indexA, string? strB, int indexB, int length, bool ignoreCase)
		{
			int num = length;
			int num2 = length;
			if ((object)strA != null)
			{
				num = Math.Min(num, strA.Length - indexA);
			}
			if ((object)strB != null)
			{
				num2 = Math.Min(num2, strB.Length - indexB);
			}
			CompareOptions options = (ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
			return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, num, strB, indexB, num2, options);
		}

		public static int Compare(string? strA, int indexA, string? strB, int indexB, int length, bool ignoreCase, CultureInfo? culture)
		{
			CompareOptions options = (ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
			return Compare(strA, indexA, strB, indexB, length, culture, options);
		}

		public static int Compare(string? strA, int indexA, string? strB, int indexB, int length, CultureInfo? culture, CompareOptions options)
		{
			CultureInfo cultureInfo = culture ?? CultureInfo.CurrentCulture;
			int num = length;
			int num2 = length;
			if ((object)strA != null)
			{
				num = Math.Min(num, strA.Length - indexA);
			}
			if ((object)strB != null)
			{
				num2 = Math.Min(num2, strB.Length - indexB);
			}
			return cultureInfo.CompareInfo.Compare(strA, indexA, num, strB, indexB, num2, options);
		}

		public static int Compare(string? strA, int indexA, string? strB, int indexB, int length, StringComparison comparisonType)
		{
			CheckStringComparison(comparisonType);
			if ((object)strA == null || (object)strB == null)
			{
				if ((object)strA == strB)
				{
					return 0;
				}
				if ((object)strA != null)
				{
					return 1;
				}
				return -1;
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NegativeLength);
			}
			if (indexA < 0 || indexB < 0)
			{
				string paramName = ((indexA < 0) ? "indexA" : "indexB");
				throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_Index);
			}
			if (strA.Length - indexA < 0 || strB.Length - indexB < 0)
			{
				string paramName2 = ((strA.Length - indexA < 0) ? "indexA" : "indexB");
				throw new ArgumentOutOfRangeException(paramName2, SR.ArgumentOutOfRange_Index);
			}
			if (length == 0 || ((object)strA == strB && indexA == indexB))
			{
				return 0;
			}
			int num = Math.Min(length, strA.Length - indexA);
			int num2 = Math.Min(length, strB.Length - indexB);
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, num, strB, indexB, num2, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.Compare(strA, indexA, num, strB, indexB, num2, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				return CompareOrdinalHelper(strA, indexA, num, strB, indexB, num2);
			default:
				return Ordinal.CompareStringIgnoreCase(ref Unsafe.Add(ref strA.GetRawStringData(), indexA), num, ref Unsafe.Add(ref strB.GetRawStringData(), indexB), num2);
			}
		}

		public static int CompareOrdinal(string? strA, string? strB)
		{
			if ((object)strA == strB)
			{
				return 0;
			}
			if ((object)strA == null)
			{
				return -1;
			}
			if ((object)strB == null)
			{
				return 1;
			}
			if (strA._firstChar != strB._firstChar)
			{
				return strA._firstChar - strB._firstChar;
			}
			return CompareOrdinalHelper(strA, strB);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int CompareOrdinal(ReadOnlySpan<char> strA, ReadOnlySpan<char> strB)
		{
			return SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(strA), strA.Length, ref MemoryMarshal.GetReference(strB), strB.Length);
		}

		public static int CompareOrdinal(string? strA, int indexA, string? strB, int indexB, int length)
		{
			if ((object)strA == null || (object)strB == null)
			{
				if ((object)strA == strB)
				{
					return 0;
				}
				if ((object)strA != null)
				{
					return 1;
				}
				return -1;
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NegativeCount);
			}
			if (indexA < 0 || indexB < 0)
			{
				string paramName = ((indexA < 0) ? "indexA" : "indexB");
				throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_Index);
			}
			int num = Math.Min(length, strA.Length - indexA);
			int num2 = Math.Min(length, strB.Length - indexB);
			if (num < 0 || num2 < 0)
			{
				string paramName2 = ((num < 0) ? "indexA" : "indexB");
				throw new ArgumentOutOfRangeException(paramName2, SR.ArgumentOutOfRange_Index);
			}
			if (length == 0 || ((object)strA == strB && indexA == indexB))
			{
				return 0;
			}
			return CompareOrdinalHelper(strA, indexA, num, strB, indexB, num2);
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is string strB))
			{
				throw new ArgumentException(SR.Arg_MustBeString);
			}
			return CompareTo(strB);
		}

		public int CompareTo(string? strB)
		{
			return Compare(this, strB, StringComparison.CurrentCulture);
		}

		public bool EndsWith(string value)
		{
			return EndsWith(value, StringComparison.CurrentCulture);
		}

		public bool EndsWith(string value, StringComparison comparisonType)
		{
			if ((object)value == null)
			{
				throw new ArgumentNullException("value");
			}
			if ((object)this == value)
			{
				CheckStringComparison(comparisonType);
				return true;
			}
			if (value.Length == 0)
			{
				CheckStringComparison(comparisonType);
				return true;
			}
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.IsSuffix(this, value, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.IsSuffix(this, value, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
			{
				int num = Length - value.Length;
				if ((uint)num <= (uint)Length)
				{
					return this.AsSpan(num).SequenceEqual(value);
				}
				return false;
			}
			case StringComparison.OrdinalIgnoreCase:
				if (Length >= value.Length)
				{
					return Ordinal.CompareStringIgnoreCase(ref Unsafe.Add(ref GetRawStringData(), Length - value.Length), value.Length, ref value.GetRawStringData(), value.Length) == 0;
				}
				return false;
			default:
				throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}

		public bool EndsWith(string value, bool ignoreCase, CultureInfo? culture)
		{
			if ((object)value == null)
			{
				throw new ArgumentNullException("value");
			}
			if ((object)this == value)
			{
				return true;
			}
			CultureInfo cultureInfo = culture ?? CultureInfo.CurrentCulture;
			return cultureInfo.CompareInfo.IsSuffix(this, value, ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
		}

		public bool EndsWith(char value)
		{
			int num = Length - 1;
			if ((uint)num < (uint)Length)
			{
				return this[num] == value;
			}
			return false;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (this == obj)
			{
				return true;
			}
			if (!(obj is string text))
			{
				return false;
			}
			if (Length != text.Length)
			{
				return false;
			}
			return EqualsHelper(this, text);
		}

		public bool Equals([NotNullWhen(true)] string? value)
		{
			if ((object)this == value)
			{
				return true;
			}
			if ((object)value == null)
			{
				return false;
			}
			if (Length != value.Length)
			{
				return false;
			}
			return EqualsHelper(this, value);
		}

		public bool Equals([NotNullWhen(true)] string? value, StringComparison comparisonType)
		{
			if ((object)this == value)
			{
				CheckStringComparison(comparisonType);
				return true;
			}
			if ((object)value == null)
			{
				CheckStringComparison(comparisonType);
				return false;
			}
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, GetCaseCompareOfComparisonCulture(comparisonType)) == 0;
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.Compare(this, value, GetCaseCompareOfComparisonCulture(comparisonType)) == 0;
			case StringComparison.Ordinal:
				if (Length != value.Length)
				{
					return false;
				}
				return EqualsHelper(this, value);
			case StringComparison.OrdinalIgnoreCase:
				if (Length != value.Length)
				{
					return false;
				}
				return EqualsOrdinalIgnoreCaseNoLengthCheck(this, value);
			default:
				throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}

		public static bool Equals(string? a, string? b)
		{
			if ((object)a == b)
			{
				return true;
			}
			if ((object)a == null || (object)b == null || a.Length != b.Length)
			{
				return false;
			}
			return EqualsHelper(a, b);
		}

		public static bool Equals(string? a, string? b, StringComparison comparisonType)
		{
			if ((object)a == b)
			{
				CheckStringComparison(comparisonType);
				return true;
			}
			if ((object)a == null || (object)b == null)
			{
				CheckStringComparison(comparisonType);
				return false;
			}
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, GetCaseCompareOfComparisonCulture(comparisonType)) == 0;
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.Compare(a, b, GetCaseCompareOfComparisonCulture(comparisonType)) == 0;
			case StringComparison.Ordinal:
				if (a.Length != b.Length)
				{
					return false;
				}
				return EqualsHelper(a, b);
			case StringComparison.OrdinalIgnoreCase:
				if (a.Length != b.Length)
				{
					return false;
				}
				return EqualsOrdinalIgnoreCaseNoLengthCheck(a, b);
			default:
				throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}

		public static bool operator ==(string? a, string? b)
		{
			return Equals(a, b);
		}

		public static bool operator !=(string? a, string? b)
		{
			return !Equals(a, b);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode()
		{
			ulong defaultSeed = Marvin.DefaultSeed;
			return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref _firstChar), (uint)(_stringLength * 2), (uint)defaultSeed, (uint)(defaultSeed >> 32));
		}

		public int GetHashCode(StringComparison comparisonType)
		{
			return StringComparer.FromComparison(comparisonType).GetHashCode(this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal int GetHashCodeOrdinalIgnoreCase()
		{
			ulong defaultSeed = Marvin.DefaultSeed;
			return Marvin.ComputeHash32OrdinalIgnoreCase(ref _firstChar, _stringLength, (uint)defaultSeed, (uint)(defaultSeed >> 32));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetHashCode(ReadOnlySpan<char> value)
		{
			ulong defaultSeed = Marvin.DefaultSeed;
			return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(value)), (uint)(value.Length * 2), (uint)defaultSeed, (uint)(defaultSeed >> 32));
		}

		public static int GetHashCode(ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.GetHashCode(value, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.GetHashCode(value, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				return GetHashCode(value);
			case StringComparison.OrdinalIgnoreCase:
				return GetHashCodeOrdinalIgnoreCase(value);
			default:
				ThrowHelper.ThrowArgumentException(ExceptionResource.NotSupported_StringComparison, ExceptionArgument.comparisonType);
				return 0;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetHashCodeOrdinalIgnoreCase(ReadOnlySpan<char> value)
		{
			ulong defaultSeed = Marvin.DefaultSeed;
			return Marvin.ComputeHash32OrdinalIgnoreCase(ref MemoryMarshal.GetReference(value), value.Length, (uint)defaultSeed, (uint)(defaultSeed >> 32));
		}

		internal unsafe int GetNonRandomizedHashCode()
		{
			fixed (char* ptr = &_firstChar)
			{
				uint num = 352654597u;
				uint num2 = num;
				uint* ptr2 = (uint*)ptr;
				int num3 = Length;
				while (num3 > 2)
				{
					num3 -= 4;
					num = (BitOperations.RotateLeft(num, 5) + num) ^ *ptr2;
					num2 = (BitOperations.RotateLeft(num2, 5) + num2) ^ ptr2[1];
					ptr2 += 2;
				}
				if (num3 > 0)
				{
					num2 = (BitOperations.RotateLeft(num2, 5) + num2) ^ *ptr2;
				}
				return (int)(num + num2 * 1566083941);
			}
		}

		internal unsafe int GetNonRandomizedHashCodeOrdinalIgnoreCase()
		{
			uint num = 352654597u;
			uint num2 = num;
			fixed (char* ptr = &_firstChar)
			{
				uint* ptr2 = (uint*)ptr;
				int num3 = Length;
				while (true)
				{
					if (num3 > 2)
					{
						uint num4 = *ptr2;
						uint num5 = ptr2[1];
						if (Utf16Utility.AllCharsInUInt32AreAscii(num4 | num5))
						{
							num3 -= 4;
							num = (BitOperations.RotateLeft(num, 5) + num) ^ (num4 | 0x200020u);
							num2 = (BitOperations.RotateLeft(num2, 5) + num2) ^ (num5 | 0x200020u);
							ptr2 += 2;
							continue;
						}
					}
					else
					{
						if (num3 <= 0)
						{
							break;
						}
						uint num6 = *ptr2;
						if (Utf16Utility.AllCharsInUInt32AreAscii(num6))
						{
							num2 = (BitOperations.RotateLeft(num2, 5) + num2) ^ (num6 | 0x200020u);
							break;
						}
					}
					goto IL_00ab;
				}
			}
			return (int)(num + num2 * 1566083941);
			IL_00ab:
			return GetNonRandomizedHashCodeOrdinalIgnoreCaseSlow(this);
			unsafe static int GetNonRandomizedHashCodeOrdinalIgnoreCaseSlow(string str)
			{
				int num7 = str.Length;
				char[] array = null;
				Span<char> span = (((uint)num7 >= 64u) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(num7 + 1))) : stackalloc char[64]);
				Span<char> destination = span;
				int num8 = Ordinal.ToUpperOrdinal(str, destination);
				destination[num7] = '\0';
				uint num9 = 352654597u;
				uint num10 = num9;
				fixed (char* ptr3 = destination)
				{
					uint* ptr4 = (uint*)ptr3;
					while (num7 > 2)
					{
						num7 -= 4;
						num9 = (BitOperations.RotateLeft(num9, 5) + num9) ^ (*ptr4 | 0x200020u);
						num10 = (BitOperations.RotateLeft(num10, 5) + num10) ^ (ptr4[1] | 0x200020u);
						ptr4 += 2;
					}
					if (num7 > 0)
					{
						num10 = (BitOperations.RotateLeft(num10, 5) + num10) ^ (*ptr4 | 0x200020u);
					}
				}
				if (array != null)
				{
					ArrayPool<char>.Shared.Return(array);
				}
				return (int)(num9 + num10 * 1566083941);
			}
		}

		public bool StartsWith(string value)
		{
			if ((object)value == null)
			{
				throw new ArgumentNullException("value");
			}
			return StartsWith(value, StringComparison.CurrentCulture);
		}

		public bool StartsWith(string value, StringComparison comparisonType)
		{
			if ((object)value == null)
			{
				throw new ArgumentNullException("value");
			}
			if ((object)this == value)
			{
				CheckStringComparison(comparisonType);
				return true;
			}
			if (value.Length == 0)
			{
				CheckStringComparison(comparisonType);
				return true;
			}
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.IsPrefix(this, value, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				if (Length < value.Length || _firstChar != value._firstChar)
				{
					return false;
				}
				if (value.Length != 1)
				{
					return SpanHelpers.SequenceEqual(ref Unsafe.As<char, byte>(ref GetRawStringData()), ref Unsafe.As<char, byte>(ref value.GetRawStringData()), (nuint)value.Length * (nuint)2u);
				}
				return true;
			case StringComparison.OrdinalIgnoreCase:
				if (Length < value.Length)
				{
					return false;
				}
				return Ordinal.EqualsIgnoreCase(ref GetRawStringData(), ref value.GetRawStringData(), value.Length);
			default:
				throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}

		public bool StartsWith(string value, bool ignoreCase, CultureInfo? culture)
		{
			if ((object)value == null)
			{
				throw new ArgumentNullException("value");
			}
			if ((object)this == value)
			{
				return true;
			}
			CultureInfo cultureInfo = culture ?? CultureInfo.CurrentCulture;
			return cultureInfo.CompareInfo.IsPrefix(this, value, ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
		}

		public bool StartsWith(char value)
		{
			if (Length != 0)
			{
				return _firstChar == value;
			}
			return false;
		}

		internal static void CheckStringComparison(StringComparison comparisonType)
		{
			if ((uint)comparisonType > 5u)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.NotSupported_StringComparison, ExceptionArgument.comparisonType);
			}
		}

		internal static CompareOptions GetCaseCompareOfComparisonCulture(StringComparison comparisonType)
		{
			return (CompareOptions)(comparisonType & StringComparison.CurrentCultureIgnoreCase);
		}

		private static CompareOptions GetCompareOptionsFromOrdinalStringComparison(StringComparison comparisonType)
		{
			return (CompareOptions)(((uint)comparisonType & (uint)(0 - comparisonType)) << 28);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[DynamicDependency("Ctor(System.Char[])")]
		public extern String(char[]? value);

		private string Ctor(char[] value)
		{
			if (value == null || value.Length == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(value.Length);
			nuint elementCount = (uint)text.Length;
			Buffer.Memmove(ref text._firstChar, ref MemoryMarshal.GetArrayDataReference(value), elementCount);
			return text;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[DynamicDependency("Ctor(System.Char[],System.Int32,System.Int32)")]
		public extern String(char[] value, int startIndex, int length);

		private string Ctor(char[] value, int startIndex, int length)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NegativeLength);
			}
			if (startIndex > value.Length - length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (length == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(length);
			nuint elementCount = (uint)text.Length;
			Buffer.Memmove(ref text._firstChar, ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(value), startIndex), elementCount);
			return text;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[CLSCompliant(false)]
		[DynamicDependency("Ctor(System.Char*)")]
		public unsafe extern String(char* value);

		private unsafe string Ctor(char* ptr)
		{
			if (ptr == null)
			{
				return Empty;
			}
			int num = wcslen(ptr);
			if (num == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(num);
			nuint elementCount = (uint)text.Length;
			Buffer.Memmove(ref text._firstChar, ref *ptr, elementCount);
			return text;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[CLSCompliant(false)]
		[DynamicDependency("Ctor(System.Char*,System.Int32,System.Int32)")]
		public unsafe extern String(char* value, int startIndex, int length);

		private unsafe string Ctor(char* ptr, int startIndex, int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NegativeLength);
			}
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			char* ptr2 = ptr + startIndex;
			if (ptr2 < ptr)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_PartialWCHAR);
			}
			if (length == 0)
			{
				return Empty;
			}
			if (ptr == null)
			{
				throw new ArgumentOutOfRangeException("ptr", SR.ArgumentOutOfRange_PartialWCHAR);
			}
			string text = FastAllocateString(length);
			nuint elementCount = (uint)text.Length;
			Buffer.Memmove(ref text._firstChar, ref *ptr2, elementCount);
			return text;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[CLSCompliant(false)]
		[DynamicDependency("Ctor(System.SByte*)")]
		public unsafe extern String(sbyte* value);

		private unsafe string Ctor(sbyte* value)
		{
			if (value == null)
			{
				return Empty;
			}
			int numBytes = strlen((byte*)value);
			return CreateStringForSByteConstructor((byte*)value, numBytes);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[CLSCompliant(false)]
		[DynamicDependency("Ctor(System.SByte*,System.Int32,System.Int32)")]
		public unsafe extern String(sbyte* value, int startIndex, int length);

		private unsafe string Ctor(sbyte* value, int startIndex, int length)
		{
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NegativeLength);
			}
			if (value == null)
			{
				if (length == 0)
				{
					return Empty;
				}
				throw new ArgumentNullException("value");
			}
			byte* ptr = (byte*)(value + startIndex);
			if (ptr < value)
			{
				throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_PartialWCHAR);
			}
			return CreateStringForSByteConstructor(ptr, length);
		}

		private unsafe static string CreateStringForSByteConstructor(byte* pb, int numBytes)
		{
			if (numBytes == 0)
			{
				return Empty;
			}
			int num = Interop.Kernel32.MultiByteToWideChar(0u, 1u, pb, numBytes, null, 0);
			if (num == 0)
			{
				throw new ArgumentException(SR.Arg_InvalidANSIString);
			}
			string text = FastAllocateString(num);
			fixed (char* lpWideCharStr = &text._firstChar)
			{
				num = Interop.Kernel32.MultiByteToWideChar(0u, 1u, pb, numBytes, lpWideCharStr, num);
			}
			if (num == 0)
			{
				throw new ArgumentException(SR.Arg_InvalidANSIString);
			}
			return text;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[CLSCompliant(false)]
		[DynamicDependency("Ctor(System.SByte*,System.Int32,System.Int32,System.Text.Encoding)")]
		public unsafe extern String(sbyte* value, int startIndex, int length, Encoding enc);

		private unsafe string Ctor(sbyte* value, int startIndex, int length, Encoding enc)
		{
			if (enc == null)
			{
				return new string(value, startIndex, length);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (value == null)
			{
				if (length == 0)
				{
					return Empty;
				}
				throw new ArgumentNullException("value");
			}
			byte* ptr = (byte*)(value + startIndex);
			if (ptr < value)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_PartialWCHAR);
			}
			return enc.GetString(new ReadOnlySpan<byte>(ptr, length));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[DynamicDependency("Ctor(System.Char,System.Int32)")]
		public extern String(char c, int count);

		private unsafe string Ctor(char c, int count)
		{
			if (count <= 0)
			{
				if (count == 0)
				{
					return Empty;
				}
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NegativeCount);
			}
			string text = FastAllocateString(count);
			if (c != 0)
			{
				fixed (char* ptr = &text._firstChar)
				{
					uint num = ((uint)c << 16) | c;
					uint* ptr2 = (uint*)ptr;
					if (count >= 4)
					{
						count -= 4;
						do
						{
							*ptr2 = num;
							ptr2[1] = num;
							ptr2 += 2;
							count -= 4;
						}
						while (count >= 0);
					}
					if (((uint)count & 2u) != 0)
					{
						*ptr2 = num;
						ptr2++;
					}
					if (((uint)count & (true ? 1u : 0u)) != 0)
					{
						*(char*)ptr2 = c;
					}
				}
			}
			return text;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[DynamicDependency("Ctor(System.ReadOnlySpan{System.Char})")]
		public extern String(ReadOnlySpan<char> value);

		private string Ctor(ReadOnlySpan<char> value)
		{
			if (value.Length == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(value.Length);
			Buffer.Memmove(ref text._firstChar, ref MemoryMarshal.GetReference(value), (uint)value.Length);
			return text;
		}

		public static string Create<TState>(int length, TState state, SpanAction<char, TState> action)
		{
			if (action == null)
			{
				throw new ArgumentNullException("action");
			}
			if (length <= 0)
			{
				if (length == 0)
				{
					return Empty;
				}
				throw new ArgumentOutOfRangeException("length");
			}
			string text = FastAllocateString(length);
			action(new Span<char>(ref text.GetRawStringData(), length), state);
			return text;
		}

		public static string Create(IFormatProvider? provider, [InterpolatedStringHandlerArgument("provider")] ref DefaultInterpolatedStringHandler handler)
		{
			return handler.ToStringAndClear();
		}

		public static string Create(IFormatProvider? provider, Span<char> initialBuffer, [InterpolatedStringHandlerArgument(new string[] { "provider", "initialBuffer" })] ref DefaultInterpolatedStringHandler handler)
		{
			return handler.ToStringAndClear();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator ReadOnlySpan<char>(string? value)
		{
			if ((object)value == null)
			{
				return default(ReadOnlySpan<char>);
			}
			return new ReadOnlySpan<char>(ref value.GetRawStringData(), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool TryGetSpan(int startIndex, int count, out ReadOnlySpan<char> slice)
		{
			if ((uint)startIndex > (uint)Length || (uint)count > (uint)(Length - startIndex))
			{
				slice = default(ReadOnlySpan<char>);
				return false;
			}
			slice = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, (nint)(uint)startIndex), count);
			return true;
		}

		public object Clone()
		{
			return this;
		}

		public static string Copy(string str)
		{
			if ((object)str == null)
			{
				throw new ArgumentNullException("str");
			}
			string text = FastAllocateString(str.Length);
			nuint elementCount = (uint)text.Length;
			Buffer.Memmove(ref text._firstChar, ref str._firstChar, elementCount);
			return text;
		}

		public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NegativeCount);
			}
			if (sourceIndex < 0)
			{
				throw new ArgumentOutOfRangeException("sourceIndex", SR.ArgumentOutOfRange_Index);
			}
			if (count > Length - sourceIndex)
			{
				throw new ArgumentOutOfRangeException("sourceIndex", SR.ArgumentOutOfRange_IndexCount);
			}
			if (destinationIndex > destination.Length - count || destinationIndex < 0)
			{
				throw new ArgumentOutOfRangeException("destinationIndex", SR.ArgumentOutOfRange_IndexCount);
			}
			Buffer.Memmove(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), destinationIndex), ref Unsafe.Add(ref _firstChar, sourceIndex), (uint)count);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void CopyTo(Span<char> destination)
		{
			if ((uint)Length <= (uint)destination.Length)
			{
				Buffer.Memmove(ref destination._pointer.Value, ref _firstChar, (uint)Length);
			}
			else
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryCopyTo(Span<char> destination)
		{
			bool result = false;
			if ((uint)Length <= (uint)destination.Length)
			{
				Buffer.Memmove(ref destination._pointer.Value, ref _firstChar, (uint)Length);
				result = true;
			}
			return result;
		}

		public char[] ToCharArray()
		{
			if (Length == 0)
			{
				return Array.Empty<char>();
			}
			char[] array = new char[Length];
			Buffer.Memmove(ref MemoryMarshal.GetArrayDataReference(array), ref _firstChar, (uint)Length);
			return array;
		}

		public char[] ToCharArray(int startIndex, int length)
		{
			if (startIndex < 0 || startIndex > Length || startIndex > Length - length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (length <= 0)
			{
				if (length == 0)
				{
					return Array.Empty<char>();
				}
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_Index);
			}
			char[] array = new char[length];
			Buffer.Memmove(ref MemoryMarshal.GetArrayDataReference(array), ref Unsafe.Add(ref _firstChar, startIndex), (uint)length);
			return array;
		}

		[NonVersionable]
		public static bool IsNullOrEmpty([NotNullWhen(false)] string? value)
		{
			if ((object)value != null && value.Length != 0)
			{
				return false;
			}
			return true;
		}

		public static bool IsNullOrWhiteSpace([NotNullWhen(false)] string? value)
		{
			if ((object)value == null)
			{
				return true;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (!char.IsWhiteSpace(value[i]))
				{
					return false;
				}
			}
			return true;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[NonVersionable]
		public ref readonly char GetPinnableReference()
		{
			return ref _firstChar;
		}

		internal ref char GetRawStringData()
		{
			return ref _firstChar;
		}

		internal unsafe static string CreateStringFromEncoding(byte* bytes, int byteLength, Encoding encoding)
		{
			int charCount = encoding.GetCharCount(bytes, byteLength);
			if (charCount == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(charCount);
			fixed (char* chars = &text._firstChar)
			{
				int chars2 = encoding.GetChars(bytes, byteLength, chars, charCount);
			}
			return text;
		}

		internal static string CreateFromChar(char c)
		{
			string text = FastAllocateString(1);
			text._firstChar = c;
			return text;
		}

		internal static string CreateFromChar(char c1, char c2)
		{
			string text = FastAllocateString(2);
			text._firstChar = c1;
			Unsafe.Add(ref text._firstChar, 1) = c2;
			return text;
		}

		public override string ToString()
		{
			return this;
		}

		public string ToString(IFormatProvider? provider)
		{
			return this;
		}

		public CharEnumerator GetEnumerator()
		{
			return new CharEnumerator(this);
		}

		IEnumerator<char> IEnumerable<char>.GetEnumerator()
		{
			return new CharEnumerator(this);
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return new CharEnumerator(this);
		}

		public StringRuneEnumerator EnumerateRunes()
		{
			return new StringRuneEnumerator(this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal unsafe static int wcslen(char* ptr)
		{
			int num = SpanHelpers.IndexOf(ref *ptr, '\0', int.MaxValue);
			if (num < 0)
			{
				ThrowMustBeNullTerminatedString();
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal unsafe static int strlen(byte* ptr)
		{
			int num = SpanHelpers.IndexOf(ref *ptr, 0, int.MaxValue);
			if (num < 0)
			{
				ThrowMustBeNullTerminatedString();
			}
			return num;
		}

		[DoesNotReturn]
		private static void ThrowMustBeNullTerminatedString()
		{
			throw new ArgumentException(SR.Arg_MustBeNullTerminatedString);
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.String;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this, provider);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this, provider);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this, provider);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this, provider);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this, provider);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this, provider);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this, provider);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this, provider);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this, provider);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this, provider);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this, provider);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this, provider);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this, provider);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			return Convert.ToDateTime(this, provider);
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		public bool IsNormalized()
		{
			return IsNormalized(NormalizationForm.FormC);
		}

		public bool IsNormalized(NormalizationForm normalizationForm)
		{
			if (IsAscii() && (normalizationForm == NormalizationForm.FormC || normalizationForm == NormalizationForm.FormKC || normalizationForm == NormalizationForm.FormD || normalizationForm == NormalizationForm.FormKD))
			{
				return true;
			}
			return Normalization.IsNormalized(this, normalizationForm);
		}

		public string Normalize()
		{
			return Normalize(NormalizationForm.FormC);
		}

		public string Normalize(NormalizationForm normalizationForm)
		{
			if (IsAscii() && (normalizationForm == NormalizationForm.FormC || normalizationForm == NormalizationForm.FormKC || normalizationForm == NormalizationForm.FormD || normalizationForm == NormalizationForm.FormKD))
			{
				return this;
			}
			return Normalization.Normalize(this, normalizationForm);
		}

		private unsafe bool IsAscii()
		{
			fixed (char* pBuffer = &_firstChar)
			{
				return ASCIIUtility.GetIndexOfFirstNonAsciiChar(pBuffer, (uint)Length) == (uint)Length;
			}
		}

		private static void FillStringChecked(string dest, int destPos, string src)
		{
			if (src.Length > dest.Length - destPos)
			{
				throw new IndexOutOfRangeException();
			}
			Buffer.Memmove(ref Unsafe.Add(ref dest._firstChar, destPos), ref src._firstChar, (uint)src.Length);
		}

		public static string Concat(object? arg0)
		{
			return arg0?.ToString() ?? Empty;
		}

		public static string Concat(object? arg0, object? arg1)
		{
			return arg0?.ToString() + arg1;
		}

		public static string Concat(object? arg0, object? arg1, object? arg2)
		{
			return arg0?.ToString() + arg1?.ToString() + arg2;
		}

		public static string Concat(params object?[] args)
		{
			if (args == null)
			{
				throw new ArgumentNullException("args");
			}
			if (args.Length <= 1)
			{
				object obj;
				if (args.Length != 0)
				{
					obj = args[0]?.ToString();
					if (obj == null)
					{
						return Empty;
					}
				}
				else
				{
					obj = Empty;
				}
				return (string)obj;
			}
			string[] array = new string[args.Length];
			int num = 0;
			for (int i = 0; i < args.Length; i++)
			{
				num += (array[i] = args[i]?.ToString() ?? Empty).Length;
				if (num < 0)
				{
					throw new OutOfMemoryException();
				}
			}
			if (num == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(num);
			int num2 = 0;
			foreach (string text2 in array)
			{
				FillStringChecked(text, num2, text2);
				num2 += text2.Length;
			}
			return text;
		}

		public static string Concat<T>(IEnumerable<T> values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (typeof(T) == typeof(char))
			{
				using (IEnumerator<char> enumerator = Unsafe.As<IEnumerable<char>>(values).GetEnumerator())
				{
					if (!enumerator.MoveNext())
					{
						return Empty;
					}
					char current = enumerator.Current;
					if (!enumerator.MoveNext())
					{
						return CreateFromChar(current);
					}
					Span<char> initialBuffer = stackalloc char[256];
					ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
					valueStringBuilder.Append(current);
					do
					{
						current = enumerator.Current;
						valueStringBuilder.Append(current);
					}
					while (enumerator.MoveNext());
					return valueStringBuilder.ToString();
				}
			}
			using IEnumerator<T> enumerator2 = values.GetEnumerator();
			if (!enumerator2.MoveNext())
			{
				return Empty;
			}
			string text = enumerator2.Current?.ToString();
			if (!enumerator2.MoveNext())
			{
				return text ?? Empty;
			}
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder2 = new ValueStringBuilder(initialBuffer);
			valueStringBuilder2.Append(text);
			do
			{
				T current2 = enumerator2.Current;
				if (current2 != null)
				{
					valueStringBuilder2.Append(current2.ToString());
				}
			}
			while (enumerator2.MoveNext());
			return valueStringBuilder2.ToString();
		}

		public static string Concat(IEnumerable<string?> values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			using IEnumerator<string> enumerator = values.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				return Empty;
			}
			string current = enumerator.Current;
			if (!enumerator.MoveNext())
			{
				return current ?? Empty;
			}
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.Append(current);
			do
			{
				valueStringBuilder.Append(enumerator.Current);
			}
			while (enumerator.MoveNext());
			return valueStringBuilder.ToString();
		}

		public static string Concat(string? str0, string? str1)
		{
			if (IsNullOrEmpty(str0))
			{
				if (IsNullOrEmpty(str1))
				{
					return Empty;
				}
				return str1;
			}
			if (IsNullOrEmpty(str1))
			{
				return str0;
			}
			int length = str0.Length;
			string text = FastAllocateString(length + str1.Length);
			FillStringChecked(text, 0, str0);
			FillStringChecked(text, length, str1);
			return text;
		}

		public static string Concat(string? str0, string? str1, string? str2)
		{
			if (IsNullOrEmpty(str0))
			{
				return str1 + str2;
			}
			if (IsNullOrEmpty(str1))
			{
				return str0 + str2;
			}
			if (IsNullOrEmpty(str2))
			{
				return str0 + str1;
			}
			int length = str0.Length + str1.Length + str2.Length;
			string text = FastAllocateString(length);
			FillStringChecked(text, 0, str0);
			FillStringChecked(text, str0.Length, str1);
			FillStringChecked(text, str0.Length + str1.Length, str2);
			return text;
		}

		public static string Concat(string? str0, string? str1, string? str2, string? str3)
		{
			if (IsNullOrEmpty(str0))
			{
				return str1 + str2 + str3;
			}
			if (IsNullOrEmpty(str1))
			{
				return str0 + str2 + str3;
			}
			if (IsNullOrEmpty(str2))
			{
				return str0 + str1 + str3;
			}
			if (IsNullOrEmpty(str3))
			{
				return str0 + str1 + str2;
			}
			int length = str0.Length + str1.Length + str2.Length + str3.Length;
			string text = FastAllocateString(length);
			FillStringChecked(text, 0, str0);
			FillStringChecked(text, str0.Length, str1);
			FillStringChecked(text, str0.Length + str1.Length, str2);
			FillStringChecked(text, str0.Length + str1.Length + str2.Length, str3);
			return text;
		}

		public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1)
		{
			int num = checked(str0.Length + str1.Length);
			if (num == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(num);
			Span<char> destination = new Span<char>(ref text._firstChar, text.Length);
			str0.CopyTo(destination);
			str1.CopyTo(destination.Slice(str0.Length));
			return text;
		}

		public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2)
		{
			int num = checked(str0.Length + str1.Length + str2.Length);
			if (num == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(num);
			Span<char> destination = new Span<char>(ref text._firstChar, text.Length);
			str0.CopyTo(destination);
			destination = destination.Slice(str0.Length);
			str1.CopyTo(destination);
			destination = destination.Slice(str1.Length);
			str2.CopyTo(destination);
			return text;
		}

		public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3)
		{
			int num = checked(str0.Length + str1.Length + str2.Length + str3.Length);
			if (num == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(num);
			Span<char> destination = new Span<char>(ref text._firstChar, text.Length);
			str0.CopyTo(destination);
			destination = destination.Slice(str0.Length);
			str1.CopyTo(destination);
			destination = destination.Slice(str1.Length);
			str2.CopyTo(destination);
			destination = destination.Slice(str2.Length);
			str3.CopyTo(destination);
			return text;
		}

		public static string Concat(params string?[] values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (values.Length <= 1)
			{
				object obj;
				if (values.Length != 0)
				{
					obj = values[0];
					if (obj == null)
					{
						return Empty;
					}
				}
				else
				{
					obj = Empty;
				}
				return (string)obj;
			}
			long num = 0L;
			foreach (string text in values)
			{
				if ((object)text != null)
				{
					num += text.Length;
				}
			}
			if (num > int.MaxValue)
			{
				throw new OutOfMemoryException();
			}
			int num2 = (int)num;
			if (num2 == 0)
			{
				return Empty;
			}
			string text2 = FastAllocateString(num2);
			int num3 = 0;
			foreach (string text3 in values)
			{
				if (!IsNullOrEmpty(text3))
				{
					int length = text3.Length;
					if (length > num2 - num3)
					{
						num3 = -1;
						break;
					}
					FillStringChecked(text2, num3, text3);
					num3 += length;
				}
			}
			if (num3 != num2)
			{
				return Concat((string[])values.Clone());
			}
			return text2;
		}

		public static string Format(string format, object? arg0)
		{
			return FormatHelper(null, format, new ParamsArray(arg0));
		}

		public static string Format(string format, object? arg0, object? arg1)
		{
			return FormatHelper(null, format, new ParamsArray(arg0, arg1));
		}

		public static string Format(string format, object? arg0, object? arg1, object? arg2)
		{
			return FormatHelper(null, format, new ParamsArray(arg0, arg1, arg2));
		}

		public static string Format(string format, params object?[] args)
		{
			if (args == null)
			{
				throw new ArgumentNullException(((object)format == null) ? "format" : "args");
			}
			return FormatHelper(null, format, new ParamsArray(args));
		}

		public static string Format(IFormatProvider? provider, string format, object? arg0)
		{
			return FormatHelper(provider, format, new ParamsArray(arg0));
		}

		public static string Format(IFormatProvider? provider, string format, object? arg0, object? arg1)
		{
			return FormatHelper(provider, format, new ParamsArray(arg0, arg1));
		}

		public static string Format(IFormatProvider? provider, string format, object? arg0, object? arg1, object? arg2)
		{
			return FormatHelper(provider, format, new ParamsArray(arg0, arg1, arg2));
		}

		public static string Format(IFormatProvider? provider, string format, params object?[] args)
		{
			if (args == null)
			{
				throw new ArgumentNullException(((object)format == null) ? "format" : "args");
			}
			return FormatHelper(provider, format, new ParamsArray(args));
		}

		private static string FormatHelper(IFormatProvider provider, string format, ParamsArray args)
		{
			if ((object)format == null)
			{
				throw new ArgumentNullException("format");
			}
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.EnsureCapacity(format.Length + args.Length * 8);
			valueStringBuilder.AppendFormatHelper(provider, format, args);
			return valueStringBuilder.ToString();
		}

		public string Insert(int startIndex, string value)
		{
			if ((object)value == null)
			{
				throw new ArgumentNullException("value");
			}
			if ((uint)startIndex > Length)
			{
				throw new ArgumentOutOfRangeException("startIndex");
			}
			int length = Length;
			int length2 = value.Length;
			if (length == 0)
			{
				return value;
			}
			if (length2 == 0)
			{
				return this;
			}
			int length3 = length + length2;
			string text = FastAllocateString(length3);
			Buffer.Memmove(ref text._firstChar, ref _firstChar, (nuint)startIndex);
			Buffer.Memmove(ref Unsafe.Add(ref text._firstChar, startIndex), ref value._firstChar, (nuint)length2);
			Buffer.Memmove(ref Unsafe.Add(ref text._firstChar, startIndex + length2), ref Unsafe.Add(ref _firstChar, startIndex), (nuint)(length - startIndex));
			return text;
		}

		public static string Join(char separator, params string?[] value)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			return JoinCore(MemoryMarshal.CreateReadOnlySpan(ref separator, 1), new ReadOnlySpan<string>(value));
		}

		public static string Join(string? separator, params string?[] value)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			return JoinCore(separator.AsSpan(), new ReadOnlySpan<string>(value));
		}

		public static string Join(char separator, string?[] value, int startIndex, int count)
		{
			return JoinCore(MemoryMarshal.CreateReadOnlySpan(ref separator, 1), value, startIndex, count);
		}

		public static string Join(string? separator, string?[] value, int startIndex, int count)
		{
			return JoinCore(separator.AsSpan(), value, startIndex, count);
		}

		private static string JoinCore(ReadOnlySpan<char> separator, string[] value, int startIndex, int count)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NegativeCount);
			}
			if (startIndex > value.Length - count)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			return JoinCore(separator, new ReadOnlySpan<string>(value, startIndex, count));
		}

		public static string Join(string? separator, IEnumerable<string?> values)
		{
			if (values is List<string> list)
			{
				return JoinCore(separator.AsSpan(), CollectionsMarshal.AsSpan(list));
			}
			if (values is string[] array)
			{
				return JoinCore(separator.AsSpan(), new ReadOnlySpan<string>(array));
			}
			if (values == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.values);
			}
			using IEnumerator<string> enumerator = values.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				return Empty;
			}
			string current = enumerator.Current;
			if (!enumerator.MoveNext())
			{
				return current ?? Empty;
			}
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.Append(current);
			do
			{
				valueStringBuilder.Append(separator);
				valueStringBuilder.Append(enumerator.Current);
			}
			while (enumerator.MoveNext());
			return valueStringBuilder.ToString();
		}

		public static string Join(char separator, params object?[] values)
		{
			return JoinCore(MemoryMarshal.CreateReadOnlySpan(ref separator, 1), values);
		}

		public static string Join(string? separator, params object?[] values)
		{
			return JoinCore(separator.AsSpan(), values);
		}

		private static string JoinCore(ReadOnlySpan<char> separator, object[] values)
		{
			if (values == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.values);
			}
			if (values.Length == 0)
			{
				return Empty;
			}
			string text = values[0]?.ToString();
			if (values.Length == 1)
			{
				return text ?? Empty;
			}
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.Append(text);
			for (int i = 1; i < values.Length; i++)
			{
				valueStringBuilder.Append(separator);
				object obj = values[i];
				if (obj != null)
				{
					valueStringBuilder.Append(obj.ToString());
				}
			}
			return valueStringBuilder.ToString();
		}

		public static string Join<T>(char separator, IEnumerable<T> values)
		{
			return JoinCore(MemoryMarshal.CreateReadOnlySpan(ref separator, 1), values);
		}

		public static string Join<T>(string? separator, IEnumerable<T> values)
		{
			return JoinCore(separator.AsSpan(), values);
		}

		private static string JoinCore<T>(ReadOnlySpan<char> separator, IEnumerable<T> values)
		{
			if (typeof(T) == typeof(string))
			{
				if (values is List<string> list)
				{
					return JoinCore(separator, CollectionsMarshal.AsSpan(list));
				}
				if (values is string[] array)
				{
					return JoinCore(separator, new ReadOnlySpan<string>(array));
				}
			}
			if (values == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.values);
			}
			using IEnumerator<T> enumerator = values.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				return Empty;
			}
			string text = enumerator.Current?.ToString();
			if (!enumerator.MoveNext())
			{
				return text ?? Empty;
			}
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.Append(text);
			do
			{
				T current = enumerator.Current;
				valueStringBuilder.Append(separator);
				if (current != null)
				{
					valueStringBuilder.Append(current.ToString());
				}
			}
			while (enumerator.MoveNext());
			return valueStringBuilder.ToString();
		}

		private static string JoinCore(ReadOnlySpan<char> separator, ReadOnlySpan<string> values)
		{
			if (values.Length <= 1)
			{
				object obj;
				if (!values.IsEmpty)
				{
					obj = values[0];
					if (obj == null)
					{
						return Empty;
					}
				}
				else
				{
					obj = Empty;
				}
				return (string)obj;
			}
			long num = (long)(values.Length - 1) * (long)separator.Length;
			if (num > int.MaxValue)
			{
				ThrowHelper.ThrowOutOfMemoryException();
			}
			int num2 = (int)num;
			ReadOnlySpan<string> readOnlySpan = values;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				string text = readOnlySpan[i];
				if ((object)text != null)
				{
					num2 += text.Length;
					if (num2 < 0)
					{
						ThrowHelper.ThrowOutOfMemoryException();
					}
				}
			}
			string text2 = FastAllocateString(num2);
			int num3 = 0;
			for (int j = 0; j < values.Length; j++)
			{
				string text3 = values[j];
				if ((object)text3 != null)
				{
					int length = text3.Length;
					if (length > num2 - num3)
					{
						num3 = -1;
						break;
					}
					FillStringChecked(text2, num3, text3);
					num3 += length;
				}
				if (j < values.Length - 1)
				{
					ref char reference = ref Unsafe.Add(ref text2._firstChar, num3);
					if (separator.Length == 1)
					{
						reference = separator[0];
					}
					else
					{
						separator.CopyTo(new Span<char>(ref reference, separator.Length));
					}
					num3 += separator.Length;
				}
			}
			if (num3 != num2)
			{
				return JoinCore(separator, values.ToArray().AsSpan());
			}
			return text2;
		}

		public string PadLeft(int totalWidth)
		{
			return PadLeft(totalWidth, ' ');
		}

		public string PadLeft(int totalWidth, char paddingChar)
		{
			if (totalWidth < 0)
			{
				throw new ArgumentOutOfRangeException("totalWidth", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			int length = Length;
			int num = totalWidth - length;
			if (num <= 0)
			{
				return this;
			}
			string text = FastAllocateString(totalWidth);
			new Span<char>(ref text._firstChar, num).Fill(paddingChar);
			Buffer.Memmove(ref Unsafe.Add(ref text._firstChar, num), ref _firstChar, (nuint)length);
			return text;
		}

		public string PadRight(int totalWidth)
		{
			return PadRight(totalWidth, ' ');
		}

		public string PadRight(int totalWidth, char paddingChar)
		{
			if (totalWidth < 0)
			{
				throw new ArgumentOutOfRangeException("totalWidth", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			int length = Length;
			int num = totalWidth - length;
			if (num <= 0)
			{
				return this;
			}
			string text = FastAllocateString(totalWidth);
			Buffer.Memmove(ref text._firstChar, ref _firstChar, (nuint)length);
			new Span<char>(ref Unsafe.Add(ref text._firstChar, length), num).Fill(paddingChar);
			return text;
		}

		public string Remove(int startIndex, int count)
		{
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NegativeCount);
			}
			int length = Length;
			if (count > length - startIndex)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_IndexCount);
			}
			if (count == 0)
			{
				return this;
			}
			int num = length - count;
			if (num == 0)
			{
				return Empty;
			}
			string text = FastAllocateString(num);
			Buffer.Memmove(ref text._firstChar, ref _firstChar, (nuint)startIndex);
			Buffer.Memmove(ref Unsafe.Add(ref text._firstChar, startIndex), ref Unsafe.Add(ref _firstChar, startIndex + count), (nuint)(num - startIndex));
			return text;
		}

		public string Remove(int startIndex)
		{
			if ((uint)startIndex > Length)
			{
				throw new ArgumentOutOfRangeException("startIndex", (startIndex < 0) ? SR.ArgumentOutOfRange_StartIndex : SR.ArgumentOutOfRange_StartIndexLargerThanLength);
			}
			return Substring(0, startIndex);
		}

		public string Replace(string oldValue, string? newValue, bool ignoreCase, CultureInfo? culture)
		{
			return ReplaceCore(oldValue, newValue, culture?.CompareInfo, ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
		}

		public string Replace(string oldValue, string? newValue, StringComparison comparisonType)
		{
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return ReplaceCore(oldValue, newValue, CultureInfo.CurrentCulture.CompareInfo, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return ReplaceCore(oldValue, newValue, CompareInfo.Invariant, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				return Replace(oldValue, newValue);
			case StringComparison.OrdinalIgnoreCase:
				return ReplaceCore(oldValue, newValue, CompareInfo.Invariant, CompareOptions.OrdinalIgnoreCase);
			default:
				throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}

		private string ReplaceCore(string oldValue, string newValue, CompareInfo ci, CompareOptions options)
		{
			if ((object)oldValue == null)
			{
				throw new ArgumentNullException("oldValue");
			}
			if (oldValue.Length == 0)
			{
				throw new ArgumentException(SR.Argument_StringZeroLength, "oldValue");
			}
			return ReplaceCore(this, oldValue.AsSpan(), newValue.AsSpan(), ci ?? CultureInfo.CurrentCulture.CompareInfo, options) ?? this;
		}

		private static string ReplaceCore(ReadOnlySpan<char> searchSpace, ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue, CompareInfo compareInfo, CompareOptions options)
		{
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.EnsureCapacity(searchSpace.Length);
			bool flag = false;
			while (true)
			{
				int matchLength;
				int num = compareInfo.IndexOf(searchSpace, oldValue, options, out matchLength);
				if (num < 0 || matchLength == 0)
				{
					break;
				}
				valueStringBuilder.Append(searchSpace.Slice(0, num));
				valueStringBuilder.Append(newValue);
				searchSpace = searchSpace.Slice(num + matchLength);
				flag = true;
			}
			if (!flag)
			{
				valueStringBuilder.Dispose();
				return null;
			}
			valueStringBuilder.Append(searchSpace);
			return valueStringBuilder.ToString();
		}

		public string Replace(char oldChar, char newChar)
		{
			if (oldChar == newChar)
			{
				return this;
			}
			int num = IndexOf(oldChar);
			if (num < 0)
			{
				return this;
			}
			int num2 = Length - num;
			string text = FastAllocateString(Length);
			int num3 = num;
			if (num3 > 0)
			{
				Buffer.Memmove(ref text._firstChar, ref _firstChar, (uint)num3);
			}
			ref ushort reference = ref Unsafe.Add(ref Unsafe.As<char, ushort>(ref _firstChar), num3);
			ref ushort reference2 = ref Unsafe.Add(ref Unsafe.As<char, ushort>(ref text._firstChar), num3);
			if (Vector.IsHardwareAccelerated && num2 >= Vector<ushort>.Count)
			{
				Vector<ushort> right = new Vector<ushort>(oldChar);
				Vector<ushort> left = new Vector<ushort>(newChar);
				do
				{
					Vector<ushort> vector = Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<ushort, byte>(ref reference));
					Vector<ushort> condition = Vector.Equals(vector, right);
					Vector<ushort> value = Vector.ConditionalSelect(condition, left, vector);
					Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref reference2), value);
					reference = ref Unsafe.Add(ref reference, Vector<ushort>.Count);
					reference2 = ref Unsafe.Add(ref reference2, Vector<ushort>.Count);
					num2 -= Vector<ushort>.Count;
				}
				while (num2 >= Vector<ushort>.Count);
			}
			while (num2 > 0)
			{
				ushort num4 = reference;
				reference2 = ((num4 == oldChar) ? newChar : num4);
				reference = ref Unsafe.Add(ref reference, 1);
				reference2 = ref Unsafe.Add(ref reference2, 1);
				num2--;
			}
			return text;
		}

		public string Replace(string oldValue, string? newValue)
		{
			if ((object)oldValue == null)
			{
				throw new ArgumentNullException("oldValue");
			}
			if (oldValue.Length == 0)
			{
				throw new ArgumentException(SR.Argument_StringZeroLength, "oldValue");
			}
			if ((object)newValue == null)
			{
				newValue = Empty;
			}
			Span<int> initialSpan = stackalloc int[128];
			ValueListBuilder<int> valueListBuilder = new ValueListBuilder<int>(initialSpan);
			if (oldValue.Length == 1)
			{
				if (newValue.Length == 1)
				{
					return Replace(oldValue[0], newValue[0]);
				}
				char value = oldValue[0];
				int num = 0;
				while (true)
				{
					int num2 = SpanHelpers.IndexOf(ref Unsafe.Add(ref _firstChar, num), value, Length - num);
					if (num2 == -1)
					{
						break;
					}
					valueListBuilder.Append(num + num2);
					num += num2 + 1;
				}
			}
			else
			{
				int num3 = 0;
				while (true)
				{
					int num4 = SpanHelpers.IndexOf(ref Unsafe.Add(ref _firstChar, num3), Length - num3, ref oldValue._firstChar, oldValue.Length);
					if (num4 == -1)
					{
						break;
					}
					valueListBuilder.Append(num3 + num4);
					num3 += num4 + oldValue.Length;
				}
			}
			if (valueListBuilder.Length == 0)
			{
				return this;
			}
			string result = ReplaceHelper(oldValue.Length, newValue, valueListBuilder.AsSpan());
			valueListBuilder.Dispose();
			return result;
		}

		private string ReplaceHelper(int oldValueLength, string newValue, ReadOnlySpan<int> indices)
		{
			long num = Length + (long)(newValue.Length - oldValueLength) * (long)indices.Length;
			if (num > int.MaxValue)
			{
				throw new OutOfMemoryException();
			}
			string text = FastAllocateString((int)num);
			Span<char> span = new Span<char>(ref text._firstChar, text.Length);
			int num2 = 0;
			int num3 = 0;
			for (int i = 0; i < indices.Length; i++)
			{
				int num4 = indices[i];
				int num5 = num4 - num2;
				if (num5 != 0)
				{
					this.AsSpan(num2, num5).CopyTo(span.Slice(num3));
					num3 += num5;
				}
				num2 = num4 + oldValueLength;
				newValue.CopyTo(span.Slice(num3));
				num3 += newValue.Length;
			}
			this.AsSpan(num2).CopyTo(span.Slice(num3));
			return text;
		}

		public string ReplaceLineEndings()
		{
			return ReplaceLineEndings("\r\n");
		}

		public string ReplaceLineEndings(string replacementText)
		{
			if ((object)replacementText == null)
			{
				throw new ArgumentNullException("replacementText");
			}
			int stride;
			int num = IndexOfNewlineChar(this, out stride);
			if (num < 0)
			{
				return this;
			}
			ReadOnlySpan<char> readOnlySpan = this.AsSpan(0, num);
			ReadOnlySpan<char> readOnlySpan2 = this.AsSpan(num + stride);
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			while (true)
			{
				int num2 = IndexOfNewlineChar(readOnlySpan2, out stride);
				if (num2 < 0)
				{
					break;
				}
				valueStringBuilder.Append(replacementText);
				valueStringBuilder.Append(readOnlySpan2.Slice(0, num2));
				readOnlySpan2 = readOnlySpan2.Slice(num2 + stride);
			}
			string result = Concat(readOnlySpan, valueStringBuilder.AsSpan(), replacementText, readOnlySpan2);
			valueStringBuilder.Dispose();
			return result;
		}

		internal static int IndexOfNewlineChar(ReadOnlySpan<char> text, out int stride)
		{
			stride = 0;
			int num = text.IndexOfAny("\r\n\f\u0085\u2028\u2029");
			if ((uint)num < (uint)text.Length)
			{
				stride = 1;
				if (text[num] == '\r')
				{
					int num2 = num + 1;
					if ((uint)num2 < (uint)text.Length && text[num2] == '\n')
					{
						stride = 2;
					}
				}
			}
			return num;
		}

		public string[] Split(char separator, StringSplitOptions options = StringSplitOptions.None)
		{
			return SplitInternal(new ReadOnlySpan<char>(ref separator, 1), int.MaxValue, options);
		}

		public string[] Split(char separator, int count, StringSplitOptions options = StringSplitOptions.None)
		{
			return SplitInternal(new ReadOnlySpan<char>(ref separator, 1), count, options);
		}

		public string[] Split(params char[]? separator)
		{
			return SplitInternal(separator, int.MaxValue, StringSplitOptions.None);
		}

		public string[] Split(char[]? separator, int count)
		{
			return SplitInternal(separator, count, StringSplitOptions.None);
		}

		public string[] Split(char[]? separator, StringSplitOptions options)
		{
			return SplitInternal(separator, int.MaxValue, options);
		}

		public string[] Split(char[]? separator, int count, StringSplitOptions options)
		{
			return SplitInternal(separator, count, options);
		}

		private string[] SplitInternal(ReadOnlySpan<char> separators, int count, StringSplitOptions options)
		{
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NegativeCount);
			}
			CheckStringSplitOptions(options);
			ValueListBuilder<int> sepListBuilder;
			ReadOnlySpan<int> sepList;
			while (true)
			{
				if (count <= 1 || Length == 0)
				{
					string text = this;
					if ((options & StringSplitOptions.TrimEntries) != 0 && count > 0)
					{
						text = text.Trim();
					}
					if ((options & StringSplitOptions.RemoveEmptyEntries) != 0 && text.Length == 0)
					{
						count = 0;
					}
					if (count != 0)
					{
						return new string[1] { text };
					}
					return Array.Empty<string>();
				}
				if (separators.IsEmpty)
				{
					options &= ~StringSplitOptions.TrimEntries;
				}
				Span<int> initialSpan = stackalloc int[128];
				sepListBuilder = new ValueListBuilder<int>(initialSpan);
				MakeSeparatorList(separators, ref sepListBuilder);
				sepList = sepListBuilder.AsSpan();
				if (sepList.Length != 0)
				{
					break;
				}
				count = 1;
			}
			string[] result = ((options != 0) ? SplitWithPostProcessing(sepList, default(ReadOnlySpan<int>), 1, count, options) : SplitWithoutPostProcessing(sepList, default(ReadOnlySpan<int>), 1, count));
			sepListBuilder.Dispose();
			return result;
		}

		public string[] Split(string? separator, StringSplitOptions options = StringSplitOptions.None)
		{
			return SplitInternal(separator ?? Empty, null, int.MaxValue, options);
		}

		public string[] Split(string? separator, int count, StringSplitOptions options = StringSplitOptions.None)
		{
			return SplitInternal(separator ?? Empty, null, count, options);
		}

		public string[] Split(string[]? separator, StringSplitOptions options)
		{
			return SplitInternal(null, separator, int.MaxValue, options);
		}

		public string[] Split(string[]? separator, int count, StringSplitOptions options)
		{
			return SplitInternal(null, separator, count, options);
		}

		private string[] SplitInternal(string separator, string[] separators, int count, StringSplitOptions options)
		{
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NegativeCount);
			}
			CheckStringSplitOptions(options);
			bool flag = (object)separator != null;
			if (!flag && (separators == null || separators.Length == 0))
			{
				return SplitInternal(default(ReadOnlySpan<char>), count, options);
			}
			while (true)
			{
				if (count <= 1 || Length == 0)
				{
					string text = this;
					if ((options & StringSplitOptions.TrimEntries) != 0 && count > 0)
					{
						text = text.Trim();
					}
					if ((options & StringSplitOptions.RemoveEmptyEntries) != 0 && text.Length == 0)
					{
						count = 0;
					}
					if (count != 0)
					{
						return new string[1] { text };
					}
					return Array.Empty<string>();
				}
				if (!flag)
				{
					break;
				}
				if (separator.Length == 0)
				{
					count = 1;
					continue;
				}
				return SplitInternal(separator, count, options);
			}
			Span<int> initialSpan = stackalloc int[128];
			ValueListBuilder<int> sepListBuilder = new ValueListBuilder<int>(initialSpan);
			initialSpan = stackalloc int[128];
			ValueListBuilder<int> lengthListBuilder = new ValueListBuilder<int>(initialSpan);
			MakeSeparatorList(separators, ref sepListBuilder, ref lengthListBuilder);
			ReadOnlySpan<int> sepList = sepListBuilder.AsSpan();
			ReadOnlySpan<int> lengthList = lengthListBuilder.AsSpan();
			if (sepList.Length == 0)
			{
				return new string[1] { this };
			}
			string[] result = ((options != 0) ? SplitWithPostProcessing(sepList, lengthList, 0, count, options) : SplitWithoutPostProcessing(sepList, lengthList, 0, count));
			sepListBuilder.Dispose();
			lengthListBuilder.Dispose();
			return result;
		}

		private string[] SplitInternal(string separator, int count, StringSplitOptions options)
		{
			Span<int> initialSpan = stackalloc int[128];
			ValueListBuilder<int> sepListBuilder = new ValueListBuilder<int>(initialSpan);
			MakeSeparatorList(separator, ref sepListBuilder);
			ReadOnlySpan<int> sepList = sepListBuilder.AsSpan();
			if (sepList.Length == 0)
			{
				string text = this;
				if ((options & StringSplitOptions.TrimEntries) != 0)
				{
					text = text.Trim();
				}
				if (text.Length != 0 || (options & StringSplitOptions.RemoveEmptyEntries) == 0)
				{
					return new string[1] { text };
				}
				return Array.Empty<string>();
			}
			string[] result = ((options != 0) ? SplitWithPostProcessing(sepList, default(ReadOnlySpan<int>), separator.Length, count, options) : SplitWithoutPostProcessing(sepList, default(ReadOnlySpan<int>), separator.Length, count));
			sepListBuilder.Dispose();
			return result;
		}

		private string[] SplitWithoutPostProcessing(ReadOnlySpan<int> sepList, ReadOnlySpan<int> lengthList, int defaultLength, int count)
		{
			int num = 0;
			int num2 = 0;
			count--;
			int num3 = ((sepList.Length < count) ? sepList.Length : count);
			string[] array = new string[num3 + 1];
			for (int i = 0; i < num3; i++)
			{
				if (num >= Length)
				{
					break;
				}
				array[num2++] = Substring(num, sepList[i] - num);
				num = sepList[i] + (lengthList.IsEmpty ? defaultLength : lengthList[i]);
			}
			if (num < Length && num3 >= 0)
			{
				array[num2] = Substring(num);
			}
			else if (num2 == num3)
			{
				array[num2] = Empty;
			}
			return array;
		}

		private string[] SplitWithPostProcessing(ReadOnlySpan<int> sepList, ReadOnlySpan<int> lengthList, int defaultLength, int count, StringSplitOptions options)
		{
			int length = sepList.Length;
			int num = ((length < count) ? (length + 1) : count);
			string[] array = new string[num];
			int num2 = 0;
			int num3 = 0;
			ReadOnlySpan<char> span;
			for (int i = 0; i < length; i++)
			{
				span = this.AsSpan(num2, sepList[i] - num2);
				if ((options & StringSplitOptions.TrimEntries) != 0)
				{
					span = span.Trim();
				}
				if (!span.IsEmpty || (options & StringSplitOptions.RemoveEmptyEntries) == 0)
				{
					array[num3++] = span.ToString();
				}
				num2 = sepList[i] + (lengthList.IsEmpty ? defaultLength : lengthList[i]);
				if (num3 != count - 1)
				{
					continue;
				}
				if ((options & StringSplitOptions.RemoveEmptyEntries) == 0)
				{
					break;
				}
				while (++i < length)
				{
					span = this.AsSpan(num2, sepList[i] - num2);
					if ((options & StringSplitOptions.TrimEntries) != 0)
					{
						span = span.Trim();
					}
					if (!span.IsEmpty)
					{
						break;
					}
					num2 = sepList[i] + (lengthList.IsEmpty ? defaultLength : lengthList[i]);
				}
				break;
			}
			span = this.AsSpan(num2);
			if ((options & StringSplitOptions.TrimEntries) != 0)
			{
				span = span.Trim();
			}
			if (!span.IsEmpty || (options & StringSplitOptions.RemoveEmptyEntries) == 0)
			{
				array[num3++] = span.ToString();
			}
			Array.Resize(ref array, num3);
			return array;
		}

		private unsafe void MakeSeparatorList(ReadOnlySpan<char> separators, ref ValueListBuilder<int> sepListBuilder)
		{
			if (separators.Length == 0)
			{
				for (int i = 0; i < Length; i++)
				{
					if (char.IsWhiteSpace(this[i]))
					{
						sepListBuilder.Append(i);
					}
				}
				return;
			}
			if (separators.Length <= 3)
			{
				char c = separators[0];
				char c2 = ((separators.Length > 1) ? separators[1] : c);
				char c3 = ((separators.Length > 2) ? separators[2] : c2);
				if (Length >= 16 && Sse41.IsSupported)
				{
					MakeSeparatorListVectorized(ref sepListBuilder, c, c2, c3);
					return;
				}
				for (int j = 0; j < Length; j++)
				{
					char c4 = this[j];
					if (c4 == c || c4 == c2 || c4 == c3)
					{
						sepListBuilder.Append(j);
					}
				}
				return;
			}
			ProbabilisticMap probabilisticMap = default(ProbabilisticMap);
			uint* charMap = (uint*)(&probabilisticMap);
			InitializeProbabilisticMap(charMap, separators);
			for (int k = 0; k < Length; k++)
			{
				char c5 = this[k];
				if (IsCharBitSet(charMap, (byte)c5) && IsCharBitSet(charMap, (byte)((int)c5 >> 8)) && separators.Contains(c5))
				{
					sepListBuilder.Append(k);
				}
			}
		}

		private void MakeSeparatorListVectorized(ref ValueListBuilder<int> sepListBuilder, char c, char c2, char c3)
		{
			if (!Sse41.IsSupported)
			{
				throw new PlatformNotSupportedException();
			}
			Vector128<byte> mask = Vector128.Create(0, 2, 4, 6, 8, 10, 12, 14, byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
			Vector128<ushort> right = Vector128.Create(c);
			Vector128<ushort> right2 = Vector128.Create(c2);
			Vector128<ushort> right3 = Vector128.Create(c3);
			ref char reference = ref MemoryMarshal.GetReference(this.AsSpan());
			int num = Length & -Vector128<ushort>.Count;
			int i;
			for (i = 0; i < num; i += Vector128<ushort>.Count)
			{
				Vector128<ushort> left = ReadVector(ref reference, i);
				Vector128<ushort> right4 = Sse2.CompareEqual(left, right);
				right4 = Sse2.Or(Sse2.CompareEqual(left, right2), right4);
				right4 = Sse2.Or(Sse2.CompareEqual(left, right3), right4);
				if (Sse41.TestZ(right4, right4))
				{
					continue;
				}
				Vector128<byte> value = Sse2.ShiftRightLogical(right4.AsUInt64(), 4).AsByte();
				value = Ssse3.Shuffle(value, mask);
				uint num2 = Sse2.ConvertToUInt32(value.AsUInt32());
				value = Sse2.ShiftRightLogical(value.AsUInt64(), 32).AsByte();
				uint num3 = Sse2.ConvertToUInt32(value.AsUInt32());
				int num4 = i;
				while (num2 != 0)
				{
					if ((num2 & 0xFu) != 0)
					{
						sepListBuilder.Append(num4);
					}
					num2 >>= 8;
					num4++;
				}
				int num5 = i + 4;
				while (num3 != 0)
				{
					if ((num3 & 0xFu) != 0)
					{
						sepListBuilder.Append(num5);
					}
					num3 >>= 8;
					num5++;
				}
			}
			for (; i < Length; i++)
			{
				char c4 = Unsafe.Add(ref reference, (IntPtr)(uint)i);
				if (c4 == c || c4 == c2 || c4 == c3)
				{
					sepListBuilder.Append(i);
				}
			}
			static Vector128<ushort> ReadVector(ref char c0, int offset)
			{
				return Unsafe.ReadUnaligned<Vector128<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref c0, (IntPtr)(uint)offset)));
			}
		}

		private void MakeSeparatorList(string separator, ref ValueListBuilder<int> sepListBuilder)
		{
			int length = separator.Length;
			for (int i = 0; i < Length; i++)
			{
				if (this[i] == separator[0] && length <= Length - i && (length == 1 || this.AsSpan(i, length).SequenceEqual(separator)))
				{
					sepListBuilder.Append(i);
					i += length - 1;
				}
			}
		}

		private void MakeSeparatorList(string[] separators, ref ValueListBuilder<int> sepListBuilder, ref ValueListBuilder<int> lengthListBuilder)
		{
			for (int i = 0; i < Length; i++)
			{
				foreach (string text in separators)
				{
					if (!IsNullOrEmpty(text))
					{
						int length = text.Length;
						if (this[i] == text[0] && length <= Length - i && (length == 1 || this.AsSpan(i, length).SequenceEqual(text)))
						{
							sepListBuilder.Append(i);
							lengthListBuilder.Append(length);
							i += length - 1;
							break;
						}
					}
				}
			}
		}

		private static void CheckStringSplitOptions(StringSplitOptions options)
		{
			if (((uint)options & 0xFFFFFFFCu) != 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidFlag, ExceptionArgument.options);
			}
		}

		public string Substring(int startIndex)
		{
			return Substring(startIndex, Length - startIndex);
		}

		public string Substring(int startIndex, int length)
		{
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (startIndex > Length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndexLargerThanLength);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NegativeLength);
			}
			if (startIndex > Length - length)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_IndexLength);
			}
			if (length == 0)
			{
				return Empty;
			}
			if (startIndex == 0 && length == Length)
			{
				return this;
			}
			return InternalSubString(startIndex, length);
		}

		private string InternalSubString(int startIndex, int length)
		{
			string text = FastAllocateString(length);
			nuint elementCount = (uint)text.Length;
			Buffer.Memmove(ref text._firstChar, ref Unsafe.Add(ref _firstChar, (nint)(uint)startIndex), elementCount);
			return text;
		}

		public string ToLower()
		{
			return ToLower(null);
		}

		public string ToLower(CultureInfo? culture)
		{
			CultureInfo cultureInfo = culture ?? CultureInfo.CurrentCulture;
			return cultureInfo.TextInfo.ToLower(this);
		}

		public string ToLowerInvariant()
		{
			return TextInfo.Invariant.ToLower(this);
		}

		public string ToUpper()
		{
			return ToUpper(null);
		}

		public string ToUpper(CultureInfo? culture)
		{
			CultureInfo cultureInfo = culture ?? CultureInfo.CurrentCulture;
			return cultureInfo.TextInfo.ToUpper(this);
		}

		public string ToUpperInvariant()
		{
			return TextInfo.Invariant.ToUpper(this);
		}

		public string Trim()
		{
			return TrimWhiteSpaceHelper(TrimType.Both);
		}

		public unsafe string Trim(char trimChar)
		{
			return TrimHelper(&trimChar, 1, TrimType.Both);
		}

		public unsafe string Trim(params char[]? trimChars)
		{
			if (trimChars == null || trimChars.Length == 0)
			{
				return TrimWhiteSpaceHelper(TrimType.Both);
			}
			fixed (char* trimChars2 = &trimChars[0])
			{
				return TrimHelper(trimChars2, trimChars.Length, TrimType.Both);
			}
		}

		public string TrimStart()
		{
			return TrimWhiteSpaceHelper(TrimType.Head);
		}

		public unsafe string TrimStart(char trimChar)
		{
			return TrimHelper(&trimChar, 1, TrimType.Head);
		}

		public unsafe string TrimStart(params char[]? trimChars)
		{
			if (trimChars == null || trimChars.Length == 0)
			{
				return TrimWhiteSpaceHelper(TrimType.Head);
			}
			fixed (char* trimChars2 = &trimChars[0])
			{
				return TrimHelper(trimChars2, trimChars.Length, TrimType.Head);
			}
		}

		public string TrimEnd()
		{
			return TrimWhiteSpaceHelper(TrimType.Tail);
		}

		public unsafe string TrimEnd(char trimChar)
		{
			return TrimHelper(&trimChar, 1, TrimType.Tail);
		}

		public unsafe string TrimEnd(params char[]? trimChars)
		{
			if (trimChars == null || trimChars.Length == 0)
			{
				return TrimWhiteSpaceHelper(TrimType.Tail);
			}
			fixed (char* trimChars2 = &trimChars[0])
			{
				return TrimHelper(trimChars2, trimChars.Length, TrimType.Tail);
			}
		}

		private string TrimWhiteSpaceHelper(TrimType trimType)
		{
			int num = Length - 1;
			int i = 0;
			if ((trimType & TrimType.Head) != 0)
			{
				for (i = 0; i < Length && char.IsWhiteSpace(this[i]); i++)
				{
				}
			}
			if ((trimType & TrimType.Tail) != 0)
			{
				num = Length - 1;
				while (num >= i && char.IsWhiteSpace(this[num]))
				{
					num--;
				}
			}
			return CreateTrimmedString(i, num);
		}

		private unsafe string TrimHelper(char* trimChars, int trimCharsLength, TrimType trimType)
		{
			int num = Length - 1;
			int i = 0;
			if ((trimType & TrimType.Head) != 0)
			{
				for (i = 0; i < Length; i++)
				{
					int num2 = 0;
					char c = this[i];
					for (num2 = 0; num2 < trimCharsLength && trimChars[num2] != c; num2++)
					{
					}
					if (num2 == trimCharsLength)
					{
						break;
					}
				}
			}
			if ((trimType & TrimType.Tail) != 0)
			{
				for (num = Length - 1; num >= i; num--)
				{
					int num3 = 0;
					char c2 = this[num];
					for (num3 = 0; num3 < trimCharsLength && trimChars[num3] != c2; num3++)
					{
					}
					if (num3 == trimCharsLength)
					{
						break;
					}
				}
			}
			return CreateTrimmedString(i, num);
		}

		private string CreateTrimmedString(int start, int end)
		{
			int num = end - start + 1;
			if (num != Length)
			{
				if (num != 0)
				{
					return InternalSubString(start, num);
				}
				return Empty;
			}
			return this;
		}

		public bool Contains(string value)
		{
			if ((object)value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			return SpanHelpers.IndexOf(ref _firstChar, Length, ref value._firstChar, value.Length) >= 0;
		}

		public bool Contains(string value, StringComparison comparisonType)
		{
			return IndexOf(value, comparisonType) >= 0;
		}

		public bool Contains(char value)
		{
			return SpanHelpers.Contains(ref _firstChar, value, Length);
		}

		public bool Contains(char value, StringComparison comparisonType)
		{
			return IndexOf(value, comparisonType) != -1;
		}

		public int IndexOf(char value)
		{
			return SpanHelpers.IndexOf(ref _firstChar, value, Length);
		}

		public int IndexOf(char value, int startIndex)
		{
			return IndexOf(value, startIndex, Length - startIndex);
		}

		public int IndexOf(char value, StringComparison comparisonType)
		{
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this, value, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.IndexOf(this, value, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				return IndexOf(value);
			case StringComparison.OrdinalIgnoreCase:
				return CompareInfo.Invariant.IndexOf(this, value, CompareOptions.OrdinalIgnoreCase);
			default:
				throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}

		public int IndexOf(char value, int startIndex, int count)
		{
			if ((uint)startIndex > (uint)Length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if ((uint)count > (uint)(Length - startIndex))
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Count);
			}
			int num = SpanHelpers.IndexOf(ref Unsafe.Add(ref _firstChar, startIndex), value, count);
			if (num != -1)
			{
				return num + startIndex;
			}
			return num;
		}

		public int IndexOfAny(char[] anyOf)
		{
			return IndexOfAny(anyOf, 0, Length);
		}

		public int IndexOfAny(char[] anyOf, int startIndex)
		{
			return IndexOfAny(anyOf, startIndex, Length - startIndex);
		}

		public int IndexOfAny(char[] anyOf, int startIndex, int count)
		{
			if (anyOf == null)
			{
				throw new ArgumentNullException("anyOf");
			}
			if ((uint)startIndex > (uint)Length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if ((uint)count > (uint)(Length - startIndex))
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Count);
			}
			if (anyOf.Length != 0 && anyOf.Length <= 5)
			{
				int num = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, startIndex), count).IndexOfAny(anyOf);
				if (num != -1)
				{
					return num + startIndex;
				}
				return num;
			}
			if (anyOf.Length > 5)
			{
				return IndexOfCharArray(anyOf, startIndex, count);
			}
			return -1;
		}

		private unsafe int IndexOfCharArray(char[] anyOf, int startIndex, int count)
		{
			ProbabilisticMap probabilisticMap = default(ProbabilisticMap);
			uint* charMap = (uint*)(&probabilisticMap);
			InitializeProbabilisticMap(charMap, anyOf);
			fixed (char* ptr = &_firstChar)
			{
				char* ptr2 = ptr + startIndex;
				while (count > 0)
				{
					int num = *ptr2;
					if (IsCharBitSet(charMap, (byte)num) && IsCharBitSet(charMap, (byte)(num >> 8)) && ArrayContains((char)num, anyOf))
					{
						return (int)(ptr2 - ptr);
					}
					count--;
					ptr2++;
				}
				return -1;
			}
		}

		private unsafe static void InitializeProbabilisticMap(uint* charMap, ReadOnlySpan<char> anyOf)
		{
			bool flag = false;
			for (int i = 0; i < anyOf.Length; i++)
			{
				int num = anyOf[i];
				SetCharBit(charMap, (byte)num);
				num >>= 8;
				if (num == 0)
				{
					flag = true;
				}
				else
				{
					SetCharBit(charMap, (byte)num);
				}
			}
			if (flag)
			{
				*charMap |= 1u;
			}
		}

		private static bool ArrayContains(char searchChar, char[] anyOf)
		{
			for (int i = 0; i < anyOf.Length; i++)
			{
				if (anyOf[i] == searchChar)
				{
					return true;
				}
			}
			return false;
		}

		private unsafe static bool IsCharBitSet(uint* charMap, byte value)
		{
			return (charMap[(uint)(value & 7)] & (uint)(1 << (value >> 3))) != 0;
		}

		private unsafe static void SetCharBit(uint* charMap, byte value)
		{
			charMap[(uint)(value & 7)] |= (uint)(1 << (value >> 3));
		}

		public int IndexOf(string value)
		{
			return IndexOf(value, StringComparison.CurrentCulture);
		}

		public int IndexOf(string value, int startIndex)
		{
			return IndexOf(value, startIndex, StringComparison.CurrentCulture);
		}

		public int IndexOf(string value, int startIndex, int count)
		{
			return IndexOf(value, startIndex, count, StringComparison.CurrentCulture);
		}

		public int IndexOf(string value, StringComparison comparisonType)
		{
			return IndexOf(value, 0, Length, comparisonType);
		}

		public int IndexOf(string value, int startIndex, StringComparison comparisonType)
		{
			return IndexOf(value, startIndex, Length - startIndex, comparisonType);
		}

		public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType)
		{
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.IndexOf(this, value, startIndex, count, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.IndexOf(this, value, startIndex, count, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
			case StringComparison.OrdinalIgnoreCase:
				return Ordinal.IndexOf(this, value, startIndex, count, comparisonType == StringComparison.OrdinalIgnoreCase);
			default:
				throw ((object)value == null) ? new ArgumentNullException("value") : new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}

		public int LastIndexOf(char value)
		{
			return SpanHelpers.LastIndexOf(ref _firstChar, value, Length);
		}

		public int LastIndexOf(char value, int startIndex)
		{
			return LastIndexOf(value, startIndex, startIndex + 1);
		}

		public int LastIndexOf(char value, int startIndex, int count)
		{
			if (Length == 0)
			{
				return -1;
			}
			if ((uint)startIndex >= (uint)Length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if ((uint)count > (uint)(startIndex + 1))
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Count);
			}
			int num = startIndex + 1 - count;
			int num2 = SpanHelpers.LastIndexOf(ref Unsafe.Add(ref _firstChar, num), value, count);
			if (num2 != -1)
			{
				return num2 + num;
			}
			return num2;
		}

		public int LastIndexOfAny(char[] anyOf)
		{
			return LastIndexOfAny(anyOf, Length - 1, Length);
		}

		public int LastIndexOfAny(char[] anyOf, int startIndex)
		{
			return LastIndexOfAny(anyOf, startIndex, startIndex + 1);
		}

		public int LastIndexOfAny(char[] anyOf, int startIndex, int count)
		{
			if (anyOf == null)
			{
				throw new ArgumentNullException("anyOf");
			}
			if (Length == 0)
			{
				return -1;
			}
			if ((uint)startIndex >= (uint)Length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (count < 0 || count - 1 > startIndex)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Count);
			}
			if (anyOf.Length > 1)
			{
				return LastIndexOfCharArray(anyOf, startIndex, count);
			}
			if (anyOf.Length == 1)
			{
				return LastIndexOf(anyOf[0], startIndex, count);
			}
			return -1;
		}

		private unsafe int LastIndexOfCharArray(char[] anyOf, int startIndex, int count)
		{
			ProbabilisticMap probabilisticMap = default(ProbabilisticMap);
			uint* charMap = (uint*)(&probabilisticMap);
			InitializeProbabilisticMap(charMap, anyOf);
			fixed (char* ptr = &_firstChar)
			{
				char* ptr2 = ptr + startIndex;
				while (count > 0)
				{
					int num = *ptr2;
					if (IsCharBitSet(charMap, (byte)num) && IsCharBitSet(charMap, (byte)(num >> 8)) && ArrayContains((char)num, anyOf))
					{
						return (int)(ptr2 - ptr);
					}
					count--;
					ptr2--;
				}
				return -1;
			}
		}

		public int LastIndexOf(string value)
		{
			return LastIndexOf(value, Length - 1, Length, StringComparison.CurrentCulture);
		}

		public int LastIndexOf(string value, int startIndex)
		{
			return LastIndexOf(value, startIndex, startIndex + 1, StringComparison.CurrentCulture);
		}

		public int LastIndexOf(string value, int startIndex, int count)
		{
			return LastIndexOf(value, startIndex, count, StringComparison.CurrentCulture);
		}

		public int LastIndexOf(string value, StringComparison comparisonType)
		{
			return LastIndexOf(value, Length - 1, Length, comparisonType);
		}

		public int LastIndexOf(string value, int startIndex, StringComparison comparisonType)
		{
			return LastIndexOf(value, startIndex, startIndex + 1, comparisonType);
		}

		public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType)
		{
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.LastIndexOf(this, value, startIndex, count, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.LastIndexOf(this, value, startIndex, count, GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
			case StringComparison.OrdinalIgnoreCase:
				return CompareInfo.Invariant.LastIndexOf(this, value, startIndex, count, GetCompareOptionsFromOrdinalStringComparison(comparisonType));
			default:
				throw ((object)value == null) ? new ArgumentNullException("value") : new ArgumentException(SR.NotSupported_StringComparison, "comparisonType");
			}
		}
	}
	public abstract class Type : MemberInfo, IReflect
	{
		private static volatile Binder s_defaultBinder;

		public static readonly char Delimiter = '.';

		public static readonly Type[] EmptyTypes = Array.Empty<Type>();

		public static readonly object Missing = System.Reflection.Missing.Value;

		public static readonly MemberFilter FilterAttribute = FilterAttributeImpl;

		public static readonly MemberFilter FilterName = (MemberInfo m, object c) => FilterNameImpl(m, c, StringComparison.Ordinal);

		public static readonly MemberFilter FilterNameIgnoreCase = (MemberInfo m, object c) => FilterNameImpl(m, c, StringComparison.OrdinalIgnoreCase);

		public bool IsInterface
		{
			get
			{
				if (this is RuntimeType type)
				{
					return RuntimeTypeHandle.IsInterface(type);
				}
				return (GetAttributeFlagsImpl() & TypeAttributes.ClassSemanticsMask) == TypeAttributes.ClassSemanticsMask;
			}
		}

		public override MemberTypes MemberType => MemberTypes.TypeInfo;

		public abstract string? Namespace { get; }

		public abstract string? AssemblyQualifiedName { get; }

		public abstract string? FullName { get; }

		public abstract Assembly Assembly { get; }

		public new abstract Module Module { get; }

		public bool IsNested => DeclaringType != null;

		public override Type? DeclaringType => null;

		public virtual MethodBase? DeclaringMethod => null;

		public override Type? ReflectedType => null;

		public abstract Type UnderlyingSystemType { get; }

		public virtual bool IsTypeDefinition
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public bool IsArray => IsArrayImpl();

		public bool IsByRef => IsByRefImpl();

		public bool IsPointer => IsPointerImpl();

		public virtual bool IsConstructedGenericType
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool IsGenericParameter => false;

		public virtual bool IsGenericTypeParameter
		{
			get
			{
				if (IsGenericParameter)
				{
					return (object)DeclaringMethod == null;
				}
				return false;
			}
		}

		public virtual bool IsGenericMethodParameter
		{
			get
			{
				if (IsGenericParameter)
				{
					return DeclaringMethod != null;
				}
				return false;
			}
		}

		public virtual bool IsGenericType => false;

		public virtual bool IsGenericTypeDefinition => false;

		public virtual bool IsSZArray
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool IsVariableBoundArray
		{
			get
			{
				if (IsArray)
				{
					return !IsSZArray;
				}
				return false;
			}
		}

		public virtual bool IsByRefLike
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SubclassOverride);
			}
		}

		public bool HasElementType => HasElementTypeImpl();

		public virtual Type[] GenericTypeArguments
		{
			get
			{
				if (!IsGenericType || IsGenericTypeDefinition)
				{
					return EmptyTypes;
				}
				return GetGenericArguments();
			}
		}

		public virtual int GenericParameterPosition
		{
			get
			{
				throw new InvalidOperationException(SR.Arg_NotGenericParameter);
			}
		}

		public virtual GenericParameterAttributes GenericParameterAttributes
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public TypeAttributes Attributes => GetAttributeFlagsImpl();

		public bool IsAbstract => (GetAttributeFlagsImpl() & TypeAttributes.Abstract) != 0;

		public bool IsImport => (GetAttributeFlagsImpl() & TypeAttributes.Import) != 0;

		public bool IsSealed => (GetAttributeFlagsImpl() & TypeAttributes.Sealed) != 0;

		public bool IsSpecialName => (GetAttributeFlagsImpl() & TypeAttributes.SpecialName) != 0;

		public bool IsClass
		{
			get
			{
				if ((GetAttributeFlagsImpl() & TypeAttributes.ClassSemanticsMask) == 0)
				{
					return !IsValueType;
				}
				return false;
			}
		}

		public bool IsNestedAssembly => (GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedAssembly;

		public bool IsNestedFamANDAssem => (GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamANDAssem;

		public bool IsNestedFamily => (GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedFamily;

		public bool IsNestedFamORAssem => (GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.VisibilityMask;

		public bool IsNestedPrivate => (GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPrivate;

		public bool IsNestedPublic => (GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.NestedPublic;

		public bool IsNotPublic => (GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == 0;

		public bool IsPublic => (GetAttributeFlagsImpl() & TypeAttributes.VisibilityMask) == TypeAttributes.Public;

		public bool IsAutoLayout => (GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == 0;

		public bool IsExplicitLayout => (GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == TypeAttributes.ExplicitLayout;

		public bool IsLayoutSequential => (GetAttributeFlagsImpl() & TypeAttributes.LayoutMask) == TypeAttributes.SequentialLayout;

		public bool IsAnsiClass => (GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == 0;

		public bool IsAutoClass => (GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == TypeAttributes.AutoClass;

		public bool IsUnicodeClass => (GetAttributeFlagsImpl() & TypeAttributes.StringFormatMask) == TypeAttributes.UnicodeClass;

		public bool IsCOMObject => IsCOMObjectImpl();

		public bool IsContextful => IsContextfulImpl();

		public virtual bool IsEnum => IsSubclassOf(typeof(Enum));

		public bool IsMarshalByRef => IsMarshalByRefImpl();

		public bool IsPrimitive => IsPrimitiveImpl();

		public bool IsValueType
		{
			[Intrinsic]
			get
			{
				return IsValueTypeImpl();
			}
		}

		public virtual bool IsSignatureType => false;

		public virtual bool IsSecurityCritical
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool IsSecuritySafeCritical
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool IsSecurityTransparent
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual StructLayoutAttribute? StructLayoutAttribute
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ConstructorInfo? TypeInitializer
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
			get
			{
				return GetConstructorImpl(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, EmptyTypes, null);
			}
		}

		public virtual RuntimeTypeHandle TypeHandle
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public abstract Guid GUID { get; }

		public abstract Type? BaseType { get; }

		public static Binder DefaultBinder
		{
			get
			{
				if (s_defaultBinder == null)
				{
					DefaultBinder value = new DefaultBinder();
					Interlocked.CompareExchange(ref s_defaultBinder, value, null);
				}
				return s_defaultBinder;
			}
		}

		public virtual bool IsSerializable
		{
			get
			{
				if ((GetAttributeFlagsImpl() & TypeAttributes.Serializable) != 0)
				{
					return true;
				}
				Type type = UnderlyingSystemType;
				if (type.IsRuntimeImplemented())
				{
					do
					{
						if (type == typeof(Delegate) || type == typeof(Enum))
						{
							return true;
						}
						type = type.BaseType;
					}
					while (type != null);
				}
				return false;
			}
		}

		public virtual bool ContainsGenericParameters
		{
			get
			{
				if (HasElementType)
				{
					return GetRootElementType().ContainsGenericParameters;
				}
				if (IsGenericParameter)
				{
					return true;
				}
				if (!IsGenericType)
				{
					return false;
				}
				Type[] genericArguments = GetGenericArguments();
				for (int i = 0; i < genericArguments.Length; i++)
				{
					if (genericArguments[i].ContainsGenericParameters)
					{
						return true;
					}
				}
				return false;
			}
		}

		public bool IsVisible
		{
			get
			{
				if (this is RuntimeType type)
				{
					return RuntimeTypeHandle.IsVisible(type);
				}
				if (IsGenericParameter)
				{
					return true;
				}
				if (HasElementType)
				{
					return GetElementType().IsVisible;
				}
				Type type2 = this;
				while (type2.IsNested)
				{
					if (!type2.IsNestedPublic)
					{
						return false;
					}
					type2 = type2.DeclaringType;
				}
				if (!type2.IsPublic)
				{
					return false;
				}
				if (IsGenericType && !IsGenericTypeDefinition)
				{
					Type[] genericArguments = GetGenericArguments();
					foreach (Type type3 in genericArguments)
					{
						if (!type3.IsVisible)
						{
							return false;
						}
					}
				}
				return true;
			}
		}

		[RequiresUnreferencedCode("The type might be removed")]
		public static Type? GetType(string typeName, bool throwOnError, bool ignoreCase)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return RuntimeType.GetType(typeName, throwOnError, ignoreCase, ref stackMark);
		}

		[RequiresUnreferencedCode("The type might be removed")]
		public static Type? GetType(string typeName, bool throwOnError)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return RuntimeType.GetType(typeName, throwOnError, ignoreCase: false, ref stackMark);
		}

		[RequiresUnreferencedCode("The type might be removed")]
		public static Type? GetType(string typeName)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return RuntimeType.GetType(typeName, throwOnError: false, ignoreCase: false, ref stackMark);
		}

		[RequiresUnreferencedCode("The type might be removed")]
		public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, throwOnError: false, ignoreCase: false, ref stackMark);
		}

		[RequiresUnreferencedCode("The type might be removed")]
		public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase: false, ref stackMark);
		}

		[RequiresUnreferencedCode("The type might be removed")]
		public static Type? GetType(string typeName, Func<AssemblyName, Assembly?>? assemblyResolver, Func<Assembly?, string, bool, Type?>? typeResolver, bool throwOnError, bool ignoreCase)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
		}

		internal virtual RuntimeTypeHandle GetTypeHandleInternal()
		{
			return TypeHandle;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeType GetTypeFromHandleUnsafe(IntPtr handle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern Type GetTypeFromHandle(RuntimeTypeHandle handle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern bool operator ==(Type? left, Type? right);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern bool operator !=(Type? left, Type? right);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool IsRuntimeImplemented()
		{
			return this is RuntimeType;
		}

		public new Type GetType()
		{
			return base.GetType();
		}

		protected abstract bool IsArrayImpl();

		protected abstract bool IsByRefImpl();

		protected abstract bool IsPointerImpl();

		protected abstract bool HasElementTypeImpl();

		public abstract Type? GetElementType();

		public virtual int GetArrayRank()
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public virtual Type GetGenericTypeDefinition()
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public virtual Type[] GetGenericArguments()
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public virtual Type[] GetGenericParameterConstraints()
		{
			if (!IsGenericParameter)
			{
				throw new InvalidOperationException(SR.Arg_NotGenericParameter);
			}
			throw new InvalidOperationException();
		}

		protected abstract TypeAttributes GetAttributeFlagsImpl();

		protected abstract bool IsCOMObjectImpl();

		protected virtual bool IsContextfulImpl()
		{
			return false;
		}

		protected virtual bool IsMarshalByRefImpl()
		{
			return false;
		}

		protected abstract bool IsPrimitiveImpl();

		[Intrinsic]
		public bool IsAssignableTo([NotNullWhen(true)] Type? targetType)
		{
			return targetType?.IsAssignableFrom(this) ?? false;
		}

		protected virtual bool IsValueTypeImpl()
		{
			return IsSubclassOf(typeof(ValueType));
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
		public ConstructorInfo? GetConstructor(Type[] types)
		{
			return GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, types, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public ConstructorInfo? GetConstructor(BindingFlags bindingAttr, Type[] types)
		{
			return GetConstructor(bindingAttr, null, types, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public ConstructorInfo? GetConstructor(BindingFlags bindingAttr, Binder? binder, Type[] types, ParameterModifier[]? modifiers)
		{
			return GetConstructor(bindingAttr, binder, CallingConventions.Any, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public ConstructorInfo? GetConstructor(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers)
		{
			if (types == null)
			{
				throw new ArgumentNullException("types");
			}
			for (int i = 0; i < types.Length; i++)
			{
				if (types[i] == null)
				{
					throw new ArgumentNullException("types");
				}
			}
			return GetConstructorImpl(bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected abstract ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
		public ConstructorInfo[] GetConstructors()
		{
			return GetConstructors(BindingFlags.Instance | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public abstract ConstructorInfo[] GetConstructors(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public EventInfo? GetEvent(string name)
		{
			return GetEvent(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public abstract EventInfo? GetEvent(string name, BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public virtual EventInfo[] GetEvents()
		{
			return GetEvents(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public abstract EventInfo[] GetEvents(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)]
		public FieldInfo? GetField(string name)
		{
			return GetField(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public abstract FieldInfo? GetField(string name, BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)]
		public FieldInfo[] GetFields()
		{
			return GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public abstract FieldInfo[] GetFields(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)]
		public MemberInfo[] GetMember(string name)
		{
			return GetMember(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public virtual MemberInfo[] GetMember(string name, BindingFlags bindingAttr)
		{
			return GetMember(name, MemberTypes.All, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public virtual MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)]
		public MemberInfo[] GetMembers()
		{
			return GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2085:UnrecognizedReflectionPattern", Justification = "This is finding the MemberInfo with the same MetadataToken as specified MemberInfo. If the specified MemberInfo exists and wasn't trimmed, then the current Type's MemberInfo couldn't have been trimmed.")]
		public virtual MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo member)
		{
			if ((object)member == null)
			{
				throw new ArgumentNullException("member");
			}
			MemberInfo[] members = GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MemberInfo memberInfo in members)
			{
				if (memberInfo.HasSameMetadataDefinitionAs(member))
				{
					return memberInfo;
				}
			}
			throw CreateGetMemberWithSameMetadataDefinitionAsNotFoundException(member);
		}

		private protected static ArgumentException CreateGetMemberWithSameMetadataDefinitionAsNotFoundException(MemberInfo member)
		{
			return new ArgumentException(SR.Format(SR.Arg_MemberInfoNotFound, member.Name), "member");
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public abstract MemberInfo[] GetMembers(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
		public MethodInfo? GetMethod(string name)
		{
			return GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public MethodInfo? GetMethod(string name, BindingFlags bindingAttr)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			return GetMethodImpl(name, bindingAttr, null, CallingConventions.Any, null, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public MethodInfo? GetMethod(string name, BindingFlags bindingAttr, Type[] types)
		{
			return GetMethod(name, bindingAttr, null, types, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
		public MethodInfo? GetMethod(string name, Type[] types)
		{
			return GetMethod(name, types, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
		public MethodInfo? GetMethod(string name, Type[] types, ParameterModifier[]? modifiers)
		{
			return GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public MethodInfo? GetMethod(string name, BindingFlags bindingAttr, Binder? binder, Type[] types, ParameterModifier[]? modifiers)
		{
			return GetMethod(name, bindingAttr, binder, CallingConventions.Any, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public MethodInfo? GetMethod(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (types == null)
			{
				throw new ArgumentNullException("types");
			}
			for (int i = 0; i < types.Length; i++)
			{
				if (types[i] == null)
				{
					throw new ArgumentNullException("types");
				}
			}
			return GetMethodImpl(name, bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected abstract MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
		public MethodInfo? GetMethod(string name, int genericParameterCount, Type[] types)
		{
			return GetMethod(name, genericParameterCount, types, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
		public MethodInfo? GetMethod(string name, int genericParameterCount, Type[] types, ParameterModifier[]? modifiers)
		{
			return GetMethod(name, genericParameterCount, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public MethodInfo? GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, Type[] types, ParameterModifier[]? modifiers)
		{
			return GetMethod(name, genericParameterCount, bindingAttr, binder, CallingConventions.Any, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public MethodInfo? GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (genericParameterCount < 0)
			{
				throw new ArgumentException(SR.ArgumentOutOfRange_NeedNonNegNum, "genericParameterCount");
			}
			if (types == null)
			{
				throw new ArgumentNullException("types");
			}
			for (int i = 0; i < types.Length; i++)
			{
				if (types[i] == null)
				{
					throw new ArgumentNullException("types");
				}
			}
			return GetMethodImpl(name, genericParameterCount, bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected virtual MethodInfo? GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
		public MethodInfo[] GetMethods()
		{
			return GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public abstract MethodInfo[] GetMethods(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes)]
		public Type? GetNestedType(string name)
		{
			return GetNestedType(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public abstract Type? GetNestedType(string name, BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes)]
		public Type[] GetNestedTypes()
		{
			return GetNestedTypes(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public abstract Type[] GetNestedTypes(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
		public PropertyInfo? GetProperty(string name)
		{
			return GetProperty(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public PropertyInfo? GetProperty(string name, BindingFlags bindingAttr)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			return GetPropertyImpl(name, bindingAttr, null, null, null, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2085:UnrecognizedReflectionPattern", Justification = "Linker doesn't recognize GetPropertyImpl(BindingFlags.Public) but this is what the body is doing")]
		public PropertyInfo? GetProperty(string name, Type? returnType)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			return GetPropertyImpl(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, returnType, null, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
		public PropertyInfo? GetProperty(string name, Type[] types)
		{
			return GetProperty(name, null, types);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
		public PropertyInfo? GetProperty(string name, Type? returnType, Type[] types)
		{
			return GetProperty(name, returnType, types, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
		public PropertyInfo? GetProperty(string name, Type? returnType, Type[] types, ParameterModifier[]? modifiers)
		{
			return GetProperty(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, returnType, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public PropertyInfo? GetProperty(string name, BindingFlags bindingAttr, Binder? binder, Type? returnType, Type[] types, ParameterModifier[]? modifiers)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (types == null)
			{
				throw new ArgumentNullException("types");
			}
			return GetPropertyImpl(name, bindingAttr, binder, returnType, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected abstract PropertyInfo? GetPropertyImpl(string name, BindingFlags bindingAttr, Binder? binder, Type? returnType, Type[]? types, ParameterModifier[]? modifiers);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
		public PropertyInfo[] GetProperties()
		{
			return GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public abstract PropertyInfo[] GetProperties(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)]
		public virtual MemberInfo[] GetDefaultMembers()
		{
			throw NotImplemented.ByDesign;
		}

		public static RuntimeTypeHandle GetTypeHandle(object o)
		{
			if (o == null)
			{
				throw new ArgumentNullException(null, SR.Arg_InvalidHandle);
			}
			Type type = o.GetType();
			return type.TypeHandle;
		}

		public static Type[] GetTypeArray(object[] args)
		{
			if (args == null)
			{
				throw new ArgumentNullException("args");
			}
			Type[] array = new Type[args.Length];
			for (int i = 0; i < array.Length; i++)
			{
				if (args[i] == null)
				{
					throw new ArgumentException(SR.ArgumentNull_ArrayValue, "args");
				}
				array[i] = args[i].GetType();
			}
			return array;
		}

		public static TypeCode GetTypeCode(Type? type)
		{
			return type?.GetTypeCodeImpl() ?? TypeCode.Empty;
		}

		protected virtual TypeCode GetTypeCodeImpl()
		{
			Type underlyingSystemType = UnderlyingSystemType;
			if ((object)this != underlyingSystemType && (object)underlyingSystemType != null)
			{
				return GetTypeCode(underlyingSystemType);
			}
			return TypeCode.Object;
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromCLSID(Guid clsid)
		{
			return GetTypeFromCLSID(clsid, null, throwOnError: false);
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromCLSID(Guid clsid, bool throwOnError)
		{
			return GetTypeFromCLSID(clsid, null, throwOnError);
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromCLSID(Guid clsid, string? server)
		{
			return GetTypeFromCLSID(clsid, server, throwOnError: false);
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromCLSID(Guid clsid, string? server, bool throwOnError)
		{
			return Marshal.GetTypeFromCLSID(clsid, server, throwOnError);
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromProgID(string progID)
		{
			return GetTypeFromProgID(progID, null, throwOnError: false);
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromProgID(string progID, bool throwOnError)
		{
			return GetTypeFromProgID(progID, null, throwOnError);
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromProgID(string progID, string? server)
		{
			return GetTypeFromProgID(progID, server, throwOnError: false);
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromProgID(string progID, string? server, bool throwOnError)
		{
			return Marshal.GetTypeFromProgID(progID, server, throwOnError);
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public object? InvokeMember(string name, BindingFlags invokeAttr, Binder? binder, object? target, object?[]? args)
		{
			return InvokeMember(name, invokeAttr, binder, target, args, null, null, null);
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public object? InvokeMember(string name, BindingFlags invokeAttr, Binder? binder, object? target, object?[]? args, CultureInfo? culture)
		{
			return InvokeMember(name, invokeAttr, binder, target, args, null, culture, null);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public abstract object? InvokeMember(string name, BindingFlags invokeAttr, Binder? binder, object? target, object?[]? args, ParameterModifier[]? modifiers, CultureInfo? culture, string[]? namedParameters);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public Type? GetInterface(string name)
		{
			return GetInterface(name, ignoreCase: false);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public abstract Type? GetInterface(string name, bool ignoreCase);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public abstract Type[] GetInterfaces();

		public virtual InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public virtual bool IsInstanceOfType([NotNullWhen(true)] object? o)
		{
			if (o != null)
			{
				return IsAssignableFrom(o.GetType());
			}
			return false;
		}

		public virtual bool IsEquivalentTo([NotNullWhen(true)] Type? other)
		{
			return this == other;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2085:UnrecognizedReflectionPattern", Justification = "The single instance field on enum types is never trimmed")]
		public virtual Type GetEnumUnderlyingType()
		{
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "enumType");
			}
			FieldInfo[] fields = GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (fields == null || fields.Length != 1)
			{
				throw new ArgumentException(SR.Argument_InvalidEnum, "enumType");
			}
			return fields[0].FieldType;
		}

		public virtual Array GetEnumValues()
		{
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "enumType");
			}
			throw NotImplemented.ByDesign;
		}

		public virtual Type MakeArrayType()
		{
			throw new NotSupportedException();
		}

		public virtual Type MakeArrayType(int rank)
		{
			throw new NotSupportedException();
		}

		public virtual Type MakeByRefType()
		{
			throw new NotSupportedException();
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public virtual Type MakeGenericType(params Type[] typeArguments)
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public virtual Type MakePointerType()
		{
			throw new NotSupportedException();
		}

		public static Type MakeGenericSignatureType(Type genericTypeDefinition, params Type[] typeArguments)
		{
			return new SignatureConstructedGenericType(genericTypeDefinition, typeArguments);
		}

		public static Type MakeGenericMethodParameter(int position)
		{
			if (position < 0)
			{
				throw new ArgumentException(SR.ArgumentOutOfRange_NeedNonNegNum, "position");
			}
			return new SignatureGenericMethodParameterType(position);
		}

		internal string FormatTypeName()
		{
			Type rootElementType = GetRootElementType();
			if (rootElementType.IsPrimitive || rootElementType.IsNested || rootElementType == typeof(void) || rootElementType == typeof(TypedReference))
			{
				return Name;
			}
			return ToString();
		}

		public override string ToString()
		{
			return "Type: " + Name;
		}

		public override bool Equals(object? o)
		{
			if (o != null)
			{
				return Equals(o as Type);
			}
			return false;
		}

		public override int GetHashCode()
		{
			Type underlyingSystemType = UnderlyingSystemType;
			if ((object)underlyingSystemType != this)
			{
				return underlyingSystemType.GetHashCode();
			}
			return base.GetHashCode();
		}

		public virtual bool Equals(Type? o)
		{
			if (!(o == null))
			{
				return (object)UnderlyingSystemType == o.UnderlyingSystemType;
			}
			return false;
		}

		[Obsolete("ReflectionOnly loading is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0018", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static Type? ReflectionOnlyGetType(string typeName, bool throwIfNotFound, bool ignoreCase)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ReflectionOnly);
		}

		public virtual bool IsEnumDefined(object value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "value");
			}
			Type type = value.GetType();
			if (type.IsEnum)
			{
				if (!type.IsEquivalentTo(this))
				{
					throw new ArgumentException(SR.Format(SR.Arg_EnumAndObjectMustBeSameType, type, this));
				}
				type = type.GetEnumUnderlyingType();
			}
			if (type == typeof(string))
			{
				string[] enumNames = GetEnumNames();
				object[] array = enumNames;
				if (Array.IndexOf(array, value) >= 0)
				{
					return true;
				}
				return false;
			}
			if (IsIntegerType(type))
			{
				Type enumUnderlyingType = GetEnumUnderlyingType();
				if (enumUnderlyingType.GetTypeCodeImpl() != type.GetTypeCodeImpl())
				{
					throw new ArgumentException(SR.Format(SR.Arg_EnumUnderlyingTypeAndObjectMustBeSameType, type, enumUnderlyingType));
				}
				Array enumRawConstantValues = GetEnumRawConstantValues();
				return BinarySearch(enumRawConstantValues, value) >= 0;
			}
			throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
		}

		public virtual string? GetEnumName(object value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "value");
			}
			Type type = value.GetType();
			if (!type.IsEnum && !IsIntegerType(type))
			{
				throw new ArgumentException(SR.Arg_MustBeEnumBaseTypeOrEnum, "value");
			}
			Array enumRawConstantValues = GetEnumRawConstantValues();
			int num = BinarySearch(enumRawConstantValues, value);
			if (num >= 0)
			{
				string[] enumNames = GetEnumNames();
				return enumNames[num];
			}
			return null;
		}

		public virtual string[] GetEnumNames()
		{
			if (!IsEnum)
			{
				throw new ArgumentException(SR.Arg_MustBeEnum, "enumType");
			}
			GetEnumData(out var enumNames, out var _);
			return enumNames;
		}

		private Array GetEnumRawConstantValues()
		{
			GetEnumData(out var _, out var enumValues);
			return enumValues;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2085:UnrecognizedReflectionPattern", Justification = "Literal fields on enums can never be trimmed")]
		private void GetEnumData(out string[] enumNames, out Array enumValues)
		{
			FieldInfo[] fields = GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			object[] array = new object[fields.Length];
			string[] array2 = new string[fields.Length];
			for (int i = 0; i < fields.Length; i++)
			{
				array2[i] = fields[i].Name;
				array[i] = fields[i].GetRawConstantValue();
			}
			Comparer @default = Comparer.Default;
			for (int j = 1; j < array.Length; j++)
			{
				int num = j;
				string text = array2[j];
				object obj = array[j];
				bool flag = false;
				while (@default.Compare(array[num - 1], obj) > 0)
				{
					array2[num] = array2[num - 1];
					array[num] = array[num - 1];
					num--;
					flag = true;
					if (num == 0)
					{
						break;
					}
				}
				if (flag)
				{
					array2[num] = text;
					array[num] = obj;
				}
			}
			enumNames = array2;
			enumValues = array;
		}

		private static int BinarySearch(Array array, object value)
		{
			ulong[] array2 = new ulong[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array2[i] = Enum.ToUInt64(array.GetValue(i));
			}
			ulong value2 = Enum.ToUInt64(value);
			return Array.BinarySearch(array2, value2);
		}

		internal static bool IsIntegerType(Type t)
		{
			if (!(t == typeof(int)) && !(t == typeof(short)) && !(t == typeof(ushort)) && !(t == typeof(byte)) && !(t == typeof(sbyte)) && !(t == typeof(uint)) && !(t == typeof(long)) && !(t == typeof(ulong)) && !(t == typeof(char)))
			{
				return t == typeof(bool);
			}
			return true;
		}

		internal Type GetRootElementType()
		{
			Type type = this;
			while (type.HasElementType)
			{
				type = type.GetElementType();
			}
			return type;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public virtual Type[] FindInterfaces(TypeFilter filter, object? filterCriteria)
		{
			if (filter == null)
			{
				throw new ArgumentNullException("filter");
			}
			Type[] interfaces = GetInterfaces();
			int num = 0;
			for (int i = 0; i < interfaces.Length; i++)
			{
				if (!filter(interfaces[i], filterCriteria))
				{
					interfaces[i] = null;
				}
				else
				{
					num++;
				}
			}
			if (num == interfaces.Length)
			{
				return interfaces;
			}
			Type[] array = new Type[num];
			num = 0;
			foreach (Type type in interfaces)
			{
				if ((object)type != null)
				{
					array[num++] = type;
				}
			}
			return array;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public virtual MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bindingAttr, MemberFilter? filter, object? filterCriteria)
		{
			MethodInfo[] array = null;
			ConstructorInfo[] array2 = null;
			FieldInfo[] array3 = null;
			PropertyInfo[] array4 = null;
			EventInfo[] array5 = null;
			Type[] array6 = null;
			int num = 0;
			if ((memberType & MemberTypes.Method) != 0)
			{
				array = GetMethods(bindingAttr);
				if (filter != null)
				{
					for (int i = 0; i < array.Length; i++)
					{
						if (!filter(array[i], filterCriteria))
						{
							array[i] = null;
						}
						else
						{
							num++;
						}
					}
				}
				else
				{
					num += array.Length;
				}
			}
			if ((memberType & MemberTypes.Constructor) != 0)
			{
				array2 = GetConstructors(bindingAttr);
				if (filter != null)
				{
					for (int i = 0; i < array2.Length; i++)
					{
						if (!filter(array2[i], filterCriteria))
						{
							array2[i] = null;
						}
						else
						{
							num++;
						}
					}
				}
				else
				{
					num += array2.Length;
				}
			}
			if ((memberType & MemberTypes.Field) != 0)
			{
				array3 = GetFields(bindingAttr);
				if (filter != null)
				{
					for (int i = 0; i < array3.Length; i++)
					{
						if (!filter(array3[i], filterCriteria))
						{
							array3[i] = null;
						}
						else
						{
							num++;
						}
					}
				}
				else
				{
					num += array3.Length;
				}
			}
			if ((memberType & MemberTypes.Property) != 0)
			{
				array4 = GetProperties(bindingAttr);
				if (filter != null)
				{
					for (int i = 0; i < array4.Length; i++)
					{
						if (!filter(array4[i], filterCriteria))
						{
							array4[i] = null;
						}
						else
						{
							num++;
						}
					}
				}
				else
				{
					num += array4.Length;
				}
			}
			if ((memberType & MemberTypes.Event) != 0)
			{
				array5 = GetEvents(bindingAttr);
				if (filter != null)
				{
					for (int i = 0; i < array5.Length; i++)
					{
						if (!filter(array5[i], filterCriteria))
						{
							array5[i] = null;
						}
						else
						{
							num++;
						}
					}
				}
				else
				{
					num += array5.Length;
				}
			}
			if ((memberType & MemberTypes.NestedType) != 0)
			{
				array6 = GetNestedTypes(bindingAttr);
				if (filter != null)
				{
					for (int i = 0; i < array6.Length; i++)
					{
						if (!filter(array6[i], filterCriteria))
						{
							array6[i] = null;
						}
						else
						{
							num++;
						}
					}
				}
				else
				{
					num += array6.Length;
				}
			}
			MemberInfo[] array7 = new MemberInfo[num];
			num = 0;
			if (array != null)
			{
				for (int i = 0; i < array.Length; i++)
				{
					if (array[i] != null)
					{
						array7[num++] = array[i];
					}
				}
			}
			if (array2 != null)
			{
				foreach (ConstructorInfo constructorInfo in array2)
				{
					if ((object)constructorInfo != null)
					{
						array7[num++] = constructorInfo;
					}
				}
			}
			if (array3 != null)
			{
				foreach (FieldInfo fieldInfo in array3)
				{
					if ((object)fieldInfo != null)
					{
						array7[num++] = fieldInfo;
					}
				}
			}
			if (array4 != null)
			{
				foreach (PropertyInfo propertyInfo in array4)
				{
					if ((object)propertyInfo != null)
					{
						array7[num++] = propertyInfo;
					}
				}
			}
			if (array5 != null)
			{
				foreach (EventInfo eventInfo in array5)
				{
					if ((object)eventInfo != null)
					{
						array7[num++] = eventInfo;
					}
				}
			}
			if (array6 != null)
			{
				foreach (Type type in array6)
				{
					if ((object)type != null)
					{
						array7[num++] = type;
					}
				}
			}
			return array7;
		}

		public virtual bool IsSubclassOf(Type c)
		{
			Type type = this;
			if (type == c)
			{
				return false;
			}
			while (type != null)
			{
				if (type == c)
				{
					return true;
				}
				type = type.BaseType;
			}
			return false;
		}

		[Intrinsic]
		public virtual bool IsAssignableFrom([NotNullWhen(true)] Type? c)
		{
			if (c == null)
			{
				return false;
			}
			if (this == c)
			{
				return true;
			}
			Type underlyingSystemType = UnderlyingSystemType;
			if ((object)underlyingSystemType != null && underlyingSystemType.IsRuntimeImplemented())
			{
				return underlyingSystemType.IsAssignableFrom(c);
			}
			if (c.IsSubclassOf(this))
			{
				return true;
			}
			if (IsInterface)
			{
				return c.ImplementInterface(this);
			}
			if (IsGenericParameter)
			{
				Type[] genericParameterConstraints = GetGenericParameterConstraints();
				for (int i = 0; i < genericParameterConstraints.Length; i++)
				{
					if (!genericParameterConstraints[i].IsAssignableFrom(c))
					{
						return false;
					}
				}
				return true;
			}
			return false;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2085:UnrecognizedReflectionPattern", Justification = "The GetInterfaces technically requires all interfaces to be preservedBut this method only compares the result against the passed in ifaceType.So if ifaceType exists, then trimming should have kept it implemented on any type.")]
		internal bool ImplementInterface(Type ifaceType)
		{
			Type type = this;
			while (type != null)
			{
				Type[] interfaces = type.GetInterfaces();
				if (interfaces != null)
				{
					for (int i = 0; i < interfaces.Length; i++)
					{
						if (interfaces[i] == ifaceType || (interfaces[i] != null && interfaces[i].ImplementInterface(ifaceType)))
						{
							return true;
						}
					}
				}
				type = type.BaseType;
			}
			return false;
		}

		private static bool FilterAttributeImpl(MemberInfo m, object filterCriteria)
		{
			if (filterCriteria == null)
			{
				throw new InvalidFilterCriteriaException(SR.InvalidFilterCriteriaException_CritInt);
			}
			switch (m.MemberType)
			{
			case MemberTypes.Constructor:
			case MemberTypes.Method:
			{
				MethodAttributes methodAttributes;
				try
				{
					int num2 = (int)filterCriteria;
					methodAttributes = (MethodAttributes)num2;
				}
				catch
				{
					throw new InvalidFilterCriteriaException(SR.InvalidFilterCriteriaException_CritInt);
				}
				MethodAttributes methodAttributes2 = ((m.MemberType != MemberTypes.Method) ? ((ConstructorInfo)m).Attributes : ((MethodInfo)m).Attributes);
				if ((methodAttributes & MethodAttributes.MemberAccessMask) != 0 && (methodAttributes2 & MethodAttributes.MemberAccessMask) != (methodAttributes & MethodAttributes.MemberAccessMask))
				{
					return false;
				}
				if ((methodAttributes & MethodAttributes.Static) != 0 && (methodAttributes2 & MethodAttributes.Static) == 0)
				{
					return false;
				}
				if ((methodAttributes & MethodAttributes.Final) != 0 && (methodAttributes2 & MethodAttributes.Final) == 0)
				{
					return false;
				}
				if ((methodAttributes & MethodAttributes.Virtual) != 0 && (methodAttributes2 & MethodAttributes.Virtual) == 0)
				{
					return false;
				}
				if ((methodAttributes & MethodAttributes.Abstract) != 0 && (methodAttributes2 & MethodAttributes.Abstract) == 0)
				{
					return false;
				}
				if ((methodAttributes & MethodAttributes.SpecialName) != 0 && (methodAttributes2 & MethodAttributes.SpecialName) == 0)
				{
					return false;
				}
				return true;
			}
			case MemberTypes.Field:
			{
				FieldAttributes fieldAttributes;
				try
				{
					int num = (int)filterCriteria;
					fieldAttributes = (FieldAttributes)num;
				}
				catch
				{
					throw new InvalidFilterCriteriaException(SR.InvalidFilterCriteriaException_CritInt);
				}
				FieldAttributes attributes = ((FieldInfo)m).Attributes;
				if ((fieldAttributes & FieldAttributes.FieldAccessMask) != 0 && (attributes & FieldAttributes.FieldAccessMask) != (fieldAttributes & FieldAttributes.FieldAccessMask))
				{
					return false;
				}
				if ((fieldAttributes & FieldAttributes.Static) != 0 && (attributes & FieldAttributes.Static) == 0)
				{
					return false;
				}
				if ((fieldAttributes & FieldAttributes.InitOnly) != 0 && (attributes & FieldAttributes.InitOnly) == 0)
				{
					return false;
				}
				if ((fieldAttributes & FieldAttributes.Literal) != 0 && (attributes & FieldAttributes.Literal) == 0)
				{
					return false;
				}
				if ((fieldAttributes & FieldAttributes.NotSerialized) != 0 && (attributes & FieldAttributes.NotSerialized) == 0)
				{
					return false;
				}
				if ((fieldAttributes & FieldAttributes.PinvokeImpl) != 0 && (attributes & FieldAttributes.PinvokeImpl) == 0)
				{
					return false;
				}
				return true;
			}
			default:
				return false;
			}
		}

		private static bool FilterNameImpl(MemberInfo m, object filterCriteria, StringComparison comparison)
		{
			if (!(filterCriteria is string text))
			{
				throw new InvalidFilterCriteriaException(SR.InvalidFilterCriteriaException_CritString);
			}
			ReadOnlySpan<char> readOnlySpan = text.AsSpan().Trim();
			ReadOnlySpan<char> span = m.Name;
			if (m.MemberType == MemberTypes.NestedType)
			{
				span = span.Slice(span.LastIndexOf('+') + 1);
			}
			if (readOnlySpan.Length > 0 && readOnlySpan[readOnlySpan.Length - 1] == '*')
			{
				readOnlySpan = readOnlySpan.Slice(0, readOnlySpan.Length - 1);
				return span.StartsWith(readOnlySpan, comparison);
			}
			return MemoryExtensions.Equals(span, readOnlySpan, comparison);
		}
	}
	[CLSCompliant(false)]
	[NonVersionable]
	public ref struct TypedReference
	{
		private readonly ByReference<byte> _value;

		private readonly IntPtr _type;

		internal bool IsNull
		{
			get
			{
				if (Unsafe.IsNullRef(ref _value.Value))
				{
					return _type == IntPtr.Zero;
				}
				return false;
			}
		}

		public unsafe static TypedReference MakeTypedReference(object target, FieldInfo[] flds)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (flds == null)
			{
				throw new ArgumentNullException("flds");
			}
			if (flds.Length == 0)
			{
				throw new ArgumentException(SR.Arg_ArrayZeroError, "flds");
			}
			IntPtr[] array = new IntPtr[flds.Length];
			RuntimeType runtimeType = (RuntimeType)target.GetType();
			for (int i = 0; i < flds.Length; i++)
			{
				RuntimeFieldInfo runtimeFieldInfo = flds[i] as RuntimeFieldInfo;
				if (runtimeFieldInfo == null)
				{
					throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo);
				}
				if (runtimeFieldInfo.IsStatic)
				{
					throw new ArgumentException(SR.Format(SR.Argument_TypedReferenceInvalidField, runtimeFieldInfo.Name));
				}
				if (runtimeType != runtimeFieldInfo.GetDeclaringTypeInternal() && !runtimeType.IsSubclassOf(runtimeFieldInfo.GetDeclaringTypeInternal()))
				{
					throw new MissingMemberException(SR.MissingMemberTypeRef);
				}
				RuntimeType runtimeType2 = (RuntimeType)runtimeFieldInfo.FieldType;
				if (runtimeType2.IsPrimitive)
				{
					throw new ArgumentException(SR.Format(SR.Arg_TypeRefPrimitve, runtimeFieldInfo.Name));
				}
				if (i < flds.Length - 1 && !runtimeType2.IsValueType)
				{
					throw new MissingMemberException(SR.MissingMemberNestErr);
				}
				array[i] = runtimeFieldInfo.FieldHandle.Value;
				runtimeType = runtimeType2;
			}
			TypedReference result = default(TypedReference);
			InternalMakeTypedReference(&result, target, array, runtimeType);
			return result;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void InternalMakeTypedReference(void* result, object target, IntPtr[] flds, RuntimeType lastFieldType);

		public override int GetHashCode()
		{
			if (_type == IntPtr.Zero)
			{
				return 0;
			}
			return __reftype(this).GetHashCode();
		}

		public override bool Equals(object? o)
		{
			throw new NotSupportedException(SR.NotSupported_NYI);
		}

		public unsafe static object ToObject(TypedReference value)
		{
			return InternalToObject(&value);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern object InternalToObject(void* value);

		public static Type GetTargetType(TypedReference value)
		{
			return __reftype(value);
		}

		public static RuntimeTypeHandle TargetTypeToken(TypedReference value)
		{
			return __reftype(value).TypeHandle;
		}

		public static void SetTypedReference(TypedReference target, object? value)
		{
			throw new NotSupportedException();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class TypeLoadException : SystemException, ISerializable
	{
		private string _className;

		private string _assemblyName;

		private readonly string _messageArg;

		private readonly int _resourceId;

		public override string Message
		{
			get
			{
				SetMessageField();
				return _message;
			}
		}

		public string TypeName => _className ?? string.Empty;

		private TypeLoadException(string className, string assemblyName, string messageArg, int resourceId)
			: base(null)
		{
			base.HResult = -2146233054;
			_className = className;
			_assemblyName = assemblyName;
			_messageArg = messageArg;
			_resourceId = resourceId;
			SetMessageField();
		}

		private void SetMessageField()
		{
			if (_message != null)
			{
				return;
			}
			if (_className == null && _resourceId == 0)
			{
				_message = SR.Arg_TypeLoadException;
				return;
			}
			if (_assemblyName == null)
			{
				_assemblyName = SR.IO_UnknownFileName;
			}
			if (_className == null)
			{
				_className = SR.IO_UnknownFileName;
			}
			string s = null;
			GetTypeLoadExceptionMessage(_resourceId, new StringHandleOnStack(ref s));
			_message = string.Format(s, _className, _assemblyName, _messageArg);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetTypeLoadExceptionMessage(int resourceId, StringHandleOnStack retString);

		public TypeLoadException()
			: base(SR.Arg_TypeLoadException)
		{
			base.HResult = -2146233054;
		}

		public TypeLoadException(string? message)
			: base(message)
		{
			base.HResult = -2146233054;
		}

		public TypeLoadException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233054;
		}

		protected TypeLoadException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_className = info.GetString("TypeLoadClassName");
			_assemblyName = info.GetString("TypeLoadAssemblyName");
			_messageArg = info.GetString("TypeLoadMessageArg");
			_resourceId = info.GetInt32("TypeLoadResourceID");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("TypeLoadClassName", _className, typeof(string));
			info.AddValue("TypeLoadAssemblyName", _assemblyName, typeof(string));
			info.AddValue("TypeLoadMessageArg", _messageArg, typeof(string));
			info.AddValue("TypeLoadResourceID", _resourceId);
		}
	}
	internal sealed class SafeTypeNameParserHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _ReleaseTypeNameParser(IntPtr pTypeNameParser);

		public SafeTypeNameParserHandle()
			: base(ownsHandle: true)
		{
		}

		protected override bool ReleaseHandle()
		{
			_ReleaseTypeNameParser(handle);
			handle = IntPtr.Zero;
			return true;
		}
	}
	internal sealed class TypeNameParser : IDisposable
	{
		private readonly SafeTypeNameParserHandle m_NativeParser;

		private static readonly char[] SPECIAL_CHARS = new char[7] { ',', '[', ']', '&', '*', '+', '\\' };

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _CreateTypeNameParser(string typeName, ObjectHandleOnStack retHandle, bool throwOnError);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _GetNames(SafeTypeNameParserHandle pTypeNameParser, ObjectHandleOnStack retArray);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _GetTypeArguments(SafeTypeNameParserHandle pTypeNameParser, ObjectHandleOnStack retArray);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _GetModifiers(SafeTypeNameParserHandle pTypeNameParser, ObjectHandleOnStack retArray);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _GetAssemblyName(SafeTypeNameParserHandle pTypeNameParser, StringHandleOnStack retString);

		[RequiresUnreferencedCode("The type might be removed")]
		internal static Type GetType(string typeName, Func<AssemblyName, Assembly> assemblyResolver, Func<Assembly, string, bool, Type> typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
		{
			if (typeName == null)
			{
				throw new ArgumentNullException("typeName");
			}
			if (typeName.Length > 0 && typeName[0] == '\0')
			{
				throw new ArgumentException(SR.Format_StringZeroLength);
			}
			Type result = null;
			SafeTypeNameParserHandle safeTypeNameParserHandle = CreateTypeNameParser(typeName, throwOnError);
			if (safeTypeNameParserHandle != null)
			{
				using TypeNameParser typeNameParser = new TypeNameParser(safeTypeNameParserHandle);
				result = typeNameParser.ConstructType(assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
			}
			return result;
		}

		private TypeNameParser(SafeTypeNameParserHandle handle)
		{
			m_NativeParser = handle;
		}

		public void Dispose()
		{
			m_NativeParser.Dispose();
		}

		[RequiresUnreferencedCode("The type might be removed")]
		private unsafe Type ConstructType(Func<AssemblyName, Assembly> assemblyResolver, Func<Assembly, string, bool, Type> typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
		{
			Assembly assembly = null;
			string assemblyName = GetAssemblyName();
			if (assemblyName.Length > 0)
			{
				assembly = ResolveAssembly(assemblyName, assemblyResolver, throwOnError, ref stackMark);
				if (assembly == null)
				{
					return null;
				}
			}
			string[] names = GetNames();
			if (names == null)
			{
				if (throwOnError)
				{
					throw new TypeLoadException(SR.Arg_TypeLoadNullStr);
				}
				return null;
			}
			Type type = ResolveType(assembly, names, typeResolver, throwOnError, ignoreCase, ref stackMark);
			if (type == null)
			{
				return null;
			}
			SafeTypeNameParserHandle[] typeArguments = GetTypeArguments();
			Type[] array = null;
			if (typeArguments != null)
			{
				array = new Type[typeArguments.Length];
				for (int i = 0; i < typeArguments.Length; i++)
				{
					using (TypeNameParser typeNameParser = new TypeNameParser(typeArguments[i]))
					{
						array[i] = typeNameParser.ConstructType(assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
					}
					if (array[i] == null)
					{
						return null;
					}
				}
			}
			int[] modifiers = GetModifiers();
			fixed (int* value = modifiers)
			{
				IntPtr pModifiers = new IntPtr(value);
				return RuntimeTypeHandle.GetTypeHelper(type, array, pModifiers, (modifiers != null) ? modifiers.Length : 0);
			}
		}

		private static Assembly ResolveAssembly(string asmName, Func<AssemblyName, Assembly> assemblyResolver, bool throwOnError, ref StackCrawlMark stackMark)
		{
			Assembly assembly;
			if (assemblyResolver == null)
			{
				if (throwOnError)
				{
					assembly = RuntimeAssembly.InternalLoad(asmName, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext);
				}
				else
				{
					try
					{
						assembly = RuntimeAssembly.InternalLoad(asmName, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext);
					}
					catch (FileNotFoundException)
					{
						return null;
					}
				}
			}
			else
			{
				assembly = assemblyResolver(new AssemblyName(asmName));
				if (assembly == null && throwOnError)
				{
					throw new FileNotFoundException(SR.Format(SR.FileNotFound_ResolveAssembly, asmName));
				}
			}
			return assembly;
		}

		[RequiresUnreferencedCode("The type might be removed")]
		private static Type ResolveType(Assembly assembly, string[] names, Func<Assembly, string, bool, Type> typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
		{
			string text = EscapeTypeName(names[0]);
			Type type;
			if (typeResolver == null)
			{
				type = ((!(assembly == null)) ? assembly.GetType(text, throwOnError, ignoreCase) : RuntimeType.GetType(text, throwOnError, ignoreCase, ref stackMark));
			}
			else
			{
				type = typeResolver(assembly, text, ignoreCase);
				if (type == null && throwOnError)
				{
					string message = ((assembly == null) ? SR.Format(SR.TypeLoad_ResolveType, text) : SR.Format(SR.TypeLoad_ResolveTypeFromAssembly, text, assembly.FullName));
					throw new TypeLoadException(message);
				}
			}
			if (type != null)
			{
				BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic;
				if (ignoreCase)
				{
					bindingFlags |= BindingFlags.IgnoreCase;
				}
				for (int i = 1; i < names.Length; i++)
				{
					type = type.GetNestedType(names[i], bindingFlags);
					if (type == null)
					{
						if (!throwOnError)
						{
							break;
						}
						throw new TypeLoadException(SR.Format(SR.TypeLoad_ResolveNestedType, names[i], names[i - 1]));
					}
				}
			}
			return type;
		}

		private static string EscapeTypeName(string name)
		{
			if (name.IndexOfAny(SPECIAL_CHARS) < 0)
			{
				return name;
			}
			Span<char> initialBuffer = stackalloc char[64];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			foreach (char c in name)
			{
				if (Array.IndexOf(SPECIAL_CHARS, c) >= 0)
				{
					valueStringBuilder.Append('\\');
				}
				valueStringBuilder.Append(c);
			}
			return valueStringBuilder.ToString();
		}

		private static SafeTypeNameParserHandle CreateTypeNameParser(string typeName, bool throwOnError)
		{
			SafeTypeNameParserHandle o = null;
			_CreateTypeNameParser(typeName, ObjectHandleOnStack.Create(ref o), throwOnError);
			return o;
		}

		private string[] GetNames()
		{
			string[] o = null;
			_GetNames(m_NativeParser, ObjectHandleOnStack.Create(ref o));
			return o;
		}

		private SafeTypeNameParserHandle[] GetTypeArguments()
		{
			SafeTypeNameParserHandle[] o = null;
			_GetTypeArguments(m_NativeParser, ObjectHandleOnStack.Create(ref o));
			return o;
		}

		private int[] GetModifiers()
		{
			int[] o = null;
			_GetModifiers(m_NativeParser, ObjectHandleOnStack.Create(ref o));
			return o;
		}

		private string GetAssemblyName()
		{
			string s = null;
			_GetAssemblyName(m_NativeParser, new StringHandleOnStack(ref s));
			return s;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public abstract class ValueType
	{
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "Trimmed fields don't make a difference for equality")]
		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			Type type = GetType();
			Type type2 = obj.GetType();
			if (type2 != type)
			{
				return false;
			}
			if (CanCompareBits(this))
			{
				return FastEqualsCheck(this, obj);
			}
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			for (int i = 0; i < fields.Length; i++)
			{
				object value = fields[i].GetValue(this);
				object value2 = fields[i].GetValue(obj);
				if (value == null)
				{
					if (value2 != null)
					{
						return false;
					}
				}
				else if (!value.Equals(value2))
				{
					return false;
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool CanCompareBits(object obj);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool FastEqualsCheck(object a, object b);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public override extern int GetHashCode();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetHashCodeOfPtr(IntPtr ptr);

		public override string? ToString()
		{
			return GetType().ToString();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class WeakReference : ISerializable
	{
		internal IntPtr m_handle;

		public virtual extern bool IsAlive
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		public virtual bool TrackResurrection => IsTrackResurrection();

		public virtual extern object? Target
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			set;
		}

		protected WeakReference()
		{
			throw new NotImplementedException();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		extern ~WeakReference();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Create(object target, bool trackResurrection);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern bool IsTrackResurrection();

		public WeakReference(object? target)
			: this(target, trackResurrection: false)
		{
		}

		public WeakReference(object? target, bool trackResurrection)
		{
			Create(target, trackResurrection);
		}

		protected WeakReference(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			object value = info.GetValue("TrackedObject", typeof(object));
			bool boolean = info.GetBoolean("TrackResurrection");
			Create(value, boolean);
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("TrackedObject", Target, typeof(object));
			info.AddValue("TrackResurrection", IsTrackResurrection());
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class WeakReference<T> : ISerializable where T : class?
	{
		internal IntPtr m_handle;

		private extern T Target
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[return: MaybeNull]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			set;
		}

		public void SetTarget(T target)
		{
			Target = target;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		extern ~WeakReference();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Create(T target, bool trackResurrection);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern bool IsTrackResurrection();

		public WeakReference(T target)
			: this(target, trackResurrection: false)
		{
		}

		public WeakReference(T target, bool trackResurrection)
		{
			Create(target, trackResurrection);
		}

		private WeakReference(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			T target = (T)info.GetValue("TrackedObject", typeof(T));
			bool boolean = info.GetBoolean("TrackResurrection");
			Create(target, boolean);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryGetTarget([MaybeNullWhen(false)][NotNullWhen(true)] out T target)
		{
			return (target = Target) != null;
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("TrackedObject", Target, typeof(T));
			info.AddValue("TrackResurrection", IsTrackResurrection());
		}
	}
	[SupportedOSPlatform("windows")]
	internal class __ComObject : MarshalByRefObject
	{
		private Hashtable m_ObjectToDataMap;

		protected __ComObject()
		{
		}

		internal object GetData(object key)
		{
			object result = null;
			lock (this)
			{
				if (m_ObjectToDataMap != null)
				{
					result = m_ObjectToDataMap[key];
				}
			}
			return result;
		}

		internal bool SetData(object key, object data)
		{
			bool result = false;
			lock (this)
			{
				if (m_ObjectToDataMap == null)
				{
					m_ObjectToDataMap = new Hashtable();
				}
				if (m_ObjectToDataMap[key] == null)
				{
					m_ObjectToDataMap[key] = data;
					result = true;
				}
			}
			return result;
		}

		internal void ReleaseAllData()
		{
			lock (this)
			{
				if (m_ObjectToDataMap == null)
				{
					return;
				}
				foreach (object value in m_ObjectToDataMap.Values)
				{
					if (value is IDisposable disposable)
					{
						disposable.Dispose();
					}
					if (value is __ComObject o)
					{
						Marshal.ReleaseComObject(o);
					}
				}
				m_ObjectToDataMap = null;
			}
		}

		internal object GetEventProvider([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] RuntimeType t)
		{
			object data = GetData(t);
			if (data != null)
			{
				return data;
			}
			return CreateEventProvider(t);
		}

		internal int ReleaseSelf()
		{
			return Marshal.InternalReleaseComObject(this);
		}

		internal void FinalReleaseSelf()
		{
			Marshal.InternalFinalReleaseComObject(this);
		}

		private object CreateEventProvider([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] RuntimeType t)
		{
			object obj = Activator.CreateInstance(t, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance, null, new object[1] { this }, null);
			if (!SetData(t, obj))
			{
				if (obj is IDisposable disposable)
				{
					disposable.Dispose();
				}
				obj = GetData(t);
			}
			return obj;
		}
	}
	internal sealed class OleAutBinder : DefaultBinder
	{
		public override object ChangeType(object value, Type type, CultureInfo cultureInfo)
		{
			Variant source = new Variant(value);
			if (cultureInfo == null)
			{
				cultureInfo = CultureInfo.CurrentCulture;
			}
			if (type.IsByRef)
			{
				type = type.GetElementType();
			}
			if (!type.IsPrimitive && type.IsInstanceOfType(value))
			{
				return value;
			}
			Type type2 = value.GetType();
			if (type.IsEnum && type2.IsPrimitive)
			{
				return Enum.Parse(type, value.ToString());
			}
			try
			{
				return OAVariantLib.ChangeType(source, type, 16, cultureInfo).ToObject();
			}
			catch (NotSupportedException)
			{
				throw new COMException(SR.Interop_COM_TypeMismatch, -2147352571);
			}
		}
	}
	internal struct Variant
	{
		private object _objref;

		private long _data;

		private int _flags;

		internal const int CV_EMPTY = 0;

		internal const int CV_VOID = 1;

		internal const int CV_BOOLEAN = 2;

		internal const int CV_CHAR = 3;

		internal const int CV_I1 = 4;

		internal const int CV_U1 = 5;

		internal const int CV_I2 = 6;

		internal const int CV_U2 = 7;

		internal const int CV_I4 = 8;

		internal const int CV_U4 = 9;

		internal const int CV_I8 = 10;

		internal const int CV_U8 = 11;

		internal const int CV_R4 = 12;

		internal const int CV_R8 = 13;

		internal const int CV_STRING = 14;

		internal const int CV_PTR = 15;

		internal const int CV_DATETIME = 16;

		internal const int CV_TIMESPAN = 17;

		internal const int CV_OBJECT = 18;

		internal const int CV_DECIMAL = 19;

		internal const int CV_ENUM = 21;

		internal const int CV_MISSING = 22;

		internal const int CV_NULL = 23;

		internal const int CV_LAST = 24;

		internal const int TypeCodeBitMask = 65535;

		internal const int VTBitMask = -16777216;

		internal const int VTBitShift = 24;

		internal const int ArrayBitMask = 65536;

		internal const int EnumI1 = 1048576;

		internal const int EnumU1 = 2097152;

		internal const int EnumI2 = 3145728;

		internal const int EnumU2 = 4194304;

		internal const int EnumI4 = 5242880;

		internal const int EnumU4 = 6291456;

		internal const int EnumI8 = 7340032;

		internal const int EnumU8 = 8388608;

		internal const int EnumMask = 15728640;

		internal static readonly Type[] ClassTypes = new Type[23]
		{
			typeof(Empty),
			typeof(void),
			typeof(bool),
			typeof(char),
			typeof(sbyte),
			typeof(byte),
			typeof(short),
			typeof(ushort),
			typeof(int),
			typeof(uint),
			typeof(long),
			typeof(ulong),
			typeof(float),
			typeof(double),
			typeof(string),
			typeof(void),
			typeof(DateTime),
			typeof(TimeSpan),
			typeof(object),
			typeof(decimal),
			typeof(object),
			typeof(Missing),
			typeof(DBNull)
		};

		internal static readonly Variant Empty;

		internal static readonly Variant Missing = new Variant(22, Type.Missing, 0L);

		internal static readonly Variant DBNull = new Variant(23, System.DBNull.Value, 0L);

		internal int CVType => _flags & 0xFFFF;

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern void SetFieldsObject(object val);

		internal Variant(int flags, object or, long data)
		{
			_flags = flags;
			_objref = or;
			_data = data;
		}

		public Variant(bool val)
		{
			_objref = null;
			_flags = 2;
			_data = (val ? 1 : 0);
		}

		public Variant(sbyte val)
		{
			_objref = null;
			_flags = 4;
			_data = val;
		}

		public Variant(byte val)
		{
			_objref = null;
			_flags = 5;
			_data = val;
		}

		public Variant(short val)
		{
			_objref = null;
			_flags = 6;
			_data = val;
		}

		public Variant(ushort val)
		{
			_objref = null;
			_flags = 7;
			_data = val;
		}

		public Variant(char val)
		{
			_objref = null;
			_flags = 3;
			_data = val;
		}

		public Variant(int val)
		{
			_objref = null;
			_flags = 8;
			_data = val;
		}

		public Variant(uint val)
		{
			_objref = null;
			_flags = 9;
			_data = val;
		}

		public Variant(long val)
		{
			_objref = null;
			_flags = 10;
			_data = val;
		}

		public Variant(ulong val)
		{
			_objref = null;
			_flags = 11;
			_data = (long)val;
		}

		public Variant(float val)
		{
			_objref = null;
			_flags = 12;
			_data = BitConverter.SingleToUInt32Bits(val);
		}

		public Variant(double val)
		{
			_objref = null;
			_flags = 13;
			_data = BitConverter.DoubleToInt64Bits(val);
		}

		public Variant(DateTime val)
		{
			_objref = null;
			_flags = 16;
			_data = val.Ticks;
		}

		public Variant(decimal val)
		{
			_objref = val;
			_flags = 19;
			_data = 0L;
		}

		public Variant(object obj)
		{
			_data = 0L;
			VarEnum varEnum = VarEnum.VT_EMPTY;
			if (obj is DateTime)
			{
				_objref = null;
				_flags = 16;
				_data = ((DateTime)obj).Ticks;
				return;
			}
			if (obj is string)
			{
				_flags = 14;
				_objref = obj;
				return;
			}
			if (obj == null)
			{
				this = Empty;
				return;
			}
			if (obj == System.DBNull.Value)
			{
				this = DBNull;
				return;
			}
			if (obj == Type.Missing)
			{
				this = Missing;
				return;
			}
			if (obj is Array)
			{
				_flags = 65554;
				_objref = obj;
				return;
			}
			_flags = 0;
			_objref = null;
			if (obj is UnknownWrapper)
			{
				varEnum = VarEnum.VT_UNKNOWN;
				obj = ((UnknownWrapper)obj).WrappedObject;
			}
			else if (obj is DispatchWrapper)
			{
				varEnum = VarEnum.VT_DISPATCH;
				obj = ((DispatchWrapper)obj).WrappedObject;
			}
			else if (obj is ErrorWrapper)
			{
				varEnum = VarEnum.VT_ERROR;
				obj = ((ErrorWrapper)obj).ErrorCode;
			}
			else if (obj is CurrencyWrapper)
			{
				varEnum = VarEnum.VT_CY;
				obj = ((CurrencyWrapper)obj).WrappedObject;
			}
			else if (obj is BStrWrapper)
			{
				varEnum = VarEnum.VT_BSTR;
				obj = ((BStrWrapper)obj).WrappedObject;
			}
			if (obj != null)
			{
				SetFieldsObject(obj);
			}
			if (varEnum != 0)
			{
				_flags |= (int)varEnum << 24;
			}
		}

		public object ToObject()
		{
			return CVType switch
			{
				0 => null, 
				2 => (int)_data != 0, 
				4 => (sbyte)_data, 
				5 => (byte)_data, 
				3 => (char)_data, 
				6 => (short)_data, 
				7 => (ushort)_data, 
				8 => (int)_data, 
				9 => (uint)_data, 
				10 => _data, 
				11 => (ulong)_data, 
				12 => BitConverter.UInt32BitsToSingle((uint)_data), 
				13 => BitConverter.Int64BitsToDouble(_data), 
				16 => new DateTime(_data), 
				17 => new TimeSpan(_data), 
				21 => BoxEnum(), 
				22 => Type.Missing, 
				23 => System.DBNull.Value, 
				_ => _objref, 
			};
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern object BoxEnum();

		internal static void MarshalHelperConvertObjectToVariant(object o, ref Variant v)
		{
			if (o == null)
			{
				v = Empty;
			}
			else if (o is IConvertible convertible)
			{
				IFormatProvider invariantCulture = CultureInfo.InvariantCulture;
				v = convertible.GetTypeCode() switch
				{
					TypeCode.Empty => Empty, 
					TypeCode.Object => new Variant(o), 
					TypeCode.DBNull => DBNull, 
					TypeCode.Boolean => new Variant(convertible.ToBoolean(invariantCulture)), 
					TypeCode.Char => new Variant(convertible.ToChar(invariantCulture)), 
					TypeCode.SByte => new Variant(convertible.ToSByte(invariantCulture)), 
					TypeCode.Byte => new Variant(convertible.ToByte(invariantCulture)), 
					TypeCode.Int16 => new Variant(convertible.ToInt16(invariantCulture)), 
					TypeCode.UInt16 => new Variant(convertible.ToUInt16(invariantCulture)), 
					TypeCode.Int32 => new Variant(convertible.ToInt32(invariantCulture)), 
					TypeCode.UInt32 => new Variant(convertible.ToUInt32(invariantCulture)), 
					TypeCode.Int64 => new Variant(convertible.ToInt64(invariantCulture)), 
					TypeCode.UInt64 => new Variant(convertible.ToUInt64(invariantCulture)), 
					TypeCode.Single => new Variant(convertible.ToSingle(invariantCulture)), 
					TypeCode.Double => new Variant(convertible.ToDouble(invariantCulture)), 
					TypeCode.Decimal => new Variant(convertible.ToDecimal(invariantCulture)), 
					TypeCode.DateTime => new Variant(convertible.ToDateTime(invariantCulture)), 
					TypeCode.String => new Variant(convertible.ToString(invariantCulture)), 
					_ => throw new NotSupportedException(SR.Format(SR.NotSupported_UnknownTypeCode, convertible.GetTypeCode())), 
				};
			}
			else
			{
				v = new Variant(o);
			}
		}

		internal static object MarshalHelperConvertVariantToObject(ref Variant v)
		{
			return v.ToObject();
		}

		internal static void MarshalHelperCastVariant(object pValue, int vt, ref Variant v)
		{
			if (!(pValue is IConvertible convertible))
			{
				switch (vt)
				{
				case 9:
					v = new Variant(new DispatchWrapper(pValue));
					return;
				case 12:
					v = new Variant(pValue);
					return;
				case 13:
					v = new Variant(new UnknownWrapper(pValue));
					return;
				case 36:
					v = new Variant(pValue);
					return;
				case 8:
					if (pValue == null)
					{
						v = new Variant(null)
						{
							_flags = 14
						};
						return;
					}
					break;
				}
				throw new InvalidCastException(SR.InvalidCast_CannotCoerceByRefVariant);
			}
			IFormatProvider invariantCulture = CultureInfo.InvariantCulture;
			v = vt switch
			{
				0 => Empty, 
				1 => DBNull, 
				2 => new Variant(convertible.ToInt16(invariantCulture)), 
				3 => new Variant(convertible.ToInt32(invariantCulture)), 
				4 => new Variant(convertible.ToSingle(invariantCulture)), 
				5 => new Variant(convertible.ToDouble(invariantCulture)), 
				6 => new Variant(new CurrencyWrapper(convertible.ToDecimal(invariantCulture))), 
				7 => new Variant(convertible.ToDateTime(invariantCulture)), 
				8 => new Variant(convertible.ToString(invariantCulture)), 
				9 => new Variant(new DispatchWrapper(convertible)), 
				10 => new Variant(new ErrorWrapper(convertible.ToInt32(invariantCulture))), 
				11 => new Variant(convertible.ToBoolean(invariantCulture)), 
				12 => new Variant(convertible), 
				13 => new Variant(new UnknownWrapper(convertible)), 
				14 => new Variant(convertible.ToDecimal(invariantCulture)), 
				16 => new Variant(convertible.ToSByte(invariantCulture)), 
				17 => new Variant(convertible.ToByte(invariantCulture)), 
				18 => new Variant(convertible.ToUInt16(invariantCulture)), 
				19 => new Variant(convertible.ToUInt32(invariantCulture)), 
				20 => new Variant(convertible.ToInt64(invariantCulture)), 
				21 => new Variant(convertible.ToUInt64(invariantCulture)), 
				22 => new Variant(convertible.ToInt32(invariantCulture)), 
				23 => new Variant(convertible.ToUInt32(invariantCulture)), 
				_ => throw new InvalidCastException(SR.InvalidCast_CannotCoerceByRefVariant), 
			};
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class AccessViolationException : SystemException
	{
		private IntPtr _ip;

		private IntPtr _target;

		private int _accessType;

		public AccessViolationException()
			: base(SR.Arg_AccessViolationException)
		{
			base.HResult = -2147467261;
		}

		public AccessViolationException(string? message)
			: base(message)
		{
			base.HResult = -2147467261;
		}

		public AccessViolationException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147467261;
		}

		protected AccessViolationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public delegate void Action();
	public delegate void Action<in T>(T obj);
	public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
	public delegate void Action<in T1, in T2, in T3>(T1 arg1, T2 arg2, T3 arg3);
	public delegate void Action<in T1, in T2, in T3, in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);
	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);
	public delegate int Comparison<in T>(T x, T y);
	public delegate TOutput Converter<in TInput, out TOutput>(TInput input);
	public delegate bool Predicate<in T>(T obj);
	public static class Activator
	{
		[DebuggerHidden]
		[DebuggerStepThrough]
		public static object? CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type type, BindingFlags bindingAttr, Binder? binder, object?[]? args, CultureInfo? culture)
		{
			return CreateInstance(type, bindingAttr, binder, args, culture, null);
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public static object? CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type, params object?[]? args)
		{
			return CreateInstance(type, BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, null, args, null, null);
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public static object? CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type, object?[]? args, object?[]? activationAttributes)
		{
			return CreateInstance(type, BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, null, args, null, activationAttributes);
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public static object? CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type)
		{
			return CreateInstance(type, nonPublic: false);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public static ObjectHandle? CreateInstanceFrom(string assemblyFile, string typeName)
		{
			return CreateInstanceFrom(assemblyFile, typeName, ignoreCase: false, BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, null, null, null, null);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public static ObjectHandle? CreateInstanceFrom(string assemblyFile, string typeName, object?[]? activationAttributes)
		{
			return CreateInstanceFrom(assemblyFile, typeName, ignoreCase: false, BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, null, null, null, activationAttributes);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public static ObjectHandle? CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder? binder, object?[]? args, CultureInfo? culture, object?[]? activationAttributes)
		{
			Assembly assembly = Assembly.LoadFrom(assemblyFile);
			Type type = assembly.GetType(typeName, throwOnError: true, ignoreCase);
			object obj = CreateInstance(type, bindingAttr, binder, args, culture, activationAttributes);
			if (obj == null)
			{
				return null;
			}
			return new ObjectHandle(obj);
		}

		public static object? CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type type, BindingFlags bindingAttr, Binder? binder, object?[]? args, CultureInfo? culture, object?[]? activationAttributes)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (type is TypeBuilder)
			{
				throw new NotSupportedException(SR.NotSupported_CreateInstanceWithTypeBuilder);
			}
			if ((bindingAttr & (BindingFlags)255) == 0)
			{
				bindingAttr |= BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance;
			}
			if (activationAttributes != null && activationAttributes.Length != 0)
			{
				throw new PlatformNotSupportedException(SR.NotSupported_ActivAttr);
			}
			if (type.UnderlyingSystemType is RuntimeType runtimeType)
			{
				return runtimeType.CreateInstanceImpl(bindingAttr, binder, args, culture);
			}
			throw new ArgumentException(SR.Arg_MustBeType, "type");
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public static ObjectHandle? CreateInstance(string assemblyName, string typeName)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return CreateInstanceInternal(assemblyName, typeName, ignoreCase: false, BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, null, null, null, null, ref stackMark);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public static ObjectHandle? CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder? binder, object?[]? args, CultureInfo? culture, object?[]? activationAttributes)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return CreateInstanceInternal(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, ref stackMark);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public static ObjectHandle? CreateInstance(string assemblyName, string typeName, object?[]? activationAttributes)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return CreateInstanceInternal(assemblyName, typeName, ignoreCase: false, BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, null, null, null, activationAttributes, ref stackMark);
		}

		public static object? CreateInstance([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type type, bool nonPublic)
		{
			return CreateInstance(type, nonPublic, wrapExceptions: true);
		}

		internal static object CreateInstance(Type type, bool nonPublic, bool wrapExceptions)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!(type.UnderlyingSystemType is RuntimeType runtimeType))
			{
				throw new ArgumentException(SR.Arg_MustBeType, "type");
			}
			return runtimeType.CreateInstanceDefaultCtor(!nonPublic, wrapExceptions);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Implementation detail of Activator that linker intrinsically recognizes")]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2072:UnrecognizedReflectionPattern", Justification = "Implementation detail of Activator that linker intrinsically recognizes")]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2096:UnrecognizedReflectionPattern", Justification = "Implementation detail of Activator that linker intrinsically recognizes")]
		private static ObjectHandle CreateInstanceInternal(string assemblyString, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes, ref StackCrawlMark stackMark)
		{
			Assembly assembly;
			if (assemblyString == null)
			{
				assembly = Assembly.GetExecutingAssembly(ref stackMark);
			}
			else
			{
				AssemblyName assemblyName = new AssemblyName(assemblyString);
				assembly = RuntimeAssembly.InternalLoad(assemblyName, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext);
			}
			Type type = assembly.GetType(typeName, throwOnError: true, ignoreCase);
			object obj = CreateInstance(type, bindingAttr, binder, args, culture, activationAttributes);
			if (obj == null)
			{
				return null;
			}
			return new ObjectHandle(obj);
		}

		[Intrinsic]
		public static T CreateInstance<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>()
		{
			return (T)((RuntimeType)typeof(T)).CreateInstanceOfT();
		}

		private static T CreateDefaultInstance<T>() where T : struct
		{
			return default(T);
		}
	}
	[Serializable]
	[DebuggerDisplay("Count = {InnerExceptionCount}")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class AggregateException : Exception
	{
		private readonly Exception[] _innerExceptions;

		private ReadOnlyCollection<Exception> _rocView;

		public ReadOnlyCollection<Exception> InnerExceptions => _rocView ?? (_rocView = new ReadOnlyCollection<Exception>(_innerExceptions));

		public override string Message
		{
			get
			{
				if (_innerExceptions.Length == 0)
				{
					return base.Message;
				}
				StringBuilder stringBuilder = StringBuilderCache.Acquire();
				stringBuilder.Append(base.Message);
				stringBuilder.Append(' ');
				for (int i = 0; i < _innerExceptions.Length; i++)
				{
					stringBuilder.Append('(');
					stringBuilder.Append(_innerExceptions[i].Message);
					stringBuilder.Append(") ");
				}
				stringBuilder.Length--;
				return StringBuilderCache.GetStringAndRelease(stringBuilder);
			}
		}

		internal int InnerExceptionCount => _innerExceptions.Length;

		internal Exception[] InternalInnerExceptions => _innerExceptions;

		public AggregateException()
			: this(SR.AggregateException_ctor_DefaultMessage)
		{
		}

		public AggregateException(string? message)
			: base(message)
		{
			_innerExceptions = Array.Empty<Exception>();
		}

		public AggregateException(string? message, Exception innerException)
			: base(message, innerException)
		{
			if (innerException == null)
			{
				throw new ArgumentNullException("innerException");
			}
			_innerExceptions = new Exception[1] { innerException };
		}

		public AggregateException(IEnumerable<Exception> innerExceptions)
			: this(SR.AggregateException_ctor_DefaultMessage, innerExceptions)
		{
		}

		public AggregateException(params Exception[] innerExceptions)
			: this(SR.AggregateException_ctor_DefaultMessage, innerExceptions)
		{
		}

		public AggregateException(string? message, IEnumerable<Exception> innerExceptions)
			: this(message, (innerExceptions == null) ? null : new List<Exception>(innerExceptions).ToArray(), cloneExceptions: false)
		{
		}

		public AggregateException(string? message, params Exception[] innerExceptions)
			: this(message, innerExceptions, cloneExceptions: true)
		{
		}

		private AggregateException(string message, Exception[] innerExceptions, bool cloneExceptions)
			: base(message, (innerExceptions != null && innerExceptions.Length != 0) ? innerExceptions[0] : null)
		{
			if (innerExceptions == null)
			{
				throw new ArgumentNullException("innerExceptions");
			}
			_innerExceptions = (cloneExceptions ? new Exception[innerExceptions.Length] : innerExceptions);
			for (int i = 0; i < _innerExceptions.Length; i++)
			{
				_innerExceptions[i] = innerExceptions[i];
				if (innerExceptions[i] == null)
				{
					throw new ArgumentException(SR.AggregateException_ctor_InnerExceptionNull);
				}
			}
		}

		internal AggregateException(List<ExceptionDispatchInfo> innerExceptionInfos)
			: this(SR.AggregateException_ctor_DefaultMessage, innerExceptionInfos)
		{
		}

		internal AggregateException(string message, List<ExceptionDispatchInfo> innerExceptionInfos)
			: base(message, (innerExceptionInfos.Count != 0) ? innerExceptionInfos[0].SourceException : null)
		{
			_innerExceptions = new Exception[innerExceptionInfos.Count];
			for (int i = 0; i < _innerExceptions.Length; i++)
			{
				_innerExceptions[i] = innerExceptionInfos[i].SourceException;
			}
		}

		protected AggregateException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			if (!(info.GetValue("InnerExceptions", typeof(Exception[])) is Exception[] innerExceptions))
			{
				throw new SerializationException(SR.AggregateException_DeserializationFailure);
			}
			_innerExceptions = innerExceptions;
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("InnerExceptions", _innerExceptions, typeof(Exception[]));
		}

		public override Exception GetBaseException()
		{
			Exception ex = this;
			AggregateException ex2 = this;
			while (ex2 != null && ex2.InnerExceptions.Count == 1)
			{
				ex = ex.InnerException;
				ex2 = ex as AggregateException;
			}
			return ex;
		}

		public void Handle(Func<Exception, bool> predicate)
		{
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			List<Exception> list = null;
			for (int i = 0; i < _innerExceptions.Length; i++)
			{
				if (!predicate(_innerExceptions[i]))
				{
					if (list == null)
					{
						list = new List<Exception>();
					}
					list.Add(_innerExceptions[i]);
				}
			}
			if (list != null)
			{
				throw new AggregateException(Message, list.ToArray(), cloneExceptions: false);
			}
		}

		public AggregateException Flatten()
		{
			List<Exception> list = new List<Exception>();
			List<AggregateException> list2 = new List<AggregateException> { this };
			int num = 0;
			while (list2.Count > num)
			{
				ReadOnlyCollection<Exception> innerExceptions = list2[num++].InnerExceptions;
				for (int i = 0; i < innerExceptions.Count; i++)
				{
					Exception ex = innerExceptions[i];
					if (ex != null)
					{
						if (ex is AggregateException item)
						{
							list2.Add(item);
						}
						else
						{
							list.Add(ex);
						}
					}
				}
			}
			return new AggregateException((GetType() == typeof(AggregateException)) ? base.Message : Message, list.ToArray(), cloneExceptions: false);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(base.ToString());
			for (int i = 0; i < _innerExceptions.Length; i++)
			{
				if (_innerExceptions[i] != base.InnerException)
				{
					stringBuilder.Append("\r\n ---> ");
					stringBuilder.AppendFormat(CultureInfo.InvariantCulture, SR.AggregateException_InnerException, i);
					stringBuilder.Append(_innerExceptions[i].ToString());
					stringBuilder.Append("<---");
					stringBuilder.AppendLine();
				}
			}
			return stringBuilder.ToString();
		}
	}
	public static class AppContext
	{
		private static Dictionary<string, object> s_dataStore;

		private static Dictionary<string, bool> s_switches;

		private static string s_defaultBaseDirectory;

		public static string BaseDirectory => (GetData("APP_CONTEXT_BASE_DIRECTORY") as string) ?? s_defaultBaseDirectory ?? (s_defaultBaseDirectory = GetBaseDirectoryCore());

		public static string? TargetFrameworkName => Assembly.GetEntryAssembly()?.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName;

		[field: DynamicDependency(DynamicallyAccessedMemberTypes.PublicConstructors, typeof(UnhandledExceptionEventArgs))]
		public static event UnhandledExceptionEventHandler? UnhandledException;

		[field: DynamicDependency(DynamicallyAccessedMemberTypes.PublicConstructors, typeof(FirstChanceExceptionEventArgs))]
		public static event EventHandler<FirstChanceExceptionEventArgs>? FirstChanceException;

		public static event EventHandler? ProcessExit;

		public static object? GetData(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (s_dataStore == null)
			{
				return null;
			}
			lock (s_dataStore)
			{
				s_dataStore.TryGetValue(name, out var value);
				return value;
			}
		}

		public static void SetData(string name, object? data)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (s_dataStore == null)
			{
				Interlocked.CompareExchange(ref s_dataStore, new Dictionary<string, object>(), null);
			}
			lock (s_dataStore)
			{
				s_dataStore[name] = data;
			}
		}

		internal static void OnProcessExit()
		{
			AssemblyLoadContext.OnProcessExit();
			if (EventSource.IsSupported)
			{
				EventListener.DisposeOnShutdown();
			}
			AppContext.ProcessExit?.Invoke(AppDomain.CurrentDomain, EventArgs.Empty);
		}

		public static bool TryGetSwitch(string switchName, out bool isEnabled)
		{
			if (switchName == null)
			{
				throw new ArgumentNullException("switchName");
			}
			if (switchName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "switchName");
			}
			if (s_switches != null)
			{
				lock (s_switches)
				{
					if (s_switches.TryGetValue(switchName, out isEnabled))
					{
						return true;
					}
				}
			}
			if (GetData(switchName) is string value && bool.TryParse(value, out isEnabled))
			{
				return true;
			}
			isEnabled = false;
			return false;
		}

		public static void SetSwitch(string switchName, bool isEnabled)
		{
			if (switchName == null)
			{
				throw new ArgumentNullException("switchName");
			}
			if (switchName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "switchName");
			}
			if (s_switches == null)
			{
				Interlocked.CompareExchange(ref s_switches, new Dictionary<string, bool>(), null);
			}
			lock (s_switches)
			{
				s_switches[switchName] = isEnabled;
			}
		}

		internal unsafe static void Setup(char** pNames, char** pValues, int count)
		{
			s_dataStore = new Dictionary<string, object>(count);
			for (int i = 0; i < count; i++)
			{
				s_dataStore.Add(new string(pNames[i]), new string(pValues[i]));
			}
		}

		[UnconditionalSuppressMessage("SingleFile", "IL3000: Avoid accessing Assembly file path when publishing as a single file", Justification = "Single File apps should always set APP_CONTEXT_BASE_DIRECTORY therefore code handles Assembly.Location equals null")]
		private static string GetBaseDirectoryCore()
		{
			string path = Assembly.GetEntryAssembly()?.Location;
			string text = Path.GetDirectoryName(path);
			if (text == null)
			{
				return string.Empty;
			}
			if (!Path.EndsInDirectorySeparator(text))
			{
				text += "\\";
			}
			return text;
		}

		internal static void LogSwitchValues(RuntimeEventSource ev)
		{
			if (s_switches != null)
			{
				lock (s_switches)
				{
					foreach (KeyValuePair<string, bool> s_switch in s_switches)
					{
						ev.LogAppContextSwitch(s_switch.Key, s_switch.Value ? 1 : 0);
					}
				}
			}
			if (s_dataStore == null)
			{
				return;
			}
			lock (s_dataStore)
			{
				if (s_switches != null)
				{
					lock (s_switches)
					{
						LogDataStore(ev, s_switches);
						return;
					}
				}
				LogDataStore(ev, null);
			}
			static void LogDataStore(RuntimeEventSource ev, Dictionary<string, bool> switches)
			{
				foreach (KeyValuePair<string, object> item in s_dataStore)
				{
					if (item.Value is string value && bool.TryParse(value, out var result) && (switches == null || !switches.ContainsKey(item.Key)))
					{
						ev.LogAppContextSwitch(item.Key, result ? 1 : 0);
					}
				}
			}
		}
	}
	internal static class AppContextConfigHelper
	{
		internal static bool GetBooleanConfig(string configName, bool defaultValue)
		{
			if (!AppContext.TryGetSwitch(configName, out var isEnabled))
			{
				return defaultValue;
			}
			return isEnabled;
		}

		internal static bool GetBooleanConfig(string switchName, string envVariable, bool defaultValue = false)
		{
			if (!AppContext.TryGetSwitch(switchName, out var isEnabled))
			{
				string environmentVariable = Environment.GetEnvironmentVariable(envVariable);
				return (environmentVariable == null) ? defaultValue : (bool.IsTrueStringIgnoreCase(environmentVariable) || environmentVariable.Equals("1"));
			}
			return isEnabled;
		}

		internal static int GetInt32Config(string configName, int defaultValue, bool allowNegative = true)
		{
			try
			{
				object data = AppContext.GetData(configName);
				int num = defaultValue;
				if (!(data is uint num2))
				{
					if (data is string text)
					{
						num = ((!text.StartsWith('0')) ? int.Parse(text, NumberStyles.AllowLeadingSign, NumberFormatInfo.InvariantInfo) : ((text.Length < 2 || text[1] != 'x') ? Convert.ToInt32(text, 8) : Convert.ToInt32(text, 16)));
					}
					else if (data is IConvertible convertible)
					{
						num = convertible.ToInt32(NumberFormatInfo.InvariantInfo);
					}
				}
				else
				{
					num = (int)num2;
				}
				return (!allowNegative && num < 0) ? defaultValue : num;
			}
			catch (FormatException)
			{
				return defaultValue;
			}
			catch (OverflowException)
			{
				return defaultValue;
			}
		}

		internal static short GetInt16Config(string configName, short defaultValue, bool allowNegative = true)
		{
			try
			{
				object data = AppContext.GetData(configName);
				short num = defaultValue;
				if (!(data is uint num2))
				{
					if (data is string text)
					{
						num = (text.StartsWith("0x") ? Convert.ToInt16(text, 16) : ((!text.StartsWith("0")) ? short.Parse(text, NumberStyles.AllowLeadingSign, NumberFormatInfo.InvariantInfo) : Convert.ToInt16(text, 8)));
					}
					else if (data is IConvertible convertible)
					{
						num = convertible.ToInt16(NumberFormatInfo.InvariantInfo);
					}
				}
				else
				{
					num = (short)num2;
					if ((uint)num != num2)
					{
						return defaultValue;
					}
				}
				return (!allowNegative && num < 0) ? defaultValue : num;
			}
			catch (FormatException)
			{
				return defaultValue;
			}
			catch (OverflowException)
			{
				return defaultValue;
			}
		}
	}
	public sealed class AppDomain : MarshalByRefObject
	{
		private static readonly AppDomain s_domain = new AppDomain();

		private IPrincipal _defaultPrincipal;

		private PrincipalPolicy _principalPolicy = PrincipalPolicy.NoPrincipal;

		private Func<IPrincipal> s_getWindowsPrincipal;

		private Func<IPrincipal> s_getUnauthenticatedPrincipal;

		public static AppDomain CurrentDomain => s_domain;

		public string BaseDirectory => AppContext.BaseDirectory;

		public string? RelativeSearchPath => null;

		public AppDomainSetup SetupInformation => new AppDomainSetup();

		[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public PermissionSet PermissionSet => new PermissionSet(PermissionState.Unrestricted);

		public string? DynamicDirectory => null;

		public string FriendlyName
		{
			get
			{
				Assembly entryAssembly = Assembly.GetEntryAssembly();
				if (!(entryAssembly != null))
				{
					return "DefaultDomain";
				}
				return entryAssembly.GetName().Name;
			}
		}

		public int Id => 1;

		public bool IsFullyTrusted => true;

		public bool IsHomogenous => true;

		public static bool MonitoringIsEnabled
		{
			get
			{
				return true;
			}
			set
			{
				if (!value)
				{
					throw new ArgumentException(SR.Arg_MustBeTrue);
				}
			}
		}

		public long MonitoringSurvivedMemorySize => MonitoringSurvivedProcessMemorySize;

		public static long MonitoringSurvivedProcessMemorySize
		{
			get
			{
				GCMemoryInfo gCMemoryInfo = GC.GetGCMemoryInfo();
				return gCMemoryInfo.HeapSizeBytes - gCMemoryInfo.FragmentedBytes;
			}
		}

		public long MonitoringTotalAllocatedMemorySize => GC.GetTotalAllocatedBytes();

		public bool ShadowCopyFiles => false;

		public TimeSpan MonitoringTotalProcessorTime
		{
			get
			{
				if (!Interop.Kernel32.GetProcessTimes(Interop.Kernel32.GetCurrentProcess(), out var _, out var _, out var _, out var user))
				{
					return TimeSpan.Zero;
				}
				return new TimeSpan(user);
			}
		}

		public event UnhandledExceptionEventHandler? UnhandledException
		{
			add
			{
				AppContext.UnhandledException += value;
			}
			remove
			{
				AppContext.UnhandledException -= value;
			}
		}

		public event EventHandler? DomainUnload;

		public event EventHandler<FirstChanceExceptionEventArgs>? FirstChanceException
		{
			add
			{
				AppContext.FirstChanceException += value;
			}
			remove
			{
				AppContext.FirstChanceException -= value;
			}
		}

		public event EventHandler? ProcessExit
		{
			add
			{
				AppContext.ProcessExit += value;
			}
			remove
			{
				AppContext.ProcessExit -= value;
			}
		}

		public event AssemblyLoadEventHandler? AssemblyLoad
		{
			add
			{
				AssemblyLoadContext.AssemblyLoad += value;
			}
			remove
			{
				AssemblyLoadContext.AssemblyLoad -= value;
			}
		}

		public event ResolveEventHandler? AssemblyResolve
		{
			add
			{
				AssemblyLoadContext.AssemblyResolve += value;
			}
			remove
			{
				AssemblyLoadContext.AssemblyResolve -= value;
			}
		}

		public event ResolveEventHandler? ReflectionOnlyAssemblyResolve;

		public event ResolveEventHandler? TypeResolve
		{
			add
			{
				AssemblyLoadContext.TypeResolve += value;
			}
			remove
			{
				AssemblyLoadContext.TypeResolve -= value;
			}
		}

		public event ResolveEventHandler? ResourceResolve
		{
			add
			{
				AssemblyLoadContext.ResourceResolve += value;
			}
			remove
			{
				AssemblyLoadContext.ResourceResolve -= value;
			}
		}

		private AppDomain()
		{
		}

		[Obsolete("AppDomain.SetDynamicBase has been deprecated and is not supported.")]
		public void SetDynamicBase(string? path)
		{
		}

		public string ApplyPolicy(string assemblyName)
		{
			if (assemblyName == null)
			{
				throw new ArgumentNullException("assemblyName");
			}
			if (assemblyName.Length == 0 || assemblyName[0] == '\0')
			{
				throw new ArgumentException(SR.Argument_StringZeroLength, "assemblyName");
			}
			return assemblyName;
		}

		[Obsolete("Creating and unloading AppDomains is not supported and throws an exception.", DiagnosticId = "SYSLIB0024", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static AppDomain CreateDomain(string friendlyName)
		{
			if (friendlyName == null)
			{
				throw new ArgumentNullException("friendlyName");
			}
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_AppDomains);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public int ExecuteAssembly(string assemblyFile)
		{
			return ExecuteAssembly(assemblyFile, null);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public int ExecuteAssembly(string assemblyFile, string?[]? args)
		{
			if (assemblyFile == null)
			{
				throw new ArgumentNullException("assemblyFile");
			}
			string fullPath = Path.GetFullPath(assemblyFile);
			Assembly assembly = Assembly.LoadFile(fullPath);
			return ExecuteAssembly(assembly, args);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public int ExecuteAssembly(string assemblyFile, string?[]? args, byte[]? hashValue, AssemblyHashAlgorithm hashAlgorithm)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_CAS);
		}

		private static int ExecuteAssembly(Assembly assembly, string[] args)
		{
			MethodInfo entryPoint = assembly.EntryPoint;
			if (entryPoint == null)
			{
				throw new MissingMethodException(SR.Arg_EntryPointNotFoundException);
			}
			object obj = entryPoint.Invoke(null, BindingFlags.DoNotWrapExceptions, null, (entryPoint.GetParameters().Length == 0) ? null : new object[1] { args }, null);
			if (obj == null)
			{
				return 0;
			}
			return (int)obj;
		}

		public int ExecuteAssemblyByName(AssemblyName assemblyName, params string?[]? args)
		{
			return ExecuteAssembly(Assembly.Load(assemblyName), args);
		}

		public int ExecuteAssemblyByName(string assemblyName)
		{
			return ExecuteAssemblyByName(assemblyName, (string?[]?)null);
		}

		public int ExecuteAssemblyByName(string assemblyName, params string?[]? args)
		{
			return ExecuteAssembly(Assembly.Load(assemblyName), args);
		}

		public object? GetData(string name)
		{
			return AppContext.GetData(name);
		}

		public void SetData(string name, object? data)
		{
			AppContext.SetData(name, data);
		}

		public bool? IsCompatibilitySwitchSet(string value)
		{
			if (!AppContext.TryGetSwitch(value, out var isEnabled))
			{
				return null;
			}
			return isEnabled;
		}

		public bool IsDefaultAppDomain()
		{
			return true;
		}

		public bool IsFinalizingForUnload()
		{
			return false;
		}

		public override string ToString()
		{
			return SR.AppDomain_Name + FriendlyName + "\r\n" + SR.AppDomain_NoContextPolicies;
		}

		[Obsolete("Creating and unloading AppDomains is not supported and throws an exception.", DiagnosticId = "SYSLIB0024", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static void Unload(AppDomain domain)
		{
			if (domain == null)
			{
				throw new ArgumentNullException("domain");
			}
			throw new CannotUnloadAppDomainException(SR.Arg_PlatformNotSupported);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public Assembly Load(byte[] rawAssembly)
		{
			return Assembly.Load(rawAssembly);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public Assembly Load(byte[] rawAssembly, byte[]? rawSymbolStore)
		{
			return Assembly.Load(rawAssembly, rawSymbolStore);
		}

		public Assembly Load(AssemblyName assemblyRef)
		{
			return Assembly.Load(assemblyRef);
		}

		public Assembly Load(string assemblyString)
		{
			return Assembly.Load(assemblyString);
		}

		public Assembly[] ReflectionOnlyGetAssemblies()
		{
			return Array.Empty<Assembly>();
		}

		[Obsolete("AppDomain.GetCurrentThreadId has been deprecated because it does not provide a stable Id when managed threads are running on fibers (aka lightweight threads). To get a stable identifier for a managed thread, use the ManagedThreadId property on Thread instead.")]
		public static int GetCurrentThreadId()
		{
			return Environment.CurrentManagedThreadId;
		}

		[Obsolete("AppDomain.AppendPrivatePath has been deprecated and is not supported.")]
		public void AppendPrivatePath(string? path)
		{
		}

		[Obsolete("AppDomain.ClearPrivatePath has been deprecated and is not supported.")]
		public void ClearPrivatePath()
		{
		}

		[Obsolete("AppDomain.ClearShadowCopyPath has been deprecated and is not supported.")]
		public void ClearShadowCopyPath()
		{
		}

		[Obsolete("AppDomain.SetCachePath has been deprecated and is not supported.")]
		public void SetCachePath(string? path)
		{
		}

		[Obsolete("AppDomain.SetShadowCopyFiles has been deprecated and is not supported.")]
		public void SetShadowCopyFiles()
		{
		}

		[Obsolete("AppDomain.SetShadowCopyPath has been deprecated and is not supported.")]
		public void SetShadowCopyPath(string? path)
		{
		}

		public Assembly[] GetAssemblies()
		{
			return AssemblyLoadContext.GetLoadedAssemblies();
		}

		public void SetPrincipalPolicy(PrincipalPolicy policy)
		{
			_principalPolicy = policy;
		}

		public void SetThreadPrincipal(IPrincipal principal)
		{
			if (principal == null)
			{
				throw new ArgumentNullException("principal");
			}
			if (Interlocked.CompareExchange(ref _defaultPrincipal, principal, null) != null)
			{
				throw new SystemException(SR.AppDomain_Policy_PrincipalTwice);
			}
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public ObjectHandle? CreateInstance(string assemblyName, string typeName)
		{
			if (assemblyName == null)
			{
				throw new ArgumentNullException("assemblyName");
			}
			return Activator.CreateInstance(assemblyName, typeName);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public ObjectHandle? CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder? binder, object?[]? args, CultureInfo? culture, object?[]? activationAttributes)
		{
			if (assemblyName == null)
			{
				throw new ArgumentNullException("assemblyName");
			}
			return Activator.CreateInstance(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public ObjectHandle? CreateInstance(string assemblyName, string typeName, object?[]? activationAttributes)
		{
			if (assemblyName == null)
			{
				throw new ArgumentNullException("assemblyName");
			}
			return Activator.CreateInstance(assemblyName, typeName, activationAttributes);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public object? CreateInstanceAndUnwrap(string assemblyName, string typeName)
		{
			return CreateInstance(assemblyName, typeName)?.Unwrap();
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public object? CreateInstanceAndUnwrap(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder? binder, object?[]? args, CultureInfo? culture, object?[]? activationAttributes)
		{
			return CreateInstance(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes)?.Unwrap();
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public object? CreateInstanceAndUnwrap(string assemblyName, string typeName, object?[]? activationAttributes)
		{
			return CreateInstance(assemblyName, typeName, activationAttributes)?.Unwrap();
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public ObjectHandle? CreateInstanceFrom(string assemblyFile, string typeName)
		{
			return Activator.CreateInstanceFrom(assemblyFile, typeName);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public ObjectHandle? CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder? binder, object?[]? args, CultureInfo? culture, object?[]? activationAttributes)
		{
			return Activator.CreateInstanceFrom(assemblyFile, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public ObjectHandle? CreateInstanceFrom(string assemblyFile, string typeName, object?[]? activationAttributes)
		{
			return Activator.CreateInstanceFrom(assemblyFile, typeName, activationAttributes);
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public object? CreateInstanceFromAndUnwrap(string assemblyFile, string typeName)
		{
			return CreateInstanceFrom(assemblyFile, typeName)?.Unwrap();
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public object? CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder? binder, object?[]? args, CultureInfo? culture, object?[]? activationAttributes)
		{
			return CreateInstanceFrom(assemblyFile, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes)?.Unwrap();
		}

		[RequiresUnreferencedCode("Type and its constructor could be removed")]
		public object? CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, object?[]? activationAttributes)
		{
			return CreateInstanceFrom(assemblyFile, typeName, activationAttributes)?.Unwrap();
		}

		internal IPrincipal GetThreadPrincipal()
		{
			IPrincipal principal = _defaultPrincipal;
			if (principal == null)
			{
				switch (_principalPolicy)
				{
				case PrincipalPolicy.UnauthenticatedPrincipal:
					if (s_getUnauthenticatedPrincipal == null)
					{
						Type type2 = Type.GetType("System.Security.Principal.GenericPrincipal, System.Security.Claims", throwOnError: true);
						MethodInfo method2 = type2.GetMethod("GetDefaultInstance", BindingFlags.Static | BindingFlags.NonPublic);
						Volatile.Write(ref s_getUnauthenticatedPrincipal, method2.CreateDelegate<Func<IPrincipal>>());
					}
					principal = s_getUnauthenticatedPrincipal();
					break;
				case PrincipalPolicy.WindowsPrincipal:
					if (s_getWindowsPrincipal == null)
					{
						Type type = Type.GetType("System.Security.Principal.WindowsPrincipal, System.Security.Principal.Windows", throwOnError: true);
						MethodInfo method = type.GetMethod("GetDefaultInstance", BindingFlags.Static | BindingFlags.NonPublic);
						if (method == null)
						{
							throw new PlatformNotSupportedException(SR.PlatformNotSupported_Principal);
						}
						Volatile.Write(ref s_getWindowsPrincipal, method.CreateDelegate<Func<IPrincipal>>());
					}
					principal = s_getWindowsPrincipal();
					break;
				}
			}
			return principal;
		}
	}
	public sealed class AppDomainSetup
	{
		public string? ApplicationBase => AppContext.BaseDirectory;

		public string? TargetFrameworkName => AppContext.TargetFrameworkName;

		internal AppDomainSetup()
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class AppDomainUnloadedException : SystemException
	{
		public AppDomainUnloadedException()
			: base(SR.Arg_AppDomainUnloadedException)
		{
			base.HResult = -2146234348;
		}

		public AppDomainUnloadedException(string? message)
			: base(message)
		{
			base.HResult = -2146234348;
		}

		public AppDomainUnloadedException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146234348;
		}

		protected AppDomainUnloadedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ApplicationException : Exception
	{
		public ApplicationException()
			: base(SR.Arg_ApplicationException)
		{
			base.HResult = -2146232832;
		}

		public ApplicationException(string? message)
			: base(message)
		{
			base.HResult = -2146232832;
		}

		public ApplicationException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146232832;
		}

		protected ApplicationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public sealed class ApplicationId
	{
		private readonly byte[] _publicKeyToken;

		public string? Culture { get; }

		public string Name { get; }

		public string? ProcessorArchitecture { get; }

		public Version Version { get; }

		public byte[] PublicKeyToken => (byte[])_publicKeyToken.Clone();

		public ApplicationId(byte[] publicKeyToken, string name, Version version, string? processorArchitecture, string? culture)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyApplicationName);
			}
			if (version == null)
			{
				throw new ArgumentNullException("version");
			}
			if (publicKeyToken == null)
			{
				throw new ArgumentNullException("publicKeyToken");
			}
			_publicKeyToken = (byte[])publicKeyToken.Clone();
			Name = name;
			Version = version;
			ProcessorArchitecture = processorArchitecture;
			Culture = culture;
		}

		public ApplicationId Copy()
		{
			return new ApplicationId(_publicKeyToken, Name, Version, ProcessorArchitecture, Culture);
		}

		public override string ToString()
		{
			Span<char> initialBuffer = stackalloc char[128];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.Append(Name);
			if (Culture != null)
			{
				valueStringBuilder.Append(", culture=\"");
				valueStringBuilder.Append(Culture);
				valueStringBuilder.Append('"');
			}
			valueStringBuilder.Append(", version=\"");
			valueStringBuilder.Append(Version.ToString());
			valueStringBuilder.Append('"');
			if (_publicKeyToken != null)
			{
				valueStringBuilder.Append(", publicKeyToken=\"");
				HexConverter.EncodeToUtf16(_publicKeyToken, valueStringBuilder.AppendSpan(2 * _publicKeyToken.Length));
				valueStringBuilder.Append('"');
			}
			if (ProcessorArchitecture != null)
			{
				valueStringBuilder.Append(", processorArchitecture =\"");
				valueStringBuilder.Append(ProcessorArchitecture);
				valueStringBuilder.Append('"');
			}
			return valueStringBuilder.ToString();
		}

		public override bool Equals([NotNullWhen(true)] object? o)
		{
			if (!(o is ApplicationId applicationId))
			{
				return false;
			}
			if (!object.Equals(Name, applicationId.Name) || !object.Equals(Version, applicationId.Version) || !object.Equals(ProcessorArchitecture, applicationId.ProcessorArchitecture) || !object.Equals(Culture, applicationId.Culture))
			{
				return false;
			}
			if (_publicKeyToken.Length != applicationId._publicKeyToken.Length)
			{
				return false;
			}
			for (int i = 0; i < _publicKeyToken.Length; i++)
			{
				if (_publicKeyToken[i] != applicationId._publicKeyToken[i])
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			return Name.GetHashCode() ^ Version.GetHashCode();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ArgumentException : SystemException
	{
		private readonly string _paramName;

		public override string Message
		{
			get
			{
				SetMessageField();
				string text = base.Message;
				if (!string.IsNullOrEmpty(_paramName))
				{
					text = text + " " + SR.Format(SR.Arg_ParamName_Name, _paramName);
				}
				return text;
			}
		}

		public virtual string? ParamName => _paramName;

		public ArgumentException()
			: base(SR.Arg_ArgumentException)
		{
			base.HResult = -2147024809;
		}

		public ArgumentException(string? message)
			: base(message)
		{
			base.HResult = -2147024809;
		}

		public ArgumentException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024809;
		}

		public ArgumentException(string? message, string? paramName, Exception? innerException)
			: base(message, innerException)
		{
			_paramName = paramName;
			base.HResult = -2147024809;
		}

		public ArgumentException(string? message, string? paramName)
			: base(message)
		{
			_paramName = paramName;
			base.HResult = -2147024809;
		}

		protected ArgumentException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_paramName = info.GetString("ParamName");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("ParamName", _paramName, typeof(string));
		}

		private void SetMessageField()
		{
			if (_message == null && base.HResult == -2147024809)
			{
				_message = SR.Arg_ArgumentException;
			}
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ArgumentNullException : ArgumentException
	{
		public ArgumentNullException()
			: base(SR.ArgumentNull_Generic)
		{
			base.HResult = -2147467261;
		}

		public ArgumentNullException(string? paramName)
			: base(SR.ArgumentNull_Generic, paramName)
		{
			base.HResult = -2147467261;
		}

		public ArgumentNullException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147467261;
		}

		public ArgumentNullException(string? paramName, string? message)
			: base(message, paramName)
		{
			base.HResult = -2147467261;
		}

		protected ArgumentNullException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public static void ThrowIfNull([NotNull] object? argument, [CallerArgumentExpression("argument")] string? paramName = null)
		{
			if (argument == null)
			{
				Throw(paramName);
			}
		}

		[DoesNotReturn]
		private static void Throw(string paramName)
		{
			throw new ArgumentNullException(paramName);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ArgumentOutOfRangeException : ArgumentException
	{
		private readonly object _actualValue;

		public override string Message
		{
			get
			{
				string message = base.Message;
				if (_actualValue != null)
				{
					string text = SR.Format(SR.ArgumentOutOfRange_ActualValue, _actualValue);
					if (message == null)
					{
						return text;
					}
					return message + "\r\n" + text;
				}
				return message;
			}
		}

		public virtual object? ActualValue => _actualValue;

		public ArgumentOutOfRangeException()
			: base(SR.Arg_ArgumentOutOfRangeException)
		{
			base.HResult = -2146233086;
		}

		public ArgumentOutOfRangeException(string? paramName)
			: base(SR.Arg_ArgumentOutOfRangeException, paramName)
		{
			base.HResult = -2146233086;
		}

		public ArgumentOutOfRangeException(string? paramName, string? message)
			: base(message, paramName)
		{
			base.HResult = -2146233086;
		}

		public ArgumentOutOfRangeException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233086;
		}

		public ArgumentOutOfRangeException(string? paramName, object? actualValue, string? message)
			: base(message, paramName)
		{
			_actualValue = actualValue;
			base.HResult = -2146233086;
		}

		protected ArgumentOutOfRangeException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_actualValue = info.GetValue("ActualValue", typeof(object));
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("ActualValue", _actualValue, typeof(object));
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ArithmeticException : SystemException
	{
		public ArithmeticException()
			: base(SR.Arg_ArithmeticException)
		{
			base.HResult = -2147024362;
		}

		public ArithmeticException(string? message)
			: base(message)
		{
			base.HResult = -2147024362;
		}

		public ArithmeticException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024362;
		}

		protected ArithmeticException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal sealed class ArrayEnumerator : System.Collections.IEnumerator, ICloneable
	{
		private readonly Array _array;

		private nint _index;

		public object Current
		{
			get
			{
				nint index = _index;
				Array array = _array;
				if ((nuint)index >= array.NativeLength)
				{
					if (index < 0)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumNotStarted();
					}
					else
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumEnded();
					}
				}
				return array.InternalGetValue(index);
			}
		}

		internal ArrayEnumerator(Array array)
		{
			_array = array;
			_index = -1;
		}

		public object Clone()
		{
			return MemberwiseClone();
		}

		public bool MoveNext()
		{
			nint num = _index + 1;
			if ((nuint)num >= _array.NativeLength)
			{
				_index = (nint)_array.NativeLength;
				return false;
			}
			_index = num;
			return true;
		}

		public void Reset()
		{
			_index = -1;
		}
	}
	internal sealed class SZGenericArrayEnumerator<T> : IEnumerator<T>, IDisposable, System.Collections.IEnumerator
	{
		private readonly T[] _array;

		private int _index;

		internal static readonly SZGenericArrayEnumerator<T> Empty = new SZGenericArrayEnumerator<T>(new T[0]);

		public T Current
		{
			get
			{
				int index = _index;
				T[] array = _array;
				if ((uint)index >= (uint)array.Length)
				{
					ThrowHelper.ThrowInvalidOperationException_EnumCurrent(index);
				}
				return array[index];
			}
		}

		object System.Collections.IEnumerator.Current => Current;

		internal SZGenericArrayEnumerator(T[] array)
		{
			_array = array;
			_index = -1;
		}

		public bool MoveNext()
		{
			int num = _index + 1;
			if ((uint)num >= (uint)_array.Length)
			{
				_index = _array.Length;
				return false;
			}
			_index = num;
			return true;
		}

		void System.Collections.IEnumerator.Reset()
		{
			_index = -1;
		}

		public void Dispose()
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct ArraySegment<T> : IList<T>, ICollection<T>, IEnumerable<T>, System.Collections.IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>
	{
		public struct Enumerator : IEnumerator<T>, IDisposable, System.Collections.IEnumerator
		{
			private readonly T[] _array;

			private readonly int _start;

			private readonly int _end;

			private int _current;

			public T Current
			{
				get
				{
					if (_current < _start)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumNotStarted();
					}
					if (_current >= _end)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumEnded();
					}
					return _array[_current];
				}
			}

			object? System.Collections.IEnumerator.Current => Current;

			internal Enumerator(ArraySegment<T> arraySegment)
			{
				_array = arraySegment.Array;
				_start = arraySegment.Offset;
				_end = arraySegment.Offset + arraySegment.Count;
				_current = arraySegment.Offset - 1;
			}

			public bool MoveNext()
			{
				if (_current < _end)
				{
					_current++;
					return _current < _end;
				}
				return false;
			}

			void System.Collections.IEnumerator.Reset()
			{
				_current = _start - 1;
			}

			public void Dispose()
			{
			}
		}

		private readonly T[] _array;

		private readonly int _offset;

		private readonly int _count;

		public static ArraySegment<T> Empty { get; } = new ArraySegment<T>(new T[0]);


		public T[]? Array => _array;

		public int Offset => _offset;

		public int Count => _count;

		public T this[int index]
		{
			get
			{
				if ((uint)index >= (uint)_count)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				return _array[_offset + index];
			}
			set
			{
				if ((uint)index >= (uint)_count)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				_array[_offset + index] = value;
			}
		}

		T IList<T>.this[int index]
		{
			get
			{
				ThrowInvalidOperationIfDefault();
				if (index < 0 || index >= _count)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				return _array[_offset + index];
			}
			set
			{
				ThrowInvalidOperationIfDefault();
				if (index < 0 || index >= _count)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				_array[_offset + index] = value;
			}
		}

		T IReadOnlyList<T>.this[int index]
		{
			get
			{
				ThrowInvalidOperationIfDefault();
				if (index < 0 || index >= _count)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				return _array[_offset + index];
			}
		}

		bool ICollection<T>.IsReadOnly => true;

		public ArraySegment(T[] array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			_array = array;
			_offset = 0;
			_count = array.Length;
		}

		public ArraySegment(T[] array, int offset, int count)
		{
			if (array == null || (uint)offset > (uint)array.Length || (uint)count > (uint)(array.Length - offset))
			{
				ThrowHelper.ThrowArraySegmentCtorValidationFailedExceptions(array, offset, count);
			}
			_array = array;
			_offset = offset;
			_count = count;
		}

		public Enumerator GetEnumerator()
		{
			ThrowInvalidOperationIfDefault();
			return new Enumerator(this);
		}

		public override int GetHashCode()
		{
			if (_array != null)
			{
				return HashCode.Combine(_offset, _count, _array.GetHashCode());
			}
			return 0;
		}

		public void CopyTo(T[] destination)
		{
			CopyTo(destination, 0);
		}

		public void CopyTo(T[] destination, int destinationIndex)
		{
			ThrowInvalidOperationIfDefault();
			System.Array.Copy(_array, _offset, destination, destinationIndex, _count);
		}

		public void CopyTo(ArraySegment<T> destination)
		{
			ThrowInvalidOperationIfDefault();
			destination.ThrowInvalidOperationIfDefault();
			if (_count > destination._count)
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			System.Array.Copy(_array, _offset, destination._array, destination._offset, _count);
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is ArraySegment<T>)
			{
				return Equals((ArraySegment<T>)obj);
			}
			return false;
		}

		public bool Equals(ArraySegment<T> obj)
		{
			if (obj._array == _array && obj._offset == _offset)
			{
				return obj._count == _count;
			}
			return false;
		}

		public ArraySegment<T> Slice(int index)
		{
			ThrowInvalidOperationIfDefault();
			if ((uint)index > (uint)_count)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return new ArraySegment<T>(_array, _offset + index, _count - index);
		}

		public ArraySegment<T> Slice(int index, int count)
		{
			ThrowInvalidOperationIfDefault();
			if ((uint)index > (uint)_count || (uint)count > (uint)(_count - index))
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return new ArraySegment<T>(_array, _offset + index, count);
		}

		public T[] ToArray()
		{
			ThrowInvalidOperationIfDefault();
			if (_count == 0)
			{
				return Empty._array;
			}
			T[] array = new T[_count];
			System.Array.Copy(_array, _offset, array, 0, _count);
			return array;
		}

		public static bool operator ==(ArraySegment<T> a, ArraySegment<T> b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(ArraySegment<T> a, ArraySegment<T> b)
		{
			return !(a == b);
		}

		public static implicit operator ArraySegment<T>(T[] array)
		{
			if (array == null)
			{
				return default(ArraySegment<T>);
			}
			return new ArraySegment<T>(array);
		}

		int IList<T>.IndexOf(T item)
		{
			ThrowInvalidOperationIfDefault();
			int num = System.Array.IndexOf(_array, item, _offset, _count);
			if (num < 0)
			{
				return -1;
			}
			return num - _offset;
		}

		void IList<T>.Insert(int index, T item)
		{
			ThrowHelper.ThrowNotSupportedException();
		}

		void IList<T>.RemoveAt(int index)
		{
			ThrowHelper.ThrowNotSupportedException();
		}

		void ICollection<T>.Add(T item)
		{
			ThrowHelper.ThrowNotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			ThrowHelper.ThrowNotSupportedException();
		}

		bool ICollection<T>.Contains(T item)
		{
			ThrowInvalidOperationIfDefault();
			int num = System.Array.IndexOf(_array, item, _offset, _count);
			return num >= 0;
		}

		bool ICollection<T>.Remove(T item)
		{
			ThrowHelper.ThrowNotSupportedException();
			return false;
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			return GetEnumerator();
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private void ThrowInvalidOperationIfDefault()
		{
			if (_array == null)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_NullArray);
			}
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ArrayTypeMismatchException : SystemException
	{
		public ArrayTypeMismatchException()
			: base(SR.Arg_ArrayTypeMismatchException)
		{
			base.HResult = -2146233085;
		}

		public ArrayTypeMismatchException(string? message)
			: base(message)
		{
			base.HResult = -2146233085;
		}

		public ArrayTypeMismatchException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233085;
		}

		protected ArrayTypeMismatchException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public class AssemblyLoadEventArgs : EventArgs
	{
		public Assembly LoadedAssembly { get; }

		public AssemblyLoadEventArgs(Assembly loadedAssembly)
		{
			LoadedAssembly = loadedAssembly;
		}
	}
	public delegate void AssemblyLoadEventHandler(object? sender, AssemblyLoadEventArgs args);
	public delegate void AsyncCallback(IAsyncResult ar);
	[Flags]
	public enum AttributeTargets
	{
		Assembly = 1,
		Module = 2,
		Class = 4,
		Struct = 8,
		Enum = 0x10,
		Constructor = 0x20,
		Method = 0x40,
		Property = 0x80,
		Field = 0x100,
		Event = 0x200,
		Interface = 0x400,
		Parameter = 0x800,
		Delegate = 0x1000,
		ReturnValue = 0x2000,
		GenericParameter = 0x4000,
		All = 0x7FFF
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = true)]
	public sealed class AttributeUsageAttribute : Attribute
	{
		private readonly AttributeTargets _attributeTarget;

		private bool _allowMultiple;

		private bool _inherited;

		internal static readonly AttributeUsageAttribute Default = new AttributeUsageAttribute(AttributeTargets.All);

		public AttributeTargets ValidOn => _attributeTarget;

		public bool AllowMultiple
		{
			get
			{
				return _allowMultiple;
			}
			set
			{
				_allowMultiple = value;
			}
		}

		public bool Inherited
		{
			get
			{
				return _inherited;
			}
			set
			{
				_inherited = value;
			}
		}

		public AttributeUsageAttribute(AttributeTargets validOn)
		{
			_attributeTarget = validOn;
			_inherited = true;
		}

		internal AttributeUsageAttribute(AttributeTargets validOn, bool allowMultiple, bool inherited)
		{
			_attributeTarget = validOn;
			_allowMultiple = allowMultiple;
			_inherited = inherited;
		}
	}
	public static class BitConverter
	{
		[Intrinsic]
		public static readonly bool IsLittleEndian = true;

		public static byte[] GetBytes(bool value)
		{
			return new byte[1] { (byte)(value ? 1 : 0) };
		}

		public static bool TryWriteBytes(Span<byte> destination, bool value)
		{
			if (destination.Length < 1)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), (byte)(value ? 1 : 0));
			return true;
		}

		public static byte[] GetBytes(char value)
		{
			byte[] array = new byte[2];
			Unsafe.As<byte, char>(ref array[0]) = value;
			return array;
		}

		public static bool TryWriteBytes(Span<byte> destination, char value)
		{
			if (destination.Length < 2)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		public static byte[] GetBytes(short value)
		{
			byte[] array = new byte[2];
			Unsafe.As<byte, short>(ref array[0]) = value;
			return array;
		}

		public static bool TryWriteBytes(Span<byte> destination, short value)
		{
			if (destination.Length < 2)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		public static byte[] GetBytes(int value)
		{
			byte[] array = new byte[4];
			Unsafe.As<byte, int>(ref array[0]) = value;
			return array;
		}

		public static bool TryWriteBytes(Span<byte> destination, int value)
		{
			if (destination.Length < 4)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		public static byte[] GetBytes(long value)
		{
			byte[] array = new byte[8];
			Unsafe.As<byte, long>(ref array[0]) = value;
			return array;
		}

		public static bool TryWriteBytes(Span<byte> destination, long value)
		{
			if (destination.Length < 8)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		[CLSCompliant(false)]
		public static byte[] GetBytes(ushort value)
		{
			byte[] array = new byte[2];
			Unsafe.As<byte, ushort>(ref array[0]) = value;
			return array;
		}

		[CLSCompliant(false)]
		public static bool TryWriteBytes(Span<byte> destination, ushort value)
		{
			if (destination.Length < 2)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		[CLSCompliant(false)]
		public static byte[] GetBytes(uint value)
		{
			byte[] array = new byte[4];
			Unsafe.As<byte, uint>(ref array[0]) = value;
			return array;
		}

		[CLSCompliant(false)]
		public static bool TryWriteBytes(Span<byte> destination, uint value)
		{
			if (destination.Length < 4)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		[CLSCompliant(false)]
		public static byte[] GetBytes(ulong value)
		{
			byte[] array = new byte[8];
			Unsafe.As<byte, ulong>(ref array[0]) = value;
			return array;
		}

		[CLSCompliant(false)]
		public static bool TryWriteBytes(Span<byte> destination, ulong value)
		{
			if (destination.Length < 8)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		public unsafe static byte[] GetBytes(Half value)
		{
			byte[] array = new byte[sizeof(Half)];
			Unsafe.As<byte, Half>(ref array[0]) = value;
			return array;
		}

		public unsafe static bool TryWriteBytes(Span<byte> destination, Half value)
		{
			if (destination.Length < sizeof(Half))
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		public static byte[] GetBytes(float value)
		{
			byte[] array = new byte[4];
			Unsafe.As<byte, float>(ref array[0]) = value;
			return array;
		}

		public static bool TryWriteBytes(Span<byte> destination, float value)
		{
			if (destination.Length < 4)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		public static byte[] GetBytes(double value)
		{
			byte[] array = new byte[8];
			Unsafe.As<byte, double>(ref array[0]) = value;
			return array;
		}

		public static bool TryWriteBytes(Span<byte> destination, double value)
		{
			if (destination.Length < 8)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
			return true;
		}

		public static char ToChar(byte[] value, int startIndex)
		{
			return (char)ToInt16(value, startIndex);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char ToChar(ReadOnlySpan<byte> value)
		{
			if (value.Length < 2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<char>(ref MemoryMarshal.GetReference(value));
		}

		public static short ToInt16(byte[] value, int startIndex)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			if ((uint)startIndex >= (uint)value.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			if (startIndex > value.Length - 2)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall, ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<short>(ref value[startIndex]);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ToInt16(ReadOnlySpan<byte> value)
		{
			if (value.Length < 2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<short>(ref MemoryMarshal.GetReference(value));
		}

		public static int ToInt32(byte[] value, int startIndex)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			if ((uint)startIndex >= (uint)value.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			if (startIndex > value.Length - 4)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall, ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<int>(ref value[startIndex]);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ToInt32(ReadOnlySpan<byte> value)
		{
			if (value.Length < 4)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<int>(ref MemoryMarshal.GetReference(value));
		}

		public static long ToInt64(byte[] value, int startIndex)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			if ((uint)startIndex >= (uint)value.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			if (startIndex > value.Length - 8)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall, ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<long>(ref value[startIndex]);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long ToInt64(ReadOnlySpan<byte> value)
		{
			if (value.Length < 8)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<long>(ref MemoryMarshal.GetReference(value));
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(byte[] value, int startIndex)
		{
			return (ushort)ToInt16(value, startIndex);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ushort ToUInt16(ReadOnlySpan<byte> value)
		{
			if (value.Length < 2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<ushort>(ref MemoryMarshal.GetReference(value));
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(byte[] value, int startIndex)
		{
			return (uint)ToInt32(value, startIndex);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint ToUInt32(ReadOnlySpan<byte> value)
		{
			if (value.Length < 4)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<uint>(ref MemoryMarshal.GetReference(value));
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(byte[] value, int startIndex)
		{
			return (ulong)ToInt64(value, startIndex);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong ToUInt64(ReadOnlySpan<byte> value)
		{
			if (value.Length < 8)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<ulong>(ref MemoryMarshal.GetReference(value));
		}

		public static Half ToHalf(byte[] value, int startIndex)
		{
			return Int16BitsToHalf(ToInt16(value, startIndex));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static Half ToHalf(ReadOnlySpan<byte> value)
		{
			if (value.Length < sizeof(Half))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<Half>(ref MemoryMarshal.GetReference(value));
		}

		public static float ToSingle(byte[] value, int startIndex)
		{
			return Int32BitsToSingle(ToInt32(value, startIndex));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ToSingle(ReadOnlySpan<byte> value)
		{
			if (value.Length < 4)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(value));
		}

		public static double ToDouble(byte[] value, int startIndex)
		{
			return Int64BitsToDouble(ToInt64(value, startIndex));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double ToDouble(ReadOnlySpan<byte> value)
		{
			if (value.Length < 8)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<double>(ref MemoryMarshal.GetReference(value));
		}

		public static string ToString(byte[] value, int startIndex, int length)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			if (startIndex < 0 || (startIndex >= value.Length && startIndex > 0))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (startIndex > value.Length - length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall, ExceptionArgument.value);
			}
			if (length == 0)
			{
				return string.Empty;
			}
			if (length > 715827882)
			{
				throw new ArgumentOutOfRangeException("length", SR.Format(SR.ArgumentOutOfRange_LengthTooLarge, 715827882));
			}
			return string.Create(length * 3 - 1, (value, startIndex, length), delegate(Span<char> dst, (byte[] value, int startIndex, int length) state)
			{
				ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(state.value, state.startIndex, state.length);
				int num = 0;
				int num2 = 0;
				byte b = readOnlySpan[num++];
				dst[num2++] = HexConverter.ToCharUpper(b >> 4);
				dst[num2++] = HexConverter.ToCharUpper(b);
				while (num < readOnlySpan.Length)
				{
					b = readOnlySpan[num++];
					dst[num2++] = '-';
					dst[num2++] = HexConverter.ToCharUpper(b >> 4);
					dst[num2++] = HexConverter.ToCharUpper(b);
				}
			});
		}

		public static string ToString(byte[] value)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			return ToString(value, 0, value.Length);
		}

		public static string ToString(byte[] value, int startIndex)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			return ToString(value, startIndex, value.Length - startIndex);
		}

		public static bool ToBoolean(byte[] value, int startIndex)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			if (startIndex < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			if (startIndex > value.Length - 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			return value[startIndex] != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool ToBoolean(ReadOnlySpan<byte> value)
		{
			if (value.Length < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			return Unsafe.ReadUnaligned<byte>(ref MemoryMarshal.GetReference(value)) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static long DoubleToInt64Bits(double value)
		{
			if (Sse2.X64.IsSupported)
			{
				Vector128<long> value2 = Vector128.CreateScalarUnsafe(value).AsInt64();
				return Sse2.X64.ConvertToInt64(value2);
			}
			return *(long*)(&value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static double Int64BitsToDouble(long value)
		{
			if (Sse2.X64.IsSupported)
			{
				Vector128<double> vector = Vector128.CreateScalarUnsafe(value).AsDouble();
				return vector.ToScalar();
			}
			return *(double*)(&value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static int SingleToInt32Bits(float value)
		{
			if (Sse2.IsSupported)
			{
				Vector128<int> value2 = Vector128.CreateScalarUnsafe(value).AsInt32();
				return Sse2.ConvertToInt32(value2);
			}
			return *(int*)(&value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static float Int32BitsToSingle(int value)
		{
			if (Sse2.IsSupported)
			{
				Vector128<float> vector = Vector128.CreateScalarUnsafe(value).AsSingle();
				return vector.ToScalar();
			}
			return *(float*)(&value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static short HalfToInt16Bits(Half value)
		{
			return *(short*)(&value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static Half Int16BitsToHalf(short value)
		{
			return *(Half*)(&value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong DoubleToUInt64Bits(double value)
		{
			return (ulong)DoubleToInt64Bits(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static double UInt64BitsToDouble(ulong value)
		{
			return Int64BitsToDouble((long)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint SingleToUInt32Bits(float value)
		{
			return (uint)SingleToInt32Bits(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static float UInt32BitsToSingle(uint value)
		{
			return Int32BitsToSingle((int)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ushort HalfToUInt16Bits(Half value)
		{
			return (ushort)HalfToInt16Bits(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Half UInt16BitsToHalf(ushort value)
		{
			return Int16BitsToHalf((short)value);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Boolean : IComparable, IConvertible, IComparable<bool>, IEquatable<bool>
	{
		private readonly bool m_value;

		public static readonly string TrueString = "True";

		public static readonly string FalseString = "False";

		public override int GetHashCode()
		{
			if (!this)
			{
				return 0;
			}
			return 1;
		}

		public override string ToString()
		{
			if (!this)
			{
				return "False";
			}
			return "True";
		}

		public string ToString(IFormatProvider? provider)
		{
			return ToString();
		}

		public bool TryFormat(Span<char> destination, out int charsWritten)
		{
			if (this)
			{
				if ((uint)destination.Length > 3u)
				{
					destination[0] = 'T';
					destination[1] = 'r';
					destination[2] = 'u';
					destination[3] = 'e';
					charsWritten = 4;
					return true;
				}
			}
			else if ((uint)destination.Length > 4u)
			{
				destination[0] = 'F';
				destination[1] = 'a';
				destination[2] = 'l';
				destination[3] = 's';
				destination[4] = 'e';
				charsWritten = 5;
				return true;
			}
			charsWritten = 0;
			return false;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is bool))
			{
				return false;
			}
			return this == (bool)obj;
		}

		[NonVersionable]
		public bool Equals(bool obj)
		{
			return this == obj;
		}

		public int CompareTo(object? obj)
		{
			if (obj == null)
			{
				return 1;
			}
			if (!(obj is bool))
			{
				throw new ArgumentException(SR.Arg_MustBeBoolean);
			}
			if (this == (bool)obj)
			{
				return 0;
			}
			if (!this)
			{
				return -1;
			}
			return 1;
		}

		public int CompareTo(bool value)
		{
			if (this == value)
			{
				return 0;
			}
			if (!this)
			{
				return -1;
			}
			return 1;
		}

		internal static bool IsTrueStringIgnoreCase(ReadOnlySpan<char> value)
		{
			if (value.Length == 4 && (value[0] == 't' || value[0] == 'T') && (value[1] == 'r' || value[1] == 'R') && (value[2] == 'u' || value[2] == 'U'))
			{
				if (value[3] != 'e')
				{
					return value[3] == 'E';
				}
				return true;
			}
			return false;
		}

		internal static bool IsFalseStringIgnoreCase(ReadOnlySpan<char> value)
		{
			if (value.Length == 5 && (value[0] == 'f' || value[0] == 'F') && (value[1] == 'a' || value[1] == 'A') && (value[2] == 'l' || value[2] == 'L') && (value[3] == 's' || value[3] == 'S'))
			{
				if (value[4] != 'e')
				{
					return value[4] == 'E';
				}
				return true;
			}
			return false;
		}

		public static bool Parse(string value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			return Parse(value.AsSpan());
		}

		public static bool Parse(ReadOnlySpan<char> value)
		{
			if (!TryParse(value, out var result))
			{
				throw new FormatException(SR.Format(SR.Format_BadBoolean, new string(value)));
			}
			return result;
		}

		public static bool TryParse([NotNullWhen(true)] string? value, out bool result)
		{
			if (value == null)
			{
				result = false;
				return false;
			}
			return TryParse(value.AsSpan(), out result);
		}

		public static bool TryParse(ReadOnlySpan<char> value, out bool result)
		{
			if (IsTrueStringIgnoreCase(value))
			{
				result = true;
				return true;
			}
			if (IsFalseStringIgnoreCase(value))
			{
				result = false;
				return true;
			}
			value = TrimWhiteSpaceAndNull(value);
			if (IsTrueStringIgnoreCase(value))
			{
				result = true;
				return true;
			}
			if (IsFalseStringIgnoreCase(value))
			{
				result = false;
				return true;
			}
			result = false;
			return false;
		}

		private static ReadOnlySpan<char> TrimWhiteSpaceAndNull(ReadOnlySpan<char> value)
		{
			int i;
			for (i = 0; i < value.Length && (char.IsWhiteSpace(value[i]) || value[i] == '\0'); i++)
			{
			}
			int num = value.Length - 1;
			while (num >= i && (char.IsWhiteSpace(value[num]) || value[num] == '\0'))
			{
				num--;
			}
			return value.Slice(i, num - i + 1);
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Boolean;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return this;
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Boolean", "Char"));
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Boolean", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}
	}
	[NonVersionable]
	internal readonly ref struct ByReference<T>
	{
		private readonly IntPtr _value;

		public ref T Value
		{
			[Intrinsic]
			get
			{
				throw new PlatformNotSupportedException();
			}
		}

		[Intrinsic]
		public ByReference(ref T value)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Byte : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<byte>, IEquatable<byte>, IBinaryInteger<byte>, IBinaryNumber<byte>, IBitwiseOperators<byte, byte, byte>, INumber<byte>, IAdditionOperators<byte, byte, byte>, IAdditiveIdentity<byte, byte>, IComparisonOperators<byte, byte>, IEqualityOperators<byte, byte>, IDecrementOperators<byte>, IDivisionOperators<byte, byte, byte>, IIncrementOperators<byte>, IModulusOperators<byte, byte, byte>, IMultiplicativeIdentity<byte, byte>, IMultiplyOperators<byte, byte, byte>, ISpanParseable<byte>, IParseable<byte>, ISubtractionOperators<byte, byte, byte>, IUnaryNegationOperators<byte, byte>, IUnaryPlusOperators<byte, byte>, IShiftOperators<byte, byte>, IMinMaxValue<byte>, IUnsignedNumber<byte>
	{
		private readonly byte m_value;

		public const byte MaxValue = 255;

		public const byte MinValue = 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IAdditiveIdentity<byte, byte>.AdditiveIdentity => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IMinMaxValue<byte>.MinValue => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IMinMaxValue<byte>.MaxValue => byte.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IMultiplicativeIdentity<byte, byte>.MultiplicativeIdentity => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.One => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Zero => 0;

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is byte))
			{
				throw new ArgumentException(SR.Arg_MustBeByte);
			}
			return this - (byte)value;
		}

		public int CompareTo(byte value)
		{
			return this - value;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is byte))
			{
				return false;
			}
			return this == (byte)obj;
		}

		[NonVersionable]
		public bool Equals(byte obj)
		{
			return this == obj;
		}

		public override int GetHashCode()
		{
			return this;
		}

		public static byte Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
		}

		public static byte Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.CurrentInfo);
		}

		public static byte Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
		}

		public static byte Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static byte Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Parse(s, style, NumberFormatInfo.GetInstance(provider));
		}

		private static byte Parse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info)
		{
			uint result;
			Number.ParsingStatus parsingStatus = Number.TryParseUInt32(s, style, info, out result);
			if (parsingStatus != 0)
			{
				Number.ThrowOverflowOrFormatException(parsingStatus, TypeCode.Byte);
			}
			if (result > 255)
			{
				Number.ThrowOverflowException(TypeCode.Byte);
			}
			return (byte)result;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out byte result)
		{
			if (s == null)
			{
				result = 0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out byte result)
		{
			return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out byte result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				result = 0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out byte result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out byte result)
		{
			if (Number.TryParseUInt32(s, style, info, out var result2) != 0 || result2 > 255)
			{
				result = 0;
				return false;
			}
			result = (byte)result2;
			return true;
		}

		public override string ToString()
		{
			return Number.UInt32ToDecStr(this);
		}

		public string ToString(string? format)
		{
			return Number.FormatUInt32(this, format, null);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.UInt32ToDecStr(this);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatUInt32(this, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatUInt32(this, format, provider, destination, out charsWritten);
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Byte;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return this;
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Byte", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IAdditionOperators<byte, byte, byte>.op_Addition(byte left, byte right)
		{
			return (byte)(left + right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBinaryInteger<byte>.LeadingZeroCount(byte value)
		{
			return (byte)(BitOperations.LeadingZeroCount(value) - 24);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBinaryInteger<byte>.PopCount(byte value)
		{
			return (byte)BitOperations.PopCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBinaryInteger<byte>.RotateLeft(byte value, int rotateAmount)
		{
			return (byte)((value << (rotateAmount & 7)) | (value >> ((8 - rotateAmount) & 7)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBinaryInteger<byte>.RotateRight(byte value, int rotateAmount)
		{
			return (byte)((value >> (rotateAmount & 7)) | (value << ((8 - rotateAmount) & 7)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBinaryInteger<byte>.TrailingZeroCount(byte value)
		{
			return (byte)(BitOperations.TrailingZeroCount(value << 24) - 24);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<byte>.IsPow2(byte value)
		{
			return BitOperations.IsPow2((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBinaryNumber<byte>.Log2(byte value)
		{
			return (byte)BitOperations.Log2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBitwiseOperators<byte, byte, byte>.op_BitwiseAnd(byte left, byte right)
		{
			return (byte)(left & right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBitwiseOperators<byte, byte, byte>.op_BitwiseOr(byte left, byte right)
		{
			return (byte)(left | right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBitwiseOperators<byte, byte, byte>.op_ExclusiveOr(byte left, byte right)
		{
			return (byte)(left ^ right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IBitwiseOperators<byte, byte, byte>.op_OnesComplement(byte value)
		{
			return (byte)(~value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<byte, byte>.op_LessThan(byte left, byte right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<byte, byte>.op_LessThanOrEqual(byte left, byte right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<byte, byte>.op_GreaterThan(byte left, byte right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<byte, byte>.op_GreaterThanOrEqual(byte left, byte right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IDecrementOperators<byte>.op_Decrement(byte value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IDivisionOperators<byte, byte, byte>.op_Division(byte left, byte right)
		{
			return (byte)(left / right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<byte, byte>.op_Equality(byte left, byte right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<byte, byte>.op_Inequality(byte left, byte right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IIncrementOperators<byte>.op_Increment(byte value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IModulusOperators<byte, byte, byte>.op_Modulus(byte left, byte right)
		{
			return (byte)(left % right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IMultiplyOperators<byte, byte, byte>.op_Multiply(byte left, byte right)
		{
			return (byte)(left * right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Abs(byte value)
		{
			return value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Clamp(byte value, byte min, byte max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(char))
				{
					return (byte)(char)(object)value;
				}
				if (typeof(TOther) == typeof(decimal))
				{
					return (byte)(decimal)(object)value;
				}
				if (typeof(TOther) == typeof(double))
				{
					return (byte)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (byte)(short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (byte)(int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (byte)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (byte)(nint)(IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (byte)(sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (byte)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (byte)(ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (byte)(uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (byte)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (byte)(nuint)(UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				char c = (char)(object)value;
				if (c <= 'ÿ')
				{
					return (byte)c;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 255m))
				{
					if (!(num < 0m))
					{
						return (byte)num;
					}
					return 0;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 255.0))
				{
					if (!(num2 < 0.0))
					{
						return (byte)num2;
					}
					return 0;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 <= 255)
				{
					if (num3 >= 0)
					{
						return (byte)num3;
					}
					return 0;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 <= 255)
				{
					if (num4 >= 0)
					{
						return (byte)num4;
					}
					return 0;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 <= 255)
				{
					if (num5 >= 0)
					{
						return (byte)num5;
					}
					return 0;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr <= 255)
				{
					if ((nint)intPtr >= 0)
					{
						return (byte)(nint)intPtr;
					}
					return 0;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b >= 0)
				{
					return (byte)b;
				}
				return 0;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (!(num6 > 255f))
				{
					if (!(num6 < 0f))
					{
						return (byte)num6;
					}
					return 0;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				ushort num7 = (ushort)(object)value;
				if (num7 <= 255)
				{
					return (byte)num7;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num8 = (uint)(object)value;
				if (num8 <= 255)
				{
					return (byte)num8;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num9 = (ulong)(object)value;
				if (num9 <= 255)
				{
					return (byte)num9;
				}
				return byte.MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr <= 255)
				{
					return (byte)(nuint)uIntPtr;
				}
				return byte.MaxValue;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (byte)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (byte)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (byte)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (byte)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (byte)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (byte)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (byte)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (byte)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (byte)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (byte)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (byte)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (byte)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (byte)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (byte Quotient, byte Remainder) INumber<byte>.DivRem(byte left, byte right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Max(byte x, byte y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Min(byte x, byte y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte INumber<byte>.Sign(byte value)
		{
			return (byte)((value != 0) ? 1u : 0u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<byte>.TryCreate<TOther>(TOther value, out byte result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				char c = (char)(object)value;
				if (c > 'ÿ')
				{
					result = 0;
					return false;
				}
				result = (byte)c;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < 0m || num > 255m)
				{
					result = 0;
					return false;
				}
				result = (byte)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < 0.0 || num2 > 255.0)
				{
					result = 0;
					return false;
				}
				result = (byte)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 < 0 || num3 > 255)
				{
					result = 0;
					return false;
				}
				result = (byte)num3;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 < 0 || num4 > 255)
				{
					result = 0;
					return false;
				}
				result = (byte)num4;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 < 0 || num5 > 255)
				{
					result = 0;
					return false;
				}
				result = (byte)num5;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < 0 || (nint)intPtr > 255)
				{
					result = 0;
					return false;
				}
				result = (byte)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b < 0)
				{
					result = 0;
					return false;
				}
				result = (byte)b;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (num6 < 0f || num6 > 255f)
				{
					result = 0;
					return false;
				}
				result = (byte)num6;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				ushort num7 = (ushort)(object)value;
				if (num7 > 255)
				{
					result = 0;
					return false;
				}
				result = (byte)num7;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num8 = (uint)(object)value;
				if (num8 > 255)
				{
					result = 0;
					return false;
				}
				result = (byte)num8;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num9 = (ulong)(object)value;
				if (num9 > 255)
				{
					result = 0;
					return false;
				}
				result = (byte)num9;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr > 255)
				{
					result = 0;
					return false;
				}
				result = (byte)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<byte>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out byte result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<byte>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out byte result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IParseable<byte>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<byte>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out byte result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IShiftOperators<byte, byte>.op_LeftShift(byte value, int shiftAmount)
		{
			return (byte)(value << shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IShiftOperators<byte, byte>.op_RightShift(byte value, int shiftAmount)
		{
			return (byte)(value >> shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte ISpanParseable<byte>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<byte>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out byte result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte ISubtractionOperators<byte, byte, byte>.op_Subtraction(byte left, byte right)
		{
			return (byte)(left - right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IUnaryNegationOperators<byte, byte>.op_UnaryNegation(byte value)
		{
			return (byte)(-value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static byte IUnaryPlusOperators<byte, byte>.op_UnaryPlus(byte value)
		{
			return value;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class CannotUnloadAppDomainException : SystemException
	{
		public CannotUnloadAppDomainException()
			: base(SR.Arg_CannotUnloadAppDomainException)
		{
			base.HResult = -2146234347;
		}

		public CannotUnloadAppDomainException(string? message)
			: base(message)
		{
			base.HResult = -2146234347;
		}

		public CannotUnloadAppDomainException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146234347;
		}

		protected CannotUnloadAppDomainException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Char : IComparable, IComparable<char>, IEquatable<char>, IConvertible, ISpanFormattable, IFormattable, IBinaryInteger<char>, IBinaryNumber<char>, IBitwiseOperators<char, char, char>, INumber<char>, IAdditionOperators<char, char, char>, IAdditiveIdentity<char, char>, IComparisonOperators<char, char>, IEqualityOperators<char, char>, IDecrementOperators<char>, IDivisionOperators<char, char, char>, IIncrementOperators<char>, IModulusOperators<char, char, char>, IMultiplicativeIdentity<char, char>, IMultiplyOperators<char, char, char>, ISpanParseable<char>, IParseable<char>, ISubtractionOperators<char, char, char>, IUnaryNegationOperators<char, char>, IUnaryPlusOperators<char, char>, IShiftOperators<char, char>, IMinMaxValue<char>, IUnsignedNumber<char>
	{
		private readonly char m_value;

		public const char MaxValue = '\uffff';

		public const char MinValue = '\0';

		private static ReadOnlySpan<byte> Latin1CharInfo => new byte[256]
		{
			14, 14, 14, 14, 14, 14, 14, 14, 14, 142,
			142, 142, 142, 142, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 139, 24, 24, 24, 26, 24, 24, 24,
			20, 21, 24, 25, 24, 19, 24, 24, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 24, 24,
			25, 25, 25, 24, 24, 64, 64, 64, 64, 64,
			64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
			64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
			64, 20, 24, 21, 27, 18, 27, 33, 33, 33,
			33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
			33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
			33, 33, 33, 20, 25, 21, 25, 14, 14, 14,
			14, 14, 14, 142, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			139, 24, 26, 26, 26, 26, 28, 24, 27, 28,
			4, 22, 25, 15, 28, 27, 28, 25, 10, 10,
			27, 33, 24, 24, 27, 10, 4, 23, 10, 10,
			10, 24, 64, 64, 64, 64, 64, 64, 64, 64,
			64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
			64, 64, 64, 64, 64, 25, 64, 64, 64, 64,
			64, 64, 64, 33, 33, 33, 33, 33, 33, 33,
			33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
			33, 33, 33, 33, 33, 33, 33, 25, 33, 33,
			33, 33, 33, 33, 33, 33
		};

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IAdditiveIdentity<char, char>.AdditiveIdentity => '\0';

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IMinMaxValue<char>.MinValue => '\0';

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IMinMaxValue<char>.MaxValue => '\uffff';

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IMultiplicativeIdentity<char, char>.MultiplicativeIdentity => '\u0001';

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.One => '\u0001';

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Zero => '\0';

		private static bool IsLatin1(char c)
		{
			return (uint)c < (uint)Latin1CharInfo.Length;
		}

		public static bool IsAscii(char c)
		{
			return (uint)c <= 127u;
		}

		private static UnicodeCategory GetLatin1UnicodeCategory(char c)
		{
			return (UnicodeCategory)(Latin1CharInfo[c] & 0x1F);
		}

		public override int GetHashCode()
		{
			return (int)(this | ((uint)this << 16));
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is char))
			{
				return false;
			}
			return this == (char)obj;
		}

		[NonVersionable]
		public bool Equals(char obj)
		{
			return this == obj;
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is char))
			{
				throw new ArgumentException(SR.Arg_MustBeChar);
			}
			return this - (char)value;
		}

		public int CompareTo(char value)
		{
			return this - value;
		}

		public override string ToString()
		{
			return ToString(this);
		}

		public string ToString(IFormatProvider? provider)
		{
			return ToString(this);
		}

		public static string ToString(char c)
		{
			return string.CreateFromChar(c);
		}

		bool ISpanFormattable.TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			if (!destination.IsEmpty)
			{
				destination[0] = this;
				charsWritten = 1;
				return true;
			}
			charsWritten = 0;
			return false;
		}

		string IFormattable.ToString(string format, IFormatProvider formatProvider)
		{
			return ToString(this);
		}

		public static char Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if (s.Length != 1)
			{
				throw new FormatException(SR.Format_NeedSingleChar);
			}
			return s[0];
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out char result)
		{
			result = '\0';
			if (s == null)
			{
				return false;
			}
			if (s.Length != 1)
			{
				return false;
			}
			result = s[0];
			return true;
		}

		public static bool IsDigit(char c)
		{
			if (IsLatin1(c))
			{
				return IsInRange(c, '0', '9');
			}
			return CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.DecimalDigitNumber;
		}

		internal static bool IsInRange(char c, char min, char max)
		{
			return (uint)(c - min) <= (uint)(max - min);
		}

		private static bool IsInRange(UnicodeCategory c, UnicodeCategory min, UnicodeCategory max)
		{
			return (uint)(c - min) <= (uint)(max - min);
		}

		internal static bool CheckLetter(UnicodeCategory uc)
		{
			return IsInRange(uc, UnicodeCategory.UppercaseLetter, UnicodeCategory.OtherLetter);
		}

		public static bool IsLetter(char c)
		{
			if (IsAscii(c))
			{
				return (Latin1CharInfo[c] & 0x60) != 0;
			}
			return CheckLetter(CharUnicodeInfo.GetUnicodeCategory(c));
		}

		private static bool IsWhiteSpaceLatin1(char c)
		{
			return (Latin1CharInfo[c] & 0x80) != 0;
		}

		public static bool IsWhiteSpace(char c)
		{
			if (IsLatin1(c))
			{
				return IsWhiteSpaceLatin1(c);
			}
			return CharUnicodeInfo.GetIsWhiteSpace(c);
		}

		public static bool IsUpper(char c)
		{
			if (IsLatin1(c))
			{
				return (Latin1CharInfo[c] & 0x40) != 0;
			}
			return CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.UppercaseLetter;
		}

		public static bool IsLower(char c)
		{
			if (IsLatin1(c))
			{
				return (Latin1CharInfo[c] & 0x20) != 0;
			}
			return CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.LowercaseLetter;
		}

		internal static bool CheckPunctuation(UnicodeCategory uc)
		{
			return IsInRange(uc, UnicodeCategory.ConnectorPunctuation, UnicodeCategory.OtherPunctuation);
		}

		public static bool IsPunctuation(char c)
		{
			if (IsLatin1(c))
			{
				return CheckPunctuation(GetLatin1UnicodeCategory(c));
			}
			return CheckPunctuation(CharUnicodeInfo.GetUnicodeCategory(c));
		}

		internal static bool CheckLetterOrDigit(UnicodeCategory uc)
		{
			if (!CheckLetter(uc))
			{
				return uc == UnicodeCategory.DecimalDigitNumber;
			}
			return true;
		}

		public static bool IsLetterOrDigit(char c)
		{
			if (IsLatin1(c))
			{
				return CheckLetterOrDigit(GetLatin1UnicodeCategory(c));
			}
			return CheckLetterOrDigit(CharUnicodeInfo.GetUnicodeCategory(c));
		}

		public static char ToUpper(char c, CultureInfo culture)
		{
			if (culture == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.culture);
			}
			return culture.TextInfo.ToUpper(c);
		}

		public static char ToUpper(char c)
		{
			return CultureInfo.CurrentCulture.TextInfo.ToUpper(c);
		}

		public static char ToUpperInvariant(char c)
		{
			return TextInfo.ToUpperInvariant(c);
		}

		public static char ToLower(char c, CultureInfo culture)
		{
			if (culture == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.culture);
			}
			return culture.TextInfo.ToLower(c);
		}

		public static char ToLower(char c)
		{
			return CultureInfo.CurrentCulture.TextInfo.ToLower(c);
		}

		public static char ToLowerInvariant(char c)
		{
			return TextInfo.ToLowerInvariant(c);
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Char;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Char", "Boolean"));
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return this;
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Char", "Single"));
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Char", "Double"));
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Char", "Decimal"));
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Char", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		public static bool IsControl(char c)
		{
			return (uint)((c + 1) & -129) <= 32u;
		}

		public static bool IsControl(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return IsControl(s[index]);
		}

		public static bool IsDigit(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsLatin1(c))
			{
				return IsInRange(c, '0', '9');
			}
			return CharUnicodeInfo.GetUnicodeCategoryInternal(s, index) == UnicodeCategory.DecimalDigitNumber;
		}

		public static bool IsLetter(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsAscii(c))
			{
				return (Latin1CharInfo[c] & 0x60) != 0;
			}
			return CheckLetter(CharUnicodeInfo.GetUnicodeCategoryInternal(s, index));
		}

		public static bool IsLetterOrDigit(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsLatin1(c))
			{
				return CheckLetterOrDigit(GetLatin1UnicodeCategory(c));
			}
			return CheckLetterOrDigit(CharUnicodeInfo.GetUnicodeCategoryInternal(s, index));
		}

		public static bool IsLower(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsLatin1(c))
			{
				return (Latin1CharInfo[c] & 0x20) != 0;
			}
			return CharUnicodeInfo.GetUnicodeCategoryInternal(s, index) == UnicodeCategory.LowercaseLetter;
		}

		internal static bool CheckNumber(UnicodeCategory uc)
		{
			return IsInRange(uc, UnicodeCategory.DecimalDigitNumber, UnicodeCategory.OtherNumber);
		}

		public static bool IsNumber(char c)
		{
			if (IsLatin1(c))
			{
				if (IsAscii(c))
				{
					return IsInRange(c, '0', '9');
				}
				return CheckNumber(GetLatin1UnicodeCategory(c));
			}
			return CheckNumber(CharUnicodeInfo.GetUnicodeCategory(c));
		}

		public static bool IsNumber(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsLatin1(c))
			{
				if (IsAscii(c))
				{
					return IsInRange(c, '0', '9');
				}
				return CheckNumber(GetLatin1UnicodeCategory(c));
			}
			return CheckNumber(CharUnicodeInfo.GetUnicodeCategoryInternal(s, index));
		}

		public static bool IsPunctuation(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsLatin1(c))
			{
				return CheckPunctuation(GetLatin1UnicodeCategory(c));
			}
			return CheckPunctuation(CharUnicodeInfo.GetUnicodeCategoryInternal(s, index));
		}

		internal static bool CheckSeparator(UnicodeCategory uc)
		{
			return IsInRange(uc, UnicodeCategory.SpaceSeparator, UnicodeCategory.ParagraphSeparator);
		}

		private static bool IsSeparatorLatin1(char c)
		{
			if (c != ' ')
			{
				return c == '\u00a0';
			}
			return true;
		}

		public static bool IsSeparator(char c)
		{
			if (IsLatin1(c))
			{
				return IsSeparatorLatin1(c);
			}
			return CheckSeparator(CharUnicodeInfo.GetUnicodeCategory(c));
		}

		public static bool IsSeparator(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsLatin1(c))
			{
				return IsSeparatorLatin1(c);
			}
			return CheckSeparator(CharUnicodeInfo.GetUnicodeCategoryInternal(s, index));
		}

		public static bool IsSurrogate(char c)
		{
			return IsInRange(c, '\ud800', '\udfff');
		}

		public static bool IsSurrogate(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return IsSurrogate(s[index]);
		}

		internal static bool CheckSymbol(UnicodeCategory uc)
		{
			return IsInRange(uc, UnicodeCategory.MathSymbol, UnicodeCategory.OtherSymbol);
		}

		public static bool IsSymbol(char c)
		{
			if (IsLatin1(c))
			{
				return CheckSymbol(GetLatin1UnicodeCategory(c));
			}
			return CheckSymbol(CharUnicodeInfo.GetUnicodeCategory(c));
		}

		public static bool IsSymbol(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsLatin1(c))
			{
				return CheckSymbol(GetLatin1UnicodeCategory(c));
			}
			return CheckSymbol(CharUnicodeInfo.GetUnicodeCategoryInternal(s, index));
		}

		public static bool IsUpper(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			char c = s[index];
			if (IsLatin1(c))
			{
				return (Latin1CharInfo[c] & 0x40) != 0;
			}
			return CharUnicodeInfo.GetUnicodeCategoryInternal(s, index) == UnicodeCategory.UppercaseLetter;
		}

		public static bool IsWhiteSpace(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return IsWhiteSpace(s[index]);
		}

		public static UnicodeCategory GetUnicodeCategory(char c)
		{
			if (IsLatin1(c))
			{
				return GetLatin1UnicodeCategory(c);
			}
			return CharUnicodeInfo.GetUnicodeCategory((int)c);
		}

		public static UnicodeCategory GetUnicodeCategory(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			if (IsLatin1(s[index]))
			{
				return GetLatin1UnicodeCategory(s[index]);
			}
			return CharUnicodeInfo.GetUnicodeCategoryInternal(s, index);
		}

		public static double GetNumericValue(char c)
		{
			return CharUnicodeInfo.GetNumericValue(c);
		}

		public static double GetNumericValue(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return CharUnicodeInfo.GetNumericValueInternal(s, index);
		}

		public static bool IsHighSurrogate(char c)
		{
			return IsInRange(c, '\ud800', '\udbff');
		}

		public static bool IsHighSurrogate(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return IsHighSurrogate(s[index]);
		}

		public static bool IsLowSurrogate(char c)
		{
			return IsInRange(c, '\udc00', '\udfff');
		}

		public static bool IsLowSurrogate(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return IsLowSurrogate(s[index]);
		}

		public static bool IsSurrogatePair(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			if (index + 1 < s.Length)
			{
				return IsSurrogatePair(s[index], s[index + 1]);
			}
			return false;
		}

		public static bool IsSurrogatePair(char highSurrogate, char lowSurrogate)
		{
			uint num = (uint)(highSurrogate - 55296);
			uint num2 = (uint)(lowSurrogate - 56320);
			return (num | num2) <= 1023;
		}

		public static string ConvertFromUtf32(int utf32)
		{
			if (!UnicodeUtility.IsValidUnicodeScalar((uint)utf32))
			{
				throw new ArgumentOutOfRangeException("utf32", SR.ArgumentOutOfRange_InvalidUTF32);
			}
			return Rune.UnsafeCreate((uint)utf32).ToString();
		}

		public static int ConvertToUtf32(char highSurrogate, char lowSurrogate)
		{
			uint num = (uint)(highSurrogate - 55296);
			uint num2 = (uint)(lowSurrogate - 56320);
			if ((num | num2) > 1023)
			{
				ConvertToUtf32_ThrowInvalidArgs(num);
			}
			return (int)(num << 10) + (lowSurrogate - 56320) + 65536;
		}

		[StackTraceHidden]
		private static void ConvertToUtf32_ThrowInvalidArgs(uint highSurrogateOffset)
		{
			if (highSurrogateOffset > 1023)
			{
				throw new ArgumentOutOfRangeException("highSurrogate", SR.ArgumentOutOfRange_InvalidHighSurrogate);
			}
			throw new ArgumentOutOfRangeException("lowSurrogate", SR.ArgumentOutOfRange_InvalidLowSurrogate);
		}

		public static int ConvertToUtf32(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if (index < 0 || index >= s.Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			int num = s[index] - 55296;
			if (num >= 0 && num <= 2047)
			{
				if (num <= 1023)
				{
					if (index < s.Length - 1)
					{
						int num2 = s[index + 1] - 56320;
						if (num2 >= 0 && num2 <= 1023)
						{
							return num * 1024 + num2 + 65536;
						}
						throw new ArgumentException(SR.Format(SR.Argument_InvalidHighSurrogate, index), "s");
					}
					throw new ArgumentException(SR.Format(SR.Argument_InvalidHighSurrogate, index), "s");
				}
				throw new ArgumentException(SR.Format(SR.Argument_InvalidLowSurrogate, index), "s");
			}
			return s[index];
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IAdditionOperators<char, char, char>.op_Addition(char left, char right)
		{
			return (char)(left + right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBinaryInteger<char>.LeadingZeroCount(char value)
		{
			return (char)(BitOperations.LeadingZeroCount(value) - 16);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBinaryInteger<char>.PopCount(char value)
		{
			return (char)BitOperations.PopCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBinaryInteger<char>.RotateLeft(char value, int rotateAmount)
		{
			return (char)(((uint)value << (rotateAmount & 0xF)) | (uint)((int)value >> ((16 - rotateAmount) & 0xF)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBinaryInteger<char>.RotateRight(char value, int rotateAmount)
		{
			return (char)((uint)((int)value >> (rotateAmount & 0xF)) | ((uint)value << ((16 - rotateAmount) & 0xF)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBinaryInteger<char>.TrailingZeroCount(char value)
		{
			return (char)(BitOperations.TrailingZeroCount((int)((uint)value << 16)) - 16);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<char>.IsPow2(char value)
		{
			return BitOperations.IsPow2((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBinaryNumber<char>.Log2(char value)
		{
			return (char)BitOperations.Log2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBitwiseOperators<char, char, char>.op_BitwiseAnd(char left, char right)
		{
			return (char)(left & right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBitwiseOperators<char, char, char>.op_BitwiseOr(char left, char right)
		{
			return (char)(left | right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBitwiseOperators<char, char, char>.op_ExclusiveOr(char left, char right)
		{
			return (char)(left ^ right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IBitwiseOperators<char, char, char>.op_OnesComplement(char value)
		{
			return (char)(~(uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<char, char>.op_LessThan(char left, char right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<char, char>.op_LessThanOrEqual(char left, char right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<char, char>.op_GreaterThan(char left, char right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<char, char>.op_GreaterThanOrEqual(char left, char right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IDecrementOperators<char>.op_Decrement(char value)
		{
			return value = (char)(value - 1);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IDivisionOperators<char, char, char>.op_Division(char left, char right)
		{
			return (char)(left / right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<char, char>.op_Equality(char left, char right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<char, char>.op_Inequality(char left, char right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IIncrementOperators<char>.op_Increment(char value)
		{
			return value = (char)(value + 1);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IModulusOperators<char, char, char>.op_Modulus(char left, char right)
		{
			return (char)(left % right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IMultiplyOperators<char, char, char>.op_Multiply(char left, char right)
		{
			return (char)(left * right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Abs(char value)
		{
			return value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Clamp(char value, char min, char max)
		{
			return (char)Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (char)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (char)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (char)checked((ushort)(double)(object)value);
			}
			if (typeof(TOther) == typeof(short))
			{
				return (char)checked((ushort)(short)(object)value);
			}
			if (typeof(TOther) == typeof(int))
			{
				return (char)checked((ushort)(int)(object)value);
			}
			if (typeof(TOther) == typeof(long))
			{
				return (char)checked((ushort)(long)(object)value);
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (char)checked((ushort)(nint)(IntPtr)(object)value);
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (char)checked((ushort)(sbyte)(object)value);
			}
			if (typeof(TOther) == typeof(float))
			{
				return (char)checked((ushort)(float)(object)value);
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (char)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (char)checked((ushort)(uint)(object)value);
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (char)checked((ushort)(ulong)(object)value);
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (char)checked((ushort)(nuint)(UIntPtr)(object)value);
			}
			ThrowHelper.ThrowNotSupportedException();
			return '\0';
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (char)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 65535m))
				{
					if (!(num < 0m))
					{
						return (char)num;
					}
					return '\0';
				}
				return '\uffff';
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 65535.0))
				{
					if (!(num2 < 0.0))
					{
						return (char)num2;
					}
					return '\0';
				}
				return '\uffff';
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 >= 0)
				{
					return (char)num3;
				}
				return '\0';
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 <= 65535)
				{
					if (num4 >= 0)
					{
						return (char)num4;
					}
					return '\0';
				}
				return '\uffff';
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 <= 65535)
				{
					if (num5 >= 0)
					{
						return (char)num5;
					}
					return '\0';
				}
				return '\uffff';
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr <= 65535)
				{
					if ((nint)intPtr >= 0)
					{
						return (char)(nint)intPtr;
					}
					return '\0';
				}
				return '\uffff';
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b >= 0)
				{
					return (char)b;
				}
				return '\0';
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (!(num6 > 65535f))
				{
					if (!(num6 < 0f))
					{
						return (char)num6;
					}
					return '\0';
				}
				return '\uffff';
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (char)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num7 = (uint)(object)value;
				if (num7 <= 65535)
				{
					return (char)num7;
				}
				return '\uffff';
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num8 = (ulong)(object)value;
				if (num8 <= 65535)
				{
					return (char)num8;
				}
				return '\uffff';
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr <= 65535)
				{
					return (char)(nuint)uIntPtr;
				}
				return '\uffff';
			}
			ThrowHelper.ThrowNotSupportedException();
			return '\0';
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (char)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (char)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (char)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (char)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (char)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (char)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (char)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (char)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (char)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (char)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (char)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (char)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (char)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return '\0';
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (char Quotient, char Remainder) INumber<char>.DivRem(char left, char right)
		{
			(ushort, ushort) tuple = Math.DivRem(left, right);
			return ((char)tuple.Item1, (char)tuple.Item2);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Max(char x, char y)
		{
			return (char)Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Min(char x, char y)
		{
			return (char)Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			if (s.Length != 1)
			{
				throw new FormatException(SR.Format_NeedSingleChar);
			}
			return s[0];
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char INumber<char>.Sign(char value)
		{
			return (char)((value != 0) ? 1u : 0u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<char>.TryCreate<TOther>(TOther value, out char result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (char)(byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < 0m || num > 65535m)
				{
					result = '\0';
					return false;
				}
				result = (char)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < 0.0 || num2 > 65535.0)
				{
					result = '\0';
					return false;
				}
				result = (char)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 < 0)
				{
					result = '\0';
					return false;
				}
				result = (char)num3;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 < 0 || num4 > 65535)
				{
					result = '\0';
					return false;
				}
				result = (char)num4;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 < 0 || num5 > 65535)
				{
					result = '\0';
					return false;
				}
				result = (char)num5;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < 0 || (nint)intPtr > 65535)
				{
					result = '\0';
					return false;
				}
				result = (char)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b < 0)
				{
					result = '\0';
					return false;
				}
				result = (char)b;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (num6 < 0f || num6 > 65535f)
				{
					result = '\0';
					return false;
				}
				result = (char)num6;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				ushort num7 = (ushort)(object)value;
				if (num7 > ushort.MaxValue)
				{
					result = '\0';
					return false;
				}
				result = (char)num7;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num8 = (uint)(object)value;
				if (num8 > 65535)
				{
					result = '\0';
					return false;
				}
				result = (char)num8;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num9 = (ulong)(object)value;
				if (num9 > 65535)
				{
					result = '\0';
					return false;
				}
				result = (char)num9;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr > 65535)
				{
					result = '\0';
					return false;
				}
				result = (char)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = '\0';
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<char>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out char result)
		{
			return TryParse(s, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<char>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out char result)
		{
			if (s.Length != 1)
			{
				result = '\0';
				return false;
			}
			result = s[0];
			return true;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IParseable<char>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<char>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out char result)
		{
			return TryParse(s, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IShiftOperators<char, char>.op_LeftShift(char value, int shiftAmount)
		{
			return (char)((uint)value << shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IShiftOperators<char, char>.op_RightShift(char value, int shiftAmount)
		{
			return (char)((int)value >> shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char ISpanParseable<char>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			if (s.Length != 1)
			{
				throw new FormatException(SR.Format_NeedSingleChar);
			}
			return s[0];
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<char>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out char result)
		{
			if (s.Length != 1)
			{
				result = '\0';
				return false;
			}
			result = s[0];
			return true;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char ISubtractionOperators<char, char, char>.op_Subtraction(char left, char right)
		{
			return (char)(left - right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IUnaryNegationOperators<char, char>.op_UnaryNegation(char value)
		{
			return (char)(0 - value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static char IUnaryPlusOperators<char, char>.op_UnaryPlus(char value)
		{
			return value;
		}
	}
	public sealed class CharEnumerator : System.Collections.IEnumerator, IEnumerator<char>, IDisposable, ICloneable
	{
		private string _str;

		private int _index;

		private char _currentElement;

		object? System.Collections.IEnumerator.Current => Current;

		public char Current
		{
			get
			{
				if (_index == -1)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
				}
				if (_index >= _str.Length)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
				}
				return _currentElement;
			}
		}

		internal CharEnumerator(string str)
		{
			_str = str;
			_index = -1;
		}

		public object Clone()
		{
			return MemberwiseClone();
		}

		public bool MoveNext()
		{
			if (_index < _str.Length - 1)
			{
				_index++;
				_currentElement = _str[_index];
				return true;
			}
			_index = _str.Length;
			return false;
		}

		public void Dispose()
		{
			if (_str != null)
			{
				_index = _str.Length;
			}
			_str = null;
		}

		public void Reset()
		{
			_currentElement = '\0';
			_index = -1;
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = false)]
	public sealed class CLSCompliantAttribute : Attribute
	{
		private readonly bool _compliant;

		public bool IsCompliant => _compliant;

		public CLSCompliantAttribute(bool isCompliant)
		{
			_compliant = isCompliant;
		}
	}
	public abstract class ContextBoundObject : MarshalByRefObject
	{
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ContextMarshalException : SystemException
	{
		public ContextMarshalException()
			: this(SR.Arg_ContextMarshalException, null)
		{
		}

		public ContextMarshalException(string? message)
			: this(message, null)
		{
		}

		public ContextMarshalException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233084;
		}

		protected ContextMarshalException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Field, Inherited = false)]
	public class ContextStaticAttribute : Attribute
	{
	}
	public static class Convert
	{
		internal static readonly Type[] ConvertTypes = new Type[19]
		{
			typeof(Empty),
			typeof(object),
			typeof(DBNull),
			typeof(bool),
			typeof(char),
			typeof(sbyte),
			typeof(byte),
			typeof(short),
			typeof(ushort),
			typeof(int),
			typeof(uint),
			typeof(long),
			typeof(ulong),
			typeof(float),
			typeof(double),
			typeof(decimal),
			typeof(DateTime),
			typeof(object),
			typeof(string)
		};

		private static readonly Type EnumType = typeof(Enum);

		internal static readonly char[] base64Table = new char[65]
		{
			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
			'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
			'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
			'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
			'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
			'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
			'8', '9', '+', '/', '='
		};

		public static readonly object DBNull = System.DBNull.Value;

		private static ReadOnlySpan<sbyte> DecodingMap => new sbyte[256]
		{
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, 62, -1, -1, -1, 63, 52, 53,
			54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
			-1, -1, -1, -1, -1, 0, 1, 2, 3, 4,
			5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
			15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
			25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
			29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
			39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
			49, 50, 51, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1
		};

		private static bool TryDecodeFromUtf16(ReadOnlySpan<char> utf16, Span<byte> bytes, out int consumed, out int written)
		{
			ref char reference = ref MemoryMarshal.GetReference(utf16);
			ref byte reference2 = ref MemoryMarshal.GetReference(bytes);
			int num = utf16.Length & -4;
			int length = bytes.Length;
			int num2 = 0;
			int num3 = 0;
			if (utf16.Length != 0)
			{
				ref sbyte reference3 = ref MemoryMarshal.GetReference(DecodingMap);
				int num4 = ((length < (num >> 2) * 3) ? (length / 3 * 4) : (num - 4));
				while (true)
				{
					if (num2 < num4)
					{
						int num5 = Decode(ref Unsafe.Add(ref reference, num2), ref reference3);
						if (num5 >= 0)
						{
							WriteThreeLowOrderBytes(ref Unsafe.Add(ref reference2, num3), num5);
							num3 += 3;
							num2 += 4;
							continue;
						}
					}
					else if (num4 == num - 4 && num2 != num)
					{
						int num6 = Unsafe.Add(ref reference, num - 4);
						int num7 = Unsafe.Add(ref reference, num - 3);
						int num8 = Unsafe.Add(ref reference, num - 2);
						int num9 = Unsafe.Add(ref reference, num - 1);
						if (((num6 | num7 | num8 | num9) & 0xFFFFFF00u) == 0L)
						{
							num6 = Unsafe.Add(ref reference3, num6);
							num7 = Unsafe.Add(ref reference3, num7);
							num6 <<= 18;
							num7 <<= 12;
							num6 |= num7;
							if (num9 != 61)
							{
								num8 = Unsafe.Add(ref reference3, num8);
								num9 = Unsafe.Add(ref reference3, num9);
								num8 <<= 6;
								num6 |= num9;
								num6 |= num8;
								if (num6 >= 0 && num3 <= length - 3)
								{
									WriteThreeLowOrderBytes(ref Unsafe.Add(ref reference2, num3), num6);
									num3 += 3;
									goto IL_01e6;
								}
							}
							else if (num8 != 61)
							{
								num8 = Unsafe.Add(ref reference3, num8);
								num8 <<= 6;
								num6 |= num8;
								if (num6 >= 0 && num3 <= length - 2)
								{
									Unsafe.Add(ref reference2, num3) = (byte)(num6 >> 16);
									Unsafe.Add(ref reference2, num3 + 1) = (byte)(num6 >> 8);
									num3 += 2;
									goto IL_01e6;
								}
							}
							else if (num6 >= 0 && num3 <= length - 1)
							{
								Unsafe.Add(ref reference2, num3) = (byte)(num6 >> 16);
								num3++;
								goto IL_01e6;
							}
						}
					}
					goto IL_0200;
					IL_0200:
					consumed = num2;
					written = num3;
					return false;
					IL_01e6:
					num2 += 4;
					if (num == utf16.Length)
					{
						break;
					}
					goto IL_0200;
				}
			}
			consumed = num2;
			written = num3;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int Decode(ref char encodedChars, ref sbyte decodingMap)
		{
			int num = encodedChars;
			int num2 = Unsafe.Add(ref encodedChars, 1);
			int num3 = Unsafe.Add(ref encodedChars, 2);
			int num4 = Unsafe.Add(ref encodedChars, 3);
			if (((num | num2 | num3 | num4) & 0xFFFFFF00u) != 0L)
			{
				return -1;
			}
			num = Unsafe.Add(ref decodingMap, num);
			num2 = Unsafe.Add(ref decodingMap, num2);
			num3 = Unsafe.Add(ref decodingMap, num3);
			num4 = Unsafe.Add(ref decodingMap, num4);
			num <<= 18;
			num2 <<= 12;
			num3 <<= 6;
			num |= num4;
			num2 |= num3;
			return num | num2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteThreeLowOrderBytes(ref byte destination, int value)
		{
			destination = (byte)(value >> 16);
			Unsafe.Add(ref destination, 1) = (byte)(value >> 8);
			Unsafe.Add(ref destination, 2) = (byte)value;
		}

		public static TypeCode GetTypeCode(object? value)
		{
			if (value == null)
			{
				return TypeCode.Empty;
			}
			if (value is IConvertible convertible)
			{
				return convertible.GetTypeCode();
			}
			return TypeCode.Object;
		}

		public static bool IsDBNull([NotNullWhen(true)] object? value)
		{
			if (value == System.DBNull.Value)
			{
				return true;
			}
			if (!(value is IConvertible convertible))
			{
				return false;
			}
			return convertible.GetTypeCode() == TypeCode.DBNull;
		}

		[return: NotNullIfNotNull("value")]
		public static object? ChangeType(object? value, TypeCode typeCode)
		{
			return ChangeType(value, typeCode, CultureInfo.CurrentCulture);
		}

		[return: NotNullIfNotNull("value")]
		public static object? ChangeType(object? value, TypeCode typeCode, IFormatProvider? provider)
		{
			if (value == null && (typeCode == TypeCode.Empty || typeCode == TypeCode.String || typeCode == TypeCode.Object))
			{
				return null;
			}
			if (!(value is IConvertible convertible))
			{
				throw new InvalidCastException(SR.InvalidCast_IConvertible);
			}
			return typeCode switch
			{
				TypeCode.Boolean => convertible.ToBoolean(provider), 
				TypeCode.Char => convertible.ToChar(provider), 
				TypeCode.SByte => convertible.ToSByte(provider), 
				TypeCode.Byte => convertible.ToByte(provider), 
				TypeCode.Int16 => convertible.ToInt16(provider), 
				TypeCode.UInt16 => convertible.ToUInt16(provider), 
				TypeCode.Int32 => convertible.ToInt32(provider), 
				TypeCode.UInt32 => convertible.ToUInt32(provider), 
				TypeCode.Int64 => convertible.ToInt64(provider), 
				TypeCode.UInt64 => convertible.ToUInt64(provider), 
				TypeCode.Single => convertible.ToSingle(provider), 
				TypeCode.Double => convertible.ToDouble(provider), 
				TypeCode.Decimal => convertible.ToDecimal(provider), 
				TypeCode.DateTime => convertible.ToDateTime(provider), 
				TypeCode.String => convertible.ToString(provider), 
				TypeCode.Object => value, 
				TypeCode.DBNull => throw new InvalidCastException(SR.InvalidCast_DBNull), 
				TypeCode.Empty => throw new InvalidCastException(SR.InvalidCast_Empty), 
				_ => throw new ArgumentException(SR.Arg_UnknownTypeCode), 
			};
		}

		internal static object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider)
		{
			if (targetType == null)
			{
				throw new ArgumentNullException("targetType");
			}
			if ((object)value.GetType() == targetType)
			{
				return value;
			}
			if ((object)targetType == ConvertTypes[3])
			{
				return value.ToBoolean(provider);
			}
			if ((object)targetType == ConvertTypes[4])
			{
				return value.ToChar(provider);
			}
			if ((object)targetType == ConvertTypes[5])
			{
				return value.ToSByte(provider);
			}
			if ((object)targetType == ConvertTypes[6])
			{
				return value.ToByte(provider);
			}
			if ((object)targetType == ConvertTypes[7])
			{
				return value.ToInt16(provider);
			}
			if ((object)targetType == ConvertTypes[8])
			{
				return value.ToUInt16(provider);
			}
			if ((object)targetType == ConvertTypes[9])
			{
				return value.ToInt32(provider);
			}
			if ((object)targetType == ConvertTypes[10])
			{
				return value.ToUInt32(provider);
			}
			if ((object)targetType == ConvertTypes[11])
			{
				return value.ToInt64(provider);
			}
			if ((object)targetType == ConvertTypes[12])
			{
				return value.ToUInt64(provider);
			}
			if ((object)targetType == ConvertTypes[13])
			{
				return value.ToSingle(provider);
			}
			if ((object)targetType == ConvertTypes[14])
			{
				return value.ToDouble(provider);
			}
			if ((object)targetType == ConvertTypes[15])
			{
				return value.ToDecimal(provider);
			}
			if ((object)targetType == ConvertTypes[16])
			{
				return value.ToDateTime(provider);
			}
			if ((object)targetType == ConvertTypes[18])
			{
				return value.ToString(provider);
			}
			if ((object)targetType == ConvertTypes[1])
			{
				return value;
			}
			if ((object)targetType == EnumType)
			{
				return (Enum)value;
			}
			if ((object)targetType == ConvertTypes[2])
			{
				throw new InvalidCastException(SR.InvalidCast_DBNull);
			}
			if ((object)targetType == ConvertTypes[0])
			{
				throw new InvalidCastException(SR.InvalidCast_Empty);
			}
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, value.GetType().FullName, targetType.FullName));
		}

		[return: NotNullIfNotNull("value")]
		public static object? ChangeType(object? value, Type conversionType)
		{
			return ChangeType(value, conversionType, CultureInfo.CurrentCulture);
		}

		[return: NotNullIfNotNull("value")]
		public static object? ChangeType(object? value, Type conversionType, IFormatProvider? provider)
		{
			if ((object)conversionType == null)
			{
				throw new ArgumentNullException("conversionType");
			}
			if (value == null)
			{
				if (conversionType.IsValueType)
				{
					throw new InvalidCastException(SR.InvalidCast_CannotCastNullToValueType);
				}
				return null;
			}
			if (!(value is IConvertible convertible))
			{
				if (value.GetType() == conversionType)
				{
					return value;
				}
				throw new InvalidCastException(SR.InvalidCast_IConvertible);
			}
			if ((object)conversionType == ConvertTypes[3])
			{
				return convertible.ToBoolean(provider);
			}
			if ((object)conversionType == ConvertTypes[4])
			{
				return convertible.ToChar(provider);
			}
			if ((object)conversionType == ConvertTypes[5])
			{
				return convertible.ToSByte(provider);
			}
			if ((object)conversionType == ConvertTypes[6])
			{
				return convertible.ToByte(provider);
			}
			if ((object)conversionType == ConvertTypes[7])
			{
				return convertible.ToInt16(provider);
			}
			if ((object)conversionType == ConvertTypes[8])
			{
				return convertible.ToUInt16(provider);
			}
			if ((object)conversionType == ConvertTypes[9])
			{
				return convertible.ToInt32(provider);
			}
			if ((object)conversionType == ConvertTypes[10])
			{
				return convertible.ToUInt32(provider);
			}
			if ((object)conversionType == ConvertTypes[11])
			{
				return convertible.ToInt64(provider);
			}
			if ((object)conversionType == ConvertTypes[12])
			{
				return convertible.ToUInt64(provider);
			}
			if ((object)conversionType == ConvertTypes[13])
			{
				return convertible.ToSingle(provider);
			}
			if ((object)conversionType == ConvertTypes[14])
			{
				return convertible.ToDouble(provider);
			}
			if ((object)conversionType == ConvertTypes[15])
			{
				return convertible.ToDecimal(provider);
			}
			if ((object)conversionType == ConvertTypes[16])
			{
				return convertible.ToDateTime(provider);
			}
			if ((object)conversionType == ConvertTypes[18])
			{
				return convertible.ToString(provider);
			}
			if ((object)conversionType == ConvertTypes[1])
			{
				return value;
			}
			return convertible.ToType(conversionType, provider);
		}

		[DoesNotReturn]
		private static void ThrowCharOverflowException()
		{
			throw new OverflowException(SR.Overflow_Char);
		}

		[DoesNotReturn]
		private static void ThrowByteOverflowException()
		{
			throw new OverflowException(SR.Overflow_Byte);
		}

		[DoesNotReturn]
		private static void ThrowSByteOverflowException()
		{
			throw new OverflowException(SR.Overflow_SByte);
		}

		[DoesNotReturn]
		private static void ThrowInt16OverflowException()
		{
			throw new OverflowException(SR.Overflow_Int16);
		}

		[DoesNotReturn]
		private static void ThrowUInt16OverflowException()
		{
			throw new OverflowException(SR.Overflow_UInt16);
		}

		[DoesNotReturn]
		private static void ThrowInt32OverflowException()
		{
			throw new OverflowException(SR.Overflow_Int32);
		}

		[DoesNotReturn]
		private static void ThrowUInt32OverflowException()
		{
			throw new OverflowException(SR.Overflow_UInt32);
		}

		[DoesNotReturn]
		private static void ThrowInt64OverflowException()
		{
			throw new OverflowException(SR.Overflow_Int64);
		}

		[DoesNotReturn]
		private static void ThrowUInt64OverflowException()
		{
			throw new OverflowException(SR.Overflow_UInt64);
		}

		public static bool ToBoolean([NotNullWhen(true)] object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToBoolean(null);
			}
			return false;
		}

		public static bool ToBoolean([NotNullWhen(true)] object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToBoolean(provider);
			}
			return false;
		}

		public static bool ToBoolean(bool value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static bool ToBoolean(sbyte value)
		{
			return value != 0;
		}

		public static bool ToBoolean(char value)
		{
			return ((IConvertible)value).ToBoolean((IFormatProvider?)null);
		}

		public static bool ToBoolean(byte value)
		{
			return value != 0;
		}

		public static bool ToBoolean(short value)
		{
			return value != 0;
		}

		[CLSCompliant(false)]
		public static bool ToBoolean(ushort value)
		{
			return value != 0;
		}

		public static bool ToBoolean(int value)
		{
			return value != 0;
		}

		[CLSCompliant(false)]
		public static bool ToBoolean(uint value)
		{
			return value != 0;
		}

		public static bool ToBoolean(long value)
		{
			return value != 0;
		}

		[CLSCompliant(false)]
		public static bool ToBoolean(ulong value)
		{
			return value != 0;
		}

		public static bool ToBoolean([NotNullWhen(true)] string? value)
		{
			if (value == null)
			{
				return false;
			}
			return bool.Parse(value);
		}

		public static bool ToBoolean([NotNullWhen(true)] string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return false;
			}
			return bool.Parse(value);
		}

		public static bool ToBoolean(float value)
		{
			return value != 0f;
		}

		public static bool ToBoolean(double value)
		{
			return value != 0.0;
		}

		public static bool ToBoolean(decimal value)
		{
			return value != 0m;
		}

		public static bool ToBoolean(DateTime value)
		{
			return ((IConvertible)value).ToBoolean((IFormatProvider?)null);
		}

		public static char ToChar(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToChar(null);
			}
			return '\0';
		}

		public static char ToChar(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToChar(provider);
			}
			return '\0';
		}

		public static char ToChar(bool value)
		{
			return ((IConvertible)value).ToChar((IFormatProvider?)null);
		}

		public static char ToChar(char value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static char ToChar(sbyte value)
		{
			if (value < 0)
			{
				ThrowCharOverflowException();
			}
			return (char)value;
		}

		public static char ToChar(byte value)
		{
			return (char)value;
		}

		public static char ToChar(short value)
		{
			if (value < 0)
			{
				ThrowCharOverflowException();
			}
			return (char)value;
		}

		[CLSCompliant(false)]
		public static char ToChar(ushort value)
		{
			return (char)value;
		}

		public static char ToChar(int value)
		{
			return ToChar((uint)value);
		}

		[CLSCompliant(false)]
		public static char ToChar(uint value)
		{
			if (value > 65535)
			{
				ThrowCharOverflowException();
			}
			return (char)value;
		}

		public static char ToChar(long value)
		{
			return ToChar((ulong)value);
		}

		[CLSCompliant(false)]
		public static char ToChar(ulong value)
		{
			if (value > 65535)
			{
				ThrowCharOverflowException();
			}
			return (char)value;
		}

		public static char ToChar(string value)
		{
			return ToChar(value, null);
		}

		public static char ToChar(string value, IFormatProvider? provider)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (value.Length != 1)
			{
				throw new FormatException(SR.Format_NeedSingleChar);
			}
			return value[0];
		}

		public static char ToChar(float value)
		{
			return ((IConvertible)value).ToChar((IFormatProvider?)null);
		}

		public static char ToChar(double value)
		{
			return ((IConvertible)value).ToChar((IFormatProvider?)null);
		}

		public static char ToChar(decimal value)
		{
			return ((IConvertible)value).ToChar((IFormatProvider?)null);
		}

		public static char ToChar(DateTime value)
		{
			return ((IConvertible)value).ToChar((IFormatProvider?)null);
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToSByte(null);
			}
			return 0;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToSByte(provider);
			}
			return 0;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(bool value)
		{
			if (!value)
			{
				return 0;
			}
			return 1;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(sbyte value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(char value)
		{
			if (value > '\u007f')
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(byte value)
		{
			if (value > 127)
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(short value)
		{
			if (value < -128 || value > 127)
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(ushort value)
		{
			if (value > 127)
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(int value)
		{
			if (value < -128 || value > 127)
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(uint value)
		{
			if (value > 127)
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(long value)
		{
			if (value < -128 || value > 127)
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(ulong value)
		{
			if (value > 127)
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)value;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(float value)
		{
			return ToSByte((double)value);
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(double value)
		{
			return ToSByte(ToInt32(value));
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(decimal value)
		{
			return decimal.ToSByte(decimal.Round(value, 0));
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(string? value)
		{
			if (value == null)
			{
				return 0;
			}
			return sbyte.Parse(value);
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(string value, IFormatProvider? provider)
		{
			return sbyte.Parse(value, provider);
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(DateTime value)
		{
			return ((IConvertible)value).ToSByte((IFormatProvider?)null);
		}

		public static byte ToByte(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToByte(null);
			}
			return 0;
		}

		public static byte ToByte(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToByte(provider);
			}
			return 0;
		}

		public static byte ToByte(bool value)
		{
			if (!value)
			{
				return 0;
			}
			return 1;
		}

		public static byte ToByte(byte value)
		{
			return value;
		}

		public static byte ToByte(char value)
		{
			if (value > 'ÿ')
			{
				ThrowByteOverflowException();
			}
			return (byte)value;
		}

		[CLSCompliant(false)]
		public static byte ToByte(sbyte value)
		{
			if (value < 0)
			{
				ThrowByteOverflowException();
			}
			return (byte)value;
		}

		public static byte ToByte(short value)
		{
			if ((uint)value > 255u)
			{
				ThrowByteOverflowException();
			}
			return (byte)value;
		}

		[CLSCompliant(false)]
		public static byte ToByte(ushort value)
		{
			if (value > 255)
			{
				ThrowByteOverflowException();
			}
			return (byte)value;
		}

		public static byte ToByte(int value)
		{
			return ToByte((uint)value);
		}

		[CLSCompliant(false)]
		public static byte ToByte(uint value)
		{
			if (value > 255)
			{
				ThrowByteOverflowException();
			}
			return (byte)value;
		}

		public static byte ToByte(long value)
		{
			return ToByte((ulong)value);
		}

		[CLSCompliant(false)]
		public static byte ToByte(ulong value)
		{
			if (value > 255)
			{
				ThrowByteOverflowException();
			}
			return (byte)value;
		}

		public static byte ToByte(float value)
		{
			return ToByte((double)value);
		}

		public static byte ToByte(double value)
		{
			return ToByte(ToInt32(value));
		}

		public static byte ToByte(decimal value)
		{
			return decimal.ToByte(decimal.Round(value, 0));
		}

		public static byte ToByte(string? value)
		{
			if (value == null)
			{
				return 0;
			}
			return byte.Parse(value);
		}

		public static byte ToByte(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0;
			}
			return byte.Parse(value, provider);
		}

		public static byte ToByte(DateTime value)
		{
			return ((IConvertible)value).ToByte((IFormatProvider?)null);
		}

		public static short ToInt16(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToInt16(null);
			}
			return 0;
		}

		public static short ToInt16(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToInt16(provider);
			}
			return 0;
		}

		public static short ToInt16(bool value)
		{
			if (!value)
			{
				return 0;
			}
			return 1;
		}

		public static short ToInt16(char value)
		{
			if (value > '翿')
			{
				ThrowInt16OverflowException();
			}
			return (short)value;
		}

		[CLSCompliant(false)]
		public static short ToInt16(sbyte value)
		{
			return value;
		}

		public static short ToInt16(byte value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static short ToInt16(ushort value)
		{
			if (value > 32767)
			{
				ThrowInt16OverflowException();
			}
			return (short)value;
		}

		public static short ToInt16(int value)
		{
			if (value < -32768 || value > 32767)
			{
				ThrowInt16OverflowException();
			}
			return (short)value;
		}

		[CLSCompliant(false)]
		public static short ToInt16(uint value)
		{
			if (value > 32767)
			{
				ThrowInt16OverflowException();
			}
			return (short)value;
		}

		public static short ToInt16(short value)
		{
			return value;
		}

		public static short ToInt16(long value)
		{
			if (value < -32768 || value > 32767)
			{
				ThrowInt16OverflowException();
			}
			return (short)value;
		}

		[CLSCompliant(false)]
		public static short ToInt16(ulong value)
		{
			if (value > 32767)
			{
				ThrowInt16OverflowException();
			}
			return (short)value;
		}

		public static short ToInt16(float value)
		{
			return ToInt16((double)value);
		}

		public static short ToInt16(double value)
		{
			return ToInt16(ToInt32(value));
		}

		public static short ToInt16(decimal value)
		{
			return decimal.ToInt16(decimal.Round(value, 0));
		}

		public static short ToInt16(string? value)
		{
			if (value == null)
			{
				return 0;
			}
			return short.Parse(value);
		}

		public static short ToInt16(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0;
			}
			return short.Parse(value, provider);
		}

		public static short ToInt16(DateTime value)
		{
			return ((IConvertible)value).ToInt16((IFormatProvider?)null);
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToUInt16(null);
			}
			return 0;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToUInt16(provider);
			}
			return 0;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(bool value)
		{
			if (!value)
			{
				return 0;
			}
			return 1;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(char value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(sbyte value)
		{
			if (value < 0)
			{
				ThrowUInt16OverflowException();
			}
			return (ushort)value;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(byte value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(short value)
		{
			if (value < 0)
			{
				ThrowUInt16OverflowException();
			}
			return (ushort)value;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(int value)
		{
			return ToUInt16((uint)value);
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(ushort value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(uint value)
		{
			if (value > 65535)
			{
				ThrowUInt16OverflowException();
			}
			return (ushort)value;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(long value)
		{
			return ToUInt16((ulong)value);
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(ulong value)
		{
			if (value > 65535)
			{
				ThrowUInt16OverflowException();
			}
			return (ushort)value;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(float value)
		{
			return ToUInt16((double)value);
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(double value)
		{
			return ToUInt16(ToInt32(value));
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(decimal value)
		{
			return decimal.ToUInt16(decimal.Round(value, 0));
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(string? value)
		{
			if (value == null)
			{
				return 0;
			}
			return ushort.Parse(value);
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0;
			}
			return ushort.Parse(value, provider);
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(DateTime value)
		{
			return ((IConvertible)value).ToUInt16((IFormatProvider?)null);
		}

		public static int ToInt32(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToInt32(null);
			}
			return 0;
		}

		public static int ToInt32(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToInt32(provider);
			}
			return 0;
		}

		public static int ToInt32(bool value)
		{
			if (!value)
			{
				return 0;
			}
			return 1;
		}

		public static int ToInt32(char value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static int ToInt32(sbyte value)
		{
			return value;
		}

		public static int ToInt32(byte value)
		{
			return value;
		}

		public static int ToInt32(short value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static int ToInt32(ushort value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static int ToInt32(uint value)
		{
			if ((int)value < 0)
			{
				ThrowInt32OverflowException();
			}
			return (int)value;
		}

		public static int ToInt32(int value)
		{
			return value;
		}

		public static int ToInt32(long value)
		{
			if (value < int.MinValue || value > int.MaxValue)
			{
				ThrowInt32OverflowException();
			}
			return (int)value;
		}

		[CLSCompliant(false)]
		public static int ToInt32(ulong value)
		{
			if (value > int.MaxValue)
			{
				ThrowInt32OverflowException();
			}
			return (int)value;
		}

		public static int ToInt32(float value)
		{
			return ToInt32((double)value);
		}

		public static int ToInt32(double value)
		{
			if (value >= 0.0)
			{
				if (value < 2147483647.5)
				{
					int num = (int)value;
					double num2 = value - (double)num;
					if (num2 > 0.5 || (num2 == 0.5 && ((uint)num & (true ? 1u : 0u)) != 0))
					{
						num++;
					}
					return num;
				}
			}
			else if (value >= -2147483648.5)
			{
				int num3 = (int)value;
				double num4 = value - (double)num3;
				if (num4 < -0.5 || (num4 == -0.5 && ((uint)num3 & (true ? 1u : 0u)) != 0))
				{
					num3--;
				}
				return num3;
			}
			throw new OverflowException(SR.Overflow_Int32);
		}

		public static int ToInt32(decimal value)
		{
			return decimal.ToInt32(decimal.Round(value, 0));
		}

		public static int ToInt32(string? value)
		{
			if (value == null)
			{
				return 0;
			}
			return int.Parse(value);
		}

		public static int ToInt32(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0;
			}
			return int.Parse(value, provider);
		}

		public static int ToInt32(DateTime value)
		{
			return ((IConvertible)value).ToInt32((IFormatProvider?)null);
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToUInt32(null);
			}
			return 0u;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToUInt32(provider);
			}
			return 0u;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(bool value)
		{
			if (!value)
			{
				return 0u;
			}
			return 1u;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(char value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(sbyte value)
		{
			if (value < 0)
			{
				ThrowUInt32OverflowException();
			}
			return (uint)value;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(byte value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(short value)
		{
			if (value < 0)
			{
				ThrowUInt32OverflowException();
			}
			return (uint)value;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(ushort value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(int value)
		{
			if (value < 0)
			{
				ThrowUInt32OverflowException();
			}
			return (uint)value;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(uint value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(long value)
		{
			return ToUInt32((ulong)value);
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(ulong value)
		{
			if (value > uint.MaxValue)
			{
				ThrowUInt32OverflowException();
			}
			return (uint)value;
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(float value)
		{
			return ToUInt32((double)value);
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(double value)
		{
			if (value >= -0.5 && value < 4294967295.5)
			{
				uint num = (uint)value;
				double num2 = value - (double)num;
				if (num2 > 0.5 || (num2 == 0.5 && (num & (true ? 1u : 0u)) != 0))
				{
					num++;
				}
				return num;
			}
			throw new OverflowException(SR.Overflow_UInt32);
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(decimal value)
		{
			return decimal.ToUInt32(decimal.Round(value, 0));
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(string? value)
		{
			if (value == null)
			{
				return 0u;
			}
			return uint.Parse(value);
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0u;
			}
			return uint.Parse(value, provider);
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(DateTime value)
		{
			return ((IConvertible)value).ToUInt32((IFormatProvider?)null);
		}

		public static long ToInt64(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToInt64(null);
			}
			return 0L;
		}

		public static long ToInt64(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToInt64(provider);
			}
			return 0L;
		}

		public static long ToInt64(bool value)
		{
			return value ? 1 : 0;
		}

		public static long ToInt64(char value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static long ToInt64(sbyte value)
		{
			return value;
		}

		public static long ToInt64(byte value)
		{
			return value;
		}

		public static long ToInt64(short value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static long ToInt64(ushort value)
		{
			return value;
		}

		public static long ToInt64(int value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static long ToInt64(uint value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static long ToInt64(ulong value)
		{
			if ((long)value < 0L)
			{
				ThrowInt64OverflowException();
			}
			return (long)value;
		}

		public static long ToInt64(long value)
		{
			return value;
		}

		public static long ToInt64(float value)
		{
			return ToInt64((double)value);
		}

		public static long ToInt64(double value)
		{
			return checked((long)Math.Round(value));
		}

		public static long ToInt64(decimal value)
		{
			return decimal.ToInt64(decimal.Round(value, 0));
		}

		public static long ToInt64(string? value)
		{
			if (value == null)
			{
				return 0L;
			}
			return long.Parse(value);
		}

		public static long ToInt64(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0L;
			}
			return long.Parse(value, provider);
		}

		public static long ToInt64(DateTime value)
		{
			return ((IConvertible)value).ToInt64((IFormatProvider?)null);
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToUInt64(null);
			}
			return 0uL;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToUInt64(provider);
			}
			return 0uL;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(bool value)
		{
			if (!value)
			{
				return 0uL;
			}
			return 1uL;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(char value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(sbyte value)
		{
			if (value < 0)
			{
				ThrowUInt64OverflowException();
			}
			return (ulong)value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(byte value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(short value)
		{
			if (value < 0)
			{
				ThrowUInt64OverflowException();
			}
			return (ulong)value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(ushort value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(int value)
		{
			if (value < 0)
			{
				ThrowUInt64OverflowException();
			}
			return (ulong)value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(uint value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(long value)
		{
			if (value < 0)
			{
				ThrowUInt64OverflowException();
			}
			return (ulong)value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(ulong value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(float value)
		{
			return ToUInt64((double)value);
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(double value)
		{
			return checked((ulong)Math.Round(value));
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(decimal value)
		{
			return decimal.ToUInt64(decimal.Round(value, 0));
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(string? value)
		{
			if (value == null)
			{
				return 0uL;
			}
			return ulong.Parse(value);
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0uL;
			}
			return ulong.Parse(value, provider);
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(DateTime value)
		{
			return ((IConvertible)value).ToUInt64((IFormatProvider?)null);
		}

		public static float ToSingle(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToSingle(null);
			}
			return 0f;
		}

		public static float ToSingle(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToSingle(provider);
			}
			return 0f;
		}

		[CLSCompliant(false)]
		public static float ToSingle(sbyte value)
		{
			return value;
		}

		public static float ToSingle(byte value)
		{
			return (int)value;
		}

		public static float ToSingle(char value)
		{
			return ((IConvertible)value).ToSingle((IFormatProvider?)null);
		}

		public static float ToSingle(short value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static float ToSingle(ushort value)
		{
			return (int)value;
		}

		public static float ToSingle(int value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static float ToSingle(uint value)
		{
			return value;
		}

		public static float ToSingle(long value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static float ToSingle(ulong value)
		{
			return value;
		}

		public static float ToSingle(float value)
		{
			return value;
		}

		public static float ToSingle(double value)
		{
			return (float)value;
		}

		public static float ToSingle(decimal value)
		{
			return (float)value;
		}

		public static float ToSingle(string? value)
		{
			if (value == null)
			{
				return 0f;
			}
			return float.Parse(value);
		}

		public static float ToSingle(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0f;
			}
			return float.Parse(value, provider);
		}

		public static float ToSingle(bool value)
		{
			return value ? 1 : 0;
		}

		public static float ToSingle(DateTime value)
		{
			return ((IConvertible)value).ToSingle((IFormatProvider?)null);
		}

		public static double ToDouble(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToDouble(null);
			}
			return 0.0;
		}

		public static double ToDouble(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToDouble(provider);
			}
			return 0.0;
		}

		[CLSCompliant(false)]
		public static double ToDouble(sbyte value)
		{
			return value;
		}

		public static double ToDouble(byte value)
		{
			return (int)value;
		}

		public static double ToDouble(short value)
		{
			return value;
		}

		public static double ToDouble(char value)
		{
			return ((IConvertible)value).ToDouble((IFormatProvider?)null);
		}

		[CLSCompliant(false)]
		public static double ToDouble(ushort value)
		{
			return (int)value;
		}

		public static double ToDouble(int value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static double ToDouble(uint value)
		{
			return value;
		}

		public static double ToDouble(long value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static double ToDouble(ulong value)
		{
			return value;
		}

		public static double ToDouble(float value)
		{
			return value;
		}

		public static double ToDouble(double value)
		{
			return value;
		}

		public static double ToDouble(decimal value)
		{
			return (double)value;
		}

		public static double ToDouble(string? value)
		{
			if (value == null)
			{
				return 0.0;
			}
			return double.Parse(value);
		}

		public static double ToDouble(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0.0;
			}
			return double.Parse(value, provider);
		}

		public static double ToDouble(bool value)
		{
			return value ? 1 : 0;
		}

		public static double ToDouble(DateTime value)
		{
			return ((IConvertible)value).ToDouble((IFormatProvider?)null);
		}

		public static decimal ToDecimal(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToDecimal(null);
			}
			return 0m;
		}

		public static decimal ToDecimal(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToDecimal(provider);
			}
			return 0m;
		}

		[CLSCompliant(false)]
		public static decimal ToDecimal(sbyte value)
		{
			return value;
		}

		public static decimal ToDecimal(byte value)
		{
			return value;
		}

		public static decimal ToDecimal(char value)
		{
			return ((IConvertible)value).ToDecimal((IFormatProvider?)null);
		}

		public static decimal ToDecimal(short value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static decimal ToDecimal(ushort value)
		{
			return value;
		}

		public static decimal ToDecimal(int value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static decimal ToDecimal(uint value)
		{
			return value;
		}

		public static decimal ToDecimal(long value)
		{
			return value;
		}

		[CLSCompliant(false)]
		public static decimal ToDecimal(ulong value)
		{
			return value;
		}

		public static decimal ToDecimal(float value)
		{
			return (decimal)value;
		}

		public static decimal ToDecimal(double value)
		{
			return (decimal)value;
		}

		public static decimal ToDecimal(string? value)
		{
			if (value == null)
			{
				return 0m;
			}
			return decimal.Parse(value);
		}

		public static decimal ToDecimal(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return 0m;
			}
			return decimal.Parse(value, provider);
		}

		public static decimal ToDecimal(decimal value)
		{
			return value;
		}

		public static decimal ToDecimal(bool value)
		{
			return value ? 1 : 0;
		}

		public static decimal ToDecimal(DateTime value)
		{
			return ((IConvertible)value).ToDecimal((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(DateTime value)
		{
			return value;
		}

		public static DateTime ToDateTime(object? value)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToDateTime(null);
			}
			return DateTime.MinValue;
		}

		public static DateTime ToDateTime(object? value, IFormatProvider? provider)
		{
			if (value != null)
			{
				return ((IConvertible)value).ToDateTime(provider);
			}
			return DateTime.MinValue;
		}

		public static DateTime ToDateTime(string? value)
		{
			if (value == null)
			{
				return new DateTime(0L);
			}
			return DateTime.Parse(value);
		}

		public static DateTime ToDateTime(string? value, IFormatProvider? provider)
		{
			if (value == null)
			{
				return new DateTime(0L);
			}
			return DateTime.Parse(value, provider);
		}

		[CLSCompliant(false)]
		public static DateTime ToDateTime(sbyte value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(byte value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(short value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		[CLSCompliant(false)]
		public static DateTime ToDateTime(ushort value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(int value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		[CLSCompliant(false)]
		public static DateTime ToDateTime(uint value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(long value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		[CLSCompliant(false)]
		public static DateTime ToDateTime(ulong value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(bool value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(char value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(float value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(double value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static DateTime ToDateTime(decimal value)
		{
			return ((IConvertible)value).ToDateTime((IFormatProvider?)null);
		}

		public static string? ToString(object? value)
		{
			return ToString(value, null);
		}

		public static string? ToString(object? value, IFormatProvider? provider)
		{
			if (value is IConvertible convertible)
			{
				return convertible.ToString(provider);
			}
			if (value is IFormattable formattable)
			{
				return formattable.ToString(null, provider);
			}
			if (value != null)
			{
				return value.ToString();
			}
			return string.Empty;
		}

		public static string ToString(bool value)
		{
			return value.ToString();
		}

		public static string ToString(bool value, IFormatProvider? provider)
		{
			return value.ToString();
		}

		public static string ToString(char value)
		{
			return char.ToString(value);
		}

		public static string ToString(char value, IFormatProvider? provider)
		{
			return value.ToString();
		}

		[CLSCompliant(false)]
		public static string ToString(sbyte value)
		{
			return value.ToString();
		}

		[CLSCompliant(false)]
		public static string ToString(sbyte value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		public static string ToString(byte value)
		{
			return value.ToString();
		}

		public static string ToString(byte value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		public static string ToString(short value)
		{
			return value.ToString();
		}

		public static string ToString(short value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		[CLSCompliant(false)]
		public static string ToString(ushort value)
		{
			return value.ToString();
		}

		[CLSCompliant(false)]
		public static string ToString(ushort value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		public static string ToString(int value)
		{
			return value.ToString();
		}

		public static string ToString(int value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		[CLSCompliant(false)]
		public static string ToString(uint value)
		{
			return value.ToString();
		}

		[CLSCompliant(false)]
		public static string ToString(uint value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		public static string ToString(long value)
		{
			return value.ToString();
		}

		public static string ToString(long value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		[CLSCompliant(false)]
		public static string ToString(ulong value)
		{
			return value.ToString();
		}

		[CLSCompliant(false)]
		public static string ToString(ulong value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		public static string ToString(float value)
		{
			return value.ToString();
		}

		public static string ToString(float value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		public static string ToString(double value)
		{
			return value.ToString();
		}

		public static string ToString(double value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		public static string ToString(decimal value)
		{
			return value.ToString();
		}

		public static string ToString(decimal value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		public static string ToString(DateTime value)
		{
			return value.ToString();
		}

		public static string ToString(DateTime value, IFormatProvider? provider)
		{
			return value.ToString(provider);
		}

		[return: NotNullIfNotNull("value")]
		public static string? ToString(string? value)
		{
			return value;
		}

		[return: NotNullIfNotNull("value")]
		public static string? ToString(string? value, IFormatProvider? provider)
		{
			return value;
		}

		public static byte ToByte(string? value, int fromBase)
		{
			if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			if (value == null)
			{
				return 0;
			}
			int num = ParseNumbers.StringToInt(value.AsSpan(), fromBase, 4608);
			if ((uint)num > 255u)
			{
				ThrowByteOverflowException();
			}
			return (byte)num;
		}

		[CLSCompliant(false)]
		public static sbyte ToSByte(string? value, int fromBase)
		{
			if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			if (value == null)
			{
				return 0;
			}
			int num = ParseNumbers.StringToInt(value.AsSpan(), fromBase, 5120);
			if (fromBase != 10 && num <= 255)
			{
				return (sbyte)num;
			}
			if (num < -128 || num > 127)
			{
				ThrowSByteOverflowException();
			}
			return (sbyte)num;
		}

		public static short ToInt16(string? value, int fromBase)
		{
			if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			if (value == null)
			{
				return 0;
			}
			int num = ParseNumbers.StringToInt(value.AsSpan(), fromBase, 6144);
			if (fromBase != 10 && num <= 65535)
			{
				return (short)num;
			}
			if (num < -32768 || num > 32767)
			{
				ThrowInt16OverflowException();
			}
			return (short)num;
		}

		[CLSCompliant(false)]
		public static ushort ToUInt16(string? value, int fromBase)
		{
			if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			if (value == null)
			{
				return 0;
			}
			int num = ParseNumbers.StringToInt(value.AsSpan(), fromBase, 4608);
			if ((uint)num > 65535u)
			{
				ThrowUInt16OverflowException();
			}
			return (ushort)num;
		}

		public static int ToInt32(string? value, int fromBase)
		{
			if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			if (value == null)
			{
				return 0;
			}
			return ParseNumbers.StringToInt(value.AsSpan(), fromBase, 4096);
		}

		[CLSCompliant(false)]
		public static uint ToUInt32(string? value, int fromBase)
		{
			if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			if (value == null)
			{
				return 0u;
			}
			return (uint)ParseNumbers.StringToInt(value.AsSpan(), fromBase, 4608);
		}

		public static long ToInt64(string? value, int fromBase)
		{
			if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			if (value == null)
			{
				return 0L;
			}
			return ParseNumbers.StringToLong(value.AsSpan(), fromBase, 4096);
		}

		[CLSCompliant(false)]
		public static ulong ToUInt64(string? value, int fromBase)
		{
			if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			if (value == null)
			{
				return 0uL;
			}
			return (ulong)ParseNumbers.StringToLong(value.AsSpan(), fromBase, 4608);
		}

		public static string ToString(byte value, int toBase)
		{
			if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			return ParseNumbers.IntToString(value, toBase, -1, ' ', 64);
		}

		public static string ToString(short value, int toBase)
		{
			if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			return ParseNumbers.IntToString(value, toBase, -1, ' ', 128);
		}

		public static string ToString(int value, int toBase)
		{
			if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			return ParseNumbers.IntToString(value, toBase, -1, ' ', 0);
		}

		public static string ToString(long value, int toBase)
		{
			if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase);
			}
			return ParseNumbers.LongToString(value, toBase, -1, ' ', 0);
		}

		public static string ToBase64String(byte[] inArray)
		{
			if (inArray == null)
			{
				throw new ArgumentNullException("inArray");
			}
			return ToBase64String(new ReadOnlySpan<byte>(inArray));
		}

		public static string ToBase64String(byte[] inArray, Base64FormattingOptions options)
		{
			if (inArray == null)
			{
				throw new ArgumentNullException("inArray");
			}
			return ToBase64String(new ReadOnlySpan<byte>(inArray), options);
		}

		public static string ToBase64String(byte[] inArray, int offset, int length)
		{
			return ToBase64String(inArray, offset, length, Base64FormattingOptions.None);
		}

		public static string ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options)
		{
			if (inArray == null)
			{
				throw new ArgumentNullException("inArray");
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_Index);
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (offset > inArray.Length - length)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_OffsetLength);
			}
			return ToBase64String(new ReadOnlySpan<byte>(inArray, offset, length), options);
		}

		public unsafe static string ToBase64String(ReadOnlySpan<byte> bytes, Base64FormattingOptions options = Base64FormattingOptions.None)
		{
			if (options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks)
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)options), "options");
			}
			if (bytes.Length == 0)
			{
				return string.Empty;
			}
			bool insertLineBreaks = options == Base64FormattingOptions.InsertLineBreaks;
			string text = string.FastAllocateString(ToBase64_CalculateAndValidateOutputLength(bytes.Length, insertLineBreaks));
			fixed (byte* inData = &MemoryMarshal.GetReference(bytes))
			{
				fixed (char* outChars = text)
				{
					int num = ConvertToBase64Array(outChars, inData, 0, bytes.Length, insertLineBreaks);
				}
			}
			return text;
		}

		public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut)
		{
			return ToBase64CharArray(inArray, offsetIn, length, outArray, offsetOut, Base64FormattingOptions.None);
		}

		public unsafe static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options)
		{
			if (inArray == null)
			{
				throw new ArgumentNullException("inArray");
			}
			if (outArray == null)
			{
				throw new ArgumentNullException("outArray");
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_Index);
			}
			if (offsetIn < 0)
			{
				throw new ArgumentOutOfRangeException("offsetIn", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (offsetOut < 0)
			{
				throw new ArgumentOutOfRangeException("offsetOut", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks)
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)options), "options");
			}
			int num = inArray.Length;
			if (offsetIn > num - length)
			{
				throw new ArgumentOutOfRangeException("offsetIn", SR.ArgumentOutOfRange_OffsetLength);
			}
			if (num == 0)
			{
				return 0;
			}
			bool insertLineBreaks = options == Base64FormattingOptions.InsertLineBreaks;
			int num2 = outArray.Length;
			int num3 = ToBase64_CalculateAndValidateOutputLength(length, insertLineBreaks);
			if (offsetOut > num2 - num3)
			{
				throw new ArgumentOutOfRangeException("offsetOut", SR.ArgumentOutOfRange_OffsetOut);
			}
			int result;
			fixed (char* outChars = &outArray[offsetOut])
			{
				fixed (byte* inData = &inArray[0])
				{
					result = ConvertToBase64Array(outChars, inData, offsetIn, length, insertLineBreaks);
				}
			}
			return result;
		}

		public unsafe static bool TryToBase64Chars(ReadOnlySpan<byte> bytes, Span<char> chars, out int charsWritten, Base64FormattingOptions options = Base64FormattingOptions.None)
		{
			if (options < Base64FormattingOptions.None || options > Base64FormattingOptions.InsertLineBreaks)
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)options), "options");
			}
			if (bytes.Length == 0)
			{
				charsWritten = 0;
				return true;
			}
			bool insertLineBreaks = options == Base64FormattingOptions.InsertLineBreaks;
			int num = ToBase64_CalculateAndValidateOutputLength(bytes.Length, insertLineBreaks);
			if (num > chars.Length)
			{
				charsWritten = 0;
				return false;
			}
			fixed (char* outChars = &MemoryMarshal.GetReference(chars))
			{
				fixed (byte* inData = &MemoryMarshal.GetReference(bytes))
				{
					charsWritten = ConvertToBase64Array(outChars, inData, 0, bytes.Length, insertLineBreaks);
					return true;
				}
			}
		}

		private unsafe static int ConvertToBase64Array(char* outChars, byte* inData, int offset, int length, bool insertLineBreaks)
		{
			int num = length % 3;
			int num2 = offset + (length - num);
			int num3 = 0;
			int num4 = 0;
			fixed (char* ptr = &base64Table[0])
			{
				int i;
				for (i = offset; i < num2; i += 3)
				{
					if (insertLineBreaks)
					{
						if (num4 == 76)
						{
							outChars[num3++] = '\r';
							outChars[num3++] = '\n';
							num4 = 0;
						}
						num4 += 4;
					}
					outChars[num3] = ptr[(inData[i] & 0xFC) >> 2];
					outChars[num3 + 1] = ptr[((inData[i] & 3) << 4) | ((inData[i + 1] & 0xF0) >> 4)];
					outChars[num3 + 2] = ptr[((inData[i + 1] & 0xF) << 2) | ((inData[i + 2] & 0xC0) >> 6)];
					outChars[num3 + 3] = ptr[inData[i + 2] & 0x3F];
					num3 += 4;
				}
				i = num2;
				if (insertLineBreaks && num != 0 && num4 == 76)
				{
					outChars[num3++] = '\r';
					outChars[num3++] = '\n';
				}
				switch (num)
				{
				case 2:
					outChars[num3] = ptr[(inData[i] & 0xFC) >> 2];
					outChars[num3 + 1] = ptr[((inData[i] & 3) << 4) | ((inData[i + 1] & 0xF0) >> 4)];
					outChars[num3 + 2] = ptr[(inData[i + 1] & 0xF) << 2];
					outChars[num3 + 3] = ptr[64];
					num3 += 4;
					break;
				case 1:
					outChars[num3] = ptr[(inData[i] & 0xFC) >> 2];
					outChars[num3 + 1] = ptr[(inData[i] & 3) << 4];
					outChars[num3 + 2] = ptr[64];
					outChars[num3 + 3] = ptr[64];
					num3 += 4;
					break;
				}
			}
			return num3;
		}

		private static int ToBase64_CalculateAndValidateOutputLength(int inputLength, bool insertLineBreaks)
		{
			long num = ((long)inputLength + 2L) / 3 * 4;
			if (num == 0L)
			{
				return 0;
			}
			if (insertLineBreaks)
			{
				var (num2, num3) = Math.DivRem(num, 76L);
				if (num3 == 0L)
				{
					num2--;
				}
				num += num2 * 2;
			}
			if (num > int.MaxValue)
			{
				throw new OutOfMemoryException();
			}
			return (int)num;
		}

		public unsafe static byte[] FromBase64String(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			fixed (char* inputPtr = s)
			{
				return FromBase64CharPtr(inputPtr, s.Length);
			}
		}

		public static bool TryFromBase64String(string s, Span<byte> bytes, out int bytesWritten)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return TryFromBase64Chars(s.AsSpan(), bytes, out bytesWritten);
		}

		public static bool TryFromBase64Chars(ReadOnlySpan<char> chars, Span<byte> bytes, out int bytesWritten)
		{
			Span<char> span = stackalloc char[4];
			bytesWritten = 0;
			while (chars.Length != 0)
			{
				int consumed;
				int written;
				bool flag = TryDecodeFromUtf16(chars, bytes, out consumed, out written);
				bytesWritten += written;
				if (flag)
				{
					return true;
				}
				chars = chars.Slice(consumed);
				bytes = bytes.Slice(written);
				if (chars[0].IsSpace())
				{
					int i;
					for (i = 1; i != chars.Length && chars[i].IsSpace(); i++)
					{
					}
					chars = chars.Slice(i);
					if (written % 3 != 0 && chars.Length != 0)
					{
						bytesWritten = 0;
						return false;
					}
					continue;
				}
				CopyToTempBufferWithoutWhiteSpace(chars, span, out var consumed2, out var charsWritten);
				if (((uint)charsWritten & 3u) != 0)
				{
					bytesWritten = 0;
					return false;
				}
				span = span.Slice(0, charsWritten);
				if (!TryDecodeFromUtf16(span, bytes, out var _, out var written2))
				{
					bytesWritten = 0;
					return false;
				}
				bytesWritten += written2;
				chars = chars.Slice(consumed2);
				bytes = bytes.Slice(written2);
				if (written2 % 3 == 0)
				{
					continue;
				}
				for (int j = 0; j < chars.Length; j++)
				{
					if (!chars[j].IsSpace())
					{
						bytesWritten = 0;
						return false;
					}
				}
				return true;
			}
			return true;
		}

		private static void CopyToTempBufferWithoutWhiteSpace(ReadOnlySpan<char> chars, Span<char> tempBuffer, out int consumed, out int charsWritten)
		{
			charsWritten = 0;
			for (int i = 0; i < chars.Length; i++)
			{
				char c = chars[i];
				if (!c.IsSpace())
				{
					tempBuffer[charsWritten++] = c;
					if (charsWritten == tempBuffer.Length)
					{
						consumed = i + 1;
						return;
					}
				}
			}
			consumed = chars.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsSpace(this char c)
		{
			if (c != ' ' && c != '\t' && c != '\r')
			{
				return c == '\n';
			}
			return true;
		}

		public unsafe static byte[] FromBase64CharArray(char[] inArray, int offset, int length)
		{
			if (inArray == null)
			{
				throw new ArgumentNullException("inArray");
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_Index);
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (offset > inArray.Length - length)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_OffsetLength);
			}
			if (inArray.Length == 0)
			{
				return Array.Empty<byte>();
			}
			fixed (char* ptr = &inArray[0])
			{
				return FromBase64CharPtr(ptr + offset, length);
			}
		}

		private unsafe static byte[] FromBase64CharPtr(char* inputPtr, int inputLength)
		{
			while (inputLength > 0)
			{
				int num = inputPtr[inputLength - 1];
				if (num != 32 && num != 10 && num != 13 && num != 9)
				{
					break;
				}
				inputLength--;
			}
			int num2 = FromBase64_ComputeResultLength(inputPtr, inputLength);
			byte[] array = new byte[num2];
			if (!TryFromBase64Chars(new ReadOnlySpan<char>(inputPtr, inputLength), array, out var _))
			{
				throw new FormatException(SR.Format_BadBase64Char);
			}
			return array;
		}

		private unsafe static int FromBase64_ComputeResultLength(char* inputPtr, int inputLength)
		{
			char* ptr = inputPtr + inputLength;
			int num = inputLength;
			int num2 = 0;
			while (inputPtr < ptr)
			{
				uint num3 = *inputPtr;
				inputPtr++;
				switch (num3)
				{
				case 0u:
				case 1u:
				case 2u:
				case 3u:
				case 4u:
				case 5u:
				case 6u:
				case 7u:
				case 8u:
				case 9u:
				case 10u:
				case 11u:
				case 12u:
				case 13u:
				case 14u:
				case 15u:
				case 16u:
				case 17u:
				case 18u:
				case 19u:
				case 20u:
				case 21u:
				case 22u:
				case 23u:
				case 24u:
				case 25u:
				case 26u:
				case 27u:
				case 28u:
				case 29u:
				case 30u:
				case 31u:
				case 32u:
					num--;
					break;
				case 61u:
					num--;
					num2++;
					break;
				}
			}
			switch (num2)
			{
			case 1:
				num2 = 2;
				break;
			case 2:
				num2 = 1;
				break;
			default:
				throw new FormatException(SR.Format_BadBase64Char);
			case 0:
				break;
			}
			return num / 4 * 3 + num2;
		}

		public static byte[] FromHexString(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return FromHexString(s.AsSpan());
		}

		public static byte[] FromHexString(ReadOnlySpan<char> chars)
		{
			if (chars.Length == 0)
			{
				return Array.Empty<byte>();
			}
			if ((uint)chars.Length % 2u != 0)
			{
				throw new FormatException(SR.Format_BadHexLength);
			}
			byte[] array = GC.AllocateUninitializedArray<byte>(chars.Length >> 1);
			if (!HexConverter.TryDecodeFromUtf16(chars, array))
			{
				throw new FormatException(SR.Format_BadHexChar);
			}
			return array;
		}

		public static string ToHexString(byte[] inArray)
		{
			if (inArray == null)
			{
				throw new ArgumentNullException("inArray");
			}
			return ToHexString(new ReadOnlySpan<byte>(inArray));
		}

		public static string ToHexString(byte[] inArray, int offset, int length)
		{
			if (inArray == null)
			{
				throw new ArgumentNullException("inArray");
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_Index);
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (offset > inArray.Length - length)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_OffsetLength);
			}
			return ToHexString(new ReadOnlySpan<byte>(inArray, offset, length));
		}

		public static string ToHexString(ReadOnlySpan<byte> bytes)
		{
			if (bytes.Length == 0)
			{
				return string.Empty;
			}
			if (bytes.Length > 1073741823)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_InputTooLarge);
			}
			return HexConverter.ToString(bytes);
		}
	}
	[Flags]
	public enum Base64FormattingOptions
	{
		None = 0,
		InsertLineBreaks = 1
	}
	[Obsolete("System.CurrentSystemTimeZone has been deprecated. Investigate the use of System.TimeZoneInfo.Local instead.")]
	internal sealed class CurrentSystemTimeZone : TimeZone
	{
		private readonly long m_ticksOffset;

		private readonly string m_standardName;

		private readonly string m_daylightName;

		private readonly Hashtable m_CachedDaylightChanges = new Hashtable();

		public override string StandardName => m_standardName;

		public override string DaylightName => m_daylightName;

		internal CurrentSystemTimeZone()
		{
			TimeZoneInfo local = TimeZoneInfo.Local;
			m_ticksOffset = local.BaseUtcOffset.Ticks;
			m_standardName = local.StandardName;
			m_daylightName = local.DaylightName;
		}

		internal long GetUtcOffsetFromUniversalTime(DateTime time, ref bool isAmbiguousLocalDst)
		{
			TimeSpan timeSpan = new TimeSpan(m_ticksOffset);
			DaylightTime daylightChanges = GetDaylightChanges(time.Year);
			isAmbiguousLocalDst = false;
			if (daylightChanges == null || daylightChanges.Delta.Ticks == 0L)
			{
				return timeSpan.Ticks;
			}
			DateTime dateTime = daylightChanges.Start - timeSpan;
			DateTime dateTime2 = daylightChanges.End - timeSpan - daylightChanges.Delta;
			DateTime dateTime3;
			DateTime dateTime4;
			if (daylightChanges.Delta.Ticks > 0)
			{
				dateTime3 = dateTime2 - daylightChanges.Delta;
				dateTime4 = dateTime2;
			}
			else
			{
				dateTime3 = dateTime;
				dateTime4 = dateTime - daylightChanges.Delta;
			}
			if ((!(dateTime > dateTime2)) ? (time >= dateTime && time < dateTime2) : (time < dateTime2 || time >= dateTime))
			{
				timeSpan += daylightChanges.Delta;
				if (time >= dateTime3 && time < dateTime4)
				{
					isAmbiguousLocalDst = true;
				}
			}
			return timeSpan.Ticks;
		}

		public override DateTime ToLocalTime(DateTime time)
		{
			if (time.Kind == DateTimeKind.Local)
			{
				return time;
			}
			bool isAmbiguousLocalDst = false;
			long utcOffsetFromUniversalTime = GetUtcOffsetFromUniversalTime(time, ref isAmbiguousLocalDst);
			long num = time.Ticks + utcOffsetFromUniversalTime;
			if (num > 3155378975999999999L)
			{
				return new DateTime(3155378975999999999L, DateTimeKind.Local);
			}
			if (num < 0)
			{
				return new DateTime(0L, DateTimeKind.Local);
			}
			return new DateTime(num, DateTimeKind.Local, isAmbiguousLocalDst);
		}

		public override DaylightTime GetDaylightChanges(int year)
		{
			if (year < 1 || year > 9999)
			{
				throw new ArgumentOutOfRangeException("year", SR.Format(SR.ArgumentOutOfRange_Range, 1, 9999));
			}
			return GetCachedDaylightChanges(year);
		}

		private static DaylightTime CreateDaylightChanges(int year)
		{
			DateTime start = DateTime.MinValue;
			DateTime end = DateTime.MinValue;
			TimeSpan delta = TimeSpan.Zero;
			if (TimeZoneInfo.Local.SupportsDaylightSavingTime)
			{
				TimeZoneInfo.AdjustmentRule[] adjustmentRules = TimeZoneInfo.Local.GetAdjustmentRules();
				foreach (TimeZoneInfo.AdjustmentRule adjustmentRule in adjustmentRules)
				{
					if (adjustmentRule.DateStart.Year <= year && adjustmentRule.DateEnd.Year >= year && adjustmentRule.DaylightDelta != TimeSpan.Zero)
					{
						start = TimeZoneInfo.TransitionTimeToDateTime(year, adjustmentRule.DaylightTransitionStart);
						end = TimeZoneInfo.TransitionTimeToDateTime(year, adjustmentRule.DaylightTransitionEnd);
						delta = adjustmentRule.DaylightDelta;
						break;
					}
				}
			}
			return new DaylightTime(start, end, delta);
		}

		public override TimeSpan GetUtcOffset(DateTime time)
		{
			if (time.Kind == DateTimeKind.Utc)
			{
				return TimeSpan.Zero;
			}
			return new TimeSpan(TimeZone.CalculateUtcOffset(time, GetDaylightChanges(time.Year)).Ticks + m_ticksOffset);
		}

		private DaylightTime GetCachedDaylightChanges(int year)
		{
			object key = year;
			if (!m_CachedDaylightChanges.Contains(key))
			{
				DaylightTime value = CreateDaylightChanges(year);
				lock (m_CachedDaylightChanges)
				{
					if (!m_CachedDaylightChanges.Contains(key))
					{
						m_CachedDaylightChanges.Add(key, value);
					}
				}
			}
			return (DaylightTime)m_CachedDaylightChanges[key];
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class DataMisalignedException : SystemException
	{
		public DataMisalignedException()
			: base(SR.Arg_DataMisalignedException)
		{
			base.HResult = -2146233023;
		}

		public DataMisalignedException(string? message)
			: base(message)
		{
			base.HResult = -2146233023;
		}

		public DataMisalignedException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233023;
		}

		private DataMisalignedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public readonly struct DateOnly : IComparable, IComparable<DateOnly>, IEquatable<DateOnly>, ISpanFormattable, IFormattable, IComparisonOperators<DateOnly, DateOnly>, IEqualityOperators<DateOnly, DateOnly>, IMinMaxValue<DateOnly>, ISpanParseable<DateOnly>, IParseable<DateOnly>
	{
		private readonly int _dayNumber;

		public static DateOnly MinValue => new DateOnly(0);

		public static DateOnly MaxValue => new DateOnly(3652058);

		public int Year => GetEquivalentDateTime().Year;

		public int Month => GetEquivalentDateTime().Month;

		public int Day => GetEquivalentDateTime().Day;

		public DayOfWeek DayOfWeek => GetEquivalentDateTime().DayOfWeek;

		public int DayOfYear => GetEquivalentDateTime().DayOfYear;

		public int DayNumber => _dayNumber;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateOnly IMinMaxValue<DateOnly>.MinValue => MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateOnly IMinMaxValue<DateOnly>.MaxValue => MaxValue;

		private static int DayNumberFromDateTime(DateTime dt)
		{
			return (int)(dt.Ticks / 864000000000L);
		}

		private DateTime GetEquivalentDateTime()
		{
			return DateTime.UnsafeCreate(_dayNumber * 864000000000L);
		}

		private DateOnly(int dayNumber)
		{
			_dayNumber = dayNumber;
		}

		public DateOnly(int year, int month, int day)
		{
			_dayNumber = DayNumberFromDateTime(new DateTime(year, month, day));
		}

		public DateOnly(int year, int month, int day, Calendar calendar)
		{
			_dayNumber = DayNumberFromDateTime(new DateTime(year, month, day, calendar));
		}

		public static DateOnly FromDayNumber(int dayNumber)
		{
			if ((uint)dayNumber > 3652058u)
			{
				ThrowHelper.ThrowArgumentOutOfRange_DayNumber(dayNumber);
			}
			return new DateOnly(dayNumber);
		}

		public DateOnly AddDays(int value)
		{
			int num = _dayNumber + value;
			if ((uint)num > 3652058u)
			{
				ThrowOutOfRange();
			}
			return new DateOnly(num);
			static void ThrowOutOfRange()
			{
				throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_AddValue);
			}
		}

		public DateOnly AddMonths(int value)
		{
			return new DateOnly(DayNumberFromDateTime(GetEquivalentDateTime().AddMonths(value)));
		}

		public DateOnly AddYears(int value)
		{
			return new DateOnly(DayNumberFromDateTime(GetEquivalentDateTime().AddYears(value)));
		}

		public static bool operator ==(DateOnly left, DateOnly right)
		{
			return left._dayNumber == right._dayNumber;
		}

		public static bool operator !=(DateOnly left, DateOnly right)
		{
			return left._dayNumber != right._dayNumber;
		}

		public static bool operator >(DateOnly left, DateOnly right)
		{
			return left._dayNumber > right._dayNumber;
		}

		public static bool operator >=(DateOnly left, DateOnly right)
		{
			return left._dayNumber >= right._dayNumber;
		}

		public static bool operator <(DateOnly left, DateOnly right)
		{
			return left._dayNumber < right._dayNumber;
		}

		public static bool operator <=(DateOnly left, DateOnly right)
		{
			return left._dayNumber <= right._dayNumber;
		}

		public DateTime ToDateTime(TimeOnly time)
		{
			return new DateTime(_dayNumber * 864000000000L + time.Ticks);
		}

		public DateTime ToDateTime(TimeOnly time, DateTimeKind kind)
		{
			return new DateTime(_dayNumber * 864000000000L + time.Ticks, kind);
		}

		public static DateOnly FromDateTime(DateTime dateTime)
		{
			return new DateOnly(DayNumberFromDateTime(dateTime));
		}

		public int CompareTo(DateOnly value)
		{
			return _dayNumber.CompareTo(value._dayNumber);
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is DateOnly value2))
			{
				throw new ArgumentException(SR.Arg_MustBeDateOnly);
			}
			return CompareTo(value2);
		}

		public bool Equals(DateOnly value)
		{
			return _dayNumber == value._dayNumber;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is DateOnly dateOnly)
			{
				return _dayNumber == dateOnly._dayNumber;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _dayNumber;
		}

		public static DateOnly Parse(ReadOnlySpan<char> s, IFormatProvider? provider = null, DateTimeStyles style = DateTimeStyles.None)
		{
			DateOnly result;
			ParseFailureKind parseFailureKind = TryParseInternal(s, provider, style, out result);
			if (parseFailureKind != 0)
			{
				ThrowOnError(parseFailureKind, s);
			}
			return result;
		}

		public static DateOnly ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider = null, DateTimeStyles style = DateTimeStyles.None)
		{
			DateOnly result;
			ParseFailureKind parseFailureKind = TryParseExactInternal(s, format, provider, style, out result);
			if (parseFailureKind != 0)
			{
				ThrowOnError(parseFailureKind, s);
			}
			return result;
		}

		public static DateOnly ParseExact(ReadOnlySpan<char> s, string[] formats)
		{
			return ParseExact(s, formats, null);
		}

		public static DateOnly ParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			DateOnly result;
			ParseFailureKind parseFailureKind = TryParseExactInternal(s, formats, provider, style, out result);
			if (parseFailureKind != 0)
			{
				ThrowOnError(parseFailureKind, s);
			}
			return result;
		}

		public static DateOnly Parse(string s)
		{
			return Parse(s, null);
		}

		public static DateOnly Parse(string s, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse(s.AsSpan(), provider, style);
		}

		public static DateOnly ParseExact(string s, string format)
		{
			return ParseExact(s, format, null);
		}

		public static DateOnly ParseExact(string s, string format, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if (format == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
			}
			return ParseExact(s.AsSpan(), format.AsSpan(), provider, style);
		}

		public static DateOnly ParseExact(string s, string[] formats)
		{
			return ParseExact(s, formats, null);
		}

		public static DateOnly ParseExact(string s, string[] formats, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return ParseExact(s.AsSpan(), formats, provider, style);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out DateOnly result)
		{
			return TryParse(s, null, DateTimeStyles.None, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
		{
			return TryParseInternal(s, provider, style, out result) == ParseFailureKind.None;
		}

		private static ParseFailureKind TryParseInternal(ReadOnlySpan<char> s, IFormatProvider provider, DateTimeStyles style, out DateOnly result)
		{
			if (((uint)style & 0xFFFFFFF8u) != 0)
			{
				result = default(DateOnly);
				return ParseFailureKind.FormatWithParameter;
			}
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			if (!DateTimeParse.TryParse(s, DateTimeFormatInfo.GetInstance(provider), style, ref result2))
			{
				result = default(DateOnly);
				return ParseFailureKind.FormatWithOriginalDateTime;
			}
			if ((result2.flags & (ParseFlags.HaveHour | ParseFlags.HaveMinute | ParseFlags.HaveSecond | ParseFlags.HaveTime | ParseFlags.TimeZoneUsed | ParseFlags.TimeZoneUtc | ParseFlags.CaptureOffset | ParseFlags.UtcSortPattern)) != 0)
			{
				result = default(DateOnly);
				return ParseFailureKind.WrongParts;
			}
			result = new DateOnly(DayNumberFromDateTime(result2.parsedDate));
			return ParseFailureKind.None;
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, out DateOnly result)
		{
			return TryParseExact(s, format, null, DateTimeStyles.None, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
		{
			return TryParseExactInternal(s, format, provider, style, out result) == ParseFailureKind.None;
		}

		private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, DateTimeStyles style, out DateOnly result)
		{
			if (((uint)style & 0xFFFFFFF8u) != 0)
			{
				result = default(DateOnly);
				return ParseFailureKind.FormatWithParameter;
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'O':
				case 'o':
					format = "yyyy'-'MM'-'dd";
					provider = CultureInfo.InvariantCulture.DateTimeFormat;
					break;
				case 'R':
				case 'r':
					format = "ddd, dd MMM yyyy";
					provider = CultureInfo.InvariantCulture.DateTimeFormat;
					break;
				}
			}
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			if (!DateTimeParse.TryParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style, ref result2))
			{
				result = default(DateOnly);
				return ParseFailureKind.FormatWithOriginalDateTime;
			}
			if ((result2.flags & (ParseFlags.HaveHour | ParseFlags.HaveMinute | ParseFlags.HaveSecond | ParseFlags.HaveTime | ParseFlags.TimeZoneUsed | ParseFlags.TimeZoneUtc | ParseFlags.CaptureOffset | ParseFlags.UtcSortPattern)) != 0)
			{
				result = default(DateOnly);
				return ParseFailureKind.WrongParts;
			}
			result = new DateOnly(DayNumberFromDateTime(result2.parsedDate));
			return ParseFailureKind.None;
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true)] string?[]? formats, out DateOnly result)
		{
			return TryParseExact(s, formats, null, DateTimeStyles.None, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
		{
			return TryParseExactInternal(s, formats, provider, style, out result) == ParseFailureKind.None;
		}

		private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, DateTimeStyles style, out DateOnly result)
		{
			if (((uint)style & 0xFFFFFFF8u) != 0 || formats == null)
			{
				result = default(DateOnly);
				return ParseFailureKind.FormatWithParameter;
			}
			DateTimeFormatInfo instance = DateTimeFormatInfo.GetInstance(provider);
			for (int i = 0; i < formats.Length; i++)
			{
				DateTimeFormatInfo dtfi = instance;
				string text = formats[i];
				if (string.IsNullOrEmpty(text))
				{
					result = default(DateOnly);
					return ParseFailureKind.FormatWithFormatSpecifier;
				}
				if (text.Length == 1)
				{
					switch (text[0])
					{
					case 'O':
					case 'o':
						text = "yyyy'-'MM'-'dd";
						dtfi = CultureInfo.InvariantCulture.DateTimeFormat;
						break;
					case 'R':
					case 'r':
						text = "ddd, dd MMM yyyy";
						dtfi = CultureInfo.InvariantCulture.DateTimeFormat;
						break;
					}
				}
				DateTimeResult result2 = default(DateTimeResult);
				result2.Init(s);
				if (DateTimeParse.TryParseExact(s, text, dtfi, style, ref result2) && (result2.flags & (ParseFlags.HaveHour | ParseFlags.HaveMinute | ParseFlags.HaveSecond | ParseFlags.HaveTime | ParseFlags.TimeZoneUsed | ParseFlags.TimeZoneUtc | ParseFlags.CaptureOffset | ParseFlags.UtcSortPattern)) == 0)
				{
					result = new DateOnly(DayNumberFromDateTime(result2.parsedDate));
					return ParseFailureKind.None;
				}
			}
			result = default(DateOnly);
			return ParseFailureKind.FormatWithOriginalDateTime;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out DateOnly result)
		{
			return TryParse(s, null, DateTimeStyles.None, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
		{
			if (s == null)
			{
				result = default(DateOnly);
				return false;
			}
			return TryParse(s.AsSpan(), provider, style, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string? format, out DateOnly result)
		{
			return TryParseExact(s, format, null, DateTimeStyles.None, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string? format, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
		{
			if (s == null || format == null)
			{
				result = default(DateOnly);
				return false;
			}
			return TryParseExact(s.AsSpan(), format.AsSpan(), provider, style, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string?[]? formats, out DateOnly result)
		{
			return TryParseExact(s, formats, null, DateTimeStyles.None, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out DateOnly result)
		{
			if (s == null)
			{
				result = default(DateOnly);
				return false;
			}
			return TryParseExact(s.AsSpan(), formats, provider, style, out result);
		}

		private static void ThrowOnError(ParseFailureKind result, ReadOnlySpan<char> s)
		{
			switch (result)
			{
			case ParseFailureKind.FormatWithParameter:
				throw new ArgumentException(SR.Argument_InvalidDateStyles, "style");
			case ParseFailureKind.FormatWithOriginalDateTime:
				throw new FormatException(SR.Format(SR.Format_BadDateOnly, s.ToString()));
			case ParseFailureKind.FormatWithFormatSpecifier:
				throw new FormatException(SR.Argument_BadFormatSpecifier);
			default:
				throw new FormatException(SR.Format(SR.Format_DateTimeOnlyContainsNoneDateParts, s.ToString(), "DateOnly"));
			}
		}

		public string ToLongDateString()
		{
			return ToString("D");
		}

		public string ToShortDateString()
		{
			return ToString();
		}

		public override string ToString()
		{
			return ToString("d");
		}

		public string ToString(string? format)
		{
			return ToString(format, null);
		}

		public string ToString(IFormatProvider? provider)
		{
			return ToString("d", provider);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			if (format == null || format.Length == 0)
			{
				format = "d";
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'O':
				case 'o':
					return string.Create(10, this, delegate(Span<char> destination, DateOnly value)
					{
						bool flag = DateTimeFormat.TryFormatDateOnlyO(value.Year, value.Month, value.Day, destination);
					});
				case 'R':
				case 'r':
					return string.Create(16, this, delegate(Span<char> destination, DateOnly value)
					{
						bool flag2 = DateTimeFormat.TryFormatDateOnlyR(value.DayOfWeek, value.Year, value.Month, value.Day, destination);
					});
				case 'D':
				case 'M':
				case 'Y':
				case 'd':
				case 'm':
				case 'y':
					return DateTimeFormat.Format(GetEquivalentDateTime(), format, provider);
				default:
					throw new FormatException(SR.Format_InvalidString);
				}
			}
			DateTimeFormat.IsValidCustomDateFormat(format.AsSpan(), throwOnError: true);
			return DateTimeFormat.Format(GetEquivalentDateTime(), format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			if (format.Length == 0)
			{
				format = "d";
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'O':
				case 'o':
					if (!DateTimeFormat.TryFormatDateOnlyO(Year, Month, Day, destination))
					{
						charsWritten = 0;
						return false;
					}
					charsWritten = 10;
					return true;
				case 'R':
				case 'r':
					if (!DateTimeFormat.TryFormatDateOnlyR(DayOfWeek, Year, Month, Day, destination))
					{
						charsWritten = 0;
						return false;
					}
					charsWritten = 16;
					return true;
				case 'D':
				case 'M':
				case 'Y':
				case 'd':
				case 'm':
				case 'y':
					return DateTimeFormat.TryFormat(GetEquivalentDateTime(), destination, out charsWritten, format, provider);
				default:
					throw new FormatException(SR.Argument_BadFormatSpecifier);
				}
			}
			if (!DateTimeFormat.IsValidCustomDateFormat(format, throwOnError: false))
			{
				throw new FormatException(SR.Format(SR.Format_DateTimeOnlyContainsNoneDateParts, format.ToString(), "DateOnly"));
			}
			return DateTimeFormat.TryFormat(GetEquivalentDateTime(), destination, out charsWritten, format, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateOnly, DateOnly>.op_LessThan(DateOnly left, DateOnly right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateOnly, DateOnly>.op_LessThanOrEqual(DateOnly left, DateOnly right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateOnly, DateOnly>.op_GreaterThan(DateOnly left, DateOnly right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateOnly, DateOnly>.op_GreaterThanOrEqual(DateOnly left, DateOnly right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<DateOnly, DateOnly>.op_Equality(DateOnly left, DateOnly right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<DateOnly, DateOnly>.op_Inequality(DateOnly left, DateOnly right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateOnly IParseable<DateOnly>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<DateOnly>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out DateOnly result)
		{
			return TryParse(s, provider, DateTimeStyles.None, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateOnly ISpanParseable<DateOnly>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<DateOnly>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out DateOnly result)
		{
			return TryParse(s, provider, DateTimeStyles.None, out result);
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct DateTime : IComparable, ISpanFormattable, IFormattable, IConvertible, IComparable<DateTime>, IEquatable<DateTime>, ISerializable, IAdditionOperators<DateTime, TimeSpan, DateTime>, IAdditiveIdentity<DateTime, TimeSpan>, IComparisonOperators<DateTime, DateTime>, IEqualityOperators<DateTime, DateTime>, IMinMaxValue<DateTime>, ISpanParseable<DateTime>, IParseable<DateTime>, ISubtractionOperators<DateTime, TimeSpan, DateTime>, ISubtractionOperators<DateTime, DateTime, TimeSpan>
	{
		private sealed class LeapSecondCache
		{
			internal ulong OSFileTimeTicksAtStartOfValidityWindow;

			internal ulong DotnetDateDataAtStartOfValidityWindow;
		}

		private static readonly uint[] s_daysToMonth365 = new uint[13]
		{
			0u, 31u, 59u, 90u, 120u, 151u, 181u, 212u, 243u, 273u,
			304u, 334u, 365u
		};

		private static readonly uint[] s_daysToMonth366 = new uint[13]
		{
			0u, 31u, 60u, 91u, 121u, 152u, 182u, 213u, 244u, 274u,
			305u, 335u, 366u
		};

		public static readonly DateTime MinValue;

		public static readonly DateTime MaxValue = new DateTime(3155378975999999999L, DateTimeKind.Unspecified);

		public static readonly DateTime UnixEpoch = new DateTime(621355968000000000L, DateTimeKind.Utc);

		private readonly ulong _dateData;

		internal static readonly bool s_systemSupportsLeapSeconds = SystemSupportsLeapSeconds();

		private unsafe static readonly delegate* unmanaged[SuppressGCTransition]<ulong*, void> s_pfnGetSystemTimeAsFileTime = GetGetSystemTimeAsFileTimeFnPtr();

		private static LeapSecondCache s_leapSecondCache = new LeapSecondCache();

		private static ReadOnlySpan<byte> DaysInMonth365 => new byte[12]
		{
			31, 28, 31, 30, 31, 30, 31, 31, 30, 31,
			30, 31
		};

		private static ReadOnlySpan<byte> DaysInMonth366 => new byte[12]
		{
			31, 29, 31, 30, 31, 30, 31, 31, 30, 31,
			30, 31
		};

		private ulong UTicks => _dateData & 0x3FFFFFFFFFFFFFFFuL;

		private ulong InternalKind => _dateData & 0xC000000000000000uL;

		public DateTime Date
		{
			get
			{
				ulong uTicks = UTicks;
				return new DateTime((uTicks - uTicks % 864000000000L) | InternalKind);
			}
		}

		public int Day => GetDatePart(3);

		public DayOfWeek DayOfWeek => (DayOfWeek)((uint)((int)(UTicks / 864000000000L) + 1) % 7u);

		public int DayOfYear => GetDatePart(1);

		public int Hour => (int)((uint)(UTicks / 36000000000L) % 24);

		public DateTimeKind Kind
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return InternalKind switch
				{
					0uL => DateTimeKind.Unspecified, 
					4611686018427387904uL => DateTimeKind.Utc, 
					_ => DateTimeKind.Local, 
				};
			}
		}

		public int Millisecond => (int)(UTicks / 10000 % 1000);

		public int Minute => (int)(UTicks / 600000000 % 60);

		public int Month => GetDatePart(2);

		public static DateTime Now
		{
			get
			{
				DateTime utcNow = UtcNow;
				bool isAmbiguousLocalDst;
				long ticks = TimeZoneInfo.GetDateTimeNowUtcOffsetFromUtc(utcNow, out isAmbiguousLocalDst).Ticks;
				long num = utcNow.Ticks + ticks;
				if ((ulong)num <= 3155378975999999999uL)
				{
					if (!isAmbiguousLocalDst)
					{
						return new DateTime((ulong)num | 0x8000000000000000uL);
					}
					return new DateTime((ulong)num | 0xC000000000000000uL);
				}
				return new DateTime((num < 0) ? 9223372036854775808uL : 12378751012854775807uL);
			}
		}

		public int Second => (int)(UTicks / 10000000 % 60);

		public long Ticks => (long)(_dateData & 0x3FFFFFFFFFFFFFFFL);

		public TimeSpan TimeOfDay => new TimeSpan((long)(UTicks % 864000000000L));

		public static DateTime Today => Now.Date;

		public int Year => GetDatePart(0);

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IAdditiveIdentity<DateTime, TimeSpan>.AdditiveIdentity => default(TimeSpan);

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTime IMinMaxValue<DateTime>.MinValue => MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTime IMinMaxValue<DateTime>.MaxValue => MaxValue;

		public unsafe static DateTime UtcNow
		{
			get
			{
				System.Runtime.CompilerServices.Unsafe.SkipInit(out ulong num);
				s_pfnGetSystemTimeAsFileTime(&num);
				ulong num2 = num;
				if (s_systemSupportsLeapSeconds)
				{
					LeapSecondCache leapSecondCache = s_leapSecondCache;
					ulong num3 = num2 - leapSecondCache.OSFileTimeTicksAtStartOfValidityWindow;
					if (num3 < 3000000000u)
					{
						return new DateTime(leapSecondCache.DotnetDateDataAtStartOfValidityWindow + num3);
					}
					return UpdateLeapSecondCacheAndReturnUtcNow();
				}
				return new DateTime(num2 + 5116597250427387904L);
			}
		}

		public DateTime(long ticks)
		{
			if ((ulong)ticks > 3155378975999999999uL)
			{
				ThrowTicksOutOfRange();
			}
			_dateData = (ulong)ticks;
		}

		private DateTime(ulong dateData)
		{
			_dateData = dateData;
		}

		internal static DateTime UnsafeCreate(long ticks)
		{
			return new DateTime((ulong)ticks);
		}

		public DateTime(long ticks, DateTimeKind kind)
		{
			if ((ulong)ticks > 3155378975999999999uL)
			{
				ThrowTicksOutOfRange();
			}
			if ((uint)kind > 2u)
			{
				ThrowInvalidKind();
			}
			_dateData = (ulong)ticks | ((ulong)(uint)kind << 62);
		}

		internal DateTime(long ticks, DateTimeKind kind, bool isAmbiguousDst)
		{
			if ((ulong)ticks > 3155378975999999999uL)
			{
				ThrowTicksOutOfRange();
			}
			_dateData = (ulong)ticks | (isAmbiguousDst ? 13835058055282163712uL : 9223372036854775808uL);
		}

		private static void ThrowTicksOutOfRange()
		{
			throw new ArgumentOutOfRangeException("ticks", SR.ArgumentOutOfRange_DateTimeBadTicks);
		}

		private static void ThrowInvalidKind()
		{
			throw new ArgumentException(SR.Argument_InvalidDateTimeKind, "kind");
		}

		private static void ThrowMillisecondOutOfRange()
		{
			throw new ArgumentOutOfRangeException("millisecond", SR.Format(SR.ArgumentOutOfRange_Range, 0, 999));
		}

		private static void ThrowDateArithmetic(int param)
		{
			throw new ArgumentOutOfRangeException(param switch
			{
				0 => "value", 
				1 => "t", 
				_ => "months", 
			}, SR.ArgumentOutOfRange_DateArithmetic);
		}

		public DateTime(int year, int month, int day)
		{
			_dateData = DateToTicks(year, month, day);
		}

		public DateTime(int year, int month, int day, Calendar calendar)
			: this(year, month, day, 0, 0, 0, calendar)
		{
		}

		public DateTime(int year, int month, int day, int hour, int minute, int second)
		{
			if (second != 60 || !s_systemSupportsLeapSeconds)
			{
				_dateData = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
				return;
			}
			this = new DateTime(year, month, day, hour, minute, 59);
			ValidateLeapSecond();
		}

		public DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind)
		{
			if ((uint)kind > 2u)
			{
				ThrowInvalidKind();
			}
			if (second != 60 || !s_systemSupportsLeapSeconds)
			{
				ulong num = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
				_dateData = num | (ulong)((long)kind << 62);
			}
			else
			{
				this = new DateTime(year, month, day, hour, minute, 59, kind);
				ValidateLeapSecond();
			}
		}

		public DateTime(int year, int month, int day, int hour, int minute, int second, Calendar calendar)
		{
			if (calendar == null)
			{
				throw new ArgumentNullException("calendar");
			}
			if (second != 60 || !s_systemSupportsLeapSeconds)
			{
				_dateData = calendar.ToDateTime(year, month, day, hour, minute, second, 0).UTicks;
				return;
			}
			this = new DateTime(year, month, day, hour, minute, 59, calendar);
			ValidateLeapSecond();
		}

		public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond)
		{
			if ((uint)millisecond >= 1000u)
			{
				ThrowMillisecondOutOfRange();
			}
			if (second != 60 || !s_systemSupportsLeapSeconds)
			{
				ulong num = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
				num += (uint)(millisecond * 10000);
				_dateData = num;
			}
			else
			{
				this = new DateTime(year, month, day, hour, minute, 59, millisecond);
				ValidateLeapSecond();
			}
		}

		public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, DateTimeKind kind)
		{
			if ((uint)millisecond >= 1000u)
			{
				ThrowMillisecondOutOfRange();
			}
			if ((uint)kind > 2u)
			{
				ThrowInvalidKind();
			}
			if (second != 60 || !s_systemSupportsLeapSeconds)
			{
				ulong num = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
				num += (uint)(millisecond * 10000);
				_dateData = num | (ulong)((long)kind << 62);
			}
			else
			{
				this = new DateTime(year, month, day, hour, minute, 59, millisecond, kind);
				ValidateLeapSecond();
			}
		}

		public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar)
		{
			if (calendar == null)
			{
				throw new ArgumentNullException("calendar");
			}
			if (second != 60 || !s_systemSupportsLeapSeconds)
			{
				_dateData = calendar.ToDateTime(year, month, day, hour, minute, second, millisecond).UTicks;
				return;
			}
			this = new DateTime(year, month, day, hour, minute, 59, millisecond, calendar);
			ValidateLeapSecond();
		}

		public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, DateTimeKind kind)
		{
			if (calendar == null)
			{
				throw new ArgumentNullException("calendar");
			}
			if ((uint)millisecond >= 1000u)
			{
				ThrowMillisecondOutOfRange();
			}
			if ((uint)kind > 2u)
			{
				ThrowInvalidKind();
			}
			if (second != 60 || !s_systemSupportsLeapSeconds)
			{
				ulong uTicks = calendar.ToDateTime(year, month, day, hour, minute, second, millisecond).UTicks;
				_dateData = uTicks | (ulong)((long)kind << 62);
			}
			else
			{
				this = new DateTime(year, month, day, hour, minute, 59, millisecond, calendar, kind);
				ValidateLeapSecond();
			}
		}

		private void ValidateLeapSecond()
		{
			if (!IsValidTimeWithLeapSeconds(Year, Month, Day, Hour, Minute, Kind))
			{
				ThrowHelper.ThrowArgumentOutOfRange_BadHourMinuteSecond();
			}
		}

		private DateTime(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.info);
			}
			bool flag = false;
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (true)
			{
				if (enumerator.MoveNext())
				{
					string name = enumerator.Name;
					if (!(name == "ticks"))
					{
						if (name == "dateData")
						{
							_dateData = Convert.ToUInt64(enumerator.Value, CultureInfo.InvariantCulture);
							break;
						}
					}
					else
					{
						_dateData = (ulong)Convert.ToInt64(enumerator.Value, CultureInfo.InvariantCulture);
						flag = true;
					}
					continue;
				}
				if (flag)
				{
					break;
				}
				throw new SerializationException(SR.Serialization_MissingDateTimeData);
			}
			if (UTicks > 3155378975999999999L)
			{
				throw new SerializationException(SR.Serialization_DateTimeTicksOutOfRange);
			}
		}

		public DateTime Add(TimeSpan value)
		{
			return AddTicks(value._ticks);
		}

		private DateTime Add(double value, int scale)
		{
			double num = value * (double)scale + ((value >= 0.0) ? 0.5 : (-0.5));
			if (num <= -315537897600000.0 || num >= 315537897600000.0)
			{
				ThrowOutOfRange();
			}
			return AddTicks((long)num * 10000);
			static void ThrowOutOfRange()
			{
				throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_AddValue);
			}
		}

		public DateTime AddDays(double value)
		{
			return Add(value, 86400000);
		}

		public DateTime AddHours(double value)
		{
			return Add(value, 3600000);
		}

		public DateTime AddMilliseconds(double value)
		{
			return Add(value, 1);
		}

		public DateTime AddMinutes(double value)
		{
			return Add(value, 60000);
		}

		public DateTime AddMonths(int months)
		{
			if (months < -120000 || months > 120000)
			{
				throw new ArgumentOutOfRangeException("months", SR.ArgumentOutOfRange_DateTimeBadMonths);
			}
			GetDate(out var year, out var month, out var day);
			int num = year;
			int num2 = day;
			int num3 = month + months;
			if (num3 > 0)
			{
				int num4 = (int)((uint)(num3 - 1) / 12u);
				num += num4;
				num3 -= num4 * 12;
			}
			else
			{
				num += num3 / 12 - 1;
				num3 = 12 + num3 % 12;
			}
			if (num < 1 || num > 9999)
			{
				ThrowDateArithmetic(2);
			}
			uint[] array = (IsLeapYear(num) ? s_daysToMonth366 : s_daysToMonth365);
			uint num5 = array[num3 - 1];
			int num6 = (int)(array[num3] - num5);
			if (num2 > num6)
			{
				num2 = num6;
			}
			uint num7 = (uint)((int)(DaysToYear((uint)num) + num5) + num2 - 1);
			return new DateTime(((ulong)((long)num7 * 864000000000L) + UTicks % 864000000000L) | InternalKind);
		}

		public DateTime AddSeconds(double value)
		{
			return Add(value, 1000);
		}

		public DateTime AddTicks(long value)
		{
			ulong num = (ulong)(Ticks + value);
			if (num > 3155378975999999999L)
			{
				ThrowDateArithmetic(0);
			}
			return new DateTime(num | InternalKind);
		}

		internal bool TryAddTicks(long value, out DateTime result)
		{
			ulong num = (ulong)(Ticks + value);
			if (num > 3155378975999999999L)
			{
				result = default(DateTime);
				return false;
			}
			result = new DateTime(num | InternalKind);
			return true;
		}

		public DateTime AddYears(int value)
		{
			if (value < -10000 || value > 10000)
			{
				throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_DateTimeBadYears);
			}
			GetDate(out var year, out var month, out var day);
			int num = year + value;
			if (num < 1 || num > 9999)
			{
				ThrowDateArithmetic(0);
			}
			uint num2 = DaysToYear((uint)num);
			int num3 = month - 1;
			int num4 = day - 1;
			if (IsLeapYear(num))
			{
				num2 += s_daysToMonth366[num3];
			}
			else
			{
				if (num4 == 28 && num3 == 1)
				{
					num4--;
				}
				num2 += s_daysToMonth365[num3];
			}
			num2 += (uint)num4;
			return new DateTime(((ulong)((long)num2 * 864000000000L) + UTicks % 864000000000L) | InternalKind);
		}

		public static int Compare(DateTime t1, DateTime t2)
		{
			long ticks = t1.Ticks;
			long ticks2 = t2.Ticks;
			if (ticks > ticks2)
			{
				return 1;
			}
			if (ticks < ticks2)
			{
				return -1;
			}
			return 0;
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is DateTime))
			{
				throw new ArgumentException(SR.Arg_MustBeDateTime);
			}
			return Compare(this, (DateTime)value);
		}

		public int CompareTo(DateTime value)
		{
			return Compare(this, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ulong DateToTicks(int year, int month, int day)
		{
			if (year < 1 || year > 9999 || month < 1 || month > 12 || day < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRange_BadYearMonthDay();
			}
			uint[] array = (IsLeapYear(year) ? s_daysToMonth366 : s_daysToMonth365);
			if ((uint)day > array[month] - array[month - 1])
			{
				ThrowHelper.ThrowArgumentOutOfRange_BadYearMonthDay();
			}
			uint num = (uint)((int)(DaysToYear((uint)year) + array[month - 1]) + day - 1);
			return (ulong)num * 864000000000uL;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint DaysToYear(uint year)
		{
			uint num = year - 1;
			uint num2 = num / 100;
			return num * 1461 / 4 - num2 + num2 / 4;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ulong TimeToTicks(int hour, int minute, int second)
		{
			if ((uint)hour >= 24u || (uint)minute >= 60u || (uint)second >= 60u)
			{
				ThrowHelper.ThrowArgumentOutOfRange_BadHourMinuteSecond();
			}
			int num = hour * 3600 + minute * 60 + second;
			return (ulong)(uint)num * 10000000uL;
		}

		internal static ulong TimeToTicks(int hour, int minute, int second, int millisecond)
		{
			ulong num = TimeToTicks(hour, minute, second);
			if ((uint)millisecond >= 1000u)
			{
				ThrowMillisecondOutOfRange();
			}
			return num + (uint)(millisecond * 10000);
		}

		public static int DaysInMonth(int year, int month)
		{
			if (month < 1 || month > 12)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
			return (IsLeapYear(year) ? DaysInMonth366 : DaysInMonth365)[month - 1];
		}

		internal static long DoubleDateToTicks(double value)
		{
			if (!(value < 2958466.0) || !(value > -657435.0))
			{
				throw new ArgumentException(SR.Arg_OleAutDateInvalid);
			}
			long num = (long)(value * 86400000.0 + ((value >= 0.0) ? 0.5 : (-0.5)));
			if (num < 0)
			{
				num -= num % 86400000 * 2;
			}
			num += 59926435200000L;
			if (num < 0 || num >= 315537897600000L)
			{
				throw new ArgumentException(SR.Arg_OleAutDateScale);
			}
			return num * 10000;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is DateTime)
			{
				return Ticks == ((DateTime)value).Ticks;
			}
			return false;
		}

		public bool Equals(DateTime value)
		{
			return Ticks == value.Ticks;
		}

		public static bool Equals(DateTime t1, DateTime t2)
		{
			return t1.Ticks == t2.Ticks;
		}

		public static DateTime FromBinary(long dateData)
		{
			if ((dateData & long.MinValue) != 0L)
			{
				long num = dateData & 0x3FFFFFFFFFFFFFFFL;
				if (num > 4611685154427387904L)
				{
					num -= 4611686018427387904L;
				}
				bool isAmbiguousLocalDst = false;
				long ticks;
				if (num < 0)
				{
					ticks = TimeZoneInfo.GetLocalUtcOffset(MinValue, TimeZoneInfoOptions.NoThrowOnInvalidTime).Ticks;
				}
				else if (num > 3155378975999999999L)
				{
					ticks = TimeZoneInfo.GetLocalUtcOffset(MaxValue, TimeZoneInfoOptions.NoThrowOnInvalidTime).Ticks;
				}
				else
				{
					DateTime time = new DateTime(num, DateTimeKind.Utc);
					ticks = TimeZoneInfo.GetUtcOffsetFromUtc(time, TimeZoneInfo.Local, out var _, out isAmbiguousLocalDst).Ticks;
				}
				num += ticks;
				if (num < 0)
				{
					num += 864000000000L;
				}
				if ((ulong)num > 3155378975999999999uL)
				{
					throw new ArgumentException(SR.Argument_DateTimeBadBinaryData, "dateData");
				}
				return new DateTime(num, DateTimeKind.Local, isAmbiguousLocalDst);
			}
			if ((ulong)(dateData & 0x3FFFFFFFFFFFFFFFL) > 3155378975999999999uL)
			{
				throw new ArgumentException(SR.Argument_DateTimeBadBinaryData, "dateData");
			}
			return new DateTime((ulong)dateData);
		}

		public static DateTime FromFileTime(long fileTime)
		{
			return FromFileTimeUtc(fileTime).ToLocalTime();
		}

		public static DateTime FromFileTimeUtc(long fileTime)
		{
			if ((ulong)fileTime > 2650467743999999999uL)
			{
				throw new ArgumentOutOfRangeException("fileTime", SR.ArgumentOutOfRange_FileTimeInvalid);
			}
			if (s_systemSupportsLeapSeconds)
			{
				return FromFileTimeLeapSecondsAware((ulong)fileTime);
			}
			ulong num = (ulong)(fileTime + 504911232000000000L);
			return new DateTime(num | 0x4000000000000000uL);
		}

		public static DateTime FromOADate(double d)
		{
			return new DateTime(DoubleDateToTicks(d), DateTimeKind.Unspecified);
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.info);
			}
			info.AddValue("ticks", Ticks);
			info.AddValue("dateData", _dateData);
		}

		public bool IsDaylightSavingTime()
		{
			if (InternalKind == 4611686018427387904L)
			{
				return false;
			}
			return TimeZoneInfo.Local.IsDaylightSavingTime(this, TimeZoneInfoOptions.NoThrowOnInvalidTime);
		}

		public static DateTime SpecifyKind(DateTime value, DateTimeKind kind)
		{
			if ((uint)kind > 2u)
			{
				ThrowInvalidKind();
			}
			return new DateTime(value.UTicks | (ulong)((long)kind << 62));
		}

		public long ToBinary()
		{
			if ((_dateData & 0x8000000000000000uL) != 0L)
			{
				TimeSpan localUtcOffset = TimeZoneInfo.GetLocalUtcOffset(this, TimeZoneInfoOptions.NoThrowOnInvalidTime);
				long ticks = Ticks;
				long num = ticks - localUtcOffset.Ticks;
				if (num < 0)
				{
					num = 4611686018427387904L + num;
				}
				return num | long.MinValue;
			}
			return (long)_dateData;
		}

		private int GetDatePart(int part)
		{
			uint num = (uint)(UTicks / 864000000000L);
			uint num2 = num / 146097;
			num -= num2 * 146097;
			uint num3 = num / 36524;
			if (num3 == 4)
			{
				num3 = 3u;
			}
			num -= num3 * 36524;
			uint num4 = num / 1461;
			num -= num4 * 1461;
			uint num5 = num / 365;
			if (num5 == 4)
			{
				num5 = 3u;
			}
			if (part == 0)
			{
				return (int)(num2 * 400 + num3 * 100 + num4 * 4 + num5 + 1);
			}
			num -= num5 * 365;
			if (part == 1)
			{
				return (int)(num + 1);
			}
			uint[] array = ((num5 == 3 && (num4 != 24 || num3 == 3)) ? s_daysToMonth366 : s_daysToMonth365);
			uint num6;
			for (num6 = (num >> 5) + 1; num >= array[num6]; num6++)
			{
			}
			if (part == 2)
			{
				return (int)num6;
			}
			return (int)(num - array[num6 - 1] + 1);
		}

		internal void GetDate(out int year, out int month, out int day)
		{
			uint num = (uint)(UTicks / 864000000000L);
			uint num2 = num / 146097;
			num -= num2 * 146097;
			uint num3 = num / 36524;
			if (num3 == 4)
			{
				num3 = 3u;
			}
			num -= num3 * 36524;
			uint num4 = num / 1461;
			num -= num4 * 1461;
			uint num5 = num / 365;
			if (num5 == 4)
			{
				num5 = 3u;
			}
			year = (int)(num2 * 400 + num3 * 100 + num4 * 4 + num5 + 1);
			num -= num5 * 365;
			uint[] array = ((num5 == 3 && (num4 != 24 || num3 == 3)) ? s_daysToMonth366 : s_daysToMonth365);
			uint num6;
			for (num6 = (num >> 5) + 1; num >= array[num6]; num6++)
			{
			}
			month = (int)num6;
			day = (int)(num - array[num6 - 1] + 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void GetTime(out int hour, out int minute, out int second)
		{
			ulong num = UTicks / 10000000;
			ulong num2 = num / 60;
			second = (int)(num - num2 * 60);
			ulong num3 = num2 / 60;
			minute = (int)(num2 - num3 * 60);
			hour = (int)((uint)num3 % 24);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void GetTime(out int hour, out int minute, out int second, out int millisecond)
		{
			ulong num = UTicks / 10000;
			ulong num2 = num / 1000;
			millisecond = (int)(num - num2 * 1000);
			ulong num3 = num2 / 60;
			second = (int)(num2 - num3 * 60);
			ulong num4 = num3 / 60;
			minute = (int)(num3 - num4 * 60);
			hour = (int)((uint)num4 % 24);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void GetTimePrecise(out int hour, out int minute, out int second, out int tick)
		{
			ulong uTicks = UTicks;
			ulong num = uTicks / 10000000;
			tick = (int)(uTicks - num * 10000000);
			ulong num2 = num / 60;
			second = (int)(num - num2 * 60);
			ulong num3 = num2 / 60;
			minute = (int)(num2 - num3 * 60);
			hour = (int)((uint)num3 % 24);
		}

		public override int GetHashCode()
		{
			long ticks = Ticks;
			return (int)ticks ^ (int)(ticks >> 32);
		}

		internal bool IsAmbiguousDaylightSavingTime()
		{
			return InternalKind == 13835058055282163712uL;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsLeapYear(int year)
		{
			if (year < 1 || year > 9999)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Year();
			}
			if (((uint)year & 3u) != 0)
			{
				return false;
			}
			if ((year & 0xF) == 0)
			{
				return true;
			}
			if ((uint)year % 25u == 0)
			{
				return false;
			}
			return true;
		}

		public static DateTime Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return DateTimeParse.Parse(s, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None);
		}

		public static DateTime Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return DateTimeParse.Parse(s, DateTimeFormatInfo.GetInstance(provider), DateTimeStyles.None);
		}

		public static DateTime Parse(string s, IFormatProvider? provider, DateTimeStyles styles)
		{
			DateTimeFormatInfo.ValidateStyles(styles, styles: true);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return DateTimeParse.Parse(s, DateTimeFormatInfo.GetInstance(provider), styles);
		}

		public static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider? provider = null, DateTimeStyles styles = DateTimeStyles.None)
		{
			DateTimeFormatInfo.ValidateStyles(styles, styles: true);
			return DateTimeParse.Parse(s, DateTimeFormatInfo.GetInstance(provider), styles);
		}

		public static DateTime ParseExact(string s, string format, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if (format == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
			}
			return DateTimeParse.ParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), DateTimeStyles.None);
		}

		public static DateTime ParseExact(string s, string format, IFormatProvider? provider, DateTimeStyles style)
		{
			DateTimeFormatInfo.ValidateStyles(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if (format == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
			}
			return DateTimeParse.ParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style);
		}

		public static DateTime ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			DateTimeFormatInfo.ValidateStyles(style);
			return DateTimeParse.ParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style);
		}

		public static DateTime ParseExact(string s, string[] formats, IFormatProvider? provider, DateTimeStyles style)
		{
			DateTimeFormatInfo.ValidateStyles(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return DateTimeParse.ParseExactMultiple(s, formats, DateTimeFormatInfo.GetInstance(provider), style);
		}

		public static DateTime ParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			DateTimeFormatInfo.ValidateStyles(style);
			return DateTimeParse.ParseExactMultiple(s, formats, DateTimeFormatInfo.GetInstance(provider), style);
		}

		public TimeSpan Subtract(DateTime value)
		{
			return new TimeSpan(Ticks - value.Ticks);
		}

		public DateTime Subtract(TimeSpan value)
		{
			ulong num = (ulong)(Ticks - value._ticks);
			if (num > 3155378975999999999L)
			{
				ThrowDateArithmetic(0);
			}
			return new DateTime(num | InternalKind);
		}

		private static double TicksToOADate(long value)
		{
			if (value == 0L)
			{
				return 0.0;
			}
			if (value < 864000000000L)
			{
				value += 599264352000000000L;
			}
			if (value < 31241376000000000L)
			{
				throw new OverflowException(SR.Arg_OleAutDateInvalid);
			}
			long num = (value - 599264352000000000L) / 10000;
			if (num < 0)
			{
				long num2 = num % 86400000;
				if (num2 != 0L)
				{
					num -= (86400000 + num2) * 2;
				}
			}
			return (double)num / 86400000.0;
		}

		public double ToOADate()
		{
			return TicksToOADate(Ticks);
		}

		public long ToFileTime()
		{
			return ToUniversalTime().ToFileTimeUtc();
		}

		public long ToFileTimeUtc()
		{
			long num = (((_dateData & 0x8000000000000000uL) != 0L) ? ToUniversalTime().Ticks : Ticks);
			if (s_systemSupportsLeapSeconds)
			{
				return (long)ToFileTimeLeapSecondsAware(num);
			}
			num -= 504911232000000000L;
			if (num < 0)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_FileTimeInvalid);
			}
			return num;
		}

		public DateTime ToLocalTime()
		{
			if ((_dateData & 0x8000000000000000uL) != 0L)
			{
				return this;
			}
			bool isDaylightSavings;
			bool isAmbiguousLocalDst;
			long ticks = TimeZoneInfo.GetUtcOffsetFromUtc(this, TimeZoneInfo.Local, out isDaylightSavings, out isAmbiguousLocalDst).Ticks;
			long num = Ticks + ticks;
			if ((ulong)num <= 3155378975999999999uL)
			{
				if (!isAmbiguousLocalDst)
				{
					return new DateTime((ulong)num | 0x8000000000000000uL);
				}
				return new DateTime((ulong)num | 0xC000000000000000uL);
			}
			return new DateTime((num < 0) ? 9223372036854775808uL : 12378751012854775807uL);
		}

		public string ToLongDateString()
		{
			return DateTimeFormat.Format(this, "D", null);
		}

		public string ToLongTimeString()
		{
			return DateTimeFormat.Format(this, "T", null);
		}

		public string ToShortDateString()
		{
			return DateTimeFormat.Format(this, "d", null);
		}

		public string ToShortTimeString()
		{
			return DateTimeFormat.Format(this, "t", null);
		}

		public override string ToString()
		{
			return DateTimeFormat.Format(this, null, null);
		}

		public string ToString(string? format)
		{
			return DateTimeFormat.Format(this, format, null);
		}

		public string ToString(IFormatProvider? provider)
		{
			return DateTimeFormat.Format(this, null, provider);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return DateTimeFormat.Format(this, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return DateTimeFormat.TryFormat(this, destination, out charsWritten, format, provider);
		}

		public DateTime ToUniversalTime()
		{
			return TimeZoneInfo.ConvertTimeToUtc(this, TimeZoneInfoOptions.NoThrowOnInvalidTime);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out DateTime result)
		{
			if (s == null)
			{
				result = default(DateTime);
				return false;
			}
			return DateTimeParse.TryParse(s, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out DateTime result)
		{
			return DateTimeParse.TryParse(s, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, DateTimeStyles styles, out DateTime result)
		{
			DateTimeFormatInfo.ValidateStyles(styles, styles: true);
			if (s == null)
			{
				result = default(DateTime);
				return false;
			}
			return DateTimeParse.TryParse(s, DateTimeFormatInfo.GetInstance(provider), styles, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles styles, out DateTime result)
		{
			DateTimeFormatInfo.ValidateStyles(styles, styles: true);
			return DateTimeParse.TryParse(s, DateTimeFormatInfo.GetInstance(provider), styles, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string? format, IFormatProvider? provider, DateTimeStyles style, out DateTime result)
		{
			DateTimeFormatInfo.ValidateStyles(style);
			if (s == null || format == null)
			{
				result = default(DateTime);
				return false;
			}
			return DateTimeParse.TryParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out DateTime result)
		{
			DateTimeFormatInfo.ValidateStyles(style);
			return DateTimeParse.TryParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out DateTime result)
		{
			DateTimeFormatInfo.ValidateStyles(style);
			if (s == null)
			{
				result = default(DateTime);
				return false;
			}
			return DateTimeParse.TryParseExactMultiple(s, formats, DateTimeFormatInfo.GetInstance(provider), style, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out DateTime result)
		{
			DateTimeFormatInfo.ValidateStyles(style);
			return DateTimeParse.TryParseExactMultiple(s, formats, DateTimeFormatInfo.GetInstance(provider), style, out result);
		}

		public static DateTime operator +(DateTime d, TimeSpan t)
		{
			ulong num = (ulong)(d.Ticks + t._ticks);
			if (num > 3155378975999999999L)
			{
				ThrowDateArithmetic(1);
			}
			return new DateTime(num | d.InternalKind);
		}

		public static DateTime operator -(DateTime d, TimeSpan t)
		{
			ulong num = (ulong)(d.Ticks - t._ticks);
			if (num > 3155378975999999999L)
			{
				ThrowDateArithmetic(1);
			}
			return new DateTime(num | d.InternalKind);
		}

		public static TimeSpan operator -(DateTime d1, DateTime d2)
		{
			return new TimeSpan(d1.Ticks - d2.Ticks);
		}

		public static bool operator ==(DateTime d1, DateTime d2)
		{
			return d1.Ticks == d2.Ticks;
		}

		public static bool operator !=(DateTime d1, DateTime d2)
		{
			return d1.Ticks != d2.Ticks;
		}

		public static bool operator <(DateTime t1, DateTime t2)
		{
			return t1.Ticks < t2.Ticks;
		}

		public static bool operator <=(DateTime t1, DateTime t2)
		{
			return t1.Ticks <= t2.Ticks;
		}

		public static bool operator >(DateTime t1, DateTime t2)
		{
			return t1.Ticks > t2.Ticks;
		}

		public static bool operator >=(DateTime t1, DateTime t2)
		{
			return t1.Ticks >= t2.Ticks;
		}

		public string[] GetDateTimeFormats()
		{
			return GetDateTimeFormats(CultureInfo.CurrentCulture);
		}

		public string[] GetDateTimeFormats(IFormatProvider? provider)
		{
			return DateTimeFormat.GetAllDateTimes(this, DateTimeFormatInfo.GetInstance(provider));
		}

		public string[] GetDateTimeFormats(char format)
		{
			return GetDateTimeFormats(format, CultureInfo.CurrentCulture);
		}

		public string[] GetDateTimeFormats(char format, IFormatProvider? provider)
		{
			return DateTimeFormat.GetAllDateTimes(this, format, DateTimeFormatInfo.GetInstance(provider));
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.DateTime;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			throw InvalidCast("Boolean");
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			throw InvalidCast("Char");
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			throw InvalidCast("SByte");
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			throw InvalidCast("Byte");
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			throw InvalidCast("Int16");
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			throw InvalidCast("UInt16");
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			throw InvalidCast("Int32");
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			throw InvalidCast("UInt32");
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			throw InvalidCast("Int64");
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			throw InvalidCast("UInt64");
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			throw InvalidCast("Single");
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			throw InvalidCast("Double");
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			throw InvalidCast("Decimal");
		}

		private static Exception InvalidCast(string to)
		{
			return new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "DateTime", to));
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			return this;
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		internal static bool TryCreate(int year, int month, int day, int hour, int minute, int second, int millisecond, out DateTime result)
		{
			result = default(DateTime);
			if (year < 1 || year > 9999 || month < 1 || month > 12 || day < 1)
			{
				return false;
			}
			if ((uint)hour >= 24u || (uint)minute >= 60u || (uint)millisecond >= 1000u)
			{
				return false;
			}
			uint[] array = (IsLeapYear(year) ? s_daysToMonth366 : s_daysToMonth365);
			if ((uint)day > array[month] - array[month - 1])
			{
				return false;
			}
			ulong num = (ulong)(uint)((int)(DaysToYear((uint)year) + array[month - 1]) + day - 1) * 864000000000uL;
			if ((uint)second < 60u)
			{
				num += TimeToTicks(hour, minute, second) + (uint)(millisecond * 10000);
			}
			else
			{
				if (second != 60 || !s_systemSupportsLeapSeconds || !IsValidTimeWithLeapSeconds(year, month, day, hour, minute, DateTimeKind.Unspecified))
				{
					return false;
				}
				num += TimeToTicks(hour, minute, 59) + 9990000;
			}
			result = new DateTime(num);
			return true;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTime IAdditionOperators<DateTime, TimeSpan, DateTime>.op_Addition(DateTime left, TimeSpan right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateTime, DateTime>.op_LessThan(DateTime left, DateTime right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateTime, DateTime>.op_LessThanOrEqual(DateTime left, DateTime right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateTime, DateTime>.op_GreaterThan(DateTime left, DateTime right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateTime, DateTime>.op_GreaterThanOrEqual(DateTime left, DateTime right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<DateTime, DateTime>.op_Equality(DateTime left, DateTime right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<DateTime, DateTime>.op_Inequality(DateTime left, DateTime right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTime IParseable<DateTime>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<DateTime>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out DateTime result)
		{
			return TryParse(s, provider, DateTimeStyles.None, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTime ISpanParseable<DateTime>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<DateTime>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out DateTime result)
		{
			return TryParse(s, provider, DateTimeStyles.None, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTime ISubtractionOperators<DateTime, TimeSpan, DateTime>.op_Subtraction(DateTime left, TimeSpan right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan ISubtractionOperators<DateTime, DateTime, TimeSpan>.op_Subtraction(DateTime left, DateTime right)
		{
			return left - right;
		}

		private unsafe static bool SystemSupportsLeapSeconds()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.NtDll.SYSTEM_LEAP_SECOND_INFORMATION sYSTEM_LEAP_SECOND_INFORMATION);
			if (Interop.NtDll.NtQuerySystemInformation(206, &sYSTEM_LEAP_SECOND_INFORMATION, (uint)sizeof(Interop.NtDll.SYSTEM_LEAP_SECOND_INFORMATION), null) == 0)
			{
				return sYSTEM_LEAP_SECOND_INFORMATION.Enabled != Interop.BOOLEAN.FALSE;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal unsafe static bool IsValidTimeWithLeapSeconds(int year, int month, int day, int hour, int minute, DateTimeKind kind)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.Kernel32.SYSTEMTIME sYSTEMTIME);
			sYSTEMTIME.Year = (ushort)year;
			sYSTEMTIME.Month = (ushort)month;
			sYSTEMTIME.DayOfWeek = 0;
			sYSTEMTIME.Day = (ushort)day;
			sYSTEMTIME.Hour = (ushort)hour;
			sYSTEMTIME.Minute = (ushort)minute;
			sYSTEMTIME.Second = 60;
			sYSTEMTIME.Milliseconds = 0;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.Kernel32.SYSTEMTIME sYSTEMTIME2);
			if (kind != DateTimeKind.Utc && Interop.Kernel32.TzSpecificLocalTimeToSystemTime(IntPtr.Zero, &sYSTEMTIME, &sYSTEMTIME2) != 0)
			{
				return true;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out ulong num);
			if (kind != DateTimeKind.Local && Interop.Kernel32.SystemTimeToFileTime(&sYSTEMTIME, &num) != 0)
			{
				return true;
			}
			return false;
		}

		private unsafe static DateTime FromFileTimeLeapSecondsAware(ulong fileTime)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.Kernel32.SYSTEMTIME time);
			if (Interop.Kernel32.FileTimeToSystemTime(&fileTime, &time) == Interop.BOOL.FALSE)
			{
				throw new ArgumentOutOfRangeException("fileTime", SR.ArgumentOutOfRange_DateTimeBadTicks);
			}
			return CreateDateTimeFromSystemTime(in time, fileTime % 10000);
		}

		private unsafe static ulong ToFileTimeLeapSecondsAware(long ticks)
		{
			DateTime dateTime = new DateTime(ticks);
			dateTime.GetDate(out var year, out var month, out var day);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.Kernel32.SYSTEMTIME sYSTEMTIME);
			sYSTEMTIME.Year = (ushort)year;
			sYSTEMTIME.Month = (ushort)month;
			sYSTEMTIME.DayOfWeek = 0;
			sYSTEMTIME.Day = (ushort)day;
			dateTime.GetTimePrecise(out var hour, out var minute, out var second, out var tick);
			sYSTEMTIME.Hour = (ushort)hour;
			sYSTEMTIME.Minute = (ushort)minute;
			sYSTEMTIME.Second = (ushort)second;
			sYSTEMTIME.Milliseconds = 0;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out ulong num);
			if (Interop.Kernel32.SystemTimeToFileTime(&sYSTEMTIME, &num) == Interop.BOOL.FALSE)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_FileTimeInvalid);
			}
			return num + (uint)tick;
		}

		private static DateTime CreateDateTimeFromSystemTime(in Interop.Kernel32.SYSTEMTIME time, ulong hundredNanoSecond)
		{
			uint year = time.Year;
			uint[] array = (IsLeapYear((int)year) ? s_daysToMonth366 : s_daysToMonth365);
			int num = time.Month - 1;
			uint num2 = DaysToYear(year) + array[num] + time.Day - 1;
			ulong num3 = (ulong)num2 * 864000000000uL;
			num3 += (ulong)(time.Hour * 36000000000L);
			num3 += (ulong)((long)time.Minute * 600000000L);
			uint second = time.Second;
			if (second <= 59)
			{
				ulong num4 = (uint)((int)(second * 10000000) + time.Milliseconds * 10000) + hundredNanoSecond;
				return new DateTime((num3 + num4) | 0x4000000000000000uL);
			}
			num3 += 4611686019027387903L;
			return new DateTime(num3);
		}

		private unsafe static delegate* unmanaged[SuppressGCTransition]<ulong*, void> GetGetSystemTimeAsFileTimeFnPtr()
		{
			IntPtr handle = Interop.Kernel32.LoadLibraryEx("kernel32.dll", IntPtr.Zero, 2048);
			IntPtr intPtr = NativeLibrary.GetExport(handle, "GetSystemTimeAsFileTime");
			if (NativeLibrary.TryGetExport(handle, "GetSystemTimePreciseAsFileTime", out var address))
			{
				System.Runtime.CompilerServices.Unsafe.SkipInit(out long num);
				System.Runtime.CompilerServices.Unsafe.SkipInit(out long num2);
				for (int i = 0; i < 10; i++)
				{
					((delegate* unmanaged[SuppressGCTransition]<long*, void>)(void*)intPtr)(&num);
					((delegate* unmanaged[SuppressGCTransition]<long*, void>)(void*)address)(&num2);
					if (Math.Abs(num2 - num) <= 1000000)
					{
						intPtr = address;
						break;
					}
				}
			}
			return (delegate* unmanaged[SuppressGCTransition]<ulong*, void>)(void*)intPtr;
		}

		private unsafe static DateTime UpdateLeapSecondCacheAndReturnUtcNow()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out ulong num);
			s_pfnGetSystemTimeAsFileTime(&num);
			ulong hundredNanoSecond = num % 10000;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.Kernel32.SYSTEMTIME time);
			if (Interop.Kernel32.FileTimeToSystemTime(&num, &time) == Interop.BOOL.FALSE)
			{
				return LowGranularityNonCachedFallback();
			}
			if (time.Second >= 60)
			{
				return CreateDateTimeFromSystemTime(in time, hundredNanoSecond);
			}
			ulong num2 = num + 3000000000u;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.Kernel32.SYSTEMTIME sYSTEMTIME);
			if (Interop.Kernel32.FileTimeToSystemTime(&num2, &sYSTEMTIME) == Interop.BOOL.FALSE)
			{
				return LowGranularityNonCachedFallback();
			}
			ulong num3;
			ulong num4;
			if (sYSTEMTIME.Second == time.Second)
			{
				num3 = num;
				num4 = CreateDateTimeFromSystemTime(in time, hundredNanoSecond)._dateData;
			}
			else
			{
				Interop.Kernel32.SYSTEMTIME time2 = time;
				time2.Hour = 0;
				time2.Minute = 0;
				time2.Second = 0;
				time2.Milliseconds = 0;
				System.Runtime.CompilerServices.Unsafe.SkipInit(out ulong num5);
				if (Interop.Kernel32.SystemTimeToFileTime(&time2, &num5) == Interop.BOOL.FALSE)
				{
					return LowGranularityNonCachedFallback();
				}
				num3 = num5 + 863990000000L - 3000000000u;
				if (num - num3 >= 3000000000u)
				{
					return CreateDateTimeFromSystemTime(in time, hundredNanoSecond);
				}
				num4 = CreateDateTimeFromSystemTime(in time2, 0uL)._dateData + 863990000000L - 3000000000u;
			}
			Volatile.Write(ref s_leapSecondCache, new LeapSecondCache
			{
				OSFileTimeTicksAtStartOfValidityWindow = num3,
				DotnetDateDataAtStartOfValidityWindow = num4
			});
			return new DateTime(num4 + num - num3);
			[MethodImpl(MethodImplOptions.NoInlining)]
			static unsafe DateTime LowGranularityNonCachedFallback()
			{
				System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.Kernel32.SYSTEMTIME time3);
				Interop.Kernel32.GetSystemTime(&time3);
				return CreateDateTimeFromSystemTime(in time3, 0uL);
			}
		}
	}
	public enum DateTimeKind
	{
		Unspecified,
		Utc,
		Local
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct DateTimeOffset : IComparable, ISpanFormattable, IFormattable, IComparable<DateTimeOffset>, IEquatable<DateTimeOffset>, ISerializable, IDeserializationCallback, IAdditionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>, IAdditiveIdentity<DateTimeOffset, TimeSpan>, IComparisonOperators<DateTimeOffset, DateTimeOffset>, IEqualityOperators<DateTimeOffset, DateTimeOffset>, IMinMaxValue<DateTimeOffset>, ISpanParseable<DateTimeOffset>, IParseable<DateTimeOffset>, ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>, ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>
	{
		public static readonly DateTimeOffset MinValue = new DateTimeOffset(0L, TimeSpan.Zero);

		public static readonly DateTimeOffset MaxValue = new DateTimeOffset(3155378975999999999L, TimeSpan.Zero);

		public static readonly DateTimeOffset UnixEpoch = new DateTimeOffset(621355968000000000L, TimeSpan.Zero);

		private readonly DateTime _dateTime;

		private readonly short _offsetMinutes;

		public static DateTimeOffset Now => ToLocalTime(DateTime.UtcNow, throwOnOverflow: true);

		public static DateTimeOffset UtcNow
		{
			get
			{
				DateTime utcNow = DateTime.UtcNow;
				return new DateTimeOffset(0, utcNow);
			}
		}

		public DateTime DateTime => ClockDateTime;

		public DateTime UtcDateTime => DateTime.SpecifyKind(_dateTime, DateTimeKind.Utc);

		public DateTime LocalDateTime => UtcDateTime.ToLocalTime();

		private DateTime ClockDateTime => new DateTime((_dateTime + Offset).Ticks, DateTimeKind.Unspecified);

		public DateTime Date => ClockDateTime.Date;

		public int Day => ClockDateTime.Day;

		public DayOfWeek DayOfWeek => ClockDateTime.DayOfWeek;

		public int DayOfYear => ClockDateTime.DayOfYear;

		public int Hour => ClockDateTime.Hour;

		public int Millisecond => ClockDateTime.Millisecond;

		public int Minute => ClockDateTime.Minute;

		public int Month => ClockDateTime.Month;

		public TimeSpan Offset => new TimeSpan(0, _offsetMinutes, 0);

		public int Second => ClockDateTime.Second;

		public long Ticks => ClockDateTime.Ticks;

		public long UtcTicks => UtcDateTime.Ticks;

		public TimeSpan TimeOfDay => ClockDateTime.TimeOfDay;

		public int Year => ClockDateTime.Year;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IAdditiveIdentity<DateTimeOffset, TimeSpan>.AdditiveIdentity => default(TimeSpan);

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTimeOffset IMinMaxValue<DateTimeOffset>.MinValue => MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTimeOffset IMinMaxValue<DateTimeOffset>.MaxValue => MaxValue;

		private DateTimeOffset(short validOffsetMinutes, DateTime validDateTime)
		{
			_dateTime = validDateTime;
			_offsetMinutes = validOffsetMinutes;
		}

		public DateTimeOffset(long ticks, TimeSpan offset)
			: this(ValidateOffset(offset), ValidateDate(new DateTime(ticks), offset))
		{
		}

		public DateTimeOffset(DateTime dateTime)
		{
			TimeSpan offset = ((dateTime.Kind == DateTimeKind.Utc) ? new TimeSpan(0L) : TimeZoneInfo.GetLocalUtcOffset(dateTime, TimeZoneInfoOptions.NoThrowOnInvalidTime));
			_offsetMinutes = ValidateOffset(offset);
			_dateTime = ValidateDate(dateTime, offset);
		}

		public DateTimeOffset(DateTime dateTime, TimeSpan offset)
		{
			if (dateTime.Kind == DateTimeKind.Local)
			{
				if (offset != TimeZoneInfo.GetLocalUtcOffset(dateTime, TimeZoneInfoOptions.NoThrowOnInvalidTime))
				{
					throw new ArgumentException(SR.Argument_OffsetLocalMismatch, "offset");
				}
			}
			else if (dateTime.Kind == DateTimeKind.Utc && offset != TimeSpan.Zero)
			{
				throw new ArgumentException(SR.Argument_OffsetUtcMismatch, "offset");
			}
			_offsetMinutes = ValidateOffset(offset);
			_dateTime = ValidateDate(dateTime, offset);
		}

		public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, TimeSpan offset)
		{
			_offsetMinutes = ValidateOffset(offset);
			int num = second;
			if (second == 60 && DateTime.s_systemSupportsLeapSeconds)
			{
				second = 59;
			}
			_dateTime = ValidateDate(new DateTime(year, month, day, hour, minute, second), offset);
			if (num == 60 && !DateTime.IsValidTimeWithLeapSeconds(_dateTime.Year, _dateTime.Month, _dateTime.Day, _dateTime.Hour, _dateTime.Minute, DateTimeKind.Utc))
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadHourMinuteSecond);
			}
		}

		public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, TimeSpan offset)
		{
			_offsetMinutes = ValidateOffset(offset);
			int num = second;
			if (second == 60 && DateTime.s_systemSupportsLeapSeconds)
			{
				second = 59;
			}
			_dateTime = ValidateDate(new DateTime(year, month, day, hour, minute, second, millisecond), offset);
			if (num == 60 && !DateTime.IsValidTimeWithLeapSeconds(_dateTime.Year, _dateTime.Month, _dateTime.Day, _dateTime.Hour, _dateTime.Minute, DateTimeKind.Utc))
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadHourMinuteSecond);
			}
		}

		public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, TimeSpan offset)
		{
			_offsetMinutes = ValidateOffset(offset);
			int num = second;
			if (second == 60 && DateTime.s_systemSupportsLeapSeconds)
			{
				second = 59;
			}
			_dateTime = ValidateDate(new DateTime(year, month, day, hour, minute, second, millisecond, calendar), offset);
			if (num == 60 && !DateTime.IsValidTimeWithLeapSeconds(_dateTime.Year, _dateTime.Month, _dateTime.Day, _dateTime.Hour, _dateTime.Minute, DateTimeKind.Utc))
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadHourMinuteSecond);
			}
		}

		public DateTimeOffset ToOffset(TimeSpan offset)
		{
			return new DateTimeOffset((_dateTime + offset).Ticks, offset);
		}

		public DateTimeOffset Add(TimeSpan timeSpan)
		{
			return new DateTimeOffset(ClockDateTime.Add(timeSpan), Offset);
		}

		public DateTimeOffset AddDays(double days)
		{
			return new DateTimeOffset(ClockDateTime.AddDays(days), Offset);
		}

		public DateTimeOffset AddHours(double hours)
		{
			return new DateTimeOffset(ClockDateTime.AddHours(hours), Offset);
		}

		public DateTimeOffset AddMilliseconds(double milliseconds)
		{
			return new DateTimeOffset(ClockDateTime.AddMilliseconds(milliseconds), Offset);
		}

		public DateTimeOffset AddMinutes(double minutes)
		{
			return new DateTimeOffset(ClockDateTime.AddMinutes(minutes), Offset);
		}

		public DateTimeOffset AddMonths(int months)
		{
			return new DateTimeOffset(ClockDateTime.AddMonths(months), Offset);
		}

		public DateTimeOffset AddSeconds(double seconds)
		{
			return new DateTimeOffset(ClockDateTime.AddSeconds(seconds), Offset);
		}

		public DateTimeOffset AddTicks(long ticks)
		{
			return new DateTimeOffset(ClockDateTime.AddTicks(ticks), Offset);
		}

		public DateTimeOffset AddYears(int years)
		{
			return new DateTimeOffset(ClockDateTime.AddYears(years), Offset);
		}

		public static int Compare(DateTimeOffset first, DateTimeOffset second)
		{
			return DateTime.Compare(first.UtcDateTime, second.UtcDateTime);
		}

		int IComparable.CompareTo(object obj)
		{
			if (obj == null)
			{
				return 1;
			}
			if (!(obj is DateTimeOffset dateTimeOffset))
			{
				throw new ArgumentException(SR.Arg_MustBeDateTimeOffset);
			}
			DateTime utcDateTime = dateTimeOffset.UtcDateTime;
			DateTime utcDateTime2 = UtcDateTime;
			if (utcDateTime2 > utcDateTime)
			{
				return 1;
			}
			if (utcDateTime2 < utcDateTime)
			{
				return -1;
			}
			return 0;
		}

		public int CompareTo(DateTimeOffset other)
		{
			DateTime utcDateTime = other.UtcDateTime;
			DateTime utcDateTime2 = UtcDateTime;
			if (utcDateTime2 > utcDateTime)
			{
				return 1;
			}
			if (utcDateTime2 < utcDateTime)
			{
				return -1;
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is DateTimeOffset)
			{
				return UtcDateTime.Equals(((DateTimeOffset)obj).UtcDateTime);
			}
			return false;
		}

		public bool Equals(DateTimeOffset other)
		{
			return UtcDateTime.Equals(other.UtcDateTime);
		}

		public bool EqualsExact(DateTimeOffset other)
		{
			if (ClockDateTime == other.ClockDateTime && Offset == other.Offset)
			{
				return ClockDateTime.Kind == other.ClockDateTime.Kind;
			}
			return false;
		}

		public static bool Equals(DateTimeOffset first, DateTimeOffset second)
		{
			return DateTime.Equals(first.UtcDateTime, second.UtcDateTime);
		}

		public static DateTimeOffset FromFileTime(long fileTime)
		{
			return ToLocalTime(DateTime.FromFileTimeUtc(fileTime), throwOnOverflow: true);
		}

		public static DateTimeOffset FromUnixTimeSeconds(long seconds)
		{
			if (seconds < -62135596800L || seconds > 253402300799L)
			{
				throw new ArgumentOutOfRangeException("seconds", SR.Format(SR.ArgumentOutOfRange_Range, -62135596800L, 253402300799L));
			}
			long ticks = seconds * 10000000 + 621355968000000000L;
			return new DateTimeOffset(ticks, TimeSpan.Zero);
		}

		public static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds)
		{
			if (milliseconds < -62135596800000L || milliseconds > 253402300799999L)
			{
				throw new ArgumentOutOfRangeException("milliseconds", SR.Format(SR.ArgumentOutOfRange_Range, -62135596800000L, 253402300799999L));
			}
			long ticks = milliseconds * 10000 + 621355968000000000L;
			return new DateTimeOffset(ticks, TimeSpan.Zero);
		}

		void IDeserializationCallback.OnDeserialization(object sender)
		{
			try
			{
				ValidateOffset(Offset);
				ValidateDate(ClockDateTime, Offset);
			}
			catch (ArgumentException innerException)
			{
				throw new SerializationException(SR.Serialization_InvalidData, innerException);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("DateTime", _dateTime);
			info.AddValue("OffsetMinutes", _offsetMinutes);
		}

		private DateTimeOffset(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_dateTime = (DateTime)info.GetValue("DateTime", typeof(DateTime));
			_offsetMinutes = (short)info.GetValue("OffsetMinutes", typeof(short));
		}

		public override int GetHashCode()
		{
			return UtcDateTime.GetHashCode();
		}

		public static DateTimeOffset Parse(string input)
		{
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			TimeSpan offset;
			return new DateTimeOffset(DateTimeParse.Parse(input, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None, out offset).Ticks, offset);
		}

		public static DateTimeOffset Parse(string input, IFormatProvider? formatProvider)
		{
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			return Parse(input, formatProvider, DateTimeStyles.None);
		}

		public static DateTimeOffset Parse(string input, IFormatProvider? formatProvider, DateTimeStyles styles)
		{
			styles = ValidateStyles(styles, "styles");
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			TimeSpan offset;
			return new DateTimeOffset(DateTimeParse.Parse(input, DateTimeFormatInfo.GetInstance(formatProvider), styles, out offset).Ticks, offset);
		}

		public static DateTimeOffset Parse(ReadOnlySpan<char> input, IFormatProvider? formatProvider = null, DateTimeStyles styles = DateTimeStyles.None)
		{
			styles = ValidateStyles(styles, "styles");
			TimeSpan offset;
			return new DateTimeOffset(DateTimeParse.Parse(input, DateTimeFormatInfo.GetInstance(formatProvider), styles, out offset).Ticks, offset);
		}

		public static DateTimeOffset ParseExact(string input, string format, IFormatProvider? formatProvider)
		{
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			if (format == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
			}
			return ParseExact(input, format, formatProvider, DateTimeStyles.None);
		}

		public static DateTimeOffset ParseExact(string input, string format, IFormatProvider? formatProvider, DateTimeStyles styles)
		{
			styles = ValidateStyles(styles, "styles");
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			if (format == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
			}
			TimeSpan offset;
			return new DateTimeOffset(DateTimeParse.ParseExact(input, format, DateTimeFormatInfo.GetInstance(formatProvider), styles, out offset).Ticks, offset);
		}

		public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, DateTimeStyles styles = DateTimeStyles.None)
		{
			styles = ValidateStyles(styles, "styles");
			TimeSpan offset;
			return new DateTimeOffset(DateTimeParse.ParseExact(input, format, DateTimeFormatInfo.GetInstance(formatProvider), styles, out offset).Ticks, offset);
		}

		public static DateTimeOffset ParseExact(string input, string[] formats, IFormatProvider? formatProvider, DateTimeStyles styles)
		{
			styles = ValidateStyles(styles, "styles");
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			TimeSpan offset;
			return new DateTimeOffset(DateTimeParse.ParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out offset).Ticks, offset);
		}

		public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, DateTimeStyles styles = DateTimeStyles.None)
		{
			styles = ValidateStyles(styles, "styles");
			TimeSpan offset;
			return new DateTimeOffset(DateTimeParse.ParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out offset).Ticks, offset);
		}

		public TimeSpan Subtract(DateTimeOffset value)
		{
			return UtcDateTime.Subtract(value.UtcDateTime);
		}

		public DateTimeOffset Subtract(TimeSpan value)
		{
			return new DateTimeOffset(ClockDateTime.Subtract(value), Offset);
		}

		public long ToFileTime()
		{
			return UtcDateTime.ToFileTime();
		}

		public long ToUnixTimeSeconds()
		{
			long num = UtcDateTime.Ticks / 10000000;
			return num - 62135596800L;
		}

		public long ToUnixTimeMilliseconds()
		{
			long num = UtcDateTime.Ticks / 10000;
			return num - 62135596800000L;
		}

		public DateTimeOffset ToLocalTime()
		{
			return ToLocalTime(throwOnOverflow: false);
		}

		internal DateTimeOffset ToLocalTime(bool throwOnOverflow)
		{
			return ToLocalTime(UtcDateTime, throwOnOverflow);
		}

		private static DateTimeOffset ToLocalTime(DateTime utcDateTime, bool throwOnOverflow)
		{
			TimeSpan localUtcOffset = TimeZoneInfo.GetLocalUtcOffset(utcDateTime, TimeZoneInfoOptions.NoThrowOnInvalidTime);
			long num = utcDateTime.Ticks + localUtcOffset.Ticks;
			if (num < 0 || num > 3155378975999999999L)
			{
				if (throwOnOverflow)
				{
					throw new ArgumentException(SR.Arg_ArgumentOutOfRangeException);
				}
				num = ((num < 0) ? 0 : 3155378975999999999L);
			}
			return new DateTimeOffset(num, localUtcOffset);
		}

		public override string ToString()
		{
			return DateTimeFormat.Format(ClockDateTime, null, null, Offset);
		}

		public string ToString(string? format)
		{
			return DateTimeFormat.Format(ClockDateTime, format, null, Offset);
		}

		public string ToString(IFormatProvider? formatProvider)
		{
			return DateTimeFormat.Format(ClockDateTime, null, formatProvider, Offset);
		}

		public string ToString(string? format, IFormatProvider? formatProvider)
		{
			return DateTimeFormat.Format(ClockDateTime, format, formatProvider, Offset);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? formatProvider = null)
		{
			return DateTimeFormat.TryFormat(ClockDateTime, destination, out charsWritten, format, formatProvider, Offset);
		}

		public DateTimeOffset ToUniversalTime()
		{
			return new DateTimeOffset(UtcDateTime);
		}

		public static bool TryParse([NotNullWhen(true)] string? input, out DateTimeOffset result)
		{
			DateTime result2;
			TimeSpan offset;
			bool result3 = DateTimeParse.TryParse(input, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None, out result2, out offset);
			result = new DateTimeOffset(result2.Ticks, offset);
			return result3;
		}

		public static bool TryParse(ReadOnlySpan<char> input, out DateTimeOffset result)
		{
			DateTime result2;
			TimeSpan offset;
			bool result3 = DateTimeParse.TryParse(input, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None, out result2, out offset);
			result = new DateTimeOffset(result2.Ticks, offset);
			return result3;
		}

		public static bool TryParse([NotNullWhen(true)] string? input, IFormatProvider? formatProvider, DateTimeStyles styles, out DateTimeOffset result)
		{
			styles = ValidateStyles(styles, "styles");
			if (input == null)
			{
				result = default(DateTimeOffset);
				return false;
			}
			DateTime result2;
			TimeSpan offset;
			bool result3 = DateTimeParse.TryParse(input, DateTimeFormatInfo.GetInstance(formatProvider), styles, out result2, out offset);
			result = new DateTimeOffset(result2.Ticks, offset);
			return result3;
		}

		public static bool TryParse(ReadOnlySpan<char> input, IFormatProvider? formatProvider, DateTimeStyles styles, out DateTimeOffset result)
		{
			styles = ValidateStyles(styles, "styles");
			DateTime result2;
			TimeSpan offset;
			bool result3 = DateTimeParse.TryParse(input, DateTimeFormatInfo.GetInstance(formatProvider), styles, out result2, out offset);
			result = new DateTimeOffset(result2.Ticks, offset);
			return result3;
		}

		public static bool TryParseExact([NotNullWhen(true)] string? input, [NotNullWhen(true)] string? format, IFormatProvider? formatProvider, DateTimeStyles styles, out DateTimeOffset result)
		{
			styles = ValidateStyles(styles, "styles");
			if (input == null || format == null)
			{
				result = default(DateTimeOffset);
				return false;
			}
			DateTime result2;
			TimeSpan offset;
			bool result3 = DateTimeParse.TryParseExact(input, format, DateTimeFormatInfo.GetInstance(formatProvider), styles, out result2, out offset);
			result = new DateTimeOffset(result2.Ticks, offset);
			return result3;
		}

		public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, DateTimeStyles styles, out DateTimeOffset result)
		{
			styles = ValidateStyles(styles, "styles");
			DateTime result2;
			TimeSpan offset;
			bool result3 = DateTimeParse.TryParseExact(input, format, DateTimeFormatInfo.GetInstance(formatProvider), styles, out result2, out offset);
			result = new DateTimeOffset(result2.Ticks, offset);
			return result3;
		}

		public static bool TryParseExact([NotNullWhen(true)] string? input, [NotNullWhen(true)] string?[]? formats, IFormatProvider? formatProvider, DateTimeStyles styles, out DateTimeOffset result)
		{
			styles = ValidateStyles(styles, "styles");
			if (input == null)
			{
				result = default(DateTimeOffset);
				return false;
			}
			DateTime result2;
			TimeSpan offset;
			bool result3 = DateTimeParse.TryParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out result2, out offset);
			result = new DateTimeOffset(result2.Ticks, offset);
			return result3;
		}

		public static bool TryParseExact(ReadOnlySpan<char> input, [NotNullWhen(true)] string?[]? formats, IFormatProvider? formatProvider, DateTimeStyles styles, out DateTimeOffset result)
		{
			styles = ValidateStyles(styles, "styles");
			DateTime result2;
			TimeSpan offset;
			bool result3 = DateTimeParse.TryParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out result2, out offset);
			result = new DateTimeOffset(result2.Ticks, offset);
			return result3;
		}

		private static short ValidateOffset(TimeSpan offset)
		{
			long ticks = offset.Ticks;
			if (ticks % 600000000 != 0L)
			{
				throw new ArgumentException(SR.Argument_OffsetPrecision, "offset");
			}
			if (ticks < -504000000000L || ticks > 504000000000L)
			{
				throw new ArgumentOutOfRangeException("offset", SR.Argument_OffsetOutOfRange);
			}
			return (short)(offset.Ticks / 600000000);
		}

		private static DateTime ValidateDate(DateTime dateTime, TimeSpan offset)
		{
			long num = dateTime.Ticks - offset.Ticks;
			if (num < 0 || num > 3155378975999999999L)
			{
				throw new ArgumentOutOfRangeException("offset", SR.Argument_UTCOutOfRange);
			}
			return new DateTime(num, DateTimeKind.Unspecified);
		}

		private static DateTimeStyles ValidateStyles(DateTimeStyles style, string parameterName)
		{
			if (((uint)style & 0xFFFFFF00u) != 0)
			{
				throw new ArgumentException(SR.Argument_InvalidDateTimeStyles, parameterName);
			}
			if ((style & DateTimeStyles.AssumeLocal) != 0 && (style & DateTimeStyles.AssumeUniversal) != 0)
			{
				throw new ArgumentException(SR.Argument_ConflictingDateTimeStyles, parameterName);
			}
			if ((style & DateTimeStyles.NoCurrentDateDefault) != 0)
			{
				throw new ArgumentException(SR.Argument_DateTimeOffsetInvalidDateTimeStyles, parameterName);
			}
			style &= ~DateTimeStyles.RoundtripKind;
			style &= ~DateTimeStyles.AssumeLocal;
			return style;
		}

		public static implicit operator DateTimeOffset(DateTime dateTime)
		{
			return new DateTimeOffset(dateTime);
		}

		public static DateTimeOffset operator +(DateTimeOffset dateTimeOffset, TimeSpan timeSpan)
		{
			return new DateTimeOffset(dateTimeOffset.ClockDateTime + timeSpan, dateTimeOffset.Offset);
		}

		public static DateTimeOffset operator -(DateTimeOffset dateTimeOffset, TimeSpan timeSpan)
		{
			return new DateTimeOffset(dateTimeOffset.ClockDateTime - timeSpan, dateTimeOffset.Offset);
		}

		public static TimeSpan operator -(DateTimeOffset left, DateTimeOffset right)
		{
			return left.UtcDateTime - right.UtcDateTime;
		}

		public static bool operator ==(DateTimeOffset left, DateTimeOffset right)
		{
			return left.UtcDateTime == right.UtcDateTime;
		}

		public static bool operator !=(DateTimeOffset left, DateTimeOffset right)
		{
			return left.UtcDateTime != right.UtcDateTime;
		}

		public static bool operator <(DateTimeOffset left, DateTimeOffset right)
		{
			return left.UtcDateTime < right.UtcDateTime;
		}

		public static bool operator <=(DateTimeOffset left, DateTimeOffset right)
		{
			return left.UtcDateTime <= right.UtcDateTime;
		}

		public static bool operator >(DateTimeOffset left, DateTimeOffset right)
		{
			return left.UtcDateTime > right.UtcDateTime;
		}

		public static bool operator >=(DateTimeOffset left, DateTimeOffset right)
		{
			return left.UtcDateTime >= right.UtcDateTime;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTimeOffset IAdditionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>.op_Addition(DateTimeOffset left, TimeSpan right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateTimeOffset, DateTimeOffset>.op_LessThan(DateTimeOffset left, DateTimeOffset right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateTimeOffset, DateTimeOffset>.op_LessThanOrEqual(DateTimeOffset left, DateTimeOffset right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateTimeOffset, DateTimeOffset>.op_GreaterThan(DateTimeOffset left, DateTimeOffset right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<DateTimeOffset, DateTimeOffset>.op_GreaterThanOrEqual(DateTimeOffset left, DateTimeOffset right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<DateTimeOffset, DateTimeOffset>.op_Equality(DateTimeOffset left, DateTimeOffset right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<DateTimeOffset, DateTimeOffset>.op_Inequality(DateTimeOffset left, DateTimeOffset right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTimeOffset IParseable<DateTimeOffset>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<DateTimeOffset>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out DateTimeOffset result)
		{
			return TryParse(s, provider, DateTimeStyles.None, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTimeOffset ISpanParseable<DateTimeOffset>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<DateTimeOffset>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out DateTimeOffset result)
		{
			return TryParse(s, provider, DateTimeStyles.None, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static DateTimeOffset ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>.op_Subtraction(DateTimeOffset left, TimeSpan right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>.op_Subtraction(DateTimeOffset left, DateTimeOffset right)
		{
			return left - right;
		}
	}
	public enum DayOfWeek
	{
		Sunday,
		Monday,
		Tuesday,
		Wednesday,
		Thursday,
		Friday,
		Saturday
	}
	[Serializable]
	public sealed class DBNull : ISerializable, IConvertible
	{
		public static readonly DBNull Value = new DBNull();

		private DBNull()
		{
		}

		private DBNull(SerializationInfo info, StreamingContext context)
		{
			throw new NotSupportedException(SR.NotSupported_DBNullSerial);
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			UnitySerializationHolder.GetUnitySerializationInfo(info, 2);
		}

		public override string ToString()
		{
			return string.Empty;
		}

		public string ToString(IFormatProvider? provider)
		{
			return string.Empty;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.DBNull;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.InvalidCast_FromDBNull);
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}
	}
	internal class DefaultBinder : Binder
	{
		[Flags]
		private enum Primitives
		{
			Boolean = 8,
			Char = 0x10,
			SByte = 0x20,
			Byte = 0x40,
			Int16 = 0x80,
			UInt16 = 0x100,
			Int32 = 0x200,
			UInt32 = 0x400,
			Int64 = 0x800,
			UInt64 = 0x1000,
			Single = 0x2000,
			Double = 0x4000,
			Decimal = 0x8000,
			DateTime = 0x10000,
			String = 0x40000
		}

		internal sealed class BinderState
		{
			internal readonly int[] _argsMap;

			internal readonly int _originalSize;

			internal readonly bool _isParamArray;

			internal BinderState(int[] argsMap, int originalSize, bool isParamArray)
			{
				_argsMap = argsMap;
				_originalSize = originalSize;
				_isParamArray = isParamArray;
			}
		}

		private static readonly Primitives[] s_primitiveConversions = new Primitives[19]
		{
			(Primitives)0,
			(Primitives)0,
			(Primitives)0,
			Primitives.Boolean,
			Primitives.Char | Primitives.UInt16 | Primitives.Int32 | Primitives.UInt32 | Primitives.Int64 | Primitives.UInt64 | Primitives.Single | Primitives.Double,
			Primitives.SByte | Primitives.Int16 | Primitives.Int32 | Primitives.Int64 | Primitives.Single | Primitives.Double,
			Primitives.Char | Primitives.Byte | Primitives.Int16 | Primitives.UInt16 | Primitives.Int32 | Primitives.UInt32 | Primitives.Int64 | Primitives.UInt64 | Primitives.Single | Primitives.Double,
			Primitives.Int16 | Primitives.Int32 | Primitives.Int64 | Primitives.Single | Primitives.Double,
			Primitives.UInt16 | Primitives.Int32 | Primitives.UInt32 | Primitives.Int64 | Primitives.UInt64 | Primitives.Single | Primitives.Double,
			Primitives.Int32 | Primitives.Int64 | Primitives.Single | Primitives.Double,
			Primitives.UInt32 | Primitives.Int64 | Primitives.UInt64 | Primitives.Single | Primitives.Double,
			Primitives.Int64 | Primitives.Single | Primitives.Double,
			Primitives.UInt64 | Primitives.Single | Primitives.Double,
			Primitives.Single | Primitives.Double,
			Primitives.Double,
			Primitives.Decimal,
			Primitives.DateTime,
			(Primitives)0,
			Primitives.String
		};

		public sealed override MethodBase BindToMethod(BindingFlags bindingAttr, MethodBase[] match, ref object[] args, ParameterModifier[] modifiers, CultureInfo cultureInfo, string[] names, out object state)
		{
			if (match == null || match.Length == 0)
			{
				throw new ArgumentException(SR.Arg_EmptyArray, "match");
			}
			MethodBase[] array = (MethodBase[])match.Clone();
			state = null;
			int[][] array2 = new int[array.Length][];
			for (int i = 0; i < array.Length; i++)
			{
				ParameterInfo[] parametersNoCopy = array[i].GetParametersNoCopy();
				array2[i] = new int[(parametersNoCopy.Length > args.Length) ? parametersNoCopy.Length : args.Length];
				if (names == null)
				{
					for (int j = 0; j < args.Length; j++)
					{
						array2[i][j] = j;
					}
				}
				else if (!CreateParamOrder(array2[i], parametersNoCopy, names))
				{
					array[i] = null;
				}
			}
			Type[] array3 = new Type[array.Length];
			Type[] array4 = new Type[args.Length];
			for (int i = 0; i < args.Length; i++)
			{
				if (args[i] != null)
				{
					array4[i] = args[i].GetType();
				}
			}
			int num = 0;
			bool flag = (bindingAttr & BindingFlags.OptionalParamBinding) != 0;
			for (int i = 0; i < array.Length; i++)
			{
				Type type = null;
				if (array[i] == null)
				{
					continue;
				}
				ParameterInfo[] parametersNoCopy2 = array[i].GetParametersNoCopy();
				if (parametersNoCopy2.Length == 0)
				{
					if (args.Length == 0 || (array[i].CallingConvention & CallingConventions.VarArgs) != 0)
					{
						array2[num] = array2[i];
						array[num++] = array[i];
					}
					continue;
				}
				int j;
				if (parametersNoCopy2.Length > args.Length)
				{
					for (j = args.Length; j < parametersNoCopy2.Length - 1 && parametersNoCopy2[j].DefaultValue != DBNull.Value; j++)
					{
					}
					if (j != parametersNoCopy2.Length - 1)
					{
						continue;
					}
					if (parametersNoCopy2[j].DefaultValue == DBNull.Value)
					{
						if (!parametersNoCopy2[j].ParameterType.IsArray || !parametersNoCopy2[j].IsDefined(typeof(ParamArrayAttribute), inherit: true))
						{
							continue;
						}
						type = parametersNoCopy2[j].ParameterType.GetElementType();
					}
				}
				else if (parametersNoCopy2.Length < args.Length)
				{
					int num2 = parametersNoCopy2.Length - 1;
					if (!parametersNoCopy2[num2].ParameterType.IsArray || !parametersNoCopy2[num2].IsDefined(typeof(ParamArrayAttribute), inherit: true) || array2[i][num2] != num2)
					{
						continue;
					}
					type = parametersNoCopy2[num2].ParameterType.GetElementType();
				}
				else
				{
					int num3 = parametersNoCopy2.Length - 1;
					if (parametersNoCopy2[num3].ParameterType.IsArray && parametersNoCopy2[num3].IsDefined(typeof(ParamArrayAttribute), inherit: true) && array2[i][num3] == num3 && !parametersNoCopy2[num3].ParameterType.IsAssignableFrom(array4[num3]))
					{
						type = parametersNoCopy2[num3].ParameterType.GetElementType();
					}
				}
				int num4 = ((type != null) ? (parametersNoCopy2.Length - 1) : args.Length);
				for (j = 0; j < num4; j++)
				{
					Type type2 = parametersNoCopy2[j].ParameterType;
					if (type2.IsByRef)
					{
						type2 = type2.GetElementType();
					}
					if (type2 == array4[array2[i][j]] || (flag && args[array2[i][j]] == Type.Missing) || args[array2[i][j]] == null || type2 == typeof(object))
					{
						continue;
					}
					if (type2.IsPrimitive)
					{
						if (array4[array2[i][j]] == null || !CanChangePrimitive(args[array2[i][j]]?.GetType(), type2))
						{
							break;
						}
					}
					else if (!(array4[array2[i][j]] == null) && !type2.IsAssignableFrom(array4[array2[i][j]]) && (!array4[array2[i][j]].IsCOMObject || !type2.IsInstanceOfType(args[array2[i][j]])))
					{
						break;
					}
				}
				if (type != null && j == parametersNoCopy2.Length - 1)
				{
					for (; j < args.Length; j++)
					{
						if (type.IsPrimitive)
						{
							if (array4[j] == null || !CanChangePrimitive(args[j]?.GetType(), type))
							{
								break;
							}
						}
						else if (!(array4[j] == null) && !type.IsAssignableFrom(array4[j]) && (!array4[j].IsCOMObject || !type.IsInstanceOfType(args[j])))
						{
							break;
						}
					}
				}
				if (j == args.Length)
				{
					array2[num] = array2[i];
					array3[num] = type;
					array[num++] = array[i];
				}
			}
			switch (num)
			{
			case 0:
				throw new MissingMethodException(SR.MissingMember);
			case 1:
			{
				if (names != null)
				{
					state = new BinderState((int[])array2[0].Clone(), args.Length, array3[0] != null);
					ReorderParams(array2[0], args);
				}
				ParameterInfo[] parametersNoCopy4 = array[0].GetParametersNoCopy();
				if (parametersNoCopy4.Length == args.Length)
				{
					if (array3[0] != null)
					{
						object[] array8 = new object[parametersNoCopy4.Length];
						int num8 = parametersNoCopy4.Length - 1;
						Array.Copy(args, array8, num8);
						array8[num8] = Array.CreateInstance(array3[0], 1);
						((Array)array8[num8]).SetValue(args[num8], 0);
						args = array8;
					}
				}
				else if (parametersNoCopy4.Length > args.Length)
				{
					object[] array9 = new object[parametersNoCopy4.Length];
					int i;
					for (i = 0; i < args.Length; i++)
					{
						array9[i] = args[i];
					}
					for (; i < parametersNoCopy4.Length - 1; i++)
					{
						array9[i] = parametersNoCopy4[i].DefaultValue;
					}
					if (array3[0] != null)
					{
						array9[i] = Array.CreateInstance(array3[0], 0);
					}
					else
					{
						array9[i] = parametersNoCopy4[i].DefaultValue;
					}
					args = array9;
				}
				else if ((array[0].CallingConvention & CallingConventions.VarArgs) == 0)
				{
					object[] array10 = new object[parametersNoCopy4.Length];
					int num9 = parametersNoCopy4.Length - 1;
					Array.Copy(args, array10, num9);
					array10[num9] = Array.CreateInstance(array3[0], args.Length - num9);
					Array.Copy(args, num9, (Array)array10[num9], 0, args.Length - num9);
					args = array10;
				}
				return array[0];
			}
			default:
			{
				int num5 = 0;
				bool flag2 = false;
				for (int i = 1; i < num; i++)
				{
					switch (FindMostSpecificMethod(array[num5], array2[num5], array3[num5], array[i], array2[i], array3[i], array4, args))
					{
					case 0:
						flag2 = true;
						break;
					case 2:
						num5 = i;
						flag2 = false;
						break;
					}
				}
				if (flag2)
				{
					throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
				}
				if (names != null)
				{
					state = new BinderState((int[])array2[num5].Clone(), args.Length, array3[num5] != null);
					ReorderParams(array2[num5], args);
				}
				ParameterInfo[] parametersNoCopy3 = array[num5].GetParametersNoCopy();
				if (parametersNoCopy3.Length == args.Length)
				{
					if (array3[num5] != null)
					{
						object[] array5 = new object[parametersNoCopy3.Length];
						int num6 = parametersNoCopy3.Length - 1;
						Array.Copy(args, array5, num6);
						array5[num6] = Array.CreateInstance(array3[num5], 1);
						((Array)array5[num6]).SetValue(args[num6], 0);
						args = array5;
					}
				}
				else if (parametersNoCopy3.Length > args.Length)
				{
					object[] array6 = new object[parametersNoCopy3.Length];
					int i;
					for (i = 0; i < args.Length; i++)
					{
						array6[i] = args[i];
					}
					for (; i < parametersNoCopy3.Length - 1; i++)
					{
						array6[i] = parametersNoCopy3[i].DefaultValue;
					}
					if (array3[num5] != null)
					{
						array6[i] = Array.CreateInstance(array3[num5], 0);
					}
					else
					{
						array6[i] = parametersNoCopy3[i].DefaultValue;
					}
					args = array6;
				}
				else if ((array[num5].CallingConvention & CallingConventions.VarArgs) == 0)
				{
					object[] array7 = new object[parametersNoCopy3.Length];
					int num7 = parametersNoCopy3.Length - 1;
					Array.Copy(args, array7, num7);
					array7[num7] = Array.CreateInstance(array3[num5], args.Length - num7);
					Array.Copy(args, num7, (Array)array7[num7], 0, args.Length - num7);
					args = array7;
				}
				return array[num5];
			}
			}
		}

		public sealed override FieldInfo BindToField(BindingFlags bindingAttr, FieldInfo[] match, object value, CultureInfo cultureInfo)
		{
			if (match == null)
			{
				throw new ArgumentNullException("match");
			}
			int num = 0;
			FieldInfo[] array = (FieldInfo[])match.Clone();
			if ((bindingAttr & BindingFlags.SetField) != 0)
			{
				Type type = value.GetType();
				for (int i = 0; i < array.Length; i++)
				{
					Type fieldType = array[i].FieldType;
					if (fieldType == type)
					{
						array[num++] = array[i];
					}
					else if (value == Empty.Value && fieldType.IsClass)
					{
						array[num++] = array[i];
					}
					else if (fieldType == typeof(object))
					{
						array[num++] = array[i];
					}
					else if (fieldType.IsPrimitive)
					{
						if (CanChangePrimitive(type, fieldType))
						{
							array[num++] = array[i];
						}
					}
					else if (fieldType.IsAssignableFrom(type))
					{
						array[num++] = array[i];
					}
				}
				switch (num)
				{
				case 0:
					throw new MissingFieldException(SR.MissingField);
				case 1:
					return array[0];
				}
			}
			int num2 = 0;
			bool flag = false;
			for (int i = 1; i < num; i++)
			{
				switch (FindMostSpecificField(array[num2], array[i]))
				{
				case 0:
					flag = true;
					break;
				case 2:
					num2 = i;
					flag = false;
					break;
				}
			}
			if (flag)
			{
				throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
			}
			return array[num2];
		}

		public sealed override MethodBase SelectMethod(BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers)
		{
			Type[] array = new Type[types.Length];
			for (int i = 0; i < types.Length; i++)
			{
				array[i] = types[i].UnderlyingSystemType;
				if (!array[i].IsRuntimeImplemented() && !(array[i] is SignatureType))
				{
					throw new ArgumentException(SR.Arg_MustBeType, "types");
				}
			}
			types = array;
			if (match == null || match.Length == 0)
			{
				throw new ArgumentException(SR.Arg_EmptyArray, "match");
			}
			MethodBase[] array2 = (MethodBase[])match.Clone();
			int num = 0;
			for (int i = 0; i < array2.Length; i++)
			{
				ParameterInfo[] parametersNoCopy = array2[i].GetParametersNoCopy();
				if (parametersNoCopy.Length != types.Length)
				{
					continue;
				}
				int j;
				for (j = 0; j < types.Length; j++)
				{
					Type parameterType = parametersNoCopy[j].ParameterType;
					if (types[j].MatchesParameterTypeExactly(parametersNoCopy[j]) || parameterType == typeof(object))
					{
						continue;
					}
					Type type = types[j];
					if (type is SignatureType signatureType)
					{
						if (!(array2[i] is MethodInfo genericMethod))
						{
							break;
						}
						type = signatureType.TryResolveAgainstGenericMethod(genericMethod);
						if (type == null)
						{
							break;
						}
					}
					if (parameterType.IsPrimitive)
					{
						if (!type.UnderlyingSystemType.IsRuntimeImplemented() || !CanChangePrimitive(type.UnderlyingSystemType, parameterType.UnderlyingSystemType))
						{
							break;
						}
					}
					else if (!parameterType.IsAssignableFrom(type))
					{
						break;
					}
				}
				if (j == types.Length)
				{
					array2[num++] = array2[i];
				}
			}
			switch (num)
			{
			case 0:
				return null;
			case 1:
				return array2[0];
			default:
			{
				int num2 = 0;
				bool flag = false;
				int[] array3 = new int[types.Length];
				for (int i = 0; i < types.Length; i++)
				{
					array3[i] = i;
				}
				for (int i = 1; i < num; i++)
				{
					switch (FindMostSpecificMethod(array2[num2], array3, null, array2[i], array3, null, types, null))
					{
					case 0:
						flag = true;
						break;
					case 2:
						flag = false;
						num2 = i;
						break;
					}
				}
				if (flag)
				{
					throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
				}
				return array2[num2];
			}
			}
		}

		public sealed override PropertyInfo SelectProperty(BindingFlags bindingAttr, PropertyInfo[] match, Type returnType, Type[] indexes, ParameterModifier[] modifiers)
		{
			if (indexes != null)
			{
				foreach (Type type in indexes)
				{
					if (type == null)
					{
						throw new ArgumentNullException("indexes");
					}
				}
			}
			if (match == null || match.Length == 0)
			{
				throw new ArgumentException(SR.Arg_EmptyArray, "match");
			}
			PropertyInfo[] array = (PropertyInfo[])match.Clone();
			int j = 0;
			int num = 0;
			int num2 = ((indexes != null) ? indexes.Length : 0);
			for (int k = 0; k < array.Length; k++)
			{
				if (indexes != null)
				{
					ParameterInfo[] indexParameters = array[k].GetIndexParameters();
					if (indexParameters.Length != num2)
					{
						continue;
					}
					for (j = 0; j < num2; j++)
					{
						Type parameterType = indexParameters[j].ParameterType;
						if (parameterType == indexes[j] || parameterType == typeof(object))
						{
							continue;
						}
						if (parameterType.IsPrimitive)
						{
							if (!indexes[j].UnderlyingSystemType.IsRuntimeImplemented() || !CanChangePrimitive(indexes[j].UnderlyingSystemType, parameterType.UnderlyingSystemType))
							{
								break;
							}
						}
						else if (!parameterType.IsAssignableFrom(indexes[j]))
						{
							break;
						}
					}
				}
				if (j != num2)
				{
					continue;
				}
				if (returnType != null)
				{
					if (array[k].PropertyType.IsPrimitive)
					{
						if (!returnType.UnderlyingSystemType.IsRuntimeImplemented() || !CanChangePrimitive(returnType.UnderlyingSystemType, array[k].PropertyType.UnderlyingSystemType))
						{
							continue;
						}
					}
					else if (!array[k].PropertyType.IsAssignableFrom(returnType))
					{
						continue;
					}
				}
				array[num++] = array[k];
			}
			switch (num)
			{
			case 0:
				return null;
			case 1:
				return array[0];
			default:
			{
				int num3 = 0;
				bool flag = false;
				int[] array2 = new int[num2];
				for (int k = 0; k < num2; k++)
				{
					array2[k] = k;
				}
				for (int k = 1; k < num; k++)
				{
					int num4 = FindMostSpecificType(array[num3].PropertyType, array[k].PropertyType, returnType);
					if (num4 == 0 && indexes != null)
					{
						num4 = FindMostSpecific(array[num3].GetIndexParameters(), array2, null, array[k].GetIndexParameters(), array2, null, indexes, null);
					}
					if (num4 == 0)
					{
						num4 = FindMostSpecificProperty(array[num3], array[k]);
						if (num4 == 0)
						{
							flag = true;
						}
					}
					if (num4 == 2)
					{
						flag = false;
						num3 = k;
					}
				}
				if (flag)
				{
					throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
				}
				return array[num3];
			}
			}
		}

		public override object ChangeType(object value, Type type, CultureInfo cultureInfo)
		{
			throw new NotSupportedException(SR.NotSupported_ChangeType);
		}

		public sealed override void ReorderArgumentArray(ref object[] args, object state)
		{
			BinderState binderState = (BinderState)state;
			ReorderParams(binderState._argsMap, args);
			if (binderState._isParamArray)
			{
				int num = args.Length - 1;
				if (args.Length == binderState._originalSize)
				{
					args[num] = ((object[])args[num])[0];
					return;
				}
				object[] array = new object[args.Length];
				Array.Copy(args, array, num);
				int num2 = num;
				int num3 = 0;
				while (num2 < array.Length)
				{
					array[num2] = ((object[])args[num])[num3];
					num2++;
					num3++;
				}
				args = array;
			}
			else if (args.Length > binderState._originalSize)
			{
				object[] array2 = new object[binderState._originalSize];
				Array.Copy(args, array2, binderState._originalSize);
				args = array2;
			}
		}

		public static MethodBase ExactBinding(MethodBase[] match, Type[] types, ParameterModifier[] modifiers)
		{
			if (match == null)
			{
				throw new ArgumentNullException("match");
			}
			MethodBase[] array = new MethodBase[match.Length];
			int num = 0;
			for (int i = 0; i < match.Length; i++)
			{
				ParameterInfo[] parametersNoCopy = match[i].GetParametersNoCopy();
				if (parametersNoCopy.Length == 0)
				{
					continue;
				}
				int j;
				for (j = 0; j < types.Length; j++)
				{
					Type parameterType = parametersNoCopy[j].ParameterType;
					if (!parameterType.Equals(types[j]))
					{
						break;
					}
				}
				if (j >= types.Length)
				{
					array[num] = match[i];
					num++;
				}
			}
			return num switch
			{
				0 => null, 
				1 => array[0], 
				_ => FindMostDerivedNewSlotMeth(array, num), 
			};
		}

		public static PropertyInfo ExactPropertyBinding(PropertyInfo[] match, Type returnType, Type[] types, ParameterModifier[] modifiers)
		{
			if (match == null)
			{
				throw new ArgumentNullException("match");
			}
			PropertyInfo propertyInfo = null;
			int num = ((types != null) ? types.Length : 0);
			for (int i = 0; i < match.Length; i++)
			{
				ParameterInfo[] indexParameters = match[i].GetIndexParameters();
				int j;
				for (j = 0; j < num; j++)
				{
					Type parameterType = indexParameters[j].ParameterType;
					if (parameterType != types[j])
					{
						break;
					}
				}
				if (j >= num && (!(returnType != null) || !(returnType != match[i].PropertyType)))
				{
					if (propertyInfo != null)
					{
						throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
					}
					propertyInfo = match[i];
				}
			}
			return propertyInfo;
		}

		private static int FindMostSpecific(ParameterInfo[] p1, int[] paramOrder1, Type paramArrayType1, ParameterInfo[] p2, int[] paramOrder2, Type paramArrayType2, Type[] types, object[] args)
		{
			if (paramArrayType1 != null && paramArrayType2 == null)
			{
				return 2;
			}
			if (paramArrayType2 != null && paramArrayType1 == null)
			{
				return 1;
			}
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < types.Length; i++)
			{
				if (args != null && args[i] == Type.Missing)
				{
					continue;
				}
				Type type = ((!(paramArrayType1 != null) || paramOrder1[i] < p1.Length - 1) ? p1[paramOrder1[i]].ParameterType : paramArrayType1);
				Type type2 = ((!(paramArrayType2 != null) || paramOrder2[i] < p2.Length - 1) ? p2[paramOrder2[i]].ParameterType : paramArrayType2);
				if (!(type == type2))
				{
					switch (FindMostSpecificType(type, type2, types[i]))
					{
					case 0:
						return 0;
					case 1:
						flag = true;
						break;
					case 2:
						flag2 = true;
						break;
					}
				}
			}
			if (flag == flag2)
			{
				if (!flag && args != null)
				{
					if (p1.Length > p2.Length)
					{
						return 1;
					}
					if (p2.Length > p1.Length)
					{
						return 2;
					}
				}
				return 0;
			}
			if (!flag)
			{
				return 2;
			}
			return 1;
		}

		private static int FindMostSpecificType(Type c1, Type c2, Type t)
		{
			if (c1 == c2)
			{
				return 0;
			}
			if (t is SignatureType pattern)
			{
				if (pattern.MatchesExactly(c1))
				{
					return 1;
				}
				if (pattern.MatchesExactly(c2))
				{
					return 2;
				}
			}
			else
			{
				if (c1 == t)
				{
					return 1;
				}
				if (c2 == t)
				{
					return 2;
				}
			}
			if (c1.IsByRef || c2.IsByRef)
			{
				if (c1.IsByRef && c2.IsByRef)
				{
					c1 = c1.GetElementType();
					c2 = c2.GetElementType();
				}
				else if (c1.IsByRef)
				{
					if (c1.GetElementType() == c2)
					{
						return 2;
					}
					c1 = c1.GetElementType();
				}
				else
				{
					if (c2.GetElementType() == c1)
					{
						return 1;
					}
					c2 = c2.GetElementType();
				}
			}
			bool flag;
			bool flag2;
			if (c1.IsPrimitive && c2.IsPrimitive)
			{
				flag = CanChangePrimitive(c2, c1);
				flag2 = CanChangePrimitive(c1, c2);
			}
			else
			{
				flag = c1.IsAssignableFrom(c2);
				flag2 = c2.IsAssignableFrom(c1);
			}
			if (flag == flag2)
			{
				return 0;
			}
			if (flag)
			{
				return 2;
			}
			return 1;
		}

		private static int FindMostSpecificMethod(MethodBase m1, int[] paramOrder1, Type paramArrayType1, MethodBase m2, int[] paramOrder2, Type paramArrayType2, Type[] types, object[] args)
		{
			int num = FindMostSpecific(m1.GetParametersNoCopy(), paramOrder1, paramArrayType1, m2.GetParametersNoCopy(), paramOrder2, paramArrayType2, types, args);
			if (num != 0)
			{
				return num;
			}
			if (CompareMethodSig(m1, m2))
			{
				int hierarchyDepth = GetHierarchyDepth(m1.DeclaringType);
				int hierarchyDepth2 = GetHierarchyDepth(m2.DeclaringType);
				if (hierarchyDepth == hierarchyDepth2)
				{
					return 0;
				}
				if (hierarchyDepth < hierarchyDepth2)
				{
					return 2;
				}
				return 1;
			}
			return 0;
		}

		private static int FindMostSpecificField(FieldInfo cur1, FieldInfo cur2)
		{
			if (cur1.Name == cur2.Name)
			{
				int hierarchyDepth = GetHierarchyDepth(cur1.DeclaringType);
				int hierarchyDepth2 = GetHierarchyDepth(cur2.DeclaringType);
				if (hierarchyDepth == hierarchyDepth2)
				{
					return 0;
				}
				if (hierarchyDepth < hierarchyDepth2)
				{
					return 2;
				}
				return 1;
			}
			return 0;
		}

		private static int FindMostSpecificProperty(PropertyInfo cur1, PropertyInfo cur2)
		{
			if (cur1.Name == cur2.Name)
			{
				int hierarchyDepth = GetHierarchyDepth(cur1.DeclaringType);
				int hierarchyDepth2 = GetHierarchyDepth(cur2.DeclaringType);
				if (hierarchyDepth == hierarchyDepth2)
				{
					return 0;
				}
				if (hierarchyDepth < hierarchyDepth2)
				{
					return 2;
				}
				return 1;
			}
			return 0;
		}

		public static bool CompareMethodSig(MethodBase m1, MethodBase m2)
		{
			ParameterInfo[] parametersNoCopy = m1.GetParametersNoCopy();
			ParameterInfo[] parametersNoCopy2 = m2.GetParametersNoCopy();
			if (parametersNoCopy.Length != parametersNoCopy2.Length)
			{
				return false;
			}
			int num = parametersNoCopy.Length;
			for (int i = 0; i < num; i++)
			{
				if (parametersNoCopy[i].ParameterType != parametersNoCopy2[i].ParameterType)
				{
					return false;
				}
			}
			return true;
		}

		private static int GetHierarchyDepth(Type t)
		{
			int num = 0;
			Type type = t;
			do
			{
				num++;
				type = type.BaseType;
			}
			while (type != null);
			return num;
		}

		internal static MethodBase FindMostDerivedNewSlotMeth(MethodBase[] match, int cMatches)
		{
			int num = 0;
			MethodBase result = null;
			for (int i = 0; i < cMatches; i++)
			{
				int hierarchyDepth = GetHierarchyDepth(match[i].DeclaringType);
				if (hierarchyDepth == num)
				{
					throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
				}
				if (hierarchyDepth > num)
				{
					num = hierarchyDepth;
					result = match[i];
				}
			}
			return result;
		}

		private static void ReorderParams(int[] paramOrder, object[] vars)
		{
			object[] array = new object[vars.Length];
			for (int i = 0; i < vars.Length; i++)
			{
				array[i] = vars[i];
			}
			for (int j = 0; j < vars.Length; j++)
			{
				vars[j] = array[paramOrder[j]];
			}
		}

		private static bool CreateParamOrder(int[] paramOrder, ParameterInfo[] pars, string[] names)
		{
			bool[] array = new bool[pars.Length];
			for (int i = 0; i < pars.Length; i++)
			{
				paramOrder[i] = -1;
			}
			for (int j = 0; j < names.Length; j++)
			{
				int k;
				for (k = 0; k < pars.Length; k++)
				{
					if (names[j].Equals(pars[k].Name))
					{
						paramOrder[k] = j;
						array[j] = true;
						break;
					}
				}
				if (k == pars.Length)
				{
					return false;
				}
			}
			int l = 0;
			for (int m = 0; m < pars.Length; m++)
			{
				if (paramOrder[m] != -1)
				{
					continue;
				}
				for (; l < pars.Length; l++)
				{
					if (!array[l])
					{
						paramOrder[m] = l;
						l++;
						break;
					}
				}
			}
			return true;
		}

		internal static bool CanChangePrimitive(Type source, Type target)
		{
			if ((source == typeof(IntPtr) && target == typeof(IntPtr)) || (source == typeof(UIntPtr) && target == typeof(UIntPtr)))
			{
				return true;
			}
			Primitives primitives = s_primitiveConversions[(int)Type.GetTypeCode(source)];
			Primitives primitives2 = (Primitives)(1 << (int)Type.GetTypeCode(target));
			return (primitives & primitives2) != 0;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class DivideByZeroException : ArithmeticException
	{
		public DivideByZeroException()
			: base(SR.Arg_DivideByZero)
		{
			base.HResult = -2147352558;
		}

		public DivideByZeroException(string? message)
			: base(message)
		{
			base.HResult = -2147352558;
		}

		public DivideByZeroException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147352558;
		}

		protected DivideByZeroException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class DllNotFoundException : TypeLoadException
	{
		public DllNotFoundException()
			: base(SR.Arg_DllNotFoundException)
		{
			base.HResult = -2146233052;
		}

		public DllNotFoundException(string? message)
			: base(message)
		{
			base.HResult = -2146233052;
		}

		public DllNotFoundException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233052;
		}

		protected DllNotFoundException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Double : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<double>, IEquatable<double>, IBinaryFloatingPoint<double>, IBinaryNumber<double>, IBitwiseOperators<double, double, double>, INumber<double>, IAdditionOperators<double, double, double>, IAdditiveIdentity<double, double>, IComparisonOperators<double, double>, IEqualityOperators<double, double>, IDecrementOperators<double>, IDivisionOperators<double, double, double>, IIncrementOperators<double>, IModulusOperators<double, double, double>, IMultiplicativeIdentity<double, double>, IMultiplyOperators<double, double, double>, ISpanParseable<double>, IParseable<double>, ISubtractionOperators<double, double, double>, IUnaryNegationOperators<double, double>, IUnaryPlusOperators<double, double>, IFloatingPoint<double>, ISignedNumber<double>, IMinMaxValue<double>
	{
		private readonly double m_value;

		public const double MinValue = -1.7976931348623157E+308;

		public const double MaxValue = 1.7976931348623157E+308;

		public const double Epsilon = 5E-324;

		public const double NegativeInfinity = -1.0 / 0.0;

		public const double PositiveInfinity = 1.0 / 0.0;

		public const double NaN = 0.0 / 0.0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IAdditiveIdentity<double, double>.AdditiveIdentity => 0.0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.E => Math.E;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Epsilon => double.Epsilon;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.NaN => double.NaN;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.NegativeInfinity => double.NegativeInfinity;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.NegativeZero => -0.0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Pi => Math.PI;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.PositiveInfinity => double.PositiveInfinity;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Tau => Math.PI * 2.0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IMinMaxValue<double>.MinValue => double.MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IMinMaxValue<double>.MaxValue => double.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IMultiplicativeIdentity<double, double>.MultiplicativeIdentity => 1.0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.One => 1.0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Zero => 0.0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double ISignedNumber<double>.NegativeOne => -1.0;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsFinite(double d)
		{
			long num = BitConverter.DoubleToInt64Bits(d);
			return (num & 0x7FFFFFFFFFFFFFFFL) < 9218868437227405312L;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsInfinity(double d)
		{
			long num = BitConverter.DoubleToInt64Bits(d);
			return (num & 0x7FFFFFFFFFFFFFFFL) == 9218868437227405312L;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsNaN(double d)
		{
			return d != d;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsNegative(double d)
		{
			return BitConverter.DoubleToInt64Bits(d) < 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsNegativeInfinity(double d)
		{
			return d == double.NegativeInfinity;
		}

		[NonVersionable]
		public static bool IsNormal(double d)
		{
			long num = BitConverter.DoubleToInt64Bits(d);
			num &= 0x7FFFFFFFFFFFFFFFL;
			if (num < 9218868437227405312L && num != 0L)
			{
				return (num & 0x7FF0000000000000L) != 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsPositiveInfinity(double d)
		{
			return d == double.PositiveInfinity;
		}

		[NonVersionable]
		public static bool IsSubnormal(double d)
		{
			long num = BitConverter.DoubleToInt64Bits(d);
			num &= 0x7FFFFFFFFFFFFFFFL;
			if (num < 9218868437227405312L && num != 0L)
			{
				return (num & 0x7FF0000000000000L) == 0;
			}
			return false;
		}

		internal static int ExtractExponentFromBits(ulong bits)
		{
			return (int)(bits >> 52) & 0x7FF;
		}

		internal static ulong ExtractSignificandFromBits(ulong bits)
		{
			return bits & 0xFFFFFFFFFFFFFuL;
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is double num)
			{
				if (this < num)
				{
					return -1;
				}
				if (this > num)
				{
					return 1;
				}
				if (this == num)
				{
					return 0;
				}
				if (IsNaN(this))
				{
					if (!IsNaN(num))
					{
						return -1;
					}
					return 0;
				}
				return 1;
			}
			throw new ArgumentException(SR.Arg_MustBeDouble);
		}

		public int CompareTo(double value)
		{
			if (this < value)
			{
				return -1;
			}
			if (this > value)
			{
				return 1;
			}
			if (this == value)
			{
				return 0;
			}
			if (IsNaN(this))
			{
				if (!IsNaN(value))
				{
					return -1;
				}
				return 0;
			}
			return 1;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is double num))
			{
				return false;
			}
			if (num == this)
			{
				return true;
			}
			if (IsNaN(num))
			{
				return IsNaN(this);
			}
			return false;
		}

		[NonVersionable]
		public static bool operator ==(double left, double right)
		{
			return left == right;
		}

		[NonVersionable]
		public static bool operator !=(double left, double right)
		{
			return left != right;
		}

		[NonVersionable]
		public static bool operator <(double left, double right)
		{
			return left < right;
		}

		[NonVersionable]
		public static bool operator >(double left, double right)
		{
			return left > right;
		}

		[NonVersionable]
		public static bool operator <=(double left, double right)
		{
			return left <= right;
		}

		[NonVersionable]
		public static bool operator >=(double left, double right)
		{
			return left >= right;
		}

		public bool Equals(double obj)
		{
			if (obj == this)
			{
				return true;
			}
			if (IsNaN(obj))
			{
				return IsNaN(this);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode()
		{
			long num = Unsafe.As<double, long>(ref Unsafe.AsRef(in m_value));
			if (((num - 1) & 0x7FFFFFFFFFFFFFFFL) >= 9218868437227405312L)
			{
				num &= 0x7FF0000000000000L;
			}
			return (int)num ^ (int)(num >> 32);
		}

		public override string ToString()
		{
			return Number.FormatDouble(this, null, NumberFormatInfo.CurrentInfo);
		}

		public string ToString(string? format)
		{
			return Number.FormatDouble(this, format, NumberFormatInfo.CurrentInfo);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.FormatDouble(this, null, NumberFormatInfo.GetInstance(provider));
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatDouble(this, format, NumberFormatInfo.GetInstance(provider));
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatDouble(this, format, NumberFormatInfo.GetInstance(provider), destination, out charsWritten);
		}

		public static double Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseDouble(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo);
		}

		public static double Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseDouble(s, style, NumberFormatInfo.CurrentInfo);
		}

		public static double Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseDouble(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider));
		}

		public static double Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseDouble(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static double Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Float | NumberStyles.AllowThousands, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			return Number.ParseDouble(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out double result)
		{
			if (s == null)
			{
				result = 0.0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out double result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out double result)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				result = 0.0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out double result)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out double result)
		{
			return Number.TryParseDouble(s, style, info, out result);
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Double;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Double", "Char"));
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return this;
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Double", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IAdditionOperators<double, double, double>.op_Addition(double left, double right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<double>.IsPow2(double value)
		{
			ulong num = BitConverter.DoubleToUInt64Bits(value);
			uint num2 = (uint)(int)(num >> 52) & 0x7FFu;
			ulong num3 = num & 0xFFFFFFFFFFFFFuL;
			if (value > 0.0 && num2 != 0 && num2 != 2047)
			{
				return num3 == 0;
			}
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IBinaryNumber<double>.Log2(double value)
		{
			return Math.Log2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IBitwiseOperators<double, double, double>.op_BitwiseAnd(double left, double right)
		{
			ulong value = BitConverter.DoubleToUInt64Bits(left) & BitConverter.DoubleToUInt64Bits(right);
			return BitConverter.UInt64BitsToDouble(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IBitwiseOperators<double, double, double>.op_BitwiseOr(double left, double right)
		{
			ulong value = BitConverter.DoubleToUInt64Bits(left) | BitConverter.DoubleToUInt64Bits(right);
			return BitConverter.UInt64BitsToDouble(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IBitwiseOperators<double, double, double>.op_ExclusiveOr(double left, double right)
		{
			ulong value = BitConverter.DoubleToUInt64Bits(left) ^ BitConverter.DoubleToUInt64Bits(right);
			return BitConverter.UInt64BitsToDouble(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IBitwiseOperators<double, double, double>.op_OnesComplement(double value)
		{
			ulong value2 = ~BitConverter.DoubleToUInt64Bits(value);
			return BitConverter.UInt64BitsToDouble(value2);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<double, double>.op_LessThan(double left, double right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<double, double>.op_LessThanOrEqual(double left, double right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<double, double>.op_GreaterThan(double left, double right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<double, double>.op_GreaterThanOrEqual(double left, double right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IDecrementOperators<double>.op_Decrement(double value)
		{
			return value -= 1.0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IDivisionOperators<double, double, double>.op_Division(double left, double right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<double, double>.op_Equality(double left, double right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<double, double>.op_Inequality(double left, double right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Acos(double x)
		{
			return Math.Acos(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Acosh(double x)
		{
			return Math.Acosh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Asin(double x)
		{
			return Math.Asin(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Asinh(double x)
		{
			return Math.Asinh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Atan(double x)
		{
			return Math.Atan(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Atan2(double y, double x)
		{
			return Math.Atan2(y, x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Atanh(double x)
		{
			return Math.Atanh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.BitIncrement(double x)
		{
			return Math.BitIncrement(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.BitDecrement(double x)
		{
			return Math.BitDecrement(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Cbrt(double x)
		{
			return Math.Cbrt(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Ceiling(double x)
		{
			return Math.Ceiling(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.CopySign(double x, double y)
		{
			return Math.CopySign(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Cos(double x)
		{
			return Math.Cos(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Cosh(double x)
		{
			return Math.Cosh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Exp(double x)
		{
			return Math.Exp(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Floor(double x)
		{
			return Math.Floor(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.FusedMultiplyAdd(double left, double right, double addend)
		{
			return Math.FusedMultiplyAdd(left, right, addend);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.IEEERemainder(double left, double right)
		{
			return Math.IEEERemainder(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TInteger IFloatingPoint<double>.ILogB<TInteger>(double x)
		{
			return TInteger.Create(Math.ILogB(x));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Log(double x)
		{
			return Math.Log(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Log(double x, double newBase)
		{
			return Math.Log(x, newBase);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Log2(double x)
		{
			return Math.Log2(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Log10(double x)
		{
			return Math.Log10(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.MaxMagnitude(double x, double y)
		{
			return Math.MaxMagnitude(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.MinMagnitude(double x, double y)
		{
			return Math.MinMagnitude(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Pow(double x, double y)
		{
			return Math.Pow(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Round(double x)
		{
			return Math.Round(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Round<TInteger>(double x, TInteger digits)
		{
			return Math.Round(x, int.Create(digits));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Round(double x, MidpointRounding mode)
		{
			return Math.Round(x, mode);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Round<TInteger>(double x, TInteger digits, MidpointRounding mode)
		{
			return Math.Round(x, int.Create(digits), mode);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.ScaleB<TInteger>(double x, TInteger n)
		{
			return Math.ScaleB(x, int.Create(n));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Sin(double x)
		{
			return Math.Sin(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Sinh(double x)
		{
			return Math.Sinh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Sqrt(double x)
		{
			return Math.Sqrt(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Tan(double x)
		{
			return Math.Tan(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Tanh(double x)
		{
			return Math.Tanh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IFloatingPoint<double>.Truncate(double x)
		{
			return Math.Truncate(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<double>.IsFinite(double d)
		{
			return IsFinite(d);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<double>.IsInfinity(double d)
		{
			return IsInfinity(d);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<double>.IsNaN(double d)
		{
			return IsNaN(d);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<double>.IsNegative(double d)
		{
			return IsNegative(d);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<double>.IsNegativeInfinity(double d)
		{
			return IsNegativeInfinity(d);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<double>.IsNormal(double d)
		{
			return IsNormal(d);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<double>.IsPositiveInfinity(double d)
		{
			return IsPositiveInfinity(d);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<double>.IsSubnormal(double d)
		{
			return IsSubnormal(d);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IIncrementOperators<double>.op_Increment(double value)
		{
			return value += 1.0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IModulusOperators<double, double, double>.op_Modulus(double left, double right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IMultiplyOperators<double, double, double>.op_Multiply(double left, double right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Abs(double value)
		{
			return Math.Abs(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Clamp(double value, double min, double max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (double)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (nint)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0.0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (double)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (nint)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0.0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (double)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (nint)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0.0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (double Quotient, double Remainder) INumber<double>.DivRem(double left, double right)
		{
			return (left / right, left % right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Max(double x, double y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Min(double x, double y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double INumber<double>.Sign(double value)
		{
			return Math.Sign(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<double>.TryCreate<TOther>(TOther value, out double result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (int)(byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (int)(char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				result = (double)(decimal)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				result = (double)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				result = (short)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				result = (int)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				result = (long)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				result = (nint)(IntPtr)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				result = (float)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (int)(ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				result = (uint)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				result = (ulong)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				result = (nint)(nuint)(UIntPtr)(object)value;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0.0;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<double>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out double result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<double>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out double result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IParseable<double>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<double>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out double result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double ISpanParseable<double>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<double>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out double result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double ISubtractionOperators<double, double, double>.op_Subtraction(double left, double right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IUnaryNegationOperators<double, double>.op_UnaryNegation(double value)
		{
			return 0.0 - value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IUnaryPlusOperators<double, double>.op_UnaryPlus(double value)
		{
			return value;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class DuplicateWaitObjectException : ArgumentException
	{
		public DuplicateWaitObjectException()
			: base(SR.Arg_DuplicateWaitObjectException)
		{
			base.HResult = -2146233047;
		}

		public DuplicateWaitObjectException(string? parameterName)
			: base(SR.Arg_DuplicateWaitObjectException, parameterName)
		{
			base.HResult = -2146233047;
		}

		public DuplicateWaitObjectException(string? parameterName, string? message)
			: base(message, parameterName)
		{
			base.HResult = -2146233047;
		}

		public DuplicateWaitObjectException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233047;
		}

		protected DuplicateWaitObjectException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal sealed class Empty
	{
		public static readonly Empty Value = new Empty();

		private Empty()
		{
		}

		public override string ToString()
		{
			return string.Empty;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class EntryPointNotFoundException : TypeLoadException
	{
		public EntryPointNotFoundException()
			: base(SR.Arg_EntryPointNotFoundException)
		{
			base.HResult = -2146233053;
		}

		public EntryPointNotFoundException(string? message)
			: base(message)
		{
			base.HResult = -2146233053;
		}

		public EntryPointNotFoundException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233053;
		}

		protected EntryPointNotFoundException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public enum EnvironmentVariableTarget
	{
		Process,
		User,
		Machine
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class EventArgs
	{
		public static readonly EventArgs Empty = new EventArgs();
	}
	public delegate void EventHandler(object? sender, EventArgs e);
	public delegate void EventHandler<TEventArgs>(object? sender, TEventArgs e);
	[Serializable]
	[Obsolete("ExecutionEngineException previously indicated an unspecified fatal error in the runtime. The runtime no longer raises this exception so this type is obsolete.")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class ExecutionEngineException : SystemException
	{
		public ExecutionEngineException()
			: base(SR.Arg_ExecutionEngineException)
		{
			base.HResult = -2146233082;
		}

		public ExecutionEngineException(string? message)
			: base(message)
		{
			base.HResult = -2146233082;
		}

		public ExecutionEngineException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233082;
		}

		private ExecutionEngineException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class FieldAccessException : MemberAccessException
	{
		public FieldAccessException()
			: base(SR.Arg_FieldAccessException)
		{
			base.HResult = -2146233081;
		}

		public FieldAccessException(string? message)
			: base(message)
		{
			base.HResult = -2146233081;
		}

		public FieldAccessException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233081;
		}

		protected FieldAccessException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Enum, Inherited = false)]
	public class FlagsAttribute : Attribute
	{
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class FormatException : SystemException
	{
		public FormatException()
			: base(SR.Arg_FormatException)
		{
			base.HResult = -2146233033;
		}

		public FormatException(string? message)
			: base(message)
		{
			base.HResult = -2146233033;
		}

		public FormatException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233033;
		}

		protected FormatException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public abstract class FormattableString : IFormattable
	{
		public abstract string Format { get; }

		public abstract int ArgumentCount { get; }

		public abstract object?[] GetArguments();

		public abstract object? GetArgument(int index);

		public abstract string ToString(IFormatProvider? formatProvider);

		string IFormattable.ToString(string ignored, IFormatProvider formatProvider)
		{
			return ToString(formatProvider);
		}

		public static string Invariant(FormattableString formattable)
		{
			if (formattable == null)
			{
				throw new ArgumentNullException("formattable");
			}
			return formattable.ToString(CultureInfo.InvariantCulture);
		}

		public static string CurrentCulture(FormattableString formattable)
		{
			if (formattable == null)
			{
				throw new ArgumentNullException("formattable");
			}
			return formattable.ToString(CultureInfo.CurrentCulture);
		}

		public override string ToString()
		{
			return ToString(CultureInfo.CurrentCulture);
		}
	}
	public delegate TResult Func<out TResult>();
	public delegate TResult Func<in T, out TResult>(T arg);
	public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
	public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2 arg2, T3 arg3);
	public delegate TResult Func<in T1, in T2, in T3, in T4, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);
	public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);
	public readonly struct GCGenerationInfo
	{
		public long SizeBeforeBytes { get; }

		public long FragmentationBeforeBytes { get; }

		public long SizeAfterBytes { get; }

		public long FragmentationAfterBytes { get; }
	}
	public enum GCKind
	{
		Any,
		Ephemeral,
		FullBlocking,
		Background
	}
	[StructLayout(LayoutKind.Sequential)]
	internal sealed class GCMemoryInfoData
	{
		internal long _highMemoryLoadThresholdBytes;

		internal long _totalAvailableMemoryBytes;

		internal long _memoryLoadBytes;

		internal long _heapSizeBytes;

		internal long _fragmentedBytes;

		internal long _totalCommittedBytes;

		internal long _promotedBytes;

		internal long _pinnedObjectsCount;

		internal long _finalizationPendingCount;

		internal long _index;

		internal int _generation;

		internal int _pauseTimePercentage;

		internal bool _compacted;

		internal bool _concurrent;

		private GCGenerationInfo _generationInfo0;

		private GCGenerationInfo _generationInfo1;

		private GCGenerationInfo _generationInfo2;

		private GCGenerationInfo _generationInfo3;

		private GCGenerationInfo _generationInfo4;

		private TimeSpan _pauseDuration0;

		private TimeSpan _pauseDuration1;

		internal ReadOnlySpan<GCGenerationInfo> GenerationInfoAsSpan => MemoryMarshal.CreateReadOnlySpan(ref _generationInfo0, 5);

		internal ReadOnlySpan<TimeSpan> PauseDurationsAsSpan => MemoryMarshal.CreateReadOnlySpan(ref _pauseDuration0, 2);
	}
	public readonly struct GCMemoryInfo
	{
		private readonly GCMemoryInfoData _data;

		public long HighMemoryLoadThresholdBytes => _data._highMemoryLoadThresholdBytes;

		public long MemoryLoadBytes => _data._memoryLoadBytes;

		public long TotalAvailableMemoryBytes => _data._totalAvailableMemoryBytes;

		public long HeapSizeBytes => _data._heapSizeBytes;

		public long FragmentedBytes => _data._fragmentedBytes;

		public long Index => _data._index;

		public int Generation => _data._generation;

		public bool Compacted => _data._compacted;

		public bool Concurrent => _data._concurrent;

		public long TotalCommittedBytes => _data._totalCommittedBytes;

		public long PromotedBytes => _data._promotedBytes;

		public long PinnedObjectsCount => _data._pinnedObjectsCount;

		public long FinalizationPendingCount => _data._finalizationPendingCount;

		public ReadOnlySpan<TimeSpan> PauseDurations => _data.PauseDurationsAsSpan;

		public double PauseTimePercentage => (double)_data._pauseTimePercentage / 100.0;

		public ReadOnlySpan<GCGenerationInfo> GenerationInfo => _data.GenerationInfoAsSpan;

		internal GCMemoryInfo(GCMemoryInfoData data)
		{
			_data = data;
		}
	}
	internal sealed class Gen2GcCallback : CriticalFinalizerObject
	{
		private readonly Func<bool> _callback0;

		private readonly Func<object, bool> _callback1;

		private GCHandle _weakTargetObj;

		private Gen2GcCallback(Func<bool> callback)
		{
			_callback0 = callback;
		}

		private Gen2GcCallback(Func<object, bool> callback, object targetObj)
		{
			_callback1 = callback;
			_weakTargetObj = GCHandle.Alloc(targetObj, GCHandleType.Weak);
		}

		public static void Register(Func<bool> callback)
		{
			new Gen2GcCallback(callback);
		}

		public static void Register(Func<object, bool> callback, object targetObj)
		{
			new Gen2GcCallback(callback, targetObj);
		}

		~Gen2GcCallback()
		{
			if (_weakTargetObj.IsAllocated)
			{
				object target = _weakTargetObj.Target;
				if (target == null)
				{
					_weakTargetObj.Free();
					return;
				}
				try
				{
					if (!_callback1(target))
					{
						_weakTargetObj.Free();
						return;
					}
				}
				catch
				{
				}
			}
			else
			{
				try
				{
					if (!_callback0())
					{
						return;
					}
				}
				catch
				{
				}
			}
			GC.ReRegisterForFinalize(this);
		}
	}
	internal static class DateTimeFormat
	{
		internal static char[] allStandardFormats = new char[19]
		{
			'd', 'D', 'f', 'F', 'g', 'G', 'm', 'M', 'o', 'O',
			'r', 'R', 's', 't', 'T', 'u', 'U', 'y', 'Y'
		};

		internal static readonly DateTimeFormatInfo InvariantFormatInfo = CultureInfo.InvariantCulture.DateTimeFormat;

		internal static readonly string[] InvariantAbbreviatedMonthNames = InvariantFormatInfo.AbbreviatedMonthNames;

		internal static readonly string[] InvariantAbbreviatedDayNames = InvariantFormatInfo.AbbreviatedDayNames;

		internal static string[] fixedNumberFormats = new string[7] { "0", "00", "000", "0000", "00000", "000000", "0000000" };

		internal static void FormatDigits(StringBuilder outputBuffer, int value, int len)
		{
			FormatDigits(outputBuffer, value, len, overrideLengthLimit: false);
		}

		internal unsafe static void FormatDigits(StringBuilder outputBuffer, int value, int len, bool overrideLengthLimit)
		{
			if (!overrideLengthLimit && len > 2)
			{
				len = 2;
			}
			char* ptr = stackalloc char[16];
			char* ptr2 = ptr + 16;
			int num = value;
			do
			{
				*(--ptr2) = (char)(num % 10 + 48);
				num /= 10;
			}
			while (num != 0 && ptr2 > ptr);
			int i;
			for (i = (int)(ptr + 16 - ptr2); i < len; i++)
			{
				if (ptr2 <= ptr)
				{
					break;
				}
				*(--ptr2) = '0';
			}
			outputBuffer.Append(ptr2, i);
		}

		private static void HebrewFormatDigits(StringBuilder outputBuffer, int digits)
		{
			HebrewNumber.Append(outputBuffer, digits);
		}

		internal static int ParseRepeatPattern(ReadOnlySpan<char> format, int pos, char patternChar)
		{
			int length = format.Length;
			int i;
			for (i = pos + 1; i < length && format[i] == patternChar; i++)
			{
			}
			return i - pos;
		}

		private static string FormatDayOfWeek(int dayOfWeek, int repeat, DateTimeFormatInfo dtfi)
		{
			if (repeat == 3)
			{
				return dtfi.GetAbbreviatedDayName((DayOfWeek)dayOfWeek);
			}
			return dtfi.GetDayName((DayOfWeek)dayOfWeek);
		}

		private static string FormatMonth(int month, int repeatCount, DateTimeFormatInfo dtfi)
		{
			if (repeatCount == 3)
			{
				return dtfi.GetAbbreviatedMonthName(month);
			}
			return dtfi.GetMonthName(month);
		}

		private static string FormatHebrewMonthName(DateTime time, int month, int repeatCount, DateTimeFormatInfo dtfi)
		{
			if (dtfi.Calendar.IsLeapYear(dtfi.Calendar.GetYear(time)))
			{
				return dtfi.InternalGetMonthName(month, MonthNameStyles.LeapYear, repeatCount == 3);
			}
			if (month >= 7)
			{
				month++;
			}
			if (repeatCount == 3)
			{
				return dtfi.GetAbbreviatedMonthName(month);
			}
			return dtfi.GetMonthName(month);
		}

		internal static int ParseQuoteString(ReadOnlySpan<char> format, int pos, StringBuilder result)
		{
			int length = format.Length;
			int num = pos;
			char c = format[pos++];
			bool flag = false;
			while (pos < length)
			{
				char c2 = format[pos++];
				if (c2 == c)
				{
					flag = true;
					break;
				}
				if (c2 == '\\')
				{
					if (pos >= length)
					{
						throw new FormatException(SR.Format_InvalidString);
					}
					result.Append(format[pos++]);
				}
				else
				{
					result.Append(c2);
				}
			}
			if (!flag)
			{
				throw new FormatException(SR.Format(SR.Format_BadQuote, c));
			}
			return pos - num;
		}

		internal static int ParseNextChar(ReadOnlySpan<char> format, int pos)
		{
			if (pos >= format.Length - 1)
			{
				return -1;
			}
			return format[pos + 1];
		}

		private static bool IsUseGenitiveForm(ReadOnlySpan<char> format, int index, int tokenLen, char patternToMatch)
		{
			int num = 0;
			int num2 = index - 1;
			while (num2 >= 0 && format[num2] != patternToMatch)
			{
				num2--;
			}
			if (num2 >= 0)
			{
				while (--num2 >= 0 && format[num2] == patternToMatch)
				{
					num++;
				}
				if (num <= 1)
				{
					return true;
				}
			}
			for (num2 = index + tokenLen; num2 < format.Length && format[num2] != patternToMatch; num2++)
			{
			}
			if (num2 < format.Length)
			{
				num = 0;
				while (++num2 < format.Length && format[num2] == patternToMatch)
				{
					num++;
				}
				if (num <= 1)
				{
					return true;
				}
			}
			return false;
		}

		private static StringBuilder FormatCustomized(DateTime dateTime, ReadOnlySpan<char> format, DateTimeFormatInfo dtfi, TimeSpan offset, StringBuilder result)
		{
			Calendar calendar = dtfi.Calendar;
			bool flag = false;
			if (result == null)
			{
				flag = true;
				result = StringBuilderCache.Acquire();
			}
			bool flag2 = calendar.ID == CalendarId.HEBREW;
			bool flag3 = calendar.ID == CalendarId.JAPAN;
			bool timeOnly = true;
			int num;
			for (int i = 0; i < format.Length; i += num)
			{
				char c = format[i];
				switch (c)
				{
				case 'g':
					num = ParseRepeatPattern(format, i, c);
					result.Append(dtfi.GetEraName(calendar.GetEra(dateTime)));
					break;
				case 'h':
				{
					num = ParseRepeatPattern(format, i, c);
					int num3 = dateTime.Hour % 12;
					if (num3 == 0)
					{
						num3 = 12;
					}
					FormatDigits(result, num3, num);
					break;
				}
				case 'H':
					num = ParseRepeatPattern(format, i, c);
					FormatDigits(result, dateTime.Hour, num);
					break;
				case 'm':
					num = ParseRepeatPattern(format, i, c);
					FormatDigits(result, dateTime.Minute, num);
					break;
				case 's':
					num = ParseRepeatPattern(format, i, c);
					FormatDigits(result, dateTime.Second, num);
					break;
				case 'F':
				case 'f':
					num = ParseRepeatPattern(format, i, c);
					if (num <= 7)
					{
						long num4 = dateTime.Ticks % 10000000;
						num4 /= (long)Math.Pow(10.0, 7 - num);
						if (c == 'f')
						{
							result.AppendSpanFormattable((int)num4, fixedNumberFormats[num - 1], CultureInfo.InvariantCulture);
							break;
						}
						int num5 = num;
						while (num5 > 0 && num4 % 10 == 0L)
						{
							num4 /= 10;
							num5--;
						}
						if (num5 > 0)
						{
							result.AppendSpanFormattable((int)num4, fixedNumberFormats[num5 - 1], CultureInfo.InvariantCulture);
						}
						else if (result.Length > 0 && result[result.Length - 1] == '.')
						{
							result.Remove(result.Length - 1, 1);
						}
						break;
					}
					if (flag)
					{
						StringBuilderCache.Release(result);
					}
					throw new FormatException(SR.Format_InvalidString);
				case 't':
					num = ParseRepeatPattern(format, i, c);
					if (num == 1)
					{
						if (dateTime.Hour < 12)
						{
							if (dtfi.AMDesignator.Length >= 1)
							{
								result.Append(dtfi.AMDesignator[0]);
							}
						}
						else if (dtfi.PMDesignator.Length >= 1)
						{
							result.Append(dtfi.PMDesignator[0]);
						}
					}
					else
					{
						result.Append((dateTime.Hour < 12) ? dtfi.AMDesignator : dtfi.PMDesignator);
					}
					break;
				case 'd':
					num = ParseRepeatPattern(format, i, c);
					if (num <= 2)
					{
						int dayOfMonth = calendar.GetDayOfMonth(dateTime);
						if (flag2)
						{
							HebrewFormatDigits(result, dayOfMonth);
						}
						else
						{
							FormatDigits(result, dayOfMonth, num);
						}
					}
					else
					{
						int dayOfWeek = (int)calendar.GetDayOfWeek(dateTime);
						result.Append(FormatDayOfWeek(dayOfWeek, num, dtfi));
					}
					timeOnly = false;
					break;
				case 'M':
				{
					num = ParseRepeatPattern(format, i, c);
					int month = calendar.GetMonth(dateTime);
					if (num <= 2)
					{
						if (flag2)
						{
							HebrewFormatDigits(result, month);
						}
						else
						{
							FormatDigits(result, month, num);
						}
					}
					else if (flag2)
					{
						result.Append(FormatHebrewMonthName(dateTime, month, num, dtfi));
					}
					else if ((dtfi.FormatFlags & DateTimeFormatFlags.UseGenitiveMonth) != 0)
					{
						result.Append(dtfi.InternalGetMonthName(month, IsUseGenitiveForm(format, i, num, 'd') ? MonthNameStyles.Genitive : MonthNameStyles.Regular, num == 3));
					}
					else
					{
						result.Append(FormatMonth(month, num, dtfi));
					}
					timeOnly = false;
					break;
				}
				case 'y':
				{
					int year = calendar.GetYear(dateTime);
					num = ParseRepeatPattern(format, i, c);
					if (flag3 && !LocalAppContextSwitches.FormatJapaneseFirstYearAsANumber && year == 1 && ((i + num < format.Length && format[i + num] == '年') || (i + num < format.Length - 1 && format[i + num] == '\'' && format[i + num + 1] == '年')))
					{
						result.Append("元"[0]);
					}
					else if (dtfi.HasForceTwoDigitYears)
					{
						FormatDigits(result, year, (num <= 2) ? num : 2);
					}
					else if (calendar.ID == CalendarId.HEBREW)
					{
						HebrewFormatDigits(result, year);
					}
					else if (num <= 2)
					{
						FormatDigits(result, year % 100, num);
					}
					else if (num <= 16)
					{
						FormatDigits(result, year, num, overrideLengthLimit: true);
					}
					else
					{
						result.Append(year.ToString("D" + num.ToString(CultureInfo.InvariantCulture), CultureInfo.InvariantCulture));
					}
					timeOnly = false;
					break;
				}
				case 'z':
					num = ParseRepeatPattern(format, i, c);
					FormatCustomizedTimeZone(dateTime, offset, num, timeOnly, result);
					break;
				case 'K':
					num = 1;
					FormatCustomizedRoundripTimeZone(dateTime, offset, result);
					break;
				case ':':
					result.Append(dtfi.TimeSeparator);
					num = 1;
					break;
				case '/':
					result.Append(dtfi.DateSeparator);
					num = 1;
					break;
				case '"':
				case '\'':
					num = ParseQuoteString(format, i, result);
					break;
				case '%':
				{
					int num2 = ParseNextChar(format, i);
					if (num2 >= 0 && num2 != 37)
					{
						char reference = (char)num2;
						StringBuilder stringBuilder = FormatCustomized(dateTime, MemoryMarshal.CreateReadOnlySpan(ref reference, 1), dtfi, offset, result);
						num = 2;
						break;
					}
					if (flag)
					{
						StringBuilderCache.Release(result);
					}
					throw new FormatException(SR.Format_InvalidString);
				}
				case '\\':
				{
					int num2 = ParseNextChar(format, i);
					if (num2 >= 0)
					{
						result.Append((char)num2);
						num = 2;
						break;
					}
					if (flag)
					{
						StringBuilderCache.Release(result);
					}
					throw new FormatException(SR.Format_InvalidString);
				}
				default:
					result.Append(c);
					num = 1;
					break;
				}
			}
			return result;
		}

		private static void FormatCustomizedTimeZone(DateTime dateTime, TimeSpan offset, int tokenLen, bool timeOnly, StringBuilder result)
		{
			if (offset.Ticks == long.MinValue)
			{
				offset = ((timeOnly && dateTime.Ticks < 864000000000L) ? TimeZoneInfo.GetLocalUtcOffset(DateTime.Now, TimeZoneInfoOptions.NoThrowOnInvalidTime) : ((dateTime.Kind != DateTimeKind.Utc) ? TimeZoneInfo.GetLocalUtcOffset(dateTime, TimeZoneInfoOptions.NoThrowOnInvalidTime) : default(TimeSpan)));
			}
			if (offset.Ticks >= 0)
			{
				result.Append('+');
			}
			else
			{
				result.Append('-');
				offset = offset.Negate();
			}
			StringBuilder stringBuilder;
			IFormatProvider invariantCulture;
			if (tokenLen <= 1)
			{
				stringBuilder = result;
				StringBuilder stringBuilder2 = stringBuilder;
				invariantCulture = CultureInfo.InvariantCulture;
				IFormatProvider provider = invariantCulture;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(0, 1, stringBuilder, invariantCulture);
				handler.AppendFormatted(offset.Hours, "0");
				stringBuilder2.Append(provider, ref handler);
				return;
			}
			stringBuilder = result;
			StringBuilder stringBuilder3 = stringBuilder;
			invariantCulture = CultureInfo.InvariantCulture;
			IFormatProvider provider2 = invariantCulture;
			StringBuilder.AppendInterpolatedStringHandler handler2 = new StringBuilder.AppendInterpolatedStringHandler(0, 1, stringBuilder, invariantCulture);
			handler2.AppendFormatted(offset.Hours, "00");
			stringBuilder3.Append(provider2, ref handler2);
			if (tokenLen >= 3)
			{
				stringBuilder = result;
				StringBuilder stringBuilder4 = stringBuilder;
				invariantCulture = CultureInfo.InvariantCulture;
				IFormatProvider provider3 = invariantCulture;
				StringBuilder.AppendInterpolatedStringHandler handler3 = new StringBuilder.AppendInterpolatedStringHandler(1, 1, stringBuilder, invariantCulture);
				handler3.AppendLiteral(":");
				handler3.AppendFormatted(offset.Minutes, "00");
				stringBuilder4.Append(provider3, ref handler3);
			}
		}

		private static void FormatCustomizedRoundripTimeZone(DateTime dateTime, TimeSpan offset, StringBuilder result)
		{
			if (offset.Ticks == long.MinValue)
			{
				switch (dateTime.Kind)
				{
				case DateTimeKind.Local:
					break;
				case DateTimeKind.Utc:
					result.Append('Z');
					return;
				default:
					return;
				}
				offset = TimeZoneInfo.GetLocalUtcOffset(dateTime, TimeZoneInfoOptions.NoThrowOnInvalidTime);
			}
			if (offset.Ticks >= 0)
			{
				result.Append('+');
			}
			else
			{
				result.Append('-');
				offset = offset.Negate();
			}
			Append2DigitNumber(result, offset.Hours);
			result.Append(':');
			Append2DigitNumber(result, offset.Minutes);
		}

		private static void Append2DigitNumber(StringBuilder result, int val)
		{
			result.Append((char)(48 + val / 10));
			result.Append((char)(48 + val % 10));
		}

		internal static string GetRealFormat(ReadOnlySpan<char> format, DateTimeFormatInfo dtfi)
		{
			switch (format[0])
			{
			case 'd':
				return dtfi.ShortDatePattern;
			case 'D':
				return dtfi.LongDatePattern;
			case 'f':
				return dtfi.LongDatePattern + " " + dtfi.ShortTimePattern;
			case 'F':
				return dtfi.FullDateTimePattern;
			case 'g':
				return dtfi.GeneralShortTimePattern;
			case 'G':
				return dtfi.GeneralLongTimePattern;
			case 'M':
			case 'm':
				return dtfi.MonthDayPattern;
			case 'O':
			case 'o':
				return "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffffffK";
			case 'R':
			case 'r':
				return dtfi.RFC1123Pattern;
			case 's':
				return dtfi.SortableDateTimePattern;
			case 't':
				return dtfi.ShortTimePattern;
			case 'T':
				return dtfi.LongTimePattern;
			case 'u':
				return dtfi.UniversalSortableDateTimePattern;
			case 'U':
				return dtfi.FullDateTimePattern;
			case 'Y':
			case 'y':
				return dtfi.YearMonthPattern;
			default:
				throw new FormatException(SR.Format_InvalidString);
			}
		}

		private static string ExpandPredefinedFormat(ReadOnlySpan<char> format, ref DateTime dateTime, ref DateTimeFormatInfo dtfi, TimeSpan offset)
		{
			switch (format[0])
			{
			case 'O':
			case 'o':
				dtfi = DateTimeFormatInfo.InvariantInfo;
				break;
			case 'R':
			case 'r':
			case 'u':
				if (offset.Ticks != long.MinValue)
				{
					dateTime -= offset;
				}
				dtfi = DateTimeFormatInfo.InvariantInfo;
				break;
			case 's':
				dtfi = DateTimeFormatInfo.InvariantInfo;
				break;
			case 'U':
				if (offset.Ticks != long.MinValue)
				{
					throw new FormatException(SR.Format_InvalidString);
				}
				dtfi = (DateTimeFormatInfo)dtfi.Clone();
				if (dtfi.Calendar.GetType() != typeof(GregorianCalendar))
				{
					dtfi.Calendar = GregorianCalendar.GetDefaultInstance();
				}
				dateTime = dateTime.ToUniversalTime();
				break;
			}
			return GetRealFormat(format, dtfi);
		}

		internal static string Format(DateTime dateTime, string format, IFormatProvider provider)
		{
			return Format(dateTime, format, provider, new TimeSpan(long.MinValue));
		}

		internal static string Format(DateTime dateTime, string format, IFormatProvider provider, TimeSpan offset)
		{
			if (format != null && format.Length == 1)
			{
				switch (format[0])
				{
				case 'O':
				case 'o':
				{
					Span<char> destination = stackalloc char[33];
					TryFormatO(dateTime, offset, destination, out var charsWritten2);
					return destination.Slice(0, charsWritten2).ToString();
				}
				case 'R':
				case 'r':
				{
					string text = string.FastAllocateString(29);
					TryFormatR(dateTime, offset, new Span<char>(ref text.GetRawStringData(), text.Length), out var _);
					return text;
				}
				}
			}
			DateTimeFormatInfo instance = DateTimeFormatInfo.GetInstance(provider);
			return StringBuilderCache.GetStringAndRelease(FormatStringBuilder(dateTime, format, instance, offset));
		}

		internal static bool TryFormat(DateTime dateTime, Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			return TryFormat(dateTime, destination, out charsWritten, format, provider, new TimeSpan(long.MinValue));
		}

		internal static bool TryFormat(DateTime dateTime, Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider, TimeSpan offset)
		{
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'O':
				case 'o':
					return TryFormatO(dateTime, offset, destination, out charsWritten);
				case 'R':
				case 'r':
					return TryFormatR(dateTime, offset, destination, out charsWritten);
				}
			}
			DateTimeFormatInfo instance = DateTimeFormatInfo.GetInstance(provider);
			StringBuilder stringBuilder = FormatStringBuilder(dateTime, format, instance, offset);
			bool flag = stringBuilder.Length <= destination.Length;
			if (flag)
			{
				stringBuilder.CopyTo(0, destination, stringBuilder.Length);
				charsWritten = stringBuilder.Length;
			}
			else
			{
				charsWritten = 0;
			}
			StringBuilderCache.Release(stringBuilder);
			return flag;
		}

		private static StringBuilder FormatStringBuilder(DateTime dateTime, ReadOnlySpan<char> format, DateTimeFormatInfo dtfi, TimeSpan offset)
		{
			if (format.Length == 0)
			{
				bool flag = false;
				if (dateTime.Ticks < 864000000000L)
				{
					switch (dtfi.Calendar.ID)
					{
					case CalendarId.JAPAN:
					case CalendarId.TAIWAN:
					case CalendarId.HIJRI:
					case CalendarId.HEBREW:
					case CalendarId.JULIAN:
					case CalendarId.PERSIAN:
					case CalendarId.UMALQURA:
						flag = true;
						dtfi = DateTimeFormatInfo.InvariantInfo;
						break;
					}
				}
				format = ((offset.Ticks != long.MinValue) ? ((ReadOnlySpan<char>)(flag ? "yyyy'-'MM'-'ddTHH':'mm':'ss zzz" : dtfi.DateTimeOffsetPattern)) : ((ReadOnlySpan<char>)(flag ? "s" : "G")));
			}
			if (format.Length == 1)
			{
				format = ExpandPredefinedFormat(format, ref dateTime, ref dtfi, offset);
			}
			return FormatCustomized(dateTime, format, dtfi, offset, null);
		}

		internal static bool IsValidCustomDateFormat(ReadOnlySpan<char> format, bool throwOnError)
		{
			int i = 0;
			while (i < format.Length)
			{
				switch (format[i])
				{
				case '\\':
					if (i == format.Length - 1)
					{
						if (throwOnError)
						{
							throw new FormatException(SR.Format_InvalidString);
						}
						return false;
					}
					i += 2;
					break;
				case '"':
				case '\'':
				{
					char c;
					for (c = format[i++]; i < format.Length && format[i] != c; i++)
					{
					}
					if (i >= format.Length)
					{
						if (throwOnError)
						{
							throw new FormatException(SR.Format(SR.Format_BadQuote, c));
						}
						return false;
					}
					i++;
					break;
				}
				case ':':
				case 'F':
				case 'H':
				case 'K':
				case 'f':
				case 'h':
				case 'm':
				case 's':
				case 't':
				case 'z':
					if (throwOnError)
					{
						throw new FormatException(SR.Format_InvalidString);
					}
					return false;
				default:
					i++;
					break;
				}
			}
			return true;
		}

		internal static bool IsValidCustomTimeFormat(ReadOnlySpan<char> format, bool throwOnError)
		{
			int length = format.Length;
			int i = 0;
			while (i < length)
			{
				switch (format[i])
				{
				case '\\':
					if (i == length - 1)
					{
						if (throwOnError)
						{
							throw new FormatException(SR.Format_InvalidString);
						}
						return false;
					}
					i += 2;
					break;
				case '"':
				case '\'':
				{
					char c;
					for (c = format[i++]; i < length && format[i] != c; i++)
					{
					}
					if (i >= length)
					{
						if (throwOnError)
						{
							throw new FormatException(SR.Format(SR.Format_BadQuote, c));
						}
						return false;
					}
					i++;
					break;
				}
				case '/':
				case 'M':
				case 'd':
				case 'k':
				case 'y':
				case 'z':
					if (throwOnError)
					{
						throw new FormatException(SR.Format_InvalidString);
					}
					return false;
				default:
					i++;
					break;
				}
			}
			return true;
		}

		internal static bool TryFormatTimeOnlyO(int hour, int minute, int second, long fraction, Span<char> destination)
		{
			if (destination.Length < 16)
			{
				return false;
			}
			WriteTwoDecimalDigits((uint)hour, destination, 0);
			destination[2] = ':';
			WriteTwoDecimalDigits((uint)minute, destination, 3);
			destination[5] = ':';
			WriteTwoDecimalDigits((uint)second, destination, 6);
			destination[8] = '.';
			WriteDigits((uint)fraction, destination.Slice(9, 7));
			return true;
		}

		internal static bool TryFormatTimeOnlyR(int hour, int minute, int second, Span<char> destination)
		{
			if (destination.Length < 8)
			{
				return false;
			}
			WriteTwoDecimalDigits((uint)hour, destination, 0);
			destination[2] = ':';
			WriteTwoDecimalDigits((uint)minute, destination, 3);
			destination[5] = ':';
			WriteTwoDecimalDigits((uint)second, destination, 6);
			return true;
		}

		internal static bool TryFormatDateOnlyO(int year, int month, int day, Span<char> destination)
		{
			if (destination.Length < 10)
			{
				return false;
			}
			WriteFourDecimalDigits((uint)year, destination);
			destination[4] = '-';
			WriteTwoDecimalDigits((uint)month, destination, 5);
			destination[7] = '-';
			WriteTwoDecimalDigits((uint)day, destination, 8);
			return true;
		}

		internal static bool TryFormatDateOnlyR(DayOfWeek dayOfWeek, int year, int month, int day, Span<char> destination)
		{
			if (destination.Length < 16)
			{
				return false;
			}
			string text = InvariantAbbreviatedDayNames[(int)dayOfWeek];
			string text2 = InvariantAbbreviatedMonthNames[month - 1];
			destination[0] = text[0];
			destination[1] = text[1];
			destination[2] = text[2];
			destination[3] = ',';
			destination[4] = ' ';
			WriteTwoDecimalDigits((uint)day, destination, 5);
			destination[7] = ' ';
			destination[8] = text2[0];
			destination[9] = text2[1];
			destination[10] = text2[2];
			destination[11] = ' ';
			WriteFourDecimalDigits((uint)year, destination, 12);
			return true;
		}

		private static bool TryFormatO(DateTime dateTime, TimeSpan offset, Span<char> destination, out int charsWritten)
		{
			int num = 27;
			DateTimeKind dateTimeKind = DateTimeKind.Local;
			if (offset.Ticks == long.MinValue)
			{
				dateTimeKind = dateTime.Kind;
				switch (dateTimeKind)
				{
				case DateTimeKind.Local:
					offset = TimeZoneInfo.Local.GetUtcOffset(dateTime);
					num += 6;
					break;
				case DateTimeKind.Utc:
					num++;
					break;
				}
			}
			else
			{
				num += 6;
			}
			if (destination.Length < num)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			_ = ref destination[26];
			dateTime.GetDate(out var year, out var month, out var day);
			dateTime.GetTimePrecise(out var hour, out var minute, out var second, out var tick);
			WriteFourDecimalDigits((uint)year, destination);
			destination[4] = '-';
			WriteTwoDecimalDigits((uint)month, destination, 5);
			destination[7] = '-';
			WriteTwoDecimalDigits((uint)day, destination, 8);
			destination[10] = 'T';
			WriteTwoDecimalDigits((uint)hour, destination, 11);
			destination[13] = ':';
			WriteTwoDecimalDigits((uint)minute, destination, 14);
			destination[16] = ':';
			WriteTwoDecimalDigits((uint)second, destination, 17);
			destination[19] = '.';
			WriteDigits((uint)tick, destination.Slice(20, 7));
			switch (dateTimeKind)
			{
			case DateTimeKind.Local:
			{
				int num2 = (int)(offset.Ticks / 600000000);
				char c;
				if (num2 < 0)
				{
					c = '-';
					num2 = -num2;
				}
				else
				{
					c = '+';
				}
				int result;
				int value = Math.DivRem(num2, 60, out result);
				WriteTwoDecimalDigits((uint)result, destination, 31);
				destination[30] = ':';
				WriteTwoDecimalDigits((uint)value, destination, 28);
				destination[27] = c;
				break;
			}
			case DateTimeKind.Utc:
				destination[27] = 'Z';
				break;
			}
			return true;
		}

		private static bool TryFormatR(DateTime dateTime, TimeSpan offset, Span<char> destination, out int charsWritten)
		{
			if (destination.Length <= 28)
			{
				charsWritten = 0;
				return false;
			}
			if (offset.Ticks != long.MinValue)
			{
				dateTime -= offset;
			}
			dateTime.GetDate(out var year, out var month, out var day);
			dateTime.GetTime(out var hour, out var minute, out var second);
			string text = InvariantAbbreviatedDayNames[(int)dateTime.DayOfWeek];
			string text2 = InvariantAbbreviatedMonthNames[month - 1];
			destination[0] = text[0];
			destination[1] = text[1];
			destination[2] = text[2];
			destination[3] = ',';
			destination[4] = ' ';
			WriteTwoDecimalDigits((uint)day, destination, 5);
			destination[7] = ' ';
			destination[8] = text2[0];
			destination[9] = text2[1];
			destination[10] = text2[2];
			destination[11] = ' ';
			WriteFourDecimalDigits((uint)year, destination, 12);
			destination[16] = ' ';
			WriteTwoDecimalDigits((uint)hour, destination, 17);
			destination[19] = ':';
			WriteTwoDecimalDigits((uint)minute, destination, 20);
			destination[22] = ':';
			WriteTwoDecimalDigits((uint)second, destination, 23);
			destination[25] = ' ';
			destination[26] = 'G';
			destination[27] = 'M';
			destination[28] = 'T';
			charsWritten = 29;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteTwoDecimalDigits(uint value, Span<char> destination, int offset)
		{
			uint num = 48 + value;
			value /= 10;
			destination[offset + 1] = (char)(num - value * 10);
			destination[offset] = (char)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteFourDecimalDigits(uint value, Span<char> buffer, int startingIndex = 0)
		{
			uint num = 48 + value;
			value /= 10;
			buffer[startingIndex + 3] = (char)(num - value * 10);
			num = 48 + value;
			value /= 10;
			buffer[startingIndex + 2] = (char)(num - value * 10);
			num = 48 + value;
			value /= 10;
			buffer[startingIndex + 1] = (char)(num - value * 10);
			buffer[startingIndex] = (char)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteDigits(ulong value, Span<char> buffer)
		{
			for (int num = buffer.Length - 1; num >= 1; num--)
			{
				ulong num2 = 48 + value;
				value /= 10;
				buffer[num] = (char)(num2 - value * 10);
			}
			buffer[0] = (char)(48 + value);
		}

		internal static string[] GetAllDateTimes(DateTime dateTime, char format, DateTimeFormatInfo dtfi)
		{
			string[] array;
			switch (format)
			{
			case 'D':
			case 'F':
			case 'G':
			case 'M':
			case 'T':
			case 'Y':
			case 'd':
			case 'f':
			case 'g':
			case 'm':
			case 't':
			case 'y':
			{
				string[] allDateTimePatterns = dtfi.GetAllDateTimePatterns(format);
				array = new string[allDateTimePatterns.Length];
				for (int j = 0; j < allDateTimePatterns.Length; j++)
				{
					array[j] = Format(dateTime, allDateTimePatterns[j], dtfi);
				}
				break;
			}
			case 'U':
			{
				DateTime dateTime2 = dateTime.ToUniversalTime();
				string[] allDateTimePatterns = dtfi.GetAllDateTimePatterns(format);
				array = new string[allDateTimePatterns.Length];
				for (int i = 0; i < allDateTimePatterns.Length; i++)
				{
					array[i] = Format(dateTime2, allDateTimePatterns[i], dtfi);
				}
				break;
			}
			case 'O':
			case 'R':
			case 'o':
			case 'r':
			case 's':
			case 'u':
				array = new string[1] { Format(dateTime, char.ToString(format), dtfi) };
				break;
			default:
				throw new FormatException(SR.Format_InvalidString);
			}
			return array;
		}

		internal static string[] GetAllDateTimes(DateTime dateTime, DateTimeFormatInfo dtfi)
		{
			List<string> list = new List<string>(132);
			for (int i = 0; i < allStandardFormats.Length; i++)
			{
				string[] allDateTimes = GetAllDateTimes(dateTime, allStandardFormats[i], dtfi);
				for (int j = 0; j < allDateTimes.Length; j++)
				{
					list.Add(allDateTimes[j]);
				}
			}
			return list.ToArray();
		}
	}
	internal static class DateTimeParse
	{
		internal delegate bool MatchNumberDelegate(ref __DTString str, int digitLen, out int result);

		internal enum DTT
		{
			End,
			NumEnd,
			NumAmpm,
			NumSpace,
			NumDatesep,
			NumTimesep,
			MonthEnd,
			MonthSpace,
			MonthDatesep,
			NumDatesuff,
			NumTimesuff,
			DayOfWeek,
			YearSpace,
			YearDateSep,
			YearEnd,
			TimeZone,
			Era,
			NumUTCTimeMark,
			Unk,
			NumLocalTimeMark,
			Max
		}

		internal enum TM
		{
			NotSet = -1,
			AM,
			PM
		}

		internal enum DS
		{
			BEGIN,
			N,
			NN,
			D_Nd,
			D_NN,
			D_NNd,
			D_M,
			D_MN,
			D_NM,
			D_MNd,
			D_NDS,
			D_Y,
			D_YN,
			D_YNd,
			D_YM,
			D_YMd,
			D_S,
			T_S,
			T_Nt,
			T_NNt,
			ERROR,
			DX_NN,
			DX_NNN,
			DX_MN,
			DX_NM,
			DX_MNN,
			DX_DS,
			DX_DSN,
			DX_NDS,
			DX_NNDS,
			DX_YNN,
			DX_YMN,
			DX_YN,
			DX_YM,
			TX_N,
			TX_NN,
			TX_NNN,
			TX_TS,
			DX_NNY
		}

		private static readonly MatchNumberDelegate s_hebrewNumberParser = MatchHebrewDigits;

		private static readonly DS[][] s_dateParsingStates = new DS[20][]
		{
			new DS[18]
			{
				DS.BEGIN,
				DS.ERROR,
				DS.TX_N,
				DS.N,
				DS.D_Nd,
				DS.T_Nt,
				DS.ERROR,
				DS.D_M,
				DS.D_M,
				DS.D_S,
				DS.T_S,
				DS.BEGIN,
				DS.D_Y,
				DS.D_Y,
				DS.ERROR,
				DS.BEGIN,
				DS.BEGIN,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.DX_NN,
				DS.ERROR,
				DS.NN,
				DS.D_NNd,
				DS.ERROR,
				DS.DX_NM,
				DS.D_NM,
				DS.D_MNd,
				DS.D_NDS,
				DS.ERROR,
				DS.N,
				DS.D_YN,
				DS.D_YNd,
				DS.DX_YN,
				DS.N,
				DS.N,
				DS.ERROR
			},
			new DS[18]
			{
				DS.DX_NN,
				DS.DX_NNN,
				DS.TX_N,
				DS.DX_NNN,
				DS.ERROR,
				DS.T_Nt,
				DS.DX_MNN,
				DS.DX_MNN,
				DS.ERROR,
				DS.ERROR,
				DS.T_S,
				DS.NN,
				DS.DX_NNY,
				DS.ERROR,
				DS.DX_NNY,
				DS.NN,
				DS.NN,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.DX_NN,
				DS.ERROR,
				DS.D_NN,
				DS.D_NNd,
				DS.ERROR,
				DS.DX_NM,
				DS.D_MN,
				DS.D_MNd,
				DS.ERROR,
				DS.ERROR,
				DS.D_Nd,
				DS.D_YN,
				DS.D_YNd,
				DS.DX_YN,
				DS.ERROR,
				DS.D_Nd,
				DS.ERROR
			},
			new DS[18]
			{
				DS.DX_NN,
				DS.DX_NNN,
				DS.TX_N,
				DS.DX_NNN,
				DS.ERROR,
				DS.T_Nt,
				DS.DX_MNN,
				DS.DX_MNN,
				DS.ERROR,
				DS.DX_DS,
				DS.T_S,
				DS.D_NN,
				DS.DX_NNY,
				DS.ERROR,
				DS.DX_NNY,
				DS.ERROR,
				DS.D_NN,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.DX_NNN,
				DS.DX_NNN,
				DS.DX_NNN,
				DS.ERROR,
				DS.ERROR,
				DS.DX_MNN,
				DS.DX_MNN,
				DS.ERROR,
				DS.DX_DS,
				DS.ERROR,
				DS.D_NNd,
				DS.DX_NNY,
				DS.ERROR,
				DS.DX_NNY,
				DS.ERROR,
				DS.D_NNd,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.DX_MN,
				DS.ERROR,
				DS.D_MN,
				DS.D_MNd,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_M,
				DS.D_YM,
				DS.D_YMd,
				DS.DX_YM,
				DS.ERROR,
				DS.D_M,
				DS.ERROR
			},
			new DS[18]
			{
				DS.DX_MN,
				DS.DX_MNN,
				DS.DX_MNN,
				DS.DX_MNN,
				DS.ERROR,
				DS.T_Nt,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.DX_DS,
				DS.T_S,
				DS.D_MN,
				DS.DX_YMN,
				DS.ERROR,
				DS.DX_YMN,
				DS.ERROR,
				DS.D_MN,
				DS.ERROR
			},
			new DS[18]
			{
				DS.DX_NM,
				DS.DX_MNN,
				DS.DX_MNN,
				DS.DX_MNN,
				DS.ERROR,
				DS.T_Nt,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.DX_DS,
				DS.T_S,
				DS.D_NM,
				DS.DX_YMN,
				DS.ERROR,
				DS.DX_YMN,
				DS.ERROR,
				DS.D_NM,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.DX_MNN,
				DS.ERROR,
				DS.DX_MNN,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_MNd,
				DS.DX_YMN,
				DS.ERROR,
				DS.DX_YMN,
				DS.ERROR,
				DS.D_MNd,
				DS.ERROR
			},
			new DS[18]
			{
				DS.DX_NDS,
				DS.DX_NNDS,
				DS.DX_NNDS,
				DS.DX_NNDS,
				DS.ERROR,
				DS.T_Nt,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_NDS,
				DS.T_S,
				DS.D_NDS,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_NDS,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.DX_YN,
				DS.ERROR,
				DS.D_YN,
				DS.D_YNd,
				DS.ERROR,
				DS.DX_YM,
				DS.D_YM,
				DS.D_YMd,
				DS.D_YM,
				DS.ERROR,
				DS.D_Y,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_Y,
				DS.ERROR
			},
			new DS[18]
			{
				DS.DX_YN,
				DS.DX_YNN,
				DS.DX_YNN,
				DS.DX_YNN,
				DS.ERROR,
				DS.ERROR,
				DS.DX_YMN,
				DS.DX_YMN,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_YN,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_YN,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.DX_YNN,
				DS.DX_YNN,
				DS.DX_YNN,
				DS.ERROR,
				DS.ERROR,
				DS.DX_YMN,
				DS.DX_YMN,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_YN,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_YN,
				DS.ERROR
			},
			new DS[18]
			{
				DS.DX_YM,
				DS.DX_YMN,
				DS.DX_YMN,
				DS.DX_YMN,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_YM,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_YM,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.DX_YMN,
				DS.DX_YMN,
				DS.DX_YMN,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_YM,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_YM,
				DS.ERROR
			},
			new DS[18]
			{
				DS.DX_DS,
				DS.DX_DSN,
				DS.TX_N,
				DS.T_Nt,
				DS.ERROR,
				DS.T_Nt,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_S,
				DS.T_S,
				DS.D_S,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_S,
				DS.ERROR
			},
			new DS[18]
			{
				DS.TX_TS,
				DS.TX_TS,
				DS.TX_TS,
				DS.T_Nt,
				DS.D_Nd,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.D_S,
				DS.T_S,
				DS.T_S,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.T_S,
				DS.T_S,
				DS.ERROR
			},
			new DS[18]
			{
				DS.ERROR,
				DS.TX_NN,
				DS.TX_NN,
				DS.TX_NN,
				DS.ERROR,
				DS.T_NNt,
				DS.DX_NM,
				DS.D_NM,
				DS.ERROR,
				DS.ERROR,
				DS.T_S,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.T_Nt,
				DS.T_Nt,
				DS.TX_NN
			},
			new DS[18]
			{
				DS.ERROR,
				DS.TX_NNN,
				DS.TX_NNN,
				DS.TX_NNN,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.T_S,
				DS.T_NNt,
				DS.ERROR,
				DS.ERROR,
				DS.ERROR,
				DS.T_NNt,
				DS.T_NNt,
				DS.TX_NNN
			}
		};

		internal static DateTime ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, DateTimeFormatInfo dtfi, DateTimeStyles style)
		{
			DateTimeResult result = default(DateTimeResult);
			result.Init(s);
			if (TryParseExact(s, format, dtfi, style, ref result))
			{
				return result.parsedDate;
			}
			throw GetDateTimeParseException(ref result);
		}

		internal static DateTime ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, DateTimeFormatInfo dtfi, DateTimeStyles style, out TimeSpan offset)
		{
			DateTimeResult result = default(DateTimeResult);
			result.Init(s);
			result.flags |= ParseFlags.CaptureOffset;
			if (TryParseExact(s, format, dtfi, style, ref result))
			{
				offset = result.timeZoneOffset;
				return result.parsedDate;
			}
			throw GetDateTimeParseException(ref result);
		}

		internal static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result)
		{
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			if (TryParseExact(s, format, dtfi, style, ref result2))
			{
				result = result2.parsedDate;
				return true;
			}
			result = DateTime.MinValue;
			return false;
		}

		internal static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result, out TimeSpan offset)
		{
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			result2.flags |= ParseFlags.CaptureOffset;
			if (TryParseExact(s, format, dtfi, style, ref result2))
			{
				result = result2.parsedDate;
				offset = result2.timeZoneOffset;
				return true;
			}
			result = DateTime.MinValue;
			offset = TimeSpan.Zero;
			return false;
		}

		internal static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, DateTimeFormatInfo dtfi, DateTimeStyles style, ref DateTimeResult result)
		{
			if (s.Length == 0)
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDateTime");
				return false;
			}
			if (format.Length == 0)
			{
				result.SetBadFormatSpecifierFailure();
				return false;
			}
			return DoStrictParse(s, format, style, dtfi, ref result);
		}

		internal static DateTime ParseExactMultiple(ReadOnlySpan<char> s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style)
		{
			DateTimeResult result = default(DateTimeResult);
			result.Init(s);
			if (TryParseExactMultiple(s, formats, dtfi, style, ref result))
			{
				return result.parsedDate;
			}
			throw GetDateTimeParseException(ref result);
		}

		internal static DateTime ParseExactMultiple(ReadOnlySpan<char> s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style, out TimeSpan offset)
		{
			DateTimeResult result = default(DateTimeResult);
			result.Init(s);
			result.flags |= ParseFlags.CaptureOffset;
			if (TryParseExactMultiple(s, formats, dtfi, style, ref result))
			{
				offset = result.timeZoneOffset;
				return result.parsedDate;
			}
			throw GetDateTimeParseException(ref result);
		}

		internal static bool TryParseExactMultiple(ReadOnlySpan<char> s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result, out TimeSpan offset)
		{
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			result2.flags |= ParseFlags.CaptureOffset;
			if (TryParseExactMultiple(s, formats, dtfi, style, ref result2))
			{
				result = result2.parsedDate;
				offset = result2.timeZoneOffset;
				return true;
			}
			result = DateTime.MinValue;
			offset = TimeSpan.Zero;
			return false;
		}

		internal static bool TryParseExactMultiple(ReadOnlySpan<char> s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result)
		{
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			if (TryParseExactMultiple(s, formats, dtfi, style, ref result2))
			{
				result = result2.parsedDate;
				return true;
			}
			result = DateTime.MinValue;
			return false;
		}

		internal static bool TryParseExactMultiple(ReadOnlySpan<char> s, string[] formats, DateTimeFormatInfo dtfi, DateTimeStyles style, ref DateTimeResult result)
		{
			if (formats == null)
			{
				result.SetFailure(ParseFailureKind.ArgumentNull, "ArgumentNull_String", null, "formats");
				return false;
			}
			if (s.Length == 0)
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDateTime");
				return false;
			}
			if (formats.Length == 0)
			{
				result.SetFailure(ParseFailureKind.Format, "Format_NoFormatSpecifier");
				return false;
			}
			foreach (string text in formats)
			{
				if (string.IsNullOrEmpty(text))
				{
					result.SetBadFormatSpecifierFailure();
					return false;
				}
				DateTimeResult result2 = default(DateTimeResult);
				result2.Init(s);
				result2.flags = result.flags;
				if (TryParseExact(s, text, dtfi, style, ref result2))
				{
					result.parsedDate = result2.parsedDate;
					result.timeZoneOffset = result2.timeZoneOffset;
					return true;
				}
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool MatchWord(ref __DTString str, string target)
		{
			if (target.Length > str.Value.Length - str.Index)
			{
				return false;
			}
			if (str.CompareInfo.Compare(str.Value.Slice(str.Index, target.Length), target, CompareOptions.IgnoreCase) != 0)
			{
				return false;
			}
			int num = str.Index + target.Length;
			if (num < str.Value.Length)
			{
				char c = str.Value[num];
				if (char.IsLetter(c))
				{
					return false;
				}
			}
			str.Index = num;
			if (str.Index < str.Length)
			{
				str.m_current = str.Value[str.Index];
			}
			return true;
		}

		private static bool GetTimeZoneName(ref __DTString str)
		{
			if (MatchWord(ref str, "GMT"))
			{
				return true;
			}
			if (MatchWord(ref str, "Z"))
			{
				return true;
			}
			return false;
		}

		internal static bool IsDigit(char ch)
		{
			return (uint)(ch - 48) <= 9u;
		}

		private static bool ParseFraction(ref __DTString str, out double result)
		{
			result = 0.0;
			double num = 0.1;
			int num2 = 0;
			char current;
			while (str.GetNext() && IsDigit(current = str.m_current))
			{
				result += (double)(current - 48) * num;
				num *= 0.1;
				num2++;
			}
			return num2 > 0;
		}

		private static bool ParseTimeZone(ref __DTString str, ref TimeSpan result)
		{
			int num = 0;
			DTSubString subString = str.GetSubString();
			if (subString.length != 1)
			{
				return false;
			}
			char c = subString[0];
			if (c != '+' && c != '-')
			{
				return false;
			}
			str.ConsumeSubString(subString);
			subString = str.GetSubString();
			if (subString.type != DTSubStringType.Number)
			{
				return false;
			}
			int value = subString.value;
			int hours;
			switch (subString.length)
			{
			case 1:
			case 2:
				hours = value;
				str.ConsumeSubString(subString);
				subString = str.GetSubString();
				if (subString.length == 1 && subString[0] == ':')
				{
					str.ConsumeSubString(subString);
					subString = str.GetSubString();
					if (subString.type != DTSubStringType.Number || subString.length < 1 || subString.length > 2)
					{
						return false;
					}
					num = subString.value;
					str.ConsumeSubString(subString);
				}
				break;
			case 3:
			case 4:
				hours = value / 100;
				num = value % 100;
				str.ConsumeSubString(subString);
				break;
			default:
				return false;
			}
			if (num < 0 || num >= 60)
			{
				return false;
			}
			result = new TimeSpan(hours, num, 0);
			if (c == '-')
			{
				result = result.Negate();
			}
			return true;
		}

		private static bool HandleTimeZone(ref __DTString str, ref DateTimeResult result)
		{
			if (str.Index < str.Length - 1)
			{
				char c = str.Value[str.Index];
				int num = 0;
				while (char.IsWhiteSpace(c) && str.Index + num < str.Length - 1)
				{
					num++;
					c = str.Value[str.Index + num];
				}
				if (c == '+' || c == '-')
				{
					str.Index += num;
					if ((result.flags & ParseFlags.TimeZoneUsed) != 0)
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					result.flags |= ParseFlags.TimeZoneUsed;
					if (!ParseTimeZone(ref str, ref result.timeZoneOffset))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
				}
			}
			return true;
		}

		private static bool Lex(DS dps, ref __DTString str, ref DateTimeToken dtok, ref DateTimeRawInfo raw, ref DateTimeResult result, ref DateTimeFormatInfo dtfi, DateTimeStyles styles)
		{
			dtok.dtt = DTT.Unk;
			str.GetRegularToken(out var tokenType, out var tokenValue, dtfi);
			int indexBeforeSeparator;
			char charBeforeSeparator;
			switch (tokenType)
			{
			case TokenType.NumberToken:
			case TokenType.YearNumberToken:
			{
				if (raw.numCount == 3 || tokenValue == -1)
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (dps == DS.T_NNt && str.Index < str.Length - 1)
				{
					char c = str.Value[str.Index];
					if (c == '.')
					{
						ParseFraction(ref str, out raw.fraction);
					}
				}
				if ((dps == DS.T_NNt || dps == DS.T_Nt) && str.Index < str.Length - 1 && !HandleTimeZone(ref str, ref result))
				{
					return false;
				}
				dtok.num = tokenValue;
				TokenType separatorToken;
				if (tokenType == TokenType.YearNumberToken)
				{
					if (raw.year == -1)
					{
						raw.year = tokenValue;
						switch (separatorToken = str.GetSeparatorToken(dtfi, out indexBeforeSeparator, out charBeforeSeparator))
						{
						case TokenType.SEP_End:
							dtok.dtt = DTT.YearEnd;
							break;
						case TokenType.SEP_Am:
						case TokenType.SEP_Pm:
							if (raw.timeMark == TM.NotSet)
							{
								raw.timeMark = ((separatorToken != TokenType.SEP_Am) ? TM.PM : TM.AM);
								dtok.dtt = DTT.YearSpace;
							}
							else
							{
								result.SetBadDateTimeFailure();
							}
							break;
						case TokenType.SEP_Space:
							dtok.dtt = DTT.YearSpace;
							break;
						case TokenType.SEP_Date:
							dtok.dtt = DTT.YearDateSep;
							break;
						case TokenType.SEP_Time:
							if (!raw.hasSameDateAndTimeSeparators)
							{
								result.SetBadDateTimeFailure();
								return false;
							}
							dtok.dtt = DTT.YearDateSep;
							break;
						case TokenType.SEP_DateOrOffset:
							if (s_dateParsingStates[(int)dps][13] == DS.ERROR && s_dateParsingStates[(int)dps][12] > DS.ERROR)
							{
								str.Index = indexBeforeSeparator;
								str.m_current = charBeforeSeparator;
								dtok.dtt = DTT.YearSpace;
							}
							else
							{
								dtok.dtt = DTT.YearDateSep;
							}
							break;
						case TokenType.SEP_YearSuff:
						case TokenType.SEP_MonthSuff:
						case TokenType.SEP_DaySuff:
							dtok.dtt = DTT.NumDatesuff;
							dtok.suffix = separatorToken;
							break;
						case TokenType.SEP_HourSuff:
						case TokenType.SEP_MinuteSuff:
						case TokenType.SEP_SecondSuff:
							dtok.dtt = DTT.NumTimesuff;
							dtok.suffix = separatorToken;
							break;
						default:
							result.SetBadDateTimeFailure();
							return false;
						}
						return true;
					}
					result.SetBadDateTimeFailure();
					return false;
				}
				switch (separatorToken = str.GetSeparatorToken(dtfi, out indexBeforeSeparator, out charBeforeSeparator))
				{
				case TokenType.SEP_End:
					dtok.dtt = DTT.NumEnd;
					raw.AddNumber(dtok.num);
					break;
				case TokenType.SEP_Am:
				case TokenType.SEP_Pm:
					if (raw.timeMark == TM.NotSet)
					{
						raw.timeMark = ((separatorToken != TokenType.SEP_Am) ? TM.PM : TM.AM);
						dtok.dtt = DTT.NumAmpm;
						if (dps == DS.D_NN && !ProcessTerminalState(DS.DX_NN, ref result, ref styles, ref raw, dtfi))
						{
							return false;
						}
						raw.AddNumber(dtok.num);
						if ((dps == DS.T_NNt || dps == DS.T_Nt) && !HandleTimeZone(ref str, ref result))
						{
							return false;
						}
					}
					else
					{
						result.SetBadDateTimeFailure();
					}
					break;
				case TokenType.SEP_Space:
					dtok.dtt = DTT.NumSpace;
					raw.AddNumber(dtok.num);
					break;
				case TokenType.SEP_Date:
					dtok.dtt = DTT.NumDatesep;
					raw.AddNumber(dtok.num);
					break;
				case TokenType.SEP_DateOrOffset:
					if (s_dateParsingStates[(int)dps][4] == DS.ERROR && s_dateParsingStates[(int)dps][3] > DS.ERROR)
					{
						str.Index = indexBeforeSeparator;
						str.m_current = charBeforeSeparator;
						dtok.dtt = DTT.NumSpace;
					}
					else
					{
						dtok.dtt = DTT.NumDatesep;
					}
					raw.AddNumber(dtok.num);
					break;
				case TokenType.SEP_Time:
					if (raw.hasSameDateAndTimeSeparators && (dps == DS.D_Y || dps == DS.D_YN || dps == DS.D_YNd || dps == DS.D_YM || dps == DS.D_YMd))
					{
						dtok.dtt = DTT.NumDatesep;
						raw.AddNumber(dtok.num);
					}
					else
					{
						dtok.dtt = DTT.NumTimesep;
						raw.AddNumber(dtok.num);
					}
					break;
				case TokenType.SEP_YearSuff:
					try
					{
						dtok.num = dtfi.Calendar.ToFourDigitYear(tokenValue);
					}
					catch (ArgumentOutOfRangeException)
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					dtok.dtt = DTT.NumDatesuff;
					dtok.suffix = separatorToken;
					break;
				case TokenType.SEP_MonthSuff:
				case TokenType.SEP_DaySuff:
					dtok.dtt = DTT.NumDatesuff;
					dtok.suffix = separatorToken;
					break;
				case TokenType.SEP_HourSuff:
				case TokenType.SEP_MinuteSuff:
				case TokenType.SEP_SecondSuff:
					dtok.dtt = DTT.NumTimesuff;
					dtok.suffix = separatorToken;
					break;
				case TokenType.SEP_LocalTimeMark:
					dtok.dtt = DTT.NumLocalTimeMark;
					raw.AddNumber(dtok.num);
					break;
				default:
					result.SetBadDateTimeFailure();
					return false;
				}
				break;
			}
			case TokenType.HebrewNumber:
			{
				TokenType separatorToken;
				if (tokenValue >= 100)
				{
					if (raw.year == -1)
					{
						raw.year = tokenValue;
						TokenType tokenType2 = (separatorToken = str.GetSeparatorToken(dtfi, out indexBeforeSeparator, out charBeforeSeparator));
						if (tokenType2 != TokenType.SEP_End)
						{
							if (tokenType2 != TokenType.SEP_Space)
							{
								if (tokenType2 != TokenType.SEP_DateOrOffset || s_dateParsingStates[(int)dps][12] <= DS.ERROR)
								{
									result.SetBadDateTimeFailure();
									return false;
								}
								str.Index = indexBeforeSeparator;
								str.m_current = charBeforeSeparator;
								dtok.dtt = DTT.YearSpace;
							}
							else
							{
								dtok.dtt = DTT.YearSpace;
							}
						}
						else
						{
							dtok.dtt = DTT.YearEnd;
						}
						break;
					}
					result.SetBadDateTimeFailure();
					return false;
				}
				dtok.num = tokenValue;
				raw.AddNumber(dtok.num);
				switch (separatorToken = str.GetSeparatorToken(dtfi, out indexBeforeSeparator, out charBeforeSeparator))
				{
				case TokenType.SEP_End:
					dtok.dtt = DTT.NumEnd;
					break;
				case TokenType.SEP_Space:
				case TokenType.SEP_Date:
					dtok.dtt = DTT.NumDatesep;
					break;
				case TokenType.SEP_DateOrOffset:
					if (s_dateParsingStates[(int)dps][4] == DS.ERROR && s_dateParsingStates[(int)dps][3] > DS.ERROR)
					{
						str.Index = indexBeforeSeparator;
						str.m_current = charBeforeSeparator;
						dtok.dtt = DTT.NumSpace;
					}
					else
					{
						dtok.dtt = DTT.NumDatesep;
					}
					break;
				default:
					result.SetBadDateTimeFailure();
					return false;
				}
				break;
			}
			case TokenType.DayOfWeekToken:
				if (raw.dayOfWeek == -1)
				{
					raw.dayOfWeek = tokenValue;
					dtok.dtt = DTT.DayOfWeek;
					break;
				}
				result.SetBadDateTimeFailure();
				return false;
			case TokenType.MonthToken:
				if (raw.month == -1)
				{
					TokenType separatorToken;
					switch (separatorToken = str.GetSeparatorToken(dtfi, out indexBeforeSeparator, out charBeforeSeparator))
					{
					case TokenType.SEP_End:
						dtok.dtt = DTT.MonthEnd;
						break;
					case TokenType.SEP_Space:
						dtok.dtt = DTT.MonthSpace;
						break;
					case TokenType.SEP_Date:
						dtok.dtt = DTT.MonthDatesep;
						break;
					case TokenType.SEP_Time:
						if (!raw.hasSameDateAndTimeSeparators)
						{
							result.SetBadDateTimeFailure();
							return false;
						}
						dtok.dtt = DTT.MonthDatesep;
						break;
					case TokenType.SEP_DateOrOffset:
						if (s_dateParsingStates[(int)dps][8] == DS.ERROR && s_dateParsingStates[(int)dps][7] > DS.ERROR)
						{
							str.Index = indexBeforeSeparator;
							str.m_current = charBeforeSeparator;
							dtok.dtt = DTT.MonthSpace;
						}
						else
						{
							dtok.dtt = DTT.MonthDatesep;
						}
						break;
					default:
						result.SetBadDateTimeFailure();
						return false;
					}
					raw.month = tokenValue;
					break;
				}
				result.SetBadDateTimeFailure();
				return false;
			case TokenType.EraToken:
				if (result.era != -1)
				{
					result.era = tokenValue;
					dtok.dtt = DTT.Era;
					break;
				}
				result.SetBadDateTimeFailure();
				return false;
			case TokenType.JapaneseEraToken:
				if (GlobalizationMode.Invariant)
				{
					return false;
				}
				result.calendar = JapaneseCalendar.GetDefaultInstance();
				dtfi = DateTimeFormatInfo.GetJapaneseCalendarDTFI();
				if (result.era != -1)
				{
					result.era = tokenValue;
					dtok.dtt = DTT.Era;
					break;
				}
				result.SetBadDateTimeFailure();
				return false;
			case TokenType.TEraToken:
				if (GlobalizationMode.Invariant)
				{
					return false;
				}
				result.calendar = TaiwanCalendar.GetDefaultInstance();
				dtfi = DateTimeFormatInfo.GetTaiwanCalendarDTFI();
				if (result.era != -1)
				{
					result.era = tokenValue;
					dtok.dtt = DTT.Era;
					break;
				}
				result.SetBadDateTimeFailure();
				return false;
			case TokenType.TimeZoneToken:
				if ((result.flags & ParseFlags.TimeZoneUsed) != 0)
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				dtok.dtt = DTT.TimeZone;
				result.flags |= ParseFlags.TimeZoneUsed;
				result.timeZoneOffset = new TimeSpan(0L);
				result.flags |= ParseFlags.TimeZoneUtc;
				break;
			case TokenType.EndOfString:
				dtok.dtt = DTT.End;
				break;
			case TokenType.Am:
			case TokenType.Pm:
				if (raw.timeMark == TM.NotSet)
				{
					raw.timeMark = (TM)tokenValue;
					break;
				}
				result.SetBadDateTimeFailure();
				return false;
			case TokenType.UnknownToken:
				if (char.IsLetter(str.m_current))
				{
					result.SetFailure(ParseFailureKind.FormatWithOriginalDateTimeAndParameter, "Format_UnknownDateTimeWord", str.Index);
					return false;
				}
				if ((str.m_current == '-' || str.m_current == '+') && (result.flags & ParseFlags.TimeZoneUsed) == 0)
				{
					int index = str.Index;
					if (ParseTimeZone(ref str, ref result.timeZoneOffset))
					{
						result.flags |= ParseFlags.TimeZoneUsed;
						return true;
					}
					str.Index = index;
				}
				if (VerifyValidPunctuation(ref str))
				{
					return true;
				}
				result.SetBadDateTimeFailure();
				return false;
			}
			return true;
		}

		private static bool VerifyValidPunctuation(ref __DTString str)
		{
			switch (str.Value[str.Index])
			{
			case '#':
			{
				bool flag = false;
				bool flag2 = false;
				for (int j = 0; j < str.Length; j++)
				{
					char c = str.Value[j];
					switch (c)
					{
					case '#':
						if (flag)
						{
							if (flag2)
							{
								return false;
							}
							flag2 = true;
						}
						else
						{
							flag = true;
						}
						break;
					case '\0':
						if (!flag2)
						{
							return false;
						}
						break;
					default:
						if (!char.IsWhiteSpace(c) && (!flag || flag2))
						{
							return false;
						}
						break;
					}
				}
				if (!flag2)
				{
					return false;
				}
				str.GetNext();
				return true;
			}
			case '\0':
			{
				for (int i = str.Index; i < str.Length; i++)
				{
					if (str.Value[i] != 0)
					{
						return false;
					}
				}
				str.Index = str.Length;
				return true;
			}
			default:
				return false;
			}
		}

		private static bool GetYearMonthDayOrder(string datePattern, out int order)
		{
			int num = -1;
			int num2 = -1;
			int num3 = -1;
			int num4 = 0;
			bool flag = false;
			for (int i = 0; i < datePattern.Length && num4 < 3; i++)
			{
				char c = datePattern[i];
				switch (c)
				{
				case '%':
				case '\\':
					i++;
					continue;
				case '"':
				case '\'':
					flag = !flag;
					break;
				}
				if (flag)
				{
					continue;
				}
				switch (c)
				{
				case 'y':
					num = num4++;
					for (; i + 1 < datePattern.Length && datePattern[i + 1] == 'y'; i++)
					{
					}
					break;
				case 'M':
					num2 = num4++;
					for (; i + 1 < datePattern.Length && datePattern[i + 1] == 'M'; i++)
					{
					}
					break;
				case 'd':
				{
					int num5 = 1;
					for (; i + 1 < datePattern.Length && datePattern[i + 1] == 'd'; i++)
					{
						num5++;
					}
					if (num5 <= 2)
					{
						num3 = num4++;
					}
					break;
				}
				}
			}
			if (num == 0 && num2 == 1 && num3 == 2)
			{
				order = 0;
				return true;
			}
			if (num2 == 0 && num3 == 1 && num == 2)
			{
				order = 1;
				return true;
			}
			if (num3 == 0 && num2 == 1 && num == 2)
			{
				order = 2;
				return true;
			}
			if (num == 0 && num3 == 1 && num2 == 2)
			{
				order = 3;
				return true;
			}
			order = -1;
			return false;
		}

		private static bool GetYearMonthOrder(string pattern, out int order)
		{
			int num = -1;
			int num2 = -1;
			int num3 = 0;
			bool flag = false;
			for (int i = 0; i < pattern.Length && num3 < 2; i++)
			{
				char c = pattern[i];
				switch (c)
				{
				case '%':
				case '\\':
					i++;
					continue;
				case '"':
				case '\'':
					flag = !flag;
					break;
				}
				if (flag)
				{
					continue;
				}
				switch (c)
				{
				case 'y':
					num = num3++;
					for (; i + 1 < pattern.Length && pattern[i + 1] == 'y'; i++)
					{
					}
					break;
				case 'M':
					num2 = num3++;
					for (; i + 1 < pattern.Length && pattern[i + 1] == 'M'; i++)
					{
					}
					break;
				}
			}
			if (num == 0 && num2 == 1)
			{
				order = 4;
				return true;
			}
			if (num2 == 0 && num == 1)
			{
				order = 5;
				return true;
			}
			order = -1;
			return false;
		}

		private static bool GetMonthDayOrder(string pattern, out int order)
		{
			int num = -1;
			int num2 = -1;
			int num3 = 0;
			bool flag = false;
			for (int i = 0; i < pattern.Length && num3 < 2; i++)
			{
				char c = pattern[i];
				switch (c)
				{
				case '%':
				case '\\':
					i++;
					continue;
				case '"':
				case '\'':
					flag = !flag;
					break;
				}
				if (flag)
				{
					continue;
				}
				switch (c)
				{
				case 'd':
				{
					int num4 = 1;
					for (; i + 1 < pattern.Length && pattern[i + 1] == 'd'; i++)
					{
						num4++;
					}
					if (num4 <= 2)
					{
						num2 = num3++;
					}
					break;
				}
				case 'M':
					num = num3++;
					for (; i + 1 < pattern.Length && pattern[i + 1] == 'M'; i++)
					{
					}
					break;
				}
			}
			if (num == 0 && num2 == 1)
			{
				order = 6;
				return true;
			}
			if (num2 == 0 && num == 1)
			{
				order = 7;
				return true;
			}
			order = -1;
			return false;
		}

		private static bool TryAdjustYear(ref DateTimeResult result, int year, out int adjustedYear)
		{
			if (year < 100)
			{
				try
				{
					year = result.calendar.ToFourDigitYear(year);
				}
				catch (ArgumentOutOfRangeException)
				{
					adjustedYear = -1;
					return false;
				}
			}
			adjustedYear = year;
			return true;
		}

		private static bool SetDateYMD(ref DateTimeResult result, int year, int month, int day)
		{
			if (result.calendar.IsValidDay(year, month, day, result.era))
			{
				result.SetDate(year, month, day);
				return true;
			}
			return false;
		}

		private static bool SetDateMDY(ref DateTimeResult result, int month, int day, int year)
		{
			return SetDateYMD(ref result, year, month, day);
		}

		private static bool SetDateDMY(ref DateTimeResult result, int day, int month, int year)
		{
			return SetDateYMD(ref result, year, month, day);
		}

		private static bool SetDateYDM(ref DateTimeResult result, int year, int day, int month)
		{
			return SetDateYMD(ref result, year, month, day);
		}

		private static void GetDefaultYear(ref DateTimeResult result, ref DateTimeStyles styles)
		{
			result.Year = result.calendar.GetYear(GetDateTimeNow(ref result, ref styles));
			result.flags |= ParseFlags.YearDefault;
		}

		private static bool GetDayOfNN(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int number = raw.GetNumber(0);
			int number2 = raw.GetNumber(1);
			GetDefaultYear(ref result, ref styles);
			if (!GetMonthDayOrder(dtfi.MonthDayPattern, out var order))
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.MonthDayPattern);
				return false;
			}
			if (order == 6)
			{
				if (SetDateYMD(ref result, result.Year, number, number2))
				{
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
			}
			else if (SetDateYMD(ref result, result.Year, number2, number))
			{
				result.flags |= ParseFlags.HaveDate;
				return true;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool GetDayOfNNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int number = raw.GetNumber(0);
			int number2 = raw.GetNumber(1);
			int number3 = raw.GetNumber(2);
			if (!GetYearMonthDayOrder(dtfi.ShortDatePattern, out var order))
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
				return false;
			}
			int adjustedYear;
			switch (order)
			{
			case 0:
				if (TryAdjustYear(ref result, number, out adjustedYear) && SetDateYMD(ref result, adjustedYear, number2, number3))
				{
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				break;
			case 1:
				if (TryAdjustYear(ref result, number3, out adjustedYear) && SetDateMDY(ref result, number, number2, adjustedYear))
				{
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				break;
			case 2:
				if (TryAdjustYear(ref result, number3, out adjustedYear) && SetDateDMY(ref result, number, number2, adjustedYear))
				{
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				break;
			case 3:
				if (TryAdjustYear(ref result, number, out adjustedYear) && SetDateYDM(ref result, adjustedYear, number2, number3))
				{
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				break;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool GetDayOfMN(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (!GetMonthDayOrder(dtfi.MonthDayPattern, out var order))
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.MonthDayPattern);
				return false;
			}
			if (order == 7)
			{
				if (!GetYearMonthOrder(dtfi.YearMonthPattern, out var order2))
				{
					result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.YearMonthPattern);
					return false;
				}
				if (order2 == 5)
				{
					if (!TryAdjustYear(ref result, raw.GetNumber(0), out var adjustedYear) || !SetDateYMD(ref result, adjustedYear, raw.month, 1))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					return true;
				}
			}
			GetDefaultYear(ref result, ref styles);
			if (!SetDateYMD(ref result, result.Year, raw.month, raw.GetNumber(0)))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			return true;
		}

		private static bool GetHebrewDayOfNM(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if (!GetMonthDayOrder(dtfi.MonthDayPattern, out var order))
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.MonthDayPattern);
				return false;
			}
			result.Month = raw.month;
			if ((order == 7 || order == 6) && result.calendar.IsValidDay(result.Year, result.Month, raw.GetNumber(0), result.era))
			{
				result.Day = raw.GetNumber(0);
				return true;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool GetDayOfNM(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (!GetMonthDayOrder(dtfi.MonthDayPattern, out var order))
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.MonthDayPattern);
				return false;
			}
			if (order == 6)
			{
				if (!GetYearMonthOrder(dtfi.YearMonthPattern, out var order2))
				{
					result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.YearMonthPattern);
					return false;
				}
				if (order2 == 4)
				{
					if (!TryAdjustYear(ref result, raw.GetNumber(0), out var adjustedYear) || !SetDateYMD(ref result, adjustedYear, raw.month, 1))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					return true;
				}
			}
			GetDefaultYear(ref result, ref styles);
			if (!SetDateYMD(ref result, result.Year, raw.month, raw.GetNumber(0)))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			return true;
		}

		private static bool GetDayOfMNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int number = raw.GetNumber(0);
			int number2 = raw.GetNumber(1);
			if (!GetYearMonthDayOrder(dtfi.ShortDatePattern, out var order))
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
				return false;
			}
			int adjustedYear;
			switch (order)
			{
			case 1:
				if (TryAdjustYear(ref result, number2, out adjustedYear) && result.calendar.IsValidDay(adjustedYear, raw.month, number, result.era))
				{
					result.SetDate(adjustedYear, raw.month, number);
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				if (TryAdjustYear(ref result, number, out adjustedYear) && result.calendar.IsValidDay(adjustedYear, raw.month, number2, result.era))
				{
					result.SetDate(adjustedYear, raw.month, number2);
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				break;
			case 0:
				if (TryAdjustYear(ref result, number, out adjustedYear) && result.calendar.IsValidDay(adjustedYear, raw.month, number2, result.era))
				{
					result.SetDate(adjustedYear, raw.month, number2);
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				if (TryAdjustYear(ref result, number2, out adjustedYear) && result.calendar.IsValidDay(adjustedYear, raw.month, number, result.era))
				{
					result.SetDate(adjustedYear, raw.month, number);
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				break;
			case 2:
				if (TryAdjustYear(ref result, number2, out adjustedYear) && result.calendar.IsValidDay(adjustedYear, raw.month, number, result.era))
				{
					result.SetDate(adjustedYear, raw.month, number);
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				if (TryAdjustYear(ref result, number, out adjustedYear) && result.calendar.IsValidDay(adjustedYear, raw.month, number2, result.era))
				{
					result.SetDate(adjustedYear, raw.month, number2);
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
				break;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool GetDayOfYNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int number = raw.GetNumber(0);
			int number2 = raw.GetNumber(1);
			string shortDatePattern = dtfi.ShortDatePattern;
			if (GetYearMonthDayOrder(shortDatePattern, out var order) && order == 3)
			{
				if (SetDateYMD(ref result, raw.year, number2, number))
				{
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
			}
			else if (SetDateYMD(ref result, raw.year, number, number2))
			{
				result.flags |= ParseFlags.HaveDate;
				return true;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool GetDayOfNNY(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int number = raw.GetNumber(0);
			int number2 = raw.GetNumber(1);
			if (!GetYearMonthDayOrder(dtfi.ShortDatePattern, out var order))
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
				return false;
			}
			if (order == 1 || order == 0)
			{
				if (SetDateYMD(ref result, raw.year, number, number2))
				{
					result.flags |= ParseFlags.HaveDate;
					return true;
				}
			}
			else if (SetDateYMD(ref result, raw.year, number2, number))
			{
				result.flags |= ParseFlags.HaveDate;
				return true;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool GetDayOfYMN(ref DateTimeResult result, ref DateTimeRawInfo raw)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (SetDateYMD(ref result, raw.year, raw.month, raw.GetNumber(0)))
			{
				result.flags |= ParseFlags.HaveDate;
				return true;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool GetDayOfYN(ref DateTimeResult result, ref DateTimeRawInfo raw)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (SetDateYMD(ref result, raw.year, raw.GetNumber(0), 1))
			{
				result.flags |= ParseFlags.HaveDate;
				return true;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool GetDayOfYM(ref DateTimeResult result, ref DateTimeRawInfo raw)
		{
			if ((result.flags & ParseFlags.HaveDate) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (SetDateYMD(ref result, raw.year, raw.month, 1))
			{
				result.flags |= ParseFlags.HaveDate;
				return true;
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static void AdjustTimeMark(DateTimeFormatInfo dtfi, ref DateTimeRawInfo raw)
		{
			if (raw.timeMark == TM.NotSet && dtfi.AMDesignator != null && dtfi.PMDesignator != null)
			{
				if (dtfi.AMDesignator.Length == 0 && dtfi.PMDesignator.Length != 0)
				{
					raw.timeMark = TM.AM;
				}
				if (dtfi.PMDesignator.Length == 0 && dtfi.AMDesignator.Length != 0)
				{
					raw.timeMark = TM.PM;
				}
			}
		}

		private static bool AdjustHour(ref int hour, TM timeMark)
		{
			switch (timeMark)
			{
			case TM.AM:
				if (hour < 0 || hour > 12)
				{
					return false;
				}
				hour = ((hour != 12) ? hour : 0);
				break;
			default:
				if (hour < 0 || hour > 23)
				{
					return false;
				}
				if (hour < 12)
				{
					hour += 12;
				}
				break;
			case TM.NotSet:
				break;
			}
			return true;
		}

		private static bool GetTimeOfN(ref DateTimeResult result, ref DateTimeRawInfo raw)
		{
			if ((result.flags & ParseFlags.HaveTime) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (raw.timeMark == TM.NotSet)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			result.Hour = raw.GetNumber(0);
			result.flags |= ParseFlags.HaveTime;
			return true;
		}

		private static bool GetTimeOfNN(ref DateTimeResult result, ref DateTimeRawInfo raw)
		{
			if ((result.flags & ParseFlags.HaveTime) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			result.Hour = raw.GetNumber(0);
			result.Minute = raw.GetNumber(1);
			result.flags |= ParseFlags.HaveTime;
			return true;
		}

		private static bool GetTimeOfNNN(ref DateTimeResult result, ref DateTimeRawInfo raw)
		{
			if ((result.flags & ParseFlags.HaveTime) != 0)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			result.Hour = raw.GetNumber(0);
			result.Minute = raw.GetNumber(1);
			result.Second = raw.GetNumber(2);
			result.flags |= ParseFlags.HaveTime;
			return true;
		}

		private static bool GetDateOfDSN(ref DateTimeResult result, ref DateTimeRawInfo raw)
		{
			if (raw.numCount != 1 || result.Day != -1)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			result.Day = raw.GetNumber(0);
			return true;
		}

		private static bool GetDateOfNDS(ref DateTimeResult result, ref DateTimeRawInfo raw)
		{
			if (result.Month == -1)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (result.Year != -1)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (!TryAdjustYear(ref result, raw.GetNumber(0), out result.Year))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			result.Day = 1;
			return true;
		}

		private static bool GetDateOfNNDS(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			if ((result.flags & ParseFlags.HaveYear) != 0)
			{
				if ((result.flags & ParseFlags.HaveMonth) == 0 && (result.flags & ParseFlags.HaveDay) == 0 && TryAdjustYear(ref result, raw.year, out result.Year) && SetDateYMD(ref result, result.Year, raw.GetNumber(0), raw.GetNumber(1)))
				{
					return true;
				}
			}
			else if ((result.flags & ParseFlags.HaveMonth) != 0 && (result.flags & ParseFlags.HaveYear) == 0 && (result.flags & ParseFlags.HaveDay) == 0)
			{
				if (!GetYearMonthDayOrder(dtfi.ShortDatePattern, out var order))
				{
					result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDatePattern", dtfi.ShortDatePattern);
					return false;
				}
				int adjustedYear;
				if (order == 0)
				{
					if (TryAdjustYear(ref result, raw.GetNumber(0), out adjustedYear) && SetDateYMD(ref result, adjustedYear, result.Month, raw.GetNumber(1)))
					{
						return true;
					}
				}
				else if (TryAdjustYear(ref result, raw.GetNumber(1), out adjustedYear) && SetDateYMD(ref result, adjustedYear, result.Month, raw.GetNumber(0)))
				{
					return true;
				}
			}
			result.SetBadDateTimeFailure();
			return false;
		}

		private static bool ProcessDateTimeSuffix(ref DateTimeResult result, ref DateTimeRawInfo raw, ref DateTimeToken dtok)
		{
			switch (dtok.suffix)
			{
			case TokenType.SEP_YearSuff:
				if ((result.flags & ParseFlags.HaveYear) != 0)
				{
					return false;
				}
				result.flags |= ParseFlags.HaveYear;
				result.Year = (raw.year = dtok.num);
				break;
			case TokenType.SEP_MonthSuff:
				if ((result.flags & ParseFlags.HaveMonth) != 0)
				{
					return false;
				}
				result.flags |= ParseFlags.HaveMonth;
				result.Month = (raw.month = dtok.num);
				break;
			case TokenType.SEP_DaySuff:
				if ((result.flags & ParseFlags.HaveDay) != 0)
				{
					return false;
				}
				result.flags |= ParseFlags.HaveDay;
				result.Day = dtok.num;
				break;
			case TokenType.SEP_HourSuff:
				if ((result.flags & ParseFlags.HaveHour) != 0)
				{
					return false;
				}
				result.flags |= ParseFlags.HaveHour;
				result.Hour = dtok.num;
				break;
			case TokenType.SEP_MinuteSuff:
				if ((result.flags & ParseFlags.HaveMinute) != 0)
				{
					return false;
				}
				result.flags |= ParseFlags.HaveMinute;
				result.Minute = dtok.num;
				break;
			case TokenType.SEP_SecondSuff:
				if ((result.flags & ParseFlags.HaveSecond) != 0)
				{
					return false;
				}
				result.flags |= ParseFlags.HaveSecond;
				result.Second = dtok.num;
				break;
			}
			return true;
		}

		internal static bool ProcessHebrewTerminalState(DS dps, ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			switch (dps)
			{
			case DS.DX_MNN:
				raw.year = raw.GetNumber(1);
				if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, parsedMonthName: true))
				{
					result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
					return false;
				}
				if (!GetDayOfMNN(ref result, ref raw, dtfi))
				{
					return false;
				}
				break;
			case DS.DX_YMN:
				if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, parsedMonthName: true))
				{
					result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
					return false;
				}
				if (!GetDayOfYMN(ref result, ref raw))
				{
					return false;
				}
				break;
			case DS.DX_NNY:
				if (raw.year < 1000)
				{
					raw.year += 5000;
				}
				if (!GetDayOfNNY(ref result, ref raw, dtfi))
				{
					return false;
				}
				if (!dtfi.YearMonthAdjustment(ref result.Year, ref raw.month, parsedMonthName: true))
				{
					result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
					return false;
				}
				break;
			case DS.DX_MN:
			case DS.DX_NM:
				GetDefaultYear(ref result, ref styles);
				if (!dtfi.YearMonthAdjustment(ref result.Year, ref raw.month, parsedMonthName: true))
				{
					result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
					return false;
				}
				if (!GetHebrewDayOfNM(ref result, ref raw, dtfi))
				{
					return false;
				}
				break;
			case DS.DX_YM:
				if (!dtfi.YearMonthAdjustment(ref raw.year, ref raw.month, parsedMonthName: true))
				{
					result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
					return false;
				}
				if (!GetDayOfYM(ref result, ref raw))
				{
					return false;
				}
				break;
			case DS.TX_N:
				if (!GetTimeOfN(ref result, ref raw))
				{
					return false;
				}
				break;
			case DS.TX_NN:
				if (!GetTimeOfNN(ref result, ref raw))
				{
					return false;
				}
				break;
			case DS.TX_NNN:
				if (!GetTimeOfNNN(ref result, ref raw))
				{
					return false;
				}
				break;
			default:
				result.SetBadDateTimeFailure();
				return false;
			}
			if (dps > DS.ERROR)
			{
				raw.numCount = 0;
			}
			return true;
		}

		internal static bool ProcessTerminalState(DS dps, ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
		{
			bool flag = true;
			switch (dps)
			{
			case DS.DX_NN:
				flag = GetDayOfNN(ref result, ref styles, ref raw, dtfi);
				break;
			case DS.DX_NNN:
				flag = GetDayOfNNN(ref result, ref raw, dtfi);
				break;
			case DS.DX_MN:
				flag = GetDayOfMN(ref result, ref styles, ref raw, dtfi);
				break;
			case DS.DX_NM:
				flag = GetDayOfNM(ref result, ref styles, ref raw, dtfi);
				break;
			case DS.DX_MNN:
				flag = GetDayOfMNN(ref result, ref raw, dtfi);
				break;
			case DS.DX_DS:
				flag = true;
				break;
			case DS.DX_YNN:
				flag = GetDayOfYNN(ref result, ref raw, dtfi);
				break;
			case DS.DX_NNY:
				flag = GetDayOfNNY(ref result, ref raw, dtfi);
				break;
			case DS.DX_YMN:
				flag = GetDayOfYMN(ref result, ref raw);
				break;
			case DS.DX_YN:
				flag = GetDayOfYN(ref result, ref raw);
				break;
			case DS.DX_YM:
				flag = GetDayOfYM(ref result, ref raw);
				break;
			case DS.TX_N:
				flag = GetTimeOfN(ref result, ref raw);
				break;
			case DS.TX_NN:
				flag = GetTimeOfNN(ref result, ref raw);
				break;
			case DS.TX_NNN:
				flag = GetTimeOfNNN(ref result, ref raw);
				break;
			case DS.TX_TS:
				flag = true;
				break;
			case DS.DX_DSN:
				flag = GetDateOfDSN(ref result, ref raw);
				break;
			case DS.DX_NDS:
				flag = GetDateOfNDS(ref result, ref raw);
				break;
			case DS.DX_NNDS:
				flag = GetDateOfNNDS(ref result, ref raw, dtfi);
				break;
			}
			if (!flag)
			{
				return false;
			}
			if (dps > DS.ERROR)
			{
				raw.numCount = 0;
			}
			return true;
		}

		internal static DateTime Parse(ReadOnlySpan<char> s, DateTimeFormatInfo dtfi, DateTimeStyles styles)
		{
			DateTimeResult result = default(DateTimeResult);
			result.Init(s);
			if (TryParse(s, dtfi, styles, ref result))
			{
				return result.parsedDate;
			}
			throw GetDateTimeParseException(ref result);
		}

		internal static DateTime Parse(ReadOnlySpan<char> s, DateTimeFormatInfo dtfi, DateTimeStyles styles, out TimeSpan offset)
		{
			DateTimeResult result = default(DateTimeResult);
			result.Init(s);
			result.flags |= ParseFlags.CaptureOffset;
			if (TryParse(s, dtfi, styles, ref result))
			{
				offset = result.timeZoneOffset;
				return result.parsedDate;
			}
			throw GetDateTimeParseException(ref result);
		}

		internal static bool TryParse(ReadOnlySpan<char> s, DateTimeFormatInfo dtfi, DateTimeStyles styles, out DateTime result)
		{
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			if (TryParse(s, dtfi, styles, ref result2))
			{
				result = result2.parsedDate;
				return true;
			}
			result = DateTime.MinValue;
			return false;
		}

		internal static bool TryParse(ReadOnlySpan<char> s, DateTimeFormatInfo dtfi, DateTimeStyles styles, out DateTime result, out TimeSpan offset)
		{
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			result2.flags |= ParseFlags.CaptureOffset;
			if (TryParse(s, dtfi, styles, ref result2))
			{
				result = result2.parsedDate;
				offset = result2.timeZoneOffset;
				return true;
			}
			result = DateTime.MinValue;
			offset = TimeSpan.Zero;
			return false;
		}

		internal unsafe static bool TryParse(ReadOnlySpan<char> s, DateTimeFormatInfo dtfi, DateTimeStyles styles, ref DateTimeResult result)
		{
			if (s.Length == 0)
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadDateTime");
				return false;
			}
			DS dS = DS.BEGIN;
			bool flag = false;
			DateTimeToken dtok = default(DateTimeToken);
			dtok.suffix = TokenType.SEP_Unk;
			DateTimeRawInfo raw = default(DateTimeRawInfo);
			int* numberBuffer = stackalloc int[3];
			raw.Init(numberBuffer);
			raw.hasSameDateAndTimeSeparators = dtfi.DateSeparator.Equals(dtfi.TimeSeparator, StringComparison.Ordinal);
			result.calendar = dtfi.Calendar;
			result.era = 0;
			__DTString str = new __DTString(s, dtfi);
			str.GetNext();
			do
			{
				if (!Lex(dS, ref str, ref dtok, ref raw, ref result, ref dtfi, styles))
				{
					return false;
				}
				if (dtok.dtt == DTT.Unk)
				{
					continue;
				}
				if (dtok.suffix != TokenType.SEP_Unk)
				{
					if (!ProcessDateTimeSuffix(ref result, ref raw, ref dtok))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					dtok.suffix = TokenType.SEP_Unk;
				}
				if (dtok.dtt == DTT.NumLocalTimeMark)
				{
					if (dS == DS.D_YNd || dS == DS.D_YN)
					{
						return ParseISO8601(ref raw, ref str, styles, ref result);
					}
					result.SetBadDateTimeFailure();
					return false;
				}
				if (raw.hasSameDateAndTimeSeparators)
				{
					if (dtok.dtt == DTT.YearEnd || dtok.dtt == DTT.YearSpace || dtok.dtt == DTT.YearDateSep)
					{
						if (dS == DS.T_Nt)
						{
							dS = DS.D_Nd;
						}
						if (dS == DS.T_NNt)
						{
							dS = DS.D_NNd;
						}
					}
					bool flag2 = str.AtEnd();
					if (s_dateParsingStates[(int)dS][(int)dtok.dtt] == DS.ERROR || flag2)
					{
						switch (dtok.dtt)
						{
						case DTT.YearDateSep:
							dtok.dtt = (flag2 ? DTT.YearEnd : DTT.YearSpace);
							break;
						case DTT.NumDatesep:
							dtok.dtt = (flag2 ? DTT.NumEnd : DTT.NumSpace);
							break;
						case DTT.NumTimesep:
							dtok.dtt = (flag2 ? DTT.NumEnd : DTT.NumSpace);
							break;
						case DTT.MonthDatesep:
							dtok.dtt = (flag2 ? DTT.MonthEnd : DTT.MonthSpace);
							break;
						}
					}
				}
				dS = s_dateParsingStates[(int)dS][(int)dtok.dtt];
				if (dS == DS.ERROR)
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (dS <= DS.ERROR)
				{
					continue;
				}
				if ((dtfi.FormatFlags & DateTimeFormatFlags.UseHebrewRule) != 0)
				{
					if (!ProcessHebrewTerminalState(dS, ref result, ref styles, ref raw, dtfi))
					{
						return false;
					}
				}
				else if (!ProcessTerminalState(dS, ref result, ref styles, ref raw, dtfi))
				{
					return false;
				}
				flag = true;
				dS = DS.BEGIN;
			}
			while (dtok.dtt != 0 && dtok.dtt != DTT.NumEnd && dtok.dtt != DTT.MonthEnd);
			if (!flag)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			AdjustTimeMark(dtfi, ref raw);
			if (!AdjustHour(ref result.Hour, raw.timeMark))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			bool bTimeOnly = result.Year == -1 && result.Month == -1 && result.Day == -1;
			if (!CheckDefaultDateTime(ref result, ref result.calendar, styles))
			{
				return false;
			}
			if (!result.calendar.TryToDateTime(result.Year, result.Month, result.Day, result.Hour, result.Minute, result.Second, 0, result.era, out var result2))
			{
				result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
				return false;
			}
			if (raw.fraction > 0.0 && !result2.TryAddTicks((long)Math.Round(raw.fraction * 10000000.0), out result2))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (raw.dayOfWeek != -1 && raw.dayOfWeek != (int)result.calendar.GetDayOfWeek(result2))
			{
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_BadDayOfWeek");
				return false;
			}
			result.parsedDate = result2;
			if (!DetermineTimeZoneAdjustments(ref result, styles, bTimeOnly))
			{
				return false;
			}
			return true;
		}

		private static bool DetermineTimeZoneAdjustments(ref DateTimeResult result, DateTimeStyles styles, bool bTimeOnly)
		{
			if ((result.flags & ParseFlags.CaptureOffset) != 0)
			{
				return DateTimeOffsetTimeZonePostProcessing(ref result, styles);
			}
			long ticks = result.timeZoneOffset.Ticks;
			if (ticks < -504000000000L || ticks > 504000000000L)
			{
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_OffsetOutOfRange");
				return false;
			}
			if ((result.flags & ParseFlags.TimeZoneUsed) == 0)
			{
				if ((styles & DateTimeStyles.AssumeLocal) != 0)
				{
					if ((styles & DateTimeStyles.AdjustToUniversal) == 0)
					{
						result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Local);
						return true;
					}
					result.flags |= ParseFlags.TimeZoneUsed;
					result.timeZoneOffset = TimeZoneInfo.GetLocalUtcOffset(result.parsedDate, TimeZoneInfoOptions.NoThrowOnInvalidTime);
				}
				else
				{
					if ((styles & DateTimeStyles.AssumeUniversal) == 0)
					{
						return true;
					}
					if ((styles & DateTimeStyles.AdjustToUniversal) != 0)
					{
						result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Utc);
						return true;
					}
					result.flags |= ParseFlags.TimeZoneUsed;
					result.timeZoneOffset = TimeSpan.Zero;
				}
			}
			if ((styles & DateTimeStyles.RoundtripKind) != 0 && (result.flags & ParseFlags.TimeZoneUtc) != 0)
			{
				result.parsedDate = DateTime.SpecifyKind(result.parsedDate, DateTimeKind.Utc);
				return true;
			}
			if ((styles & DateTimeStyles.AdjustToUniversal) != 0)
			{
				return AdjustTimeZoneToUniversal(ref result);
			}
			return AdjustTimeZoneToLocal(ref result, bTimeOnly);
		}

		private static bool DateTimeOffsetTimeZonePostProcessing(ref DateTimeResult result, DateTimeStyles styles)
		{
			if ((result.flags & ParseFlags.TimeZoneUsed) == 0)
			{
				if ((styles & DateTimeStyles.AssumeUniversal) != 0)
				{
					result.timeZoneOffset = TimeSpan.Zero;
				}
				else
				{
					result.timeZoneOffset = TimeZoneInfo.GetLocalUtcOffset(result.parsedDate, TimeZoneInfoOptions.NoThrowOnInvalidTime);
				}
			}
			long ticks = result.timeZoneOffset.Ticks;
			long num = result.parsedDate.Ticks - ticks;
			if (num < 0 || num > 3155378975999999999L)
			{
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_UTCOutOfRange");
				return false;
			}
			if (ticks < -504000000000L || ticks > 504000000000L)
			{
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_OffsetOutOfRange");
				return false;
			}
			if ((styles & DateTimeStyles.AdjustToUniversal) != 0)
			{
				if ((result.flags & ParseFlags.TimeZoneUsed) == 0 && (styles & DateTimeStyles.AssumeUniversal) == 0)
				{
					bool result2 = AdjustTimeZoneToUniversal(ref result);
					result.timeZoneOffset = TimeSpan.Zero;
					return result2;
				}
				result.parsedDate = new DateTime(num, DateTimeKind.Utc);
				result.timeZoneOffset = TimeSpan.Zero;
			}
			return true;
		}

		private static bool AdjustTimeZoneToUniversal(ref DateTimeResult result)
		{
			long ticks = result.parsedDate.Ticks;
			ticks -= result.timeZoneOffset.Ticks;
			if (ticks < 0)
			{
				ticks += 864000000000L;
			}
			if (ticks < 0 || ticks > 3155378975999999999L)
			{
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_DateOutOfRange");
				return false;
			}
			result.parsedDate = new DateTime(ticks, DateTimeKind.Utc);
			return true;
		}

		private static bool AdjustTimeZoneToLocal(ref DateTimeResult result, bool bTimeOnly)
		{
			long ticks = result.parsedDate.Ticks;
			TimeZoneInfo local = TimeZoneInfo.Local;
			bool isAmbiguousLocalDst = false;
			if (ticks < 864000000000L)
			{
				ticks -= result.timeZoneOffset.Ticks;
				ticks += local.GetUtcOffset(bTimeOnly ? DateTime.Now : result.parsedDate, TimeZoneInfoOptions.NoThrowOnInvalidTime).Ticks;
				if (ticks < 0)
				{
					ticks += 864000000000L;
				}
			}
			else
			{
				ticks -= result.timeZoneOffset.Ticks;
				if (ticks < 0 || ticks > 3155378975999999999L)
				{
					ticks += local.GetUtcOffset(result.parsedDate, TimeZoneInfoOptions.NoThrowOnInvalidTime).Ticks;
				}
				else
				{
					DateTime time = new DateTime(ticks, DateTimeKind.Utc);
					ticks += TimeZoneInfo.GetUtcOffsetFromUtc(time, TimeZoneInfo.Local, out var _, out isAmbiguousLocalDst).Ticks;
				}
			}
			if (ticks < 0 || ticks > 3155378975999999999L)
			{
				result.parsedDate = DateTime.MinValue;
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_DateOutOfRange");
				return false;
			}
			result.parsedDate = new DateTime(ticks, DateTimeKind.Local, isAmbiguousLocalDst);
			return true;
		}

		private static bool ParseISO8601(ref DateTimeRawInfo raw, ref __DTString str, DateTimeStyles styles, ref DateTimeResult result)
		{
			if (raw.year >= 0 && raw.GetNumber(0) >= 0)
			{
				raw.GetNumber(1);
				_ = 0;
			}
			str.Index--;
			int result2 = 0;
			double result3 = 0.0;
			str.SkipWhiteSpaces();
			if (!ParseDigits(ref str, 2, out var result4))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			str.SkipWhiteSpaces();
			if (!str.Match(':'))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			str.SkipWhiteSpaces();
			if (!ParseDigits(ref str, 2, out var result5))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			str.SkipWhiteSpaces();
			if (str.Match(':'))
			{
				str.SkipWhiteSpaces();
				if (!ParseDigits(ref str, 2, out result2))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (str.Match('.'))
				{
					if (!ParseFraction(ref str, out result3))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					str.Index--;
				}
				str.SkipWhiteSpaces();
			}
			if (str.GetNext())
			{
				switch (str.GetChar())
				{
				case '+':
				case '-':
					result.flags |= ParseFlags.TimeZoneUsed;
					if (!ParseTimeZone(ref str, ref result.timeZoneOffset))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					str.Index--;
					break;
				case 'Z':
				case 'z':
					result.flags |= ParseFlags.TimeZoneUsed;
					result.timeZoneOffset = TimeSpan.Zero;
					result.flags |= ParseFlags.TimeZoneUtc;
					break;
				default:
					str.Index--;
					break;
				}
				str.SkipWhiteSpaces();
				if (str.Match('#'))
				{
					if (!VerifyValidPunctuation(ref str))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					str.SkipWhiteSpaces();
				}
				if (str.Match('\0') && !VerifyValidPunctuation(ref str))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (str.GetNext())
				{
					result.SetBadDateTimeFailure();
					return false;
				}
			}
			Calendar defaultInstance = GregorianCalendar.GetDefaultInstance();
			if (!defaultInstance.TryToDateTime(raw.year, raw.GetNumber(0), raw.GetNumber(1), result4, result5, result2, 0, result.era, out var result6))
			{
				result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
				return false;
			}
			if (!result6.TryAddTicks((long)Math.Round(result3 * 10000000.0), out result6))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			result.parsedDate = result6;
			return DetermineTimeZoneAdjustments(ref result, styles, bTimeOnly: false);
		}

		internal static bool MatchHebrewDigits(ref __DTString str, int digitLen, out int number)
		{
			number = 0;
			HebrewNumberParsingContext context = new HebrewNumberParsingContext(0);
			HebrewNumberParsingState hebrewNumberParsingState = HebrewNumberParsingState.ContinueParsing;
			while (hebrewNumberParsingState == HebrewNumberParsingState.ContinueParsing && str.GetNext())
			{
				hebrewNumberParsingState = HebrewNumber.ParseByChar(str.GetChar(), ref context);
			}
			if (hebrewNumberParsingState == HebrewNumberParsingState.FoundEndOfHebrewNumber)
			{
				number = context.result;
				return true;
			}
			return false;
		}

		internal static bool ParseDigits(ref __DTString str, int digitLen, out int result)
		{
			if (digitLen == 1)
			{
				return ParseDigits(ref str, 1, 2, out result);
			}
			return ParseDigits(ref str, digitLen, digitLen, out result);
		}

		internal static bool ParseDigits(ref __DTString str, int minDigitLen, int maxDigitLen, out int result)
		{
			int num = 0;
			int index = str.Index;
			int i;
			for (i = 0; i < maxDigitLen; i++)
			{
				if (!str.GetNextDigit())
				{
					str.Index--;
					break;
				}
				num = num * 10 + str.GetDigit();
			}
			result = num;
			if (i < minDigitLen)
			{
				str.Index = index;
				return false;
			}
			return true;
		}

		private static bool ParseFractionExact(ref __DTString str, int maxDigitLen, ref double result)
		{
			if (!str.GetNextDigit())
			{
				str.Index--;
				return false;
			}
			result = str.GetDigit();
			int i;
			for (i = 1; i < maxDigitLen; i++)
			{
				if (!str.GetNextDigit())
				{
					str.Index--;
					break;
				}
				result = result * 10.0 + (double)str.GetDigit();
			}
			result /= TimeSpanParse.Pow10(i);
			return i == maxDigitLen;
		}

		private static bool ParseSign(ref __DTString str, ref bool result)
		{
			if (!str.GetNext())
			{
				return false;
			}
			switch (str.GetChar())
			{
			case '+':
				result = true;
				return true;
			case '-':
				result = false;
				return true;
			default:
				return false;
			}
		}

		private static bool ParseTimeZoneOffset(ref __DTString str, int len, ref TimeSpan result)
		{
			bool result2 = true;
			int result3 = 0;
			int result4;
			if ((uint)(len - 1) <= 1u)
			{
				if (!ParseSign(ref str, ref result2))
				{
					return false;
				}
				if (!ParseDigits(ref str, len, out result4))
				{
					return false;
				}
			}
			else
			{
				if (!ParseSign(ref str, ref result2))
				{
					return false;
				}
				if (!ParseDigits(ref str, 1, out result4))
				{
					return false;
				}
				if (str.Match(":"))
				{
					if (!ParseDigits(ref str, 2, out result3))
					{
						return false;
					}
				}
				else
				{
					str.Index--;
					if (!ParseDigits(ref str, 2, out result3))
					{
						return false;
					}
				}
			}
			if (result3 < 0 || result3 >= 60)
			{
				return false;
			}
			result = new TimeSpan(result4, result3, 0);
			if (!result2)
			{
				result = result.Negate();
			}
			return true;
		}

		private static bool MatchAbbreviatedMonthName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
		{
			int maxMatchStrLen = 0;
			result = -1;
			if (str.GetNext())
			{
				int num = ((dtfi.GetMonthName(13).Length == 0) ? 12 : 13);
				for (int i = 1; i <= num; i++)
				{
					string abbreviatedMonthName = dtfi.GetAbbreviatedMonthName(i);
					int matchLength = abbreviatedMonthName.Length;
					if ((dtfi.HasSpacesInMonthNames ? str.MatchSpecifiedWords(abbreviatedMonthName, checkWordBoundary: false, ref matchLength) : str.MatchSpecifiedWord(abbreviatedMonthName)) && matchLength > maxMatchStrLen)
					{
						maxMatchStrLen = matchLength;
						result = i;
					}
				}
				if ((dtfi.FormatFlags & DateTimeFormatFlags.UseGenitiveMonth) != 0)
				{
					int num2 = str.MatchLongestWords(dtfi.AbbreviatedMonthGenitiveNames, ref maxMatchStrLen);
					if (num2 >= 0)
					{
						result = num2 + 1;
					}
				}
				if ((dtfi.FormatFlags & DateTimeFormatFlags.UseLeapYearMonth) != 0)
				{
					int num3 = str.MatchLongestWords(dtfi.InternalGetLeapYearMonthNames(), ref maxMatchStrLen);
					if (num3 >= 0)
					{
						result = num3 + 1;
					}
				}
			}
			if (result > 0)
			{
				str.Index += maxMatchStrLen - 1;
				return true;
			}
			return false;
		}

		private static bool MatchMonthName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
		{
			int maxMatchStrLen = 0;
			result = -1;
			if (str.GetNext())
			{
				int num = ((dtfi.GetMonthName(13).Length == 0) ? 12 : 13);
				for (int i = 1; i <= num; i++)
				{
					string monthName = dtfi.GetMonthName(i);
					int matchLength = monthName.Length;
					if ((dtfi.HasSpacesInMonthNames ? str.MatchSpecifiedWords(monthName, checkWordBoundary: false, ref matchLength) : str.MatchSpecifiedWord(monthName)) && matchLength > maxMatchStrLen)
					{
						maxMatchStrLen = matchLength;
						result = i;
					}
				}
				if ((dtfi.FormatFlags & DateTimeFormatFlags.UseGenitiveMonth) != 0)
				{
					int num2 = str.MatchLongestWords(dtfi.MonthGenitiveNames, ref maxMatchStrLen);
					if (num2 >= 0)
					{
						result = num2 + 1;
					}
				}
				if ((dtfi.FormatFlags & DateTimeFormatFlags.UseLeapYearMonth) != 0)
				{
					int num3 = str.MatchLongestWords(dtfi.InternalGetLeapYearMonthNames(), ref maxMatchStrLen);
					if (num3 >= 0)
					{
						result = num3 + 1;
					}
				}
			}
			if (result > 0)
			{
				str.Index += maxMatchStrLen - 1;
				return true;
			}
			return false;
		}

		private static bool MatchAbbreviatedDayName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
		{
			int num = 0;
			result = -1;
			if (str.GetNext())
			{
				for (DayOfWeek dayOfWeek = DayOfWeek.Sunday; dayOfWeek <= DayOfWeek.Saturday; dayOfWeek++)
				{
					string abbreviatedDayName = dtfi.GetAbbreviatedDayName(dayOfWeek);
					int matchLength = abbreviatedDayName.Length;
					if ((dtfi.HasSpacesInDayNames ? str.MatchSpecifiedWords(abbreviatedDayName, checkWordBoundary: false, ref matchLength) : str.MatchSpecifiedWord(abbreviatedDayName)) && matchLength > num)
					{
						num = matchLength;
						result = (int)dayOfWeek;
					}
				}
			}
			if (result >= 0)
			{
				str.Index += num - 1;
				return true;
			}
			return false;
		}

		private static bool MatchDayName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
		{
			int num = 0;
			result = -1;
			if (str.GetNext())
			{
				for (DayOfWeek dayOfWeek = DayOfWeek.Sunday; dayOfWeek <= DayOfWeek.Saturday; dayOfWeek++)
				{
					string dayName = dtfi.GetDayName(dayOfWeek);
					int matchLength = dayName.Length;
					if ((dtfi.HasSpacesInDayNames ? str.MatchSpecifiedWords(dayName, checkWordBoundary: false, ref matchLength) : str.MatchSpecifiedWord(dayName)) && matchLength > num)
					{
						num = matchLength;
						result = (int)dayOfWeek;
					}
				}
			}
			if (result >= 0)
			{
				str.Index += num - 1;
				return true;
			}
			return false;
		}

		private static bool MatchEraName(ref __DTString str, DateTimeFormatInfo dtfi, ref int result)
		{
			if (str.GetNext())
			{
				int[] eras = dtfi.Calendar.Eras;
				if (eras != null)
				{
					for (int i = 0; i < eras.Length; i++)
					{
						string eraName = dtfi.GetEraName(eras[i]);
						if (str.MatchSpecifiedWord(eraName))
						{
							str.Index += eraName.Length - 1;
							result = eras[i];
							return true;
						}
						eraName = dtfi.GetAbbreviatedEraName(eras[i]);
						if (str.MatchSpecifiedWord(eraName))
						{
							str.Index += eraName.Length - 1;
							result = eras[i];
							return true;
						}
					}
				}
			}
			return false;
		}

		private static bool MatchTimeMark(ref __DTString str, DateTimeFormatInfo dtfi, ref TM result)
		{
			result = TM.NotSet;
			if (dtfi.AMDesignator.Length == 0)
			{
				result = TM.AM;
			}
			if (dtfi.PMDesignator.Length == 0)
			{
				result = TM.PM;
			}
			if (str.GetNext())
			{
				string aMDesignator = dtfi.AMDesignator;
				if (aMDesignator.Length > 0 && str.MatchSpecifiedWord(aMDesignator))
				{
					str.Index += aMDesignator.Length - 1;
					result = TM.AM;
					return true;
				}
				aMDesignator = dtfi.PMDesignator;
				if (aMDesignator.Length > 0 && str.MatchSpecifiedWord(aMDesignator))
				{
					str.Index += aMDesignator.Length - 1;
					result = TM.PM;
					return true;
				}
				str.Index--;
			}
			if (result != TM.NotSet)
			{
				return true;
			}
			return false;
		}

		private static bool MatchAbbreviatedTimeMark(ref __DTString str, DateTimeFormatInfo dtfi, ref TM result)
		{
			if (str.GetNext())
			{
				string aMDesignator = dtfi.AMDesignator;
				if (aMDesignator.Length > 0 && str.GetChar() == aMDesignator[0])
				{
					result = TM.AM;
					return true;
				}
				string pMDesignator = dtfi.PMDesignator;
				if (pMDesignator.Length > 0 && str.GetChar() == pMDesignator[0])
				{
					result = TM.PM;
					return true;
				}
			}
			return false;
		}

		private static bool CheckNewValue(ref int currentValue, int newValue, char patternChar, ref DateTimeResult result)
		{
			if (currentValue == -1)
			{
				currentValue = newValue;
				return true;
			}
			if (newValue != currentValue)
			{
				result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", patternChar);
				return false;
			}
			return true;
		}

		private static DateTime GetDateTimeNow(ref DateTimeResult result, ref DateTimeStyles styles)
		{
			if ((result.flags & ParseFlags.CaptureOffset) != 0)
			{
				if ((result.flags & ParseFlags.TimeZoneUsed) != 0)
				{
					return new DateTime(DateTime.UtcNow.Ticks + result.timeZoneOffset.Ticks, DateTimeKind.Unspecified);
				}
				if ((styles & DateTimeStyles.AssumeUniversal) != 0)
				{
					return DateTime.UtcNow;
				}
			}
			return DateTime.Now;
		}

		private static bool CheckDefaultDateTime(ref DateTimeResult result, ref Calendar cal, DateTimeStyles styles)
		{
			if ((result.flags & ParseFlags.CaptureOffset) != 0 && (result.Month != -1 || result.Day != -1) && (result.Year == -1 || (result.flags & ParseFlags.YearDefault) != 0) && (result.flags & ParseFlags.TimeZoneUsed) != 0)
			{
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_MissingIncompleteDate");
				return false;
			}
			if (result.Year == -1 || result.Month == -1 || result.Day == -1)
			{
				DateTime dateTimeNow = GetDateTimeNow(ref result, ref styles);
				if (result.Month == -1 && result.Day == -1)
				{
					if (result.Year == -1)
					{
						if ((styles & DateTimeStyles.NoCurrentDateDefault) != 0)
						{
							cal = GregorianCalendar.GetDefaultInstance();
							result.Year = (result.Month = (result.Day = 1));
						}
						else
						{
							result.Year = cal.GetYear(dateTimeNow);
							result.Month = cal.GetMonth(dateTimeNow);
							result.Day = cal.GetDayOfMonth(dateTimeNow);
						}
					}
					else
					{
						result.Month = 1;
						result.Day = 1;
					}
				}
				else
				{
					if (result.Year == -1)
					{
						result.Year = cal.GetYear(dateTimeNow);
					}
					if (result.Month == -1)
					{
						result.Month = 1;
					}
					if (result.Day == -1)
					{
						result.Day = 1;
					}
				}
			}
			if (result.Hour == -1)
			{
				result.Hour = 0;
			}
			if (result.Minute == -1)
			{
				result.Minute = 0;
			}
			if (result.Second == -1)
			{
				result.Second = 0;
			}
			if (result.era == -1)
			{
				result.era = 0;
			}
			return true;
		}

		private static string ExpandPredefinedFormat(ReadOnlySpan<char> format, ref DateTimeFormatInfo dtfi, ref ParsingInfo parseInfo, ref DateTimeResult result)
		{
			switch (format[0])
			{
			case 'O':
			case 'o':
			case 's':
				ConfigureFormatOS(ref dtfi, ref parseInfo);
				break;
			case 'R':
			case 'r':
				ConfigureFormatR(ref dtfi, ref parseInfo, ref result);
				break;
			case 'u':
				parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
				dtfi = DateTimeFormatInfo.InvariantInfo;
				if ((result.flags & ParseFlags.CaptureOffset) != 0)
				{
					result.flags |= ParseFlags.UtcSortPattern;
				}
				break;
			case 'U':
				parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
				result.flags |= ParseFlags.TimeZoneUsed;
				result.timeZoneOffset = new TimeSpan(0L);
				result.flags |= ParseFlags.TimeZoneUtc;
				if (dtfi.Calendar.GetType() != typeof(GregorianCalendar))
				{
					dtfi = (DateTimeFormatInfo)dtfi.Clone();
					dtfi.Calendar = GregorianCalendar.GetDefaultInstance();
				}
				break;
			}
			return DateTimeFormat.GetRealFormat(format, dtfi);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ParseJapaneseEraStart(ref __DTString str, DateTimeFormatInfo dtfi)
		{
			if (LocalAppContextSwitches.EnforceLegacyJapaneseDateParsing || dtfi.Calendar.ID != CalendarId.JAPAN || !str.GetNext())
			{
				return false;
			}
			if (str.m_current != "元"[0])
			{
				str.Index--;
				return false;
			}
			return true;
		}

		private static void ConfigureFormatR(ref DateTimeFormatInfo dtfi, ref ParsingInfo parseInfo, ref DateTimeResult result)
		{
			parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
			dtfi = DateTimeFormatInfo.InvariantInfo;
			if ((result.flags & ParseFlags.CaptureOffset) != 0)
			{
				result.flags |= ParseFlags.Rfc1123Pattern;
			}
		}

		private static void ConfigureFormatOS(ref DateTimeFormatInfo dtfi, ref ParsingInfo parseInfo)
		{
			parseInfo.calendar = GregorianCalendar.GetDefaultInstance();
			dtfi = DateTimeFormatInfo.InvariantInfo;
		}

		private static bool ParseByFormat(ref __DTString str, ref __DTString format, ref ParsingInfo parseInfo, DateTimeFormatInfo dtfi, ref DateTimeResult result)
		{
			int result2 = 0;
			int result3 = 0;
			int result4 = 0;
			int result5 = 0;
			int result6 = 0;
			int result7 = 0;
			int result8 = 0;
			double result9 = 0.0;
			TM result10 = TM.AM;
			char @char = format.GetChar();
			switch (@char)
			{
			case 'y':
			{
				int repeatCount = format.GetRepeatCount();
				bool flag;
				if (ParseJapaneseEraStart(ref str, dtfi))
				{
					result2 = 1;
					flag = true;
				}
				else if (dtfi.HasForceTwoDigitYears)
				{
					flag = ParseDigits(ref str, 1, 4, out result2);
				}
				else
				{
					if (repeatCount <= 2)
					{
						parseInfo.fUseTwoDigitYear = true;
					}
					flag = ParseDigits(ref str, repeatCount, out result2);
				}
				if (!flag && parseInfo.fCustomNumberParser)
				{
					flag = parseInfo.parseNumberDelegate(ref str, repeatCount, out result2);
				}
				if (!flag)
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (!CheckNewValue(ref result.Year, result2, @char, ref result))
				{
					return false;
				}
				break;
			}
			case 'M':
			{
				int repeatCount = format.GetRepeatCount();
				if (repeatCount <= 2)
				{
					if (!ParseDigits(ref str, repeatCount, out result3) && (!parseInfo.fCustomNumberParser || !parseInfo.parseNumberDelegate(ref str, repeatCount, out result3)))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
				}
				else
				{
					if (repeatCount == 3)
					{
						if (!MatchAbbreviatedMonthName(ref str, dtfi, ref result3))
						{
							result.SetBadDateTimeFailure();
							return false;
						}
					}
					else if (!MatchMonthName(ref str, dtfi, ref result3))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					result.flags |= ParseFlags.ParsedMonthName;
				}
				if (!CheckNewValue(ref result.Month, result3, @char, ref result))
				{
					return false;
				}
				break;
			}
			case 'd':
			{
				int repeatCount = format.GetRepeatCount();
				if (repeatCount <= 2)
				{
					if (!ParseDigits(ref str, repeatCount, out result4) && (!parseInfo.fCustomNumberParser || !parseInfo.parseNumberDelegate(ref str, repeatCount, out result4)))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					if (!CheckNewValue(ref result.Day, result4, @char, ref result))
					{
						return false;
					}
					break;
				}
				if (repeatCount == 3)
				{
					if (!MatchAbbreviatedDayName(ref str, dtfi, ref result5))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
				}
				else if (!MatchDayName(ref str, dtfi, ref result5))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (!CheckNewValue(ref parseInfo.dayOfWeek, result5, @char, ref result))
				{
					return false;
				}
				break;
			}
			case 'g':
				format.GetRepeatCount();
				if (!MatchEraName(ref str, dtfi, ref result.era))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				break;
			case 'h':
			{
				parseInfo.fUseHour12 = true;
				int repeatCount = format.GetRepeatCount();
				if (!ParseDigits(ref str, (repeatCount < 2) ? 1 : 2, out result6))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (!CheckNewValue(ref result.Hour, result6, @char, ref result))
				{
					return false;
				}
				break;
			}
			case 'H':
			{
				int repeatCount = format.GetRepeatCount();
				if (!ParseDigits(ref str, (repeatCount < 2) ? 1 : 2, out result6))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (!CheckNewValue(ref result.Hour, result6, @char, ref result))
				{
					return false;
				}
				break;
			}
			case 'm':
			{
				int repeatCount = format.GetRepeatCount();
				if (!ParseDigits(ref str, (repeatCount < 2) ? 1 : 2, out result7))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (!CheckNewValue(ref result.Minute, result7, @char, ref result))
				{
					return false;
				}
				break;
			}
			case 's':
			{
				int repeatCount = format.GetRepeatCount();
				if (!ParseDigits(ref str, (repeatCount < 2) ? 1 : 2, out result8))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (!CheckNewValue(ref result.Second, result8, @char, ref result))
				{
					return false;
				}
				break;
			}
			case 'F':
			case 'f':
			{
				int repeatCount = format.GetRepeatCount();
				if (repeatCount <= 7)
				{
					if (!ParseFractionExact(ref str, repeatCount, ref result9) && @char == 'f')
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					if (result.fraction < 0.0)
					{
						result.fraction = result9;
					}
					else if (result9 != result.fraction)
					{
						result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", @char);
						return false;
					}
					break;
				}
				result.SetBadDateTimeFailure();
				return false;
			}
			case 't':
			{
				int repeatCount = format.GetRepeatCount();
				if (repeatCount == 1)
				{
					if (!MatchAbbreviatedTimeMark(ref str, dtfi, ref result10))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
				}
				else if (!MatchTimeMark(ref str, dtfi, ref result10))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (parseInfo.timeMark == TM.NotSet)
				{
					parseInfo.timeMark = result10;
				}
				else if (parseInfo.timeMark != result10)
				{
					result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", @char);
					return false;
				}
				break;
			}
			case 'z':
			{
				int repeatCount = format.GetRepeatCount();
				TimeSpan result11 = new TimeSpan(0L);
				if (!ParseTimeZoneOffset(ref str, repeatCount, ref result11))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && result11 != result.timeZoneOffset)
				{
					result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'z');
					return false;
				}
				result.timeZoneOffset = result11;
				result.flags |= ParseFlags.TimeZoneUsed;
				break;
			}
			case 'Z':
				if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && result.timeZoneOffset != TimeSpan.Zero)
				{
					result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'Z');
					return false;
				}
				result.flags |= ParseFlags.TimeZoneUsed;
				result.timeZoneOffset = new TimeSpan(0L);
				result.flags |= ParseFlags.TimeZoneUtc;
				str.Index++;
				if (!GetTimeZoneName(ref str))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				str.Index--;
				break;
			case 'K':
				if (str.Match('Z'))
				{
					if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && result.timeZoneOffset != TimeSpan.Zero)
					{
						result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'K');
						return false;
					}
					result.flags |= ParseFlags.TimeZoneUsed;
					result.timeZoneOffset = new TimeSpan(0L);
					result.flags |= ParseFlags.TimeZoneUtc;
				}
				else if (str.Match('+') || str.Match('-'))
				{
					str.Index--;
					TimeSpan result12 = new TimeSpan(0L);
					if (!ParseTimeZoneOffset(ref str, 3, ref result12))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					if ((result.flags & ParseFlags.TimeZoneUsed) != 0 && result12 != result.timeZoneOffset)
					{
						result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_RepeatDateTimePattern", 'K');
						return false;
					}
					result.timeZoneOffset = result12;
					result.flags |= ParseFlags.TimeZoneUsed;
				}
				break;
			case ':':
				if (((dtfi.TimeSeparator.Length > 1 && dtfi.TimeSeparator[0] == ':') || !str.Match(':')) && !str.Match(dtfi.TimeSeparator))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				break;
			case '/':
				if (((dtfi.DateSeparator.Length > 1 && dtfi.DateSeparator[0] == '/') || !str.Match('/')) && !str.Match(dtfi.DateSeparator))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				break;
			case '"':
			case '\'':
			{
				StringBuilder stringBuilder = StringBuilderCache.Acquire();
				if (!TryParseQuoteString(format.Value, format.Index, stringBuilder, out var repeatCount))
				{
					result.SetFailure(ParseFailureKind.FormatWithParameter, "Format_BadQuote", @char);
					StringBuilderCache.Release(stringBuilder);
					return false;
				}
				format.Index += repeatCount - 1;
				string stringAndRelease = StringBuilderCache.GetStringAndRelease(stringBuilder);
				for (int i = 0; i < stringAndRelease.Length; i++)
				{
					if (stringAndRelease[i] == ' ' && parseInfo.fAllowInnerWhite)
					{
						str.SkipWhiteSpaces();
					}
					else if (!str.Match(stringAndRelease[i]))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
				}
				if ((result.flags & ParseFlags.CaptureOffset) != 0 && (((result.flags & ParseFlags.Rfc1123Pattern) != 0 && stringAndRelease == "GMT") || ((result.flags & ParseFlags.UtcSortPattern) != 0 && stringAndRelease == "Z")))
				{
					result.flags |= ParseFlags.TimeZoneUsed;
					result.timeZoneOffset = TimeSpan.Zero;
				}
				break;
			}
			case '%':
				if (format.Index >= format.Value.Length - 1 || format.Value[format.Index + 1] == '%')
				{
					result.SetBadFormatSpecifierFailure(format.Value);
					return false;
				}
				break;
			case '\\':
				if (format.GetNext())
				{
					if (!str.Match(format.GetChar()))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					break;
				}
				result.SetBadFormatSpecifierFailure(format.Value);
				return false;
			case '.':
				if (!str.Match(@char))
				{
					if (!format.GetNext() || !format.Match('F'))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					format.GetRepeatCount();
				}
				break;
			default:
				if (@char == ' ')
				{
					if (!parseInfo.fAllowInnerWhite && !str.Match(@char))
					{
						if (parseInfo.fAllowTrailingWhite && format.GetNext() && ParseByFormat(ref str, ref format, ref parseInfo, dtfi, ref result))
						{
							return true;
						}
						result.SetBadDateTimeFailure();
						return false;
					}
				}
				else if (format.MatchSpecifiedWord("GMT"))
				{
					format.Index += "GMT".Length - 1;
					result.flags |= ParseFlags.TimeZoneUsed;
					result.timeZoneOffset = TimeSpan.Zero;
					if (!str.Match("GMT"))
					{
						result.SetBadDateTimeFailure();
						return false;
					}
				}
				else if (!str.Match(@char))
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				break;
			}
			return true;
		}

		internal static bool TryParseQuoteString(ReadOnlySpan<char> format, int pos, StringBuilder result, out int returnValue)
		{
			returnValue = 0;
			int length = format.Length;
			int num = pos;
			char c = format[pos++];
			bool flag = false;
			while (pos < length)
			{
				char c2 = format[pos++];
				if (c2 == c)
				{
					flag = true;
					break;
				}
				if (c2 == '\\')
				{
					if (pos >= length)
					{
						return false;
					}
					result.Append(format[pos++]);
				}
				else
				{
					result.Append(c2);
				}
			}
			if (!flag)
			{
				return false;
			}
			returnValue = pos - num;
			return true;
		}

		private static bool DoStrictParse(ReadOnlySpan<char> s, ReadOnlySpan<char> formatParam, DateTimeStyles styles, DateTimeFormatInfo dtfi, ref DateTimeResult result)
		{
			ParsingInfo parseInfo = default(ParsingInfo);
			parseInfo.Init();
			parseInfo.calendar = dtfi.Calendar;
			parseInfo.fAllowInnerWhite = (styles & DateTimeStyles.AllowInnerWhite) != 0;
			parseInfo.fAllowTrailingWhite = (styles & DateTimeStyles.AllowTrailingWhite) != 0;
			if (formatParam.Length == 1)
			{
				char c = formatParam[0];
				if (styles == DateTimeStyles.None)
				{
					switch (c)
					{
					case 'R':
					case 'r':
						ConfigureFormatR(ref dtfi, ref parseInfo, ref result);
						return ParseFormatR(s, ref parseInfo, ref result);
					case 'O':
					case 'o':
						ConfigureFormatOS(ref dtfi, ref parseInfo);
						return ParseFormatO(s, ref result);
					}
				}
				if ((result.flags & ParseFlags.CaptureOffset) != 0 && c == 'U')
				{
					result.SetBadFormatSpecifierFailure(formatParam);
					return false;
				}
				formatParam = ExpandPredefinedFormat(formatParam, ref dtfi, ref parseInfo, ref result);
			}
			result.calendar = parseInfo.calendar;
			if (parseInfo.calendar.ID == CalendarId.HEBREW)
			{
				parseInfo.parseNumberDelegate = s_hebrewNumberParser;
				parseInfo.fCustomNumberParser = true;
			}
			result.Hour = (result.Minute = (result.Second = -1));
			__DTString format = new __DTString(formatParam, dtfi, checkDigitToken: false);
			__DTString str = new __DTString(s, dtfi, checkDigitToken: false);
			if (parseInfo.fAllowTrailingWhite)
			{
				format.TrimTail();
				format.RemoveTrailingInQuoteSpaces();
				str.TrimTail();
			}
			if ((styles & DateTimeStyles.AllowLeadingWhite) != 0)
			{
				format.SkipWhiteSpaces();
				format.RemoveLeadingInQuoteSpaces();
				str.SkipWhiteSpaces();
			}
			while (format.GetNext())
			{
				if (parseInfo.fAllowInnerWhite)
				{
					str.SkipWhiteSpaces();
				}
				if (!ParseByFormat(ref str, ref format, ref parseInfo, dtfi, ref result))
				{
					return false;
				}
			}
			if (str.Index < str.Value.Length - 1)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (parseInfo.fUseTwoDigitYear && (dtfi.FormatFlags & DateTimeFormatFlags.UseHebrewRule) == 0)
			{
				if (result.Year >= 100)
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				try
				{
					result.Year = parseInfo.calendar.ToFourDigitYear(result.Year);
				}
				catch (ArgumentOutOfRangeException)
				{
					result.SetBadDateTimeFailure();
					return false;
				}
			}
			if (parseInfo.fUseHour12)
			{
				if (parseInfo.timeMark == TM.NotSet)
				{
					parseInfo.timeMark = TM.AM;
				}
				if (result.Hour > 12)
				{
					result.SetBadDateTimeFailure();
					return false;
				}
				if (parseInfo.timeMark == TM.AM)
				{
					if (result.Hour == 12)
					{
						result.Hour = 0;
					}
				}
				else
				{
					result.Hour = ((result.Hour == 12) ? 12 : (result.Hour + 12));
				}
			}
			else if ((parseInfo.timeMark == TM.AM && result.Hour >= 12) || (parseInfo.timeMark == TM.PM && result.Hour < 12))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			bool flag = result.Year == -1 && result.Month == -1 && result.Day == -1;
			if (!CheckDefaultDateTime(ref result, ref parseInfo.calendar, styles))
			{
				return false;
			}
			if (!flag && dtfi.HasYearMonthAdjustment && !dtfi.YearMonthAdjustment(ref result.Year, ref result.Month, (result.flags & ParseFlags.ParsedMonthName) != 0))
			{
				result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
				return false;
			}
			if (!parseInfo.calendar.TryToDateTime(result.Year, result.Month, result.Day, result.Hour, result.Minute, result.Second, 0, result.era, out result.parsedDate))
			{
				result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
				return false;
			}
			if (result.fraction > 0.0 && !result.parsedDate.TryAddTicks((long)Math.Round(result.fraction * 10000000.0), out result.parsedDate))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (parseInfo.dayOfWeek != -1 && parseInfo.dayOfWeek != (int)parseInfo.calendar.GetDayOfWeek(result.parsedDate))
			{
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_BadDayOfWeek");
				return false;
			}
			return DetermineTimeZoneAdjustments(ref result, styles, flag);
		}

		private static bool ParseFormatR(ReadOnlySpan<char> source, ref ParsingInfo parseInfo, ref DateTimeResult result)
		{
			if (source.Length != 29)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			uint num = source[0];
			uint num2 = source[1];
			uint num3 = source[2];
			uint num4 = source[3];
			if ((num | num2 | num3 | num4) > 127)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			DayOfWeek dayOfWeek;
			switch ((num << 24) | (num2 << 16) | (num3 << 8) | num4 | 0x20202000)
			{
			case 1937075756u:
				dayOfWeek = DayOfWeek.Sunday;
				break;
			case 1836019244u:
				dayOfWeek = DayOfWeek.Monday;
				break;
			case 1953850668u:
				dayOfWeek = DayOfWeek.Tuesday;
				break;
			case 2003133484u:
				dayOfWeek = DayOfWeek.Wednesday;
				break;
			case 1953002796u:
				dayOfWeek = DayOfWeek.Thursday;
				break;
			case 1718774060u:
				dayOfWeek = DayOfWeek.Friday;
				break;
			case 1935766572u:
				dayOfWeek = DayOfWeek.Saturday;
				break;
			default:
				result.SetBadDateTimeFailure();
				return false;
			}
			if (source[4] != ' ')
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			uint num5 = (uint)(source[5] - 48);
			uint num6 = (uint)(source[6] - 48);
			if (num5 > 9 || num6 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int day = (int)(num5 * 10 + num6);
			if (source[7] != ' ')
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			uint num7 = source[8];
			uint num8 = source[9];
			uint num9 = source[10];
			uint num10 = source[11];
			if ((num7 | num8 | num9 | num10) > 127)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int month;
			switch ((num7 << 24) | (num8 << 16) | (num9 << 8) | num10 | 0x20202000)
			{
			case 1784770080u:
				month = 1;
				break;
			case 1717920288u:
				month = 2;
				break;
			case 1835102752u:
				month = 3;
				break;
			case 1634759200u:
				month = 4;
				break;
			case 1835104544u:
				month = 5;
				break;
			case 1786080800u:
				month = 6;
				break;
			case 1786080288u:
				month = 7;
				break;
			case 1635084064u:
				month = 8;
				break;
			case 1936027680u:
				month = 9;
				break;
			case 1868788768u:
				month = 10;
				break;
			case 1852798496u:
				month = 11;
				break;
			case 1684366112u:
				month = 12;
				break;
			default:
				result.SetBadDateTimeFailure();
				return false;
			}
			uint num11 = (uint)(source[12] - 48);
			uint num12 = (uint)(source[13] - 48);
			uint num13 = (uint)(source[14] - 48);
			uint num14 = (uint)(source[15] - 48);
			if (num11 > 9 || num12 > 9 || num13 > 9 || num14 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int year = (int)(num11 * 1000 + num12 * 100 + num13 * 10 + num14);
			if (source[16] != ' ')
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			uint num15 = (uint)(source[17] - 48);
			uint num16 = (uint)(source[18] - 48);
			if (num15 > 9 || num16 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int hour = (int)(num15 * 10 + num16);
			if (source[19] != ':')
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			uint num17 = (uint)(source[20] - 48);
			uint num18 = (uint)(source[21] - 48);
			if (num17 > 9 || num18 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int minute = (int)(num17 * 10 + num18);
			if (source[22] != ':')
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			uint num19 = (uint)(source[23] - 48);
			uint num20 = (uint)(source[24] - 48);
			if (num19 > 9 || num20 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int second = (int)(num19 * 10 + num20);
			if (source[25] != ' ' || source[26] != 'G' || source[27] != 'M' || source[28] != 'T')
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (!parseInfo.calendar.TryToDateTime(year, month, day, hour, minute, second, 0, 0, out result.parsedDate))
			{
				result.SetFailure(ParseFailureKind.FormatBadDateTimeCalendar, "Format_BadDateTimeCalendar");
				return false;
			}
			if (dayOfWeek != result.parsedDate.DayOfWeek)
			{
				result.SetFailure(ParseFailureKind.FormatWithOriginalDateTime, "Format_BadDayOfWeek");
				return false;
			}
			return true;
		}

		private static bool ParseFormatO(ReadOnlySpan<char> source, ref DateTimeResult result)
		{
			if ((uint)source.Length < 27u || source[4] != '-' || source[7] != '-' || source[10] != 'T' || source[13] != ':' || source[16] != ':' || source[19] != '.')
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			uint num = (uint)(source[0] - 48);
			uint num2 = (uint)(source[1] - 48);
			uint num3 = (uint)(source[2] - 48);
			uint num4 = (uint)(source[3] - 48);
			if (num > 9 || num2 > 9 || num3 > 9 || num4 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int year = (int)(num * 1000 + num2 * 100 + num3 * 10 + num4);
			uint num5 = (uint)(source[5] - 48);
			uint num6 = (uint)(source[6] - 48);
			if (num5 > 9 || num6 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int month = (int)(num5 * 10 + num6);
			uint num7 = (uint)(source[8] - 48);
			uint num8 = (uint)(source[9] - 48);
			if (num7 > 9 || num8 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int day = (int)(num7 * 10 + num8);
			uint num9 = (uint)(source[11] - 48);
			uint num10 = (uint)(source[12] - 48);
			if (num9 > 9 || num10 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int hour = (int)(num9 * 10 + num10);
			uint num11 = (uint)(source[14] - 48);
			uint num12 = (uint)(source[15] - 48);
			if (num11 > 9 || num12 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int minute = (int)(num11 * 10 + num12);
			uint num13 = (uint)(source[17] - 48);
			uint num14 = (uint)(source[18] - 48);
			if (num13 > 9 || num14 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			int second = (int)(num13 * 10 + num14);
			uint num15 = (uint)(source[20] - 48);
			uint num16 = (uint)(source[21] - 48);
			uint num17 = (uint)(source[22] - 48);
			uint num18 = (uint)(source[23] - 48);
			uint num19 = (uint)(source[24] - 48);
			uint num20 = (uint)(source[25] - 48);
			uint num21 = (uint)(source[26] - 48);
			if (num15 > 9 || num16 > 9 || num17 > 9 || num18 > 9 || num19 > 9 || num20 > 9 || num21 > 9)
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			double num22 = (double)(num15 * 1000000 + num16 * 100000 + num17 * 10000 + num18 * 1000 + num19 * 100 + num20 * 10 + num21) / 10000000.0;
			if (!DateTime.TryCreate(year, month, day, hour, minute, second, 0, out var result2))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if (!result2.TryAddTicks((long)Math.Round(num22 * 10000000.0), out result.parsedDate))
			{
				result.SetBadDateTimeFailure();
				return false;
			}
			if ((uint)source.Length > 27u)
			{
				char c = source[27];
				switch (c)
				{
				case 'Z':
					if (source.Length != 28)
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					result.flags |= ParseFlags.TimeZoneUsed | ParseFlags.TimeZoneUtc;
					break;
				case '+':
				case '-':
				{
					int num25;
					int num26;
					if (source.Length == 33)
					{
						uint num23 = (uint)(source[28] - 48);
						uint num24 = (uint)(source[29] - 48);
						if (num23 > 9 || num24 > 9)
						{
							result.SetBadDateTimeFailure();
							return false;
						}
						num25 = (int)(num23 * 10 + num24);
						num26 = 30;
					}
					else
					{
						if (source.Length != 32)
						{
							result.SetBadDateTimeFailure();
							return false;
						}
						num25 = source[28] - 48;
						if ((uint)num25 > 9u)
						{
							result.SetBadDateTimeFailure();
							return false;
						}
						num26 = 29;
					}
					if (source[num26] != ':')
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					uint num27 = (uint)(source[num26 + 1] - 48);
					uint num28 = (uint)(source[num26 + 2] - 48);
					if (num27 > 9 || num28 > 9)
					{
						result.SetBadDateTimeFailure();
						return false;
					}
					int minutes = (int)(num27 * 10 + num28);
					result.flags |= ParseFlags.TimeZoneUsed;
					result.timeZoneOffset = new TimeSpan(num25, minutes, 0);
					if (c == '-')
					{
						result.timeZoneOffset = result.timeZoneOffset.Negate();
					}
					break;
				}
				default:
					result.SetBadDateTimeFailure();
					return false;
				}
			}
			return DetermineTimeZoneAdjustments(ref result, DateTimeStyles.None, bTimeOnly: false);
		}

		private static Exception GetDateTimeParseException(ref DateTimeResult result)
		{
			return result.failure switch
			{
				ParseFailureKind.ArgumentNull => new ArgumentNullException(result.failureArgumentName, SR.GetResourceString(result.failureMessageID)), 
				ParseFailureKind.Format => new FormatException(SR.GetResourceString(result.failureMessageID)), 
				ParseFailureKind.FormatWithParameter => new FormatException(SR.Format(SR.GetResourceString(result.failureMessageID), result.failureMessageFormatArgument)), 
				ParseFailureKind.FormatBadDateTimeCalendar => new FormatException(SR.Format(SR.GetResourceString(result.failureMessageID), new string(result.originalDateTimeString), result.calendar)), 
				ParseFailureKind.FormatWithOriginalDateTime => new FormatException(SR.Format(SR.GetResourceString(result.failureMessageID), new string(result.originalDateTimeString))), 
				ParseFailureKind.FormatWithFormatSpecifier => new FormatException(SR.Format(SR.GetResourceString(result.failureMessageID), new string(result.failedFormatSpecifier))), 
				ParseFailureKind.FormatWithOriginalDateTimeAndParameter => new FormatException(SR.Format(SR.GetResourceString(result.failureMessageID), new string(result.originalDateTimeString), result.failureMessageFormatArgument)), 
				_ => null, 
			};
		}
	}
	internal ref struct __DTString
	{
		internal ReadOnlySpan<char> Value;

		internal int Index;

		internal char m_current;

		private readonly CompareInfo m_info;

		private readonly bool m_checkDigitToken;

		private static readonly char[] WhiteSpaceChecks = new char[2] { ' ', '\u00a0' };

		internal int Length => Value.Length;

		internal CompareInfo CompareInfo => m_info;

		internal __DTString(ReadOnlySpan<char> str, DateTimeFormatInfo dtfi, bool checkDigitToken)
			: this(str, dtfi)
		{
			m_checkDigitToken = checkDigitToken;
		}

		internal __DTString(ReadOnlySpan<char> str, DateTimeFormatInfo dtfi)
		{
			Index = -1;
			Value = str;
			m_current = '\0';
			m_info = dtfi.CompareInfo;
			m_checkDigitToken = (dtfi.FormatFlags & DateTimeFormatFlags.UseDigitPrefixInTokens) != 0;
		}

		internal bool GetNext()
		{
			Index++;
			if (Index < Length)
			{
				m_current = Value[Index];
				return true;
			}
			return false;
		}

		internal bool AtEnd()
		{
			if (Index >= Length)
			{
				return true;
			}
			return false;
		}

		internal bool Advance(int count)
		{
			Index += count;
			if (Index < Length)
			{
				m_current = Value[Index];
				return true;
			}
			return false;
		}

		internal void GetRegularToken(out TokenType tokenType, out int tokenValue, DateTimeFormatInfo dtfi)
		{
			tokenValue = 0;
			if (Index >= Length)
			{
				tokenType = TokenType.EndOfString;
				return;
			}
			while (true)
			{
				if (DateTimeParse.IsDigit(m_current))
				{
					tokenValue = m_current - 48;
					int index = Index;
					while (++Index < Length)
					{
						m_current = Value[Index];
						int num = m_current - 48;
						if (num < 0 || num > 9)
						{
							break;
						}
						tokenValue = tokenValue * 10 + num;
					}
					if (Index - index > 8)
					{
						tokenType = TokenType.NumberToken;
						tokenValue = -1;
					}
					else if (Index - index < 3)
					{
						tokenType = TokenType.NumberToken;
					}
					else
					{
						tokenType = TokenType.YearNumberToken;
					}
					if (m_checkDigitToken)
					{
						int index2 = Index;
						char current = m_current;
						Index = index;
						m_current = Value[Index];
						if (dtfi.Tokenize(TokenType.RegularTokenMask, out var tokenType2, out var tokenValue2, ref this))
						{
							tokenType = tokenType2;
							tokenValue = tokenValue2;
						}
						else
						{
							Index = index2;
							m_current = current;
						}
					}
					break;
				}
				if (char.IsWhiteSpace(m_current))
				{
					do
					{
						if (++Index < Length)
						{
							m_current = Value[Index];
							continue;
						}
						tokenType = TokenType.EndOfString;
						return;
					}
					while (char.IsWhiteSpace(m_current));
					continue;
				}
				dtfi.Tokenize(TokenType.RegularTokenMask, out tokenType, out tokenValue, ref this);
				break;
			}
		}

		internal TokenType GetSeparatorToken(DateTimeFormatInfo dtfi, out int indexBeforeSeparator, out char charBeforeSeparator)
		{
			indexBeforeSeparator = Index;
			charBeforeSeparator = m_current;
			if (!SkipWhiteSpaceCurrent())
			{
				return TokenType.SEP_End;
			}
			TokenType tokenType;
			if (!DateTimeParse.IsDigit(m_current))
			{
				if (!dtfi.Tokenize(TokenType.SeparatorTokenMask, out tokenType, out var _, ref this))
				{
					tokenType = TokenType.SEP_Space;
					return tokenType;
				}
				return tokenType;
			}
			tokenType = TokenType.SEP_Space;
			return tokenType;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool MatchSpecifiedWord(string target)
		{
			if (Index + target.Length <= Length)
			{
				return m_info.Compare(Value.Slice(Index, target.Length), target, CompareOptions.IgnoreCase) == 0;
			}
			return false;
		}

		internal bool MatchSpecifiedWords(string target, bool checkWordBoundary, ref int matchLength)
		{
			int num = Value.Length - Index;
			matchLength = target.Length;
			if (matchLength > num || m_info.Compare(Value.Slice(Index, matchLength), target, CompareOptions.IgnoreCase) != 0)
			{
				int num2 = 0;
				int num3 = Index;
				int num4 = target.IndexOfAny(WhiteSpaceChecks, num2);
				if (num4 == -1)
				{
					return false;
				}
				do
				{
					int num5 = num4 - num2;
					if (num3 >= Value.Length - num5)
					{
						return false;
					}
					if (num5 == 0)
					{
						matchLength--;
					}
					else
					{
						if (!char.IsWhiteSpace(Value[num3 + num5]))
						{
							return false;
						}
						if (m_info.CompareOptionIgnoreCase(Value.Slice(num3, num5), target.AsSpan(num2, num5)) != 0)
						{
							return false;
						}
						num3 = num3 + num5 + 1;
					}
					num2 = num4 + 1;
					while (num3 < Value.Length && char.IsWhiteSpace(Value[num3]))
					{
						num3++;
						matchLength++;
					}
				}
				while ((num4 = target.IndexOfAny(WhiteSpaceChecks, num2)) >= 0);
				if (num2 < target.Length)
				{
					int num6 = target.Length - num2;
					if (num3 > Value.Length - num6)
					{
						return false;
					}
					if (m_info.CompareOptionIgnoreCase(Value.Slice(num3, num6), target.AsSpan(num2, num6)) != 0)
					{
						return false;
					}
				}
			}
			if (checkWordBoundary)
			{
				int num7 = Index + matchLength;
				if (num7 < Value.Length && char.IsLetter(Value[num7]))
				{
					return false;
				}
			}
			return true;
		}

		internal bool Match(string str)
		{
			if (++Index >= Length)
			{
				return false;
			}
			if (str.Length > Value.Length - Index)
			{
				return false;
			}
			if (m_info.Compare(Value.Slice(Index, str.Length), str, CompareOptions.Ordinal) == 0)
			{
				Index += str.Length - 1;
				return true;
			}
			return false;
		}

		internal bool Match(char ch)
		{
			if (++Index >= Length)
			{
				return false;
			}
			if (Value[Index] == ch)
			{
				m_current = ch;
				return true;
			}
			Index--;
			return false;
		}

		internal int MatchLongestWords(string[] words, ref int maxMatchStrLen)
		{
			int result = -1;
			for (int i = 0; i < words.Length; i++)
			{
				string text = words[i];
				int matchLength = text.Length;
				if (MatchSpecifiedWords(text, checkWordBoundary: false, ref matchLength) && matchLength > maxMatchStrLen)
				{
					maxMatchStrLen = matchLength;
					result = i;
				}
			}
			return result;
		}

		internal int GetRepeatCount()
		{
			char c = Value[Index];
			int i;
			for (i = Index + 1; i < Length && Value[i] == c; i++)
			{
			}
			int result = i - Index;
			Index = i - 1;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool GetNextDigit()
		{
			if (++Index < Length)
			{
				return DateTimeParse.IsDigit(Value[Index]);
			}
			return false;
		}

		internal char GetChar()
		{
			return Value[Index];
		}

		internal int GetDigit()
		{
			return Value[Index] - 48;
		}

		internal void SkipWhiteSpaces()
		{
			while (Index + 1 < Length)
			{
				char c = Value[Index + 1];
				if (!char.IsWhiteSpace(c))
				{
					break;
				}
				Index++;
			}
		}

		internal bool SkipWhiteSpaceCurrent()
		{
			if (Index >= Length)
			{
				return false;
			}
			if (!char.IsWhiteSpace(m_current))
			{
				return true;
			}
			while (++Index < Length)
			{
				m_current = Value[Index];
				if (!char.IsWhiteSpace(m_current))
				{
					return true;
				}
			}
			return false;
		}

		internal void TrimTail()
		{
			int num = Length - 1;
			while (num >= 0 && char.IsWhiteSpace(Value[num]))
			{
				num--;
			}
			Value = Value.Slice(0, num + 1);
		}

		internal void RemoveTrailingInQuoteSpaces()
		{
			int num = Length - 1;
			if (num <= 1)
			{
				return;
			}
			char c = Value[num];
			if ((c == '\'' || c == '"') && char.IsWhiteSpace(Value[num - 1]))
			{
				num--;
				while (num >= 1 && char.IsWhiteSpace(Value[num - 1]))
				{
					num--;
				}
				Span<char> span = new char[num + 1];
				span[num] = c;
				Value.Slice(0, num).CopyTo(span);
				Value = span;
			}
		}

		internal void RemoveLeadingInQuoteSpaces()
		{
			if (Length <= 2)
			{
				return;
			}
			int i = 0;
			char c = Value[i];
			if (c == '\'' || c == '"')
			{
				for (; i + 1 < Length && char.IsWhiteSpace(Value[i + 1]); i++)
				{
				}
				if (i != 0)
				{
					Span<char> span = new char[Value.Length - i];
					span[0] = c;
					Value.Slice(i + 1).CopyTo(span.Slice(1));
					Value = span;
				}
			}
		}

		internal DTSubString GetSubString()
		{
			DTSubString result = default(DTSubString);
			result.index = Index;
			result.s = Value;
			while (Index + result.length < Length)
			{
				char c = Value[Index + result.length];
				DTSubStringType dTSubStringType = ((c < '0' || c > '9') ? DTSubStringType.Other : DTSubStringType.Number);
				if (result.length == 0)
				{
					result.type = dTSubStringType;
				}
				else if (result.type != dTSubStringType)
				{
					break;
				}
				result.length++;
				if (dTSubStringType != DTSubStringType.Number)
				{
					break;
				}
				if (result.length > 8)
				{
					result.type = DTSubStringType.Invalid;
					return result;
				}
				int num = c - 48;
				result.value = result.value * 10 + num;
			}
			if (result.length == 0)
			{
				result.type = DTSubStringType.End;
				return result;
			}
			return result;
		}

		internal void ConsumeSubString(DTSubString sub)
		{
			Index = sub.index + sub.length;
			if (Index < Length)
			{
				m_current = Value[Index];
			}
		}
	}
	internal enum DTSubStringType
	{
		Unknown,
		Invalid,
		Number,
		End,
		Other
	}
	internal ref struct DTSubString
	{
		internal ReadOnlySpan<char> s;

		internal int index;

		internal int length;

		internal DTSubStringType type;

		internal int value;

		internal char this[int relativeIndex] => s[index + relativeIndex];
	}
	internal struct DateTimeToken
	{
		internal DateTimeParse.DTT dtt;

		internal TokenType suffix;

		internal int num;
	}
	internal struct DateTimeRawInfo
	{
		private unsafe int* num;

		internal int numCount;

		internal int month;

		internal int year;

		internal int dayOfWeek;

		internal int era;

		internal DateTimeParse.TM timeMark;

		internal double fraction;

		internal bool hasSameDateAndTimeSeparators;

		internal unsafe void Init(int* numberBuffer)
		{
			month = -1;
			year = -1;
			dayOfWeek = -1;
			era = -1;
			timeMark = DateTimeParse.TM.NotSet;
			fraction = -1.0;
			num = numberBuffer;
		}

		internal unsafe void AddNumber(int value)
		{
			num[numCount++] = value;
		}

		internal unsafe int GetNumber(int index)
		{
			return num[index];
		}
	}
	internal enum ParseFailureKind
	{
		None,
		ArgumentNull,
		Format,
		FormatWithParameter,
		FormatWithOriginalDateTime,
		FormatWithFormatSpecifier,
		FormatWithOriginalDateTimeAndParameter,
		FormatBadDateTimeCalendar,
		WrongParts
	}
	[Flags]
	internal enum ParseFlags
	{
		HaveYear = 1,
		HaveMonth = 2,
		HaveDay = 4,
		HaveHour = 8,
		HaveMinute = 0x10,
		HaveSecond = 0x20,
		HaveTime = 0x40,
		HaveDate = 0x80,
		TimeZoneUsed = 0x100,
		TimeZoneUtc = 0x200,
		ParsedMonthName = 0x400,
		CaptureOffset = 0x800,
		YearDefault = 0x1000,
		Rfc1123Pattern = 0x2000,
		UtcSortPattern = 0x4000
	}
	internal ref struct DateTimeResult
	{
		internal int Year;

		internal int Month;

		internal int Day;

		internal int Hour;

		internal int Minute;

		internal int Second;

		internal double fraction;

		internal int era;

		internal ParseFlags flags;

		internal TimeSpan timeZoneOffset;

		internal Calendar calendar;

		internal DateTime parsedDate;

		internal ParseFailureKind failure;

		internal string failureMessageID;

		internal object failureMessageFormatArgument;

		internal string failureArgumentName;

		internal ReadOnlySpan<char> originalDateTimeString;

		internal ReadOnlySpan<char> failedFormatSpecifier;

		internal void Init(ReadOnlySpan<char> originalDateTimeString)
		{
			this.originalDateTimeString = originalDateTimeString;
			Year = -1;
			Month = -1;
			Day = -1;
			fraction = -1.0;
			era = -1;
		}

		internal void SetDate(int year, int month, int day)
		{
			Year = year;
			Month = month;
			Day = day;
		}

		internal void SetBadFormatSpecifierFailure()
		{
			SetBadFormatSpecifierFailure(ReadOnlySpan<char>.Empty);
		}

		internal void SetBadFormatSpecifierFailure(ReadOnlySpan<char> failedFormatSpecifier)
		{
			failure = ParseFailureKind.FormatWithFormatSpecifier;
			failureMessageID = "Format_BadFormatSpecifier";
			this.failedFormatSpecifier = failedFormatSpecifier;
		}

		internal void SetBadDateTimeFailure()
		{
			failure = ParseFailureKind.FormatWithOriginalDateTime;
			failureMessageID = "Format_BadDateTime";
			failureMessageFormatArgument = null;
		}

		internal void SetFailure(ParseFailureKind failure, string failureMessageID)
		{
			this.failure = failure;
			this.failureMessageID = failureMessageID;
			failureMessageFormatArgument = null;
		}

		internal void SetFailure(ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument)
		{
			this.failure = failure;
			this.failureMessageID = failureMessageID;
			this.failureMessageFormatArgument = failureMessageFormatArgument;
		}

		internal void SetFailure(ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument, string failureArgumentName)
		{
			this.failure = failure;
			this.failureMessageID = failureMessageID;
			this.failureMessageFormatArgument = failureMessageFormatArgument;
			this.failureArgumentName = failureArgumentName;
		}
	}
	internal struct ParsingInfo
	{
		internal Calendar calendar;

		internal int dayOfWeek;

		internal DateTimeParse.TM timeMark;

		internal bool fUseHour12;

		internal bool fUseTwoDigitYear;

		internal bool fAllowInnerWhite;

		internal bool fAllowTrailingWhite;

		internal bool fCustomNumberParser;

		internal DateTimeParse.MatchNumberDelegate parseNumberDelegate;

		internal void Init()
		{
			dayOfWeek = -1;
			timeMark = DateTimeParse.TM.NotSet;
		}
	}
	internal enum TokenType
	{
		NumberToken = 1,
		YearNumberToken = 2,
		Am = 3,
		Pm = 4,
		MonthToken = 5,
		EndOfString = 6,
		DayOfWeekToken = 7,
		TimeZoneToken = 8,
		EraToken = 9,
		DateWordToken = 10,
		UnknownToken = 11,
		HebrewNumber = 12,
		JapaneseEraToken = 13,
		TEraToken = 14,
		IgnorableSymbol = 15,
		SEP_Unk = 256,
		SEP_End = 512,
		SEP_Space = 768,
		SEP_Am = 1024,
		SEP_Pm = 1280,
		SEP_Date = 1536,
		SEP_Time = 1792,
		SEP_YearSuff = 2048,
		SEP_MonthSuff = 2304,
		SEP_DaySuff = 2560,
		SEP_HourSuff = 2816,
		SEP_MinuteSuff = 3072,
		SEP_SecondSuff = 3328,
		SEP_LocalTimeMark = 3584,
		SEP_DateOrOffset = 3840,
		RegularTokenMask = 255,
		SeparatorTokenMask = 65280
	}
	[Serializable]
	[NonVersionable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Guid : ISpanFormattable, IFormattable, IComparable, IComparable<Guid>, IEquatable<Guid>, IComparisonOperators<Guid, Guid>, IEqualityOperators<Guid, Guid>, ISpanParseable<Guid>, IParseable<Guid>
	{
		private enum GuidParseThrowStyle : byte
		{
			None,
			All,
			AllButOverflow
		}

		[StructLayout(LayoutKind.Explicit)]
		private struct GuidResult
		{
			[FieldOffset(0)]
			internal uint _a;

			[FieldOffset(4)]
			internal uint _bc;

			[FieldOffset(4)]
			internal ushort _b;

			[FieldOffset(6)]
			internal ushort _c;

			[FieldOffset(8)]
			internal uint _defg;

			[FieldOffset(8)]
			internal ushort _de;

			[FieldOffset(8)]
			internal byte _d;

			[FieldOffset(10)]
			internal ushort _fg;

			[FieldOffset(12)]
			internal uint _hijk;

			[FieldOffset(16)]
			private readonly GuidParseThrowStyle _throwStyle;

			internal GuidResult(GuidParseThrowStyle canThrow)
			{
				this = default(GuidResult);
				_throwStyle = canThrow;
			}

			internal readonly void SetFailure(bool overflow, string failureMessageID)
			{
				if (_throwStyle == GuidParseThrowStyle.None)
				{
					return;
				}
				if (overflow)
				{
					if (_throwStyle == GuidParseThrowStyle.All)
					{
						throw new OverflowException(SR.GetResourceString(failureMessageID));
					}
					throw new FormatException(SR.Format_GuidUnrecognized);
				}
				throw new FormatException(SR.GetResourceString(failureMessageID));
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public readonly Guid ToGuid()
			{
				return Unsafe.As<GuidResult, Guid>(ref Unsafe.AsRef(in this));
			}
		}

		public static readonly Guid Empty;

		private readonly int _a;

		private readonly short _b;

		private readonly short _c;

		private readonly byte _d;

		private readonly byte _e;

		private readonly byte _f;

		private readonly byte _g;

		private readonly byte _h;

		private readonly byte _i;

		private readonly byte _j;

		private readonly byte _k;

		public Guid(byte[] b)
			: this(new ReadOnlySpan<byte>(b ?? throw new ArgumentNullException("b")))
		{
		}

		public Guid(ReadOnlySpan<byte> b)
		{
			if (b.Length != 16)
			{
				throw new ArgumentException(SR.Format(SR.Arg_GuidArrayCtor, "16"), "b");
			}
			_ = BitConverter.IsLittleEndian;
			this = MemoryMarshal.Read<Guid>(b);
		}

		[CLSCompliant(false)]
		public Guid(uint a, ushort b, ushort c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k)
		{
			_a = (int)a;
			_b = (short)b;
			_c = (short)c;
			_d = d;
			_e = e;
			_f = f;
			_g = g;
			_h = h;
			_i = i;
			_j = j;
			_k = k;
		}

		public Guid(int a, short b, short c, byte[] d)
		{
			if (d == null)
			{
				throw new ArgumentNullException("d");
			}
			if (d.Length != 8)
			{
				throw new ArgumentException(SR.Format(SR.Arg_GuidArrayCtor, "8"), "d");
			}
			_a = a;
			_b = b;
			_c = c;
			_k = d[7];
			_d = d[0];
			_e = d[1];
			_f = d[2];
			_g = d[3];
			_h = d[4];
			_i = d[5];
			_j = d[6];
		}

		public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k)
		{
			_a = a;
			_b = b;
			_c = c;
			_d = d;
			_e = e;
			_f = f;
			_g = g;
			_h = h;
			_i = i;
			_j = j;
			_k = k;
		}

		public Guid(string g)
		{
			if (g == null)
			{
				throw new ArgumentNullException("g");
			}
			GuidResult result = new GuidResult(GuidParseThrowStyle.All);
			bool flag = TryParseGuid(g, ref result);
			this = result.ToGuid();
		}

		public static Guid Parse(string input)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			return Parse((ReadOnlySpan<char>)input);
		}

		public static Guid Parse(ReadOnlySpan<char> input)
		{
			GuidResult result = new GuidResult(GuidParseThrowStyle.AllButOverflow);
			bool flag = TryParseGuid(input, ref result);
			return result.ToGuid();
		}

		public static bool TryParse([NotNullWhen(true)] string? input, out Guid result)
		{
			if (input == null)
			{
				result = default(Guid);
				return false;
			}
			return TryParse((ReadOnlySpan<char>)input, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> input, out Guid result)
		{
			GuidResult result2 = new GuidResult(GuidParseThrowStyle.None);
			if (TryParseGuid(input, ref result2))
			{
				result = result2.ToGuid();
				return true;
			}
			result = default(Guid);
			return false;
		}

		public static Guid ParseExact(string input, string format)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			ReadOnlySpan<char> input2 = input;
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			return ParseExact(input2, format);
		}

		public static Guid ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format)
		{
			if (format.Length != 1)
			{
				throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
			}
			input = input.Trim();
			GuidResult result = new GuidResult(GuidParseThrowStyle.AllButOverflow);
			bool flag = (char)(ushort)(format[0] | 0x20) switch
			{
				'd' => TryParseExactD(input, ref result), 
				'n' => TryParseExactN(input, ref result), 
				'b' => TryParseExactB(input, ref result), 
				'p' => TryParseExactP(input, ref result), 
				'x' => TryParseExactX(input, ref result), 
				_ => throw new FormatException(SR.Format_InvalidGuidFormatSpecification), 
			};
			return result.ToGuid();
		}

		public static bool TryParseExact([NotNullWhen(true)] string? input, [NotNullWhen(true)] string? format, out Guid result)
		{
			if (input == null)
			{
				result = default(Guid);
				return false;
			}
			return TryParseExact((ReadOnlySpan<char>)input, (ReadOnlySpan<char>)format, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, out Guid result)
		{
			if (format.Length != 1)
			{
				result = default(Guid);
				return false;
			}
			input = input.Trim();
			GuidResult result2 = new GuidResult(GuidParseThrowStyle.None);
			bool flag = false;
			switch ((char)(ushort)(format[0] | 0x20))
			{
			case 'd':
				flag = TryParseExactD(input, ref result2);
				break;
			case 'n':
				flag = TryParseExactN(input, ref result2);
				break;
			case 'b':
				flag = TryParseExactB(input, ref result2);
				break;
			case 'p':
				flag = TryParseExactP(input, ref result2);
				break;
			case 'x':
				flag = TryParseExactX(input, ref result2);
				break;
			}
			if (flag)
			{
				result = result2.ToGuid();
				return true;
			}
			result = default(Guid);
			return false;
		}

		private static bool TryParseGuid(ReadOnlySpan<char> guidString, ref GuidResult result)
		{
			guidString = guidString.Trim();
			if (guidString.Length == 0)
			{
				result.SetFailure(overflow: false, "Format_GuidUnrecognized");
				return false;
			}
			return guidString[0] switch
			{
				'(' => TryParseExactP(guidString, ref result), 
				'{' => guidString.Contains('-') ? TryParseExactB(guidString, ref result) : TryParseExactX(guidString, ref result), 
				_ => guidString.Contains('-') ? TryParseExactD(guidString, ref result) : TryParseExactN(guidString, ref result), 
			};
		}

		private static bool TryParseExactB(ReadOnlySpan<char> guidString, ref GuidResult result)
		{
			if (guidString.Length != 38 || guidString[0] != '{' || guidString[37] != '}')
			{
				result.SetFailure(overflow: false, "Format_GuidInvLen");
				return false;
			}
			return TryParseExactD(guidString.Slice(1, 36), ref result);
		}

		private static bool TryParseExactD(ReadOnlySpan<char> guidString, ref GuidResult result)
		{
			if (guidString.Length != 36 || guidString[8] != '-' || guidString[13] != '-' || guidString[18] != '-' || guidString[23] != '-')
			{
				result.SetFailure(overflow: false, (guidString.Length != 36) ? "Format_GuidInvLen" : "Format_GuidDashes");
				return false;
			}
			Span<byte> span = MemoryMarshal.AsBytes(new Span<GuidResult>(ref result, 1));
			int invalidIfNegative = 0;
			span[0] = DecodeByte(guidString[6], guidString[7], ref invalidIfNegative);
			span[1] = DecodeByte(guidString[4], guidString[5], ref invalidIfNegative);
			span[2] = DecodeByte(guidString[2], guidString[3], ref invalidIfNegative);
			span[3] = DecodeByte(guidString[0], guidString[1], ref invalidIfNegative);
			span[4] = DecodeByte(guidString[11], guidString[12], ref invalidIfNegative);
			span[5] = DecodeByte(guidString[9], guidString[10], ref invalidIfNegative);
			span[6] = DecodeByte(guidString[16], guidString[17], ref invalidIfNegative);
			span[7] = DecodeByte(guidString[14], guidString[15], ref invalidIfNegative);
			span[8] = DecodeByte(guidString[19], guidString[20], ref invalidIfNegative);
			span[9] = DecodeByte(guidString[21], guidString[22], ref invalidIfNegative);
			span[10] = DecodeByte(guidString[24], guidString[25], ref invalidIfNegative);
			span[11] = DecodeByte(guidString[26], guidString[27], ref invalidIfNegative);
			span[12] = DecodeByte(guidString[28], guidString[29], ref invalidIfNegative);
			span[13] = DecodeByte(guidString[30], guidString[31], ref invalidIfNegative);
			span[14] = DecodeByte(guidString[32], guidString[33], ref invalidIfNegative);
			span[15] = DecodeByte(guidString[34], guidString[35], ref invalidIfNegative);
			if (invalidIfNegative >= 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return true;
			}
			if (guidString.IndexOfAny('X', 'x', '+') != -1 && TryCompatParsing(guidString, ref result))
			{
				return true;
			}
			result.SetFailure(overflow: false, "Format_GuidInvalidChar");
			return false;
			static bool TryCompatParsing(ReadOnlySpan<char> guidString, ref GuidResult result)
			{
				if (TryParseHex(guidString.Slice(0, 8), out result._a) && TryParseHex(guidString.Slice(9, 4), out var result2))
				{
					result._b = (ushort)result2;
					if (TryParseHex(guidString.Slice(14, 4), out result2))
					{
						result._c = (ushort)result2;
						if (TryParseHex(guidString.Slice(19, 4), out result2))
						{
							if (!BitConverter.IsLittleEndian)
							{
							}
							result._de = BinaryPrimitives.ReverseEndianness((ushort)result2);
							if (TryParseHex(guidString.Slice(24, 4), out result2))
							{
								if (!BitConverter.IsLittleEndian)
								{
								}
								result._fg = BinaryPrimitives.ReverseEndianness((ushort)result2);
								if (Number.TryParseUInt32HexNumberStyle(guidString.Slice(28, 8), NumberStyles.AllowHexSpecifier, out result2) == Number.ParsingStatus.OK)
								{
									if (!BitConverter.IsLittleEndian)
									{
									}
									result._hijk = BinaryPrimitives.ReverseEndianness(result2);
									return true;
								}
							}
						}
					}
				}
				return false;
			}
		}

		private static bool TryParseExactN(ReadOnlySpan<char> guidString, ref GuidResult result)
		{
			if (guidString.Length != 32)
			{
				result.SetFailure(overflow: false, "Format_GuidInvLen");
				return false;
			}
			Span<byte> span = MemoryMarshal.AsBytes(new Span<GuidResult>(ref result, 1));
			int invalidIfNegative = 0;
			span[0] = DecodeByte(guidString[6], guidString[7], ref invalidIfNegative);
			span[1] = DecodeByte(guidString[4], guidString[5], ref invalidIfNegative);
			span[2] = DecodeByte(guidString[2], guidString[3], ref invalidIfNegative);
			span[3] = DecodeByte(guidString[0], guidString[1], ref invalidIfNegative);
			span[4] = DecodeByte(guidString[10], guidString[11], ref invalidIfNegative);
			span[5] = DecodeByte(guidString[8], guidString[9], ref invalidIfNegative);
			span[6] = DecodeByte(guidString[14], guidString[15], ref invalidIfNegative);
			span[7] = DecodeByte(guidString[12], guidString[13], ref invalidIfNegative);
			span[8] = DecodeByte(guidString[16], guidString[17], ref invalidIfNegative);
			span[9] = DecodeByte(guidString[18], guidString[19], ref invalidIfNegative);
			span[10] = DecodeByte(guidString[20], guidString[21], ref invalidIfNegative);
			span[11] = DecodeByte(guidString[22], guidString[23], ref invalidIfNegative);
			span[12] = DecodeByte(guidString[24], guidString[25], ref invalidIfNegative);
			span[13] = DecodeByte(guidString[26], guidString[27], ref invalidIfNegative);
			span[14] = DecodeByte(guidString[28], guidString[29], ref invalidIfNegative);
			span[15] = DecodeByte(guidString[30], guidString[31], ref invalidIfNegative);
			if (invalidIfNegative >= 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return true;
			}
			result.SetFailure(overflow: false, "Format_GuidInvalidChar");
			return false;
		}

		private static bool TryParseExactP(ReadOnlySpan<char> guidString, ref GuidResult result)
		{
			if (guidString.Length != 38 || guidString[0] != '(' || guidString[37] != ')')
			{
				result.SetFailure(overflow: false, "Format_GuidInvLen");
				return false;
			}
			return TryParseExactD(guidString.Slice(1, 36), ref result);
		}

		private static bool TryParseExactX(ReadOnlySpan<char> guidString, ref GuidResult result)
		{
			guidString = EatAllWhitespace(guidString);
			if (guidString.Length == 0 || guidString[0] != '{')
			{
				result.SetFailure(overflow: false, "Format_GuidBrace");
				return false;
			}
			if (!IsHexPrefix(guidString, 1))
			{
				result.SetFailure(overflow: false, "Format_GuidHexPrefix");
				return false;
			}
			int num = 3;
			int num2 = guidString.Slice(num).IndexOf(',');
			if (num2 <= 0)
			{
				result.SetFailure(overflow: false, "Format_GuidComma");
				return false;
			}
			bool overflow = false;
			if (!TryParseHex(guidString.Slice(num, num2), out result._a, ref overflow) || overflow)
			{
				result.SetFailure(overflow, overflow ? "Overflow_UInt32" : "Format_GuidInvalidChar");
				return false;
			}
			if (!IsHexPrefix(guidString, num + num2 + 1))
			{
				result.SetFailure(overflow: false, "Format_GuidHexPrefix");
				return false;
			}
			num = num + num2 + 3;
			num2 = guidString.Slice(num).IndexOf(',');
			if (num2 <= 0)
			{
				result.SetFailure(overflow: false, "Format_GuidComma");
				return false;
			}
			if (!TryParseHex(guidString.Slice(num, num2), out result._b, ref overflow) || overflow)
			{
				result.SetFailure(overflow, overflow ? "Overflow_UInt32" : "Format_GuidInvalidChar");
				return false;
			}
			if (!IsHexPrefix(guidString, num + num2 + 1))
			{
				result.SetFailure(overflow: false, "Format_GuidHexPrefix");
				return false;
			}
			num = num + num2 + 3;
			num2 = guidString.Slice(num).IndexOf(',');
			if (num2 <= 0)
			{
				result.SetFailure(overflow: false, "Format_GuidComma");
				return false;
			}
			if (!TryParseHex(guidString.Slice(num, num2), out result._c, ref overflow) || overflow)
			{
				result.SetFailure(overflow, overflow ? "Overflow_UInt32" : "Format_GuidInvalidChar");
				return false;
			}
			if ((uint)guidString.Length <= (uint)(num + num2 + 1) || guidString[num + num2 + 1] != '{')
			{
				result.SetFailure(overflow: false, "Format_GuidBrace");
				return false;
			}
			num2++;
			for (int i = 0; i < 8; i++)
			{
				if (!IsHexPrefix(guidString, num + num2 + 1))
				{
					result.SetFailure(overflow: false, "Format_GuidHexPrefix");
					return false;
				}
				num = num + num2 + 3;
				if (i < 7)
				{
					num2 = guidString.Slice(num).IndexOf(',');
					if (num2 <= 0)
					{
						result.SetFailure(overflow: false, "Format_GuidComma");
						return false;
					}
				}
				else
				{
					num2 = guidString.Slice(num).IndexOf('}');
					if (num2 <= 0)
					{
						result.SetFailure(overflow: false, "Format_GuidBraceAfterLastNumber");
						return false;
					}
				}
				if (!TryParseHex(guidString.Slice(num, num2), out uint result2, ref overflow) || overflow || result2 > 255)
				{
					result.SetFailure(overflow, overflow ? "Overflow_UInt32" : ((result2 > 255) ? "Overflow_Byte" : "Format_GuidInvalidChar"));
					return false;
				}
				Unsafe.Add(ref result._d, i) = (byte)result2;
			}
			if (num + num2 + 1 >= guidString.Length || guidString[num + num2 + 1] != '}')
			{
				result.SetFailure(overflow: false, "Format_GuidEndBrace");
				return false;
			}
			if (num + num2 + 1 != guidString.Length - 1)
			{
				result.SetFailure(overflow: false, "Format_ExtraJunkAtEnd");
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static byte DecodeByte(nuint ch1, nuint ch2, ref int invalidIfNegative)
		{
			ReadOnlySpan<byte> charToHexLookup = HexConverter.CharToHexLookup;
			int num = -1;
			if (ch1 < (nuint)charToHexLookup.Length)
			{
				num = (sbyte)Unsafe.Add(ref MemoryMarshal.GetReference(charToHexLookup), (nint)ch1);
			}
			num <<= 4;
			int num2 = -1;
			if (ch2 < (nuint)charToHexLookup.Length)
			{
				num2 = (sbyte)Unsafe.Add(ref MemoryMarshal.GetReference(charToHexLookup), (nint)ch2);
			}
			int num3 = num | num2;
			invalidIfNegative |= num3;
			return (byte)num3;
		}

		private static bool TryParseHex(ReadOnlySpan<char> guidString, out ushort result, ref bool overflow)
		{
			uint result2;
			bool result3 = TryParseHex(guidString, out result2, ref overflow);
			result = (ushort)result2;
			return result3;
		}

		private static bool TryParseHex(ReadOnlySpan<char> guidString, out uint result)
		{
			bool overflow = false;
			return TryParseHex(guidString, out result, ref overflow);
		}

		private static bool TryParseHex(ReadOnlySpan<char> guidString, out uint result, ref bool overflow)
		{
			if (guidString.Length != 0)
			{
				if (guidString[0] == '+')
				{
					guidString = guidString.Slice(1);
				}
				if ((uint)guidString.Length > 1u && guidString[0] == '0' && (guidString[1] | 0x20) == 120)
				{
					guidString = guidString.Slice(2);
				}
			}
			int i;
			for (i = 0; i < guidString.Length && guidString[i] == '0'; i++)
			{
			}
			int num = 0;
			uint num2 = 0u;
			for (; i < guidString.Length; i++)
			{
				char c = guidString[i];
				int num3 = HexConverter.FromChar(c);
				if (num3 == 255)
				{
					if (num > 8)
					{
						overflow = true;
					}
					result = 0u;
					return false;
				}
				num2 = num2 * 16 + (uint)num3;
				num++;
			}
			if (num > 8)
			{
				overflow = true;
			}
			result = num2;
			return true;
		}

		private static ReadOnlySpan<char> EatAllWhitespace(ReadOnlySpan<char> str)
		{
			int i;
			for (i = 0; i < str.Length && !char.IsWhiteSpace(str[i]); i++)
			{
			}
			if (i == str.Length)
			{
				return str;
			}
			char[] array = new char[str.Length];
			int length = 0;
			if (i > 0)
			{
				length = i;
				str.Slice(0, i).CopyTo(array);
			}
			for (; i < str.Length; i++)
			{
				char c = str[i];
				if (!char.IsWhiteSpace(c))
				{
					array[length++] = c;
				}
			}
			return new ReadOnlySpan<char>(array, 0, length);
		}

		private static bool IsHexPrefix(ReadOnlySpan<char> str, int i)
		{
			if (i + 1 < str.Length && str[i] == '0')
			{
				return (str[i + 1] | 0x20) == 120;
			}
			return false;
		}

		public byte[] ToByteArray()
		{
			byte[] array = new byte[16];
			_ = BitConverter.IsLittleEndian;
			MemoryMarshal.TryWrite(array, ref Unsafe.AsRef(in this));
			return array;
		}

		public bool TryWriteBytes(Span<byte> destination)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.TryWrite(destination, ref Unsafe.AsRef(in this));
		}

		public override string ToString()
		{
			return ToString("D", null);
		}

		public override int GetHashCode()
		{
			ref int reference = ref Unsafe.AsRef(in _a);
			return reference ^ Unsafe.Add(ref reference, 1) ^ Unsafe.Add(ref reference, 2) ^ Unsafe.Add(ref reference, 3);
		}

		public override bool Equals([NotNullWhen(true)] object? o)
		{
			if (o is Guid right)
			{
				return EqualsCore(in this, in right);
			}
			return false;
		}

		public bool Equals(Guid g)
		{
			return EqualsCore(in this, in g);
		}

		private static bool EqualsCore(in Guid left, in Guid right)
		{
			ref int reference = ref Unsafe.AsRef(in left._a);
			ref int reference2 = ref Unsafe.AsRef(in right._a);
			if (reference == reference2 && Unsafe.Add(ref reference, 1) == Unsafe.Add(ref reference2, 1) && Unsafe.Add(ref reference, 2) == Unsafe.Add(ref reference2, 2))
			{
				return Unsafe.Add(ref reference, 3) == Unsafe.Add(ref reference2, 3);
			}
			return false;
		}

		private static int GetResult(uint me, uint them)
		{
			if (me >= them)
			{
				return 1;
			}
			return -1;
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is Guid guid))
			{
				throw new ArgumentException(SR.Arg_MustBeGuid, "value");
			}
			if (guid._a != _a)
			{
				return GetResult((uint)_a, (uint)guid._a);
			}
			if (guid._b != _b)
			{
				return GetResult((uint)_b, (uint)guid._b);
			}
			if (guid._c != _c)
			{
				return GetResult((uint)_c, (uint)guid._c);
			}
			if (guid._d != _d)
			{
				return GetResult(_d, guid._d);
			}
			if (guid._e != _e)
			{
				return GetResult(_e, guid._e);
			}
			if (guid._f != _f)
			{
				return GetResult(_f, guid._f);
			}
			if (guid._g != _g)
			{
				return GetResult(_g, guid._g);
			}
			if (guid._h != _h)
			{
				return GetResult(_h, guid._h);
			}
			if (guid._i != _i)
			{
				return GetResult(_i, guid._i);
			}
			if (guid._j != _j)
			{
				return GetResult(_j, guid._j);
			}
			if (guid._k != _k)
			{
				return GetResult(_k, guid._k);
			}
			return 0;
		}

		public int CompareTo(Guid value)
		{
			if (value._a != _a)
			{
				return GetResult((uint)_a, (uint)value._a);
			}
			if (value._b != _b)
			{
				return GetResult((uint)_b, (uint)value._b);
			}
			if (value._c != _c)
			{
				return GetResult((uint)_c, (uint)value._c);
			}
			if (value._d != _d)
			{
				return GetResult(_d, value._d);
			}
			if (value._e != _e)
			{
				return GetResult(_e, value._e);
			}
			if (value._f != _f)
			{
				return GetResult(_f, value._f);
			}
			if (value._g != _g)
			{
				return GetResult(_g, value._g);
			}
			if (value._h != _h)
			{
				return GetResult(_h, value._h);
			}
			if (value._i != _i)
			{
				return GetResult(_i, value._i);
			}
			if (value._j != _j)
			{
				return GetResult(_j, value._j);
			}
			if (value._k != _k)
			{
				return GetResult(_k, value._k);
			}
			return 0;
		}

		public static bool operator ==(Guid a, Guid b)
		{
			return EqualsCore(in a, in b);
		}

		public static bool operator !=(Guid a, Guid b)
		{
			return !EqualsCore(in a, in b);
		}

		public string ToString(string? format)
		{
			return ToString(format, null);
		}

		private unsafe static int HexsToChars(char* guidChars, int a, int b)
		{
			*guidChars = HexConverter.ToCharLower(a >> 4);
			guidChars[1] = HexConverter.ToCharLower(a);
			guidChars[2] = HexConverter.ToCharLower(b >> 4);
			guidChars[3] = HexConverter.ToCharLower(b);
			return 4;
		}

		private unsafe static int HexsToCharsHexOutput(char* guidChars, int a, int b)
		{
			*guidChars = '0';
			guidChars[1] = 'x';
			guidChars[2] = HexConverter.ToCharLower(a >> 4);
			guidChars[3] = HexConverter.ToCharLower(a);
			guidChars[4] = ',';
			guidChars[5] = '0';
			guidChars[6] = 'x';
			guidChars[7] = HexConverter.ToCharLower(b >> 4);
			guidChars[8] = HexConverter.ToCharLower(b);
			return 9;
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			if (string.IsNullOrEmpty(format))
			{
				format = "D";
			}
			if (format.Length != 1)
			{
				throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
			}
			int length;
			switch (format[0])
			{
			case 'D':
			case 'd':
				length = 36;
				break;
			case 'N':
			case 'n':
				length = 32;
				break;
			case 'B':
			case 'P':
			case 'b':
			case 'p':
				length = 38;
				break;
			case 'X':
			case 'x':
				length = 68;
				break;
			default:
				throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
			}
			string text = string.FastAllocateString(length);
			int charsWritten;
			bool flag = TryFormat(new Span<char>(ref text.GetRawStringData(), text.Length), out charsWritten, format);
			return text;
		}

		public unsafe bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>))
		{
			if (format.Length == 0)
			{
				format = "D";
			}
			if (format.Length != 1)
			{
				throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
			}
			bool flag = true;
			bool flag2 = false;
			int num = 0;
			int num2;
			switch (format[0])
			{
			case 'D':
			case 'd':
				num2 = 36;
				break;
			case 'N':
			case 'n':
				flag = false;
				num2 = 32;
				break;
			case 'B':
			case 'b':
				num = 8192123;
				num2 = 38;
				break;
			case 'P':
			case 'p':
				num = 2687016;
				num2 = 38;
				break;
			case 'X':
			case 'x':
				num = 8192123;
				flag = false;
				flag2 = true;
				num2 = 68;
				break;
			default:
				throw new FormatException(SR.Format_InvalidGuidFormatSpecification);
			}
			if (destination.Length < num2)
			{
				charsWritten = 0;
				return false;
			}
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* ptr2 = ptr;
				if (num != 0)
				{
					*(ptr2++) = (char)num;
				}
				if (flag2)
				{
					*(ptr2++) = '0';
					*(ptr2++) = 'x';
					ptr2 += HexsToChars(ptr2, _a >> 24, _a >> 16);
					ptr2 += HexsToChars(ptr2, _a >> 8, _a);
					*(ptr2++) = ',';
					*(ptr2++) = '0';
					*(ptr2++) = 'x';
					ptr2 += HexsToChars(ptr2, _b >> 8, _b);
					*(ptr2++) = ',';
					*(ptr2++) = '0';
					*(ptr2++) = 'x';
					ptr2 += HexsToChars(ptr2, _c >> 8, _c);
					*(ptr2++) = ',';
					*(ptr2++) = '{';
					ptr2 += HexsToCharsHexOutput(ptr2, _d, _e);
					*(ptr2++) = ',';
					ptr2 += HexsToCharsHexOutput(ptr2, _f, _g);
					*(ptr2++) = ',';
					ptr2 += HexsToCharsHexOutput(ptr2, _h, _i);
					*(ptr2++) = ',';
					ptr2 += HexsToCharsHexOutput(ptr2, _j, _k);
					*(ptr2++) = '}';
				}
				else
				{
					ptr2 += HexsToChars(ptr2, _a >> 24, _a >> 16);
					ptr2 += HexsToChars(ptr2, _a >> 8, _a);
					if (flag)
					{
						*(ptr2++) = '-';
					}
					ptr2 += HexsToChars(ptr2, _b >> 8, _b);
					if (flag)
					{
						*(ptr2++) = '-';
					}
					ptr2 += HexsToChars(ptr2, _c >> 8, _c);
					if (flag)
					{
						*(ptr2++) = '-';
					}
					ptr2 += HexsToChars(ptr2, _d, _e);
					if (flag)
					{
						*(ptr2++) = '-';
					}
					ptr2 += HexsToChars(ptr2, _f, _g);
					ptr2 += HexsToChars(ptr2, _h, _i);
					ptr2 += HexsToChars(ptr2, _j, _k);
				}
				if (num != 0)
				{
					*(ptr2++) = (char)(num >> 16);
				}
			}
			charsWritten = num2;
			return true;
		}

		bool ISpanFormattable.TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			return TryFormat(destination, out charsWritten, format);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<Guid, Guid>.op_LessThan(Guid left, Guid right)
		{
			if (left._a != right._a)
			{
				return (uint)left._a < (uint)right._a;
			}
			if (left._b != right._b)
			{
				return (uint)left._b < (uint)right._b;
			}
			if (left._c != right._c)
			{
				return (uint)left._c < (uint)right._c;
			}
			if (left._d != right._d)
			{
				return left._d < right._d;
			}
			if (left._e != right._e)
			{
				return left._e < right._e;
			}
			if (left._f != right._f)
			{
				return left._f < right._f;
			}
			if (left._g != right._g)
			{
				return left._g < right._g;
			}
			if (left._h != right._h)
			{
				return left._h < right._h;
			}
			if (left._i != right._i)
			{
				return left._i < right._i;
			}
			if (left._j != right._j)
			{
				return left._j < right._j;
			}
			if (left._k != right._k)
			{
				return left._k < right._k;
			}
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<Guid, Guid>.op_LessThanOrEqual(Guid left, Guid right)
		{
			if (left._a != right._a)
			{
				return (uint)left._a < (uint)right._a;
			}
			if (left._b != right._b)
			{
				return (uint)left._b < (uint)right._b;
			}
			if (left._c != right._c)
			{
				return (uint)left._c < (uint)right._c;
			}
			if (left._d != right._d)
			{
				return left._d < right._d;
			}
			if (left._e != right._e)
			{
				return left._e < right._e;
			}
			if (left._f != right._f)
			{
				return left._f < right._f;
			}
			if (left._g != right._g)
			{
				return left._g < right._g;
			}
			if (left._h != right._h)
			{
				return left._h < right._h;
			}
			if (left._i != right._i)
			{
				return left._i < right._i;
			}
			if (left._j != right._j)
			{
				return left._j < right._j;
			}
			if (left._k != right._k)
			{
				return left._k < right._k;
			}
			return true;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<Guid, Guid>.op_GreaterThan(Guid left, Guid right)
		{
			if (left._a != right._a)
			{
				return (uint)left._a > (uint)right._a;
			}
			if (left._b != right._b)
			{
				return (uint)left._b > (uint)right._b;
			}
			if (left._c != right._c)
			{
				return (uint)left._c > (uint)right._c;
			}
			if (left._d != right._d)
			{
				return left._d > right._d;
			}
			if (left._e != right._e)
			{
				return left._e > right._e;
			}
			if (left._f != right._f)
			{
				return left._f > right._f;
			}
			if (left._g != right._g)
			{
				return left._g > right._g;
			}
			if (left._h != right._h)
			{
				return left._h > right._h;
			}
			if (left._i != right._i)
			{
				return left._i > right._i;
			}
			if (left._j != right._j)
			{
				return left._j > right._j;
			}
			if (left._k != right._k)
			{
				return left._k > right._k;
			}
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<Guid, Guid>.op_GreaterThanOrEqual(Guid left, Guid right)
		{
			if (left._a != right._a)
			{
				return (uint)left._a > (uint)right._a;
			}
			if (left._b != right._b)
			{
				return (uint)left._b > (uint)right._b;
			}
			if (left._c != right._c)
			{
				return (uint)left._c > (uint)right._c;
			}
			if (left._d != right._d)
			{
				return left._d > right._d;
			}
			if (left._e != right._e)
			{
				return left._e > right._e;
			}
			if (left._f != right._f)
			{
				return left._f > right._f;
			}
			if (left._g != right._g)
			{
				return left._g > right._g;
			}
			if (left._h != right._h)
			{
				return left._h > right._h;
			}
			if (left._i != right._i)
			{
				return left._i > right._i;
			}
			if (left._j != right._j)
			{
				return left._j > right._j;
			}
			if (left._k != right._k)
			{
				return left._k > right._k;
			}
			return true;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<Guid, Guid>.op_Equality(Guid left, Guid right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<Guid, Guid>.op_Inequality(Guid left, Guid right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Guid IParseable<Guid>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<Guid>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out Guid result)
		{
			return TryParse(s, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Guid ISpanParseable<Guid>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<Guid>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out Guid result)
		{
			return TryParse(s, out result);
		}

		public static Guid NewGuid()
		{
			Guid guid;
			int num = Interop.Ole32.CoCreateGuid(out guid);
			if (num != 0)
			{
				Exception ex = new Exception();
				ex.HResult = num;
				throw ex;
			}
			return guid;
		}
	}
	public readonly struct Half : IComparable, ISpanFormattable, IFormattable, IComparable<Half>, IEquatable<Half>, IBinaryFloatingPoint<Half>, IBinaryNumber<Half>, IBitwiseOperators<Half, Half, Half>, INumber<Half>, IAdditionOperators<Half, Half, Half>, IAdditiveIdentity<Half, Half>, IComparisonOperators<Half, Half>, IEqualityOperators<Half, Half>, IDecrementOperators<Half>, IDivisionOperators<Half, Half, Half>, IIncrementOperators<Half>, IModulusOperators<Half, Half, Half>, IMultiplicativeIdentity<Half, Half>, IMultiplyOperators<Half, Half, Half>, ISpanParseable<Half>, IParseable<Half>, ISubtractionOperators<Half, Half, Half>, IUnaryNegationOperators<Half, Half>, IUnaryPlusOperators<Half, Half>, IFloatingPoint<Half>, ISignedNumber<Half>, IMinMaxValue<Half>
	{
		private static readonly Half PositiveZero = new Half(0);

		private static readonly Half NegativeZero = new Half(32768);

		private readonly ushort _value;

		public static Half Epsilon => new Half(1);

		public static Half PositiveInfinity => new Half(31744);

		public static Half NegativeInfinity => new Half(64512);

		public static Half NaN => new Half(65024);

		public static Half MinValue => new Half(64511);

		public static Half MaxValue => new Half(31743);

		private sbyte Exponent => (sbyte)((_value & 0x7C00) >> 10);

		private ushort Significand => (ushort)(_value & 0x3FFu);

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IAdditiveIdentity<Half, Half>.AdditiveIdentity => PositiveZero;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.E => (Half)(float)Math.E;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Epsilon => Epsilon;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.NaN => NaN;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.NegativeInfinity => NegativeInfinity;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.NegativeZero => NegativeZero;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Pi => (Half)(float)Math.PI;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.PositiveInfinity => PositiveInfinity;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Tau => (Half)((float)Math.PI * 2f);

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IMinMaxValue<Half>.MinValue => MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IMinMaxValue<Half>.MaxValue => MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IMultiplicativeIdentity<Half, Half>.MultiplicativeIdentity => (Half)1f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.One => (Half)1f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Zero => PositiveZero;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half ISignedNumber<Half>.NegativeOne => (Half)(-1f);

		internal Half(ushort value)
		{
			_value = value;
		}

		private Half(bool sign, ushort exp, ushort sig)
		{
			_value = (ushort)(((sign ? 1 : 0) << 15) + (exp << 10) + sig);
		}

		public static bool operator <(Half left, Half right)
		{
			if (IsNaN(left) || IsNaN(right))
			{
				return false;
			}
			bool flag = IsNegative(left);
			if (flag != IsNegative(right))
			{
				if (flag)
				{
					return !AreZero(left, right);
				}
				return false;
			}
			if (left._value != right._value)
			{
				return (left._value < right._value) ^ flag;
			}
			return false;
		}

		public static bool operator >(Half left, Half right)
		{
			return right < left;
		}

		public static bool operator <=(Half left, Half right)
		{
			if (IsNaN(left) || IsNaN(right))
			{
				return false;
			}
			bool flag = IsNegative(left);
			if (flag != IsNegative(right))
			{
				if (!flag)
				{
					return AreZero(left, right);
				}
				return true;
			}
			if (left._value != right._value)
			{
				return (left._value < right._value) ^ flag;
			}
			return true;
		}

		public static bool operator >=(Half left, Half right)
		{
			return right <= left;
		}

		public static bool operator ==(Half left, Half right)
		{
			if (IsNaN(left) || IsNaN(right))
			{
				return false;
			}
			if (left._value != right._value)
			{
				return AreZero(left, right);
			}
			return true;
		}

		public static bool operator !=(Half left, Half right)
		{
			return !(left == right);
		}

		public static bool IsFinite(Half value)
		{
			return StripSign(value) < 31744;
		}

		public static bool IsInfinity(Half value)
		{
			return StripSign(value) == 31744;
		}

		public static bool IsNaN(Half value)
		{
			return StripSign(value) > 31744;
		}

		public static bool IsNegative(Half value)
		{
			return (short)value._value < 0;
		}

		public static bool IsNegativeInfinity(Half value)
		{
			return value._value == 64512;
		}

		public static bool IsNormal(Half value)
		{
			uint num = StripSign(value);
			if (num < 31744 && num != 0)
			{
				return (num & 0x7C00) != 0;
			}
			return false;
		}

		public static bool IsPositiveInfinity(Half value)
		{
			return value._value == 31744;
		}

		public static bool IsSubnormal(Half value)
		{
			uint num = StripSign(value);
			if (num < 31744 && num != 0)
			{
				return (num & 0x7C00) == 0;
			}
			return false;
		}

		public static Half Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseHalf(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo);
		}

		public static Half Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseHalf(s, style, NumberFormatInfo.CurrentInfo);
		}

		public static Half Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseHalf(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider));
		}

		public static Half Parse(string s, NumberStyles style = NumberStyles.Float | NumberStyles.AllowThousands, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseHalf(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static Half Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Float | NumberStyles.AllowThousands, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			return Number.ParseHalf(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out Half result)
		{
			if (s == null)
			{
				result = default(Half);
				return false;
			}
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, null, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out Half result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, null, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out Half result)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				result = default(Half);
				return false;
			}
			return TryParse(s.AsSpan(), style, provider, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out Half result)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			return Number.TryParseHalf(s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		private static bool AreZero(Half left, Half right)
		{
			return (ushort)((left._value | right._value) & -32769) == 0;
		}

		private static bool IsNaNOrZero(Half value)
		{
			return ((value._value - 1) & -32769) >= 31744;
		}

		private static uint StripSign(Half value)
		{
			return (ushort)(value._value & 0xFFFF7FFFu);
		}

		public int CompareTo(object? obj)
		{
			if (!(obj is Half))
			{
				if (obj != null)
				{
					throw new ArgumentException(SR.Arg_MustBeHalf);
				}
				return 1;
			}
			return CompareTo((Half)obj);
		}

		public int CompareTo(Half other)
		{
			if (this < other)
			{
				return -1;
			}
			if (this > other)
			{
				return 1;
			}
			if (this == other)
			{
				return 0;
			}
			if (IsNaN(this))
			{
				if (!IsNaN(other))
				{
					return -1;
				}
				return 0;
			}
			return 1;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Half other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(Half other)
		{
			if (_value != other._value && !AreZero(this, other))
			{
				if (IsNaN(this))
				{
					return IsNaN(other);
				}
				return false;
			}
			return true;
		}

		public override int GetHashCode()
		{
			if (IsNaNOrZero(this))
			{
				return _value & 0x7C00;
			}
			return _value;
		}

		public override string ToString()
		{
			return Number.FormatHalf(this, null, NumberFormatInfo.CurrentInfo);
		}

		public string ToString(string? format)
		{
			return Number.FormatHalf(this, format, NumberFormatInfo.CurrentInfo);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.FormatHalf(this, null, NumberFormatInfo.GetInstance(provider));
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatHalf(this, format, NumberFormatInfo.GetInstance(provider));
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatHalf(this, format, NumberFormatInfo.GetInstance(provider), destination, out charsWritten);
		}

		public static explicit operator Half(float value)
		{
			uint num = BitConverter.SingleToUInt32Bits(value);
			bool flag = (num & 0x80000000u) >> 31 != 0;
			int num2 = (int)(num & 0x7F800000) >> 23;
			uint num3 = num & 0x7FFFFFu;
			if (num2 == 255)
			{
				if (num3 != 0)
				{
					return CreateHalfNaN(flag, (ulong)num3 << 41);
				}
				if (!flag)
				{
					return PositiveInfinity;
				}
				return NegativeInfinity;
			}
			uint num4 = (num3 >> 9) | (((num3 & 0x1FFu) != 0) ? 1u : 0u);
			if (((uint)num2 | num4) == 0)
			{
				return new Half(flag, 0, 0);
			}
			return new Half(RoundPackToHalf(flag, (short)(num2 - 113), (ushort)(num4 | 0x4000u)));
		}

		public static explicit operator Half(double value)
		{
			ulong num = BitConverter.DoubleToUInt64Bits(value);
			bool flag = (num & 0x8000000000000000uL) >> 63 != 0;
			int num2 = (int)((num & 0x7FF0000000000000L) >> 52);
			ulong num3 = num & 0xFFFFFFFFFFFFFuL;
			if (num2 == 2047)
			{
				if (num3 != 0L)
				{
					return CreateHalfNaN(flag, num3 << 12);
				}
				if (!flag)
				{
					return PositiveInfinity;
				}
				return NegativeInfinity;
			}
			uint num4 = (uint)ShiftRightJam(num3, 38);
			if (((uint)num2 | num4) == 0)
			{
				return new Half(flag, 0, 0);
			}
			return new Half(RoundPackToHalf(flag, (short)(num2 - 1009), (ushort)(num4 | 0x4000u)));
		}

		public static explicit operator float(Half value)
		{
			bool flag = IsNegative(value);
			int num = value.Exponent;
			uint num2 = value.Significand;
			switch (num)
			{
			case 31:
				if (num2 != 0)
				{
					return CreateSingleNaN(flag, (ulong)num2 << 54);
				}
				if (!flag)
				{
					return float.PositiveInfinity;
				}
				return float.NegativeInfinity;
			case 0:
			{
				if (num2 == 0)
				{
					return BitConverter.UInt32BitsToSingle(flag ? 2147483648u : 0u);
				}
				(int Exp, uint Sig) tuple = NormSubnormalF16Sig(num2);
				num = tuple.Exp;
				num2 = tuple.Sig;
				num--;
				break;
			}
			}
			return CreateSingle(flag, (byte)(num + 112), num2 << 13);
		}

		public static explicit operator double(Half value)
		{
			bool flag = IsNegative(value);
			int num = value.Exponent;
			uint num2 = value.Significand;
			switch (num)
			{
			case 31:
				if (num2 != 0)
				{
					return CreateDoubleNaN(flag, (ulong)num2 << 54);
				}
				if (!flag)
				{
					return double.PositiveInfinity;
				}
				return double.NegativeInfinity;
			case 0:
			{
				if (num2 == 0)
				{
					return BitConverter.UInt64BitsToDouble(flag ? 9223372036854775808uL : 0);
				}
				(int Exp, uint Sig) tuple = NormSubnormalF16Sig(num2);
				num = tuple.Exp;
				num2 = tuple.Sig;
				num--;
				break;
			}
			}
			return CreateDouble(flag, (ushort)(num + 1008), (ulong)num2 << 42);
		}

		internal static Half Negate(Half value)
		{
			if (!IsNaN(value))
			{
				return new Half((ushort)(value._value ^ 0x8000u));
			}
			return value;
		}

		private static (int Exp, uint Sig) NormSubnormalF16Sig(uint sig)
		{
			int num = BitOperations.LeadingZeroCount(sig) - 16 - 5;
			return (1 - num, sig << num);
		}

		private static Half CreateHalfNaN(bool sign, ulong significand)
		{
			uint num = (uint)((sign ? 1 : 0) << 15);
			uint num2 = (uint)(significand >> 54);
			return BitConverter.UInt16BitsToHalf((ushort)(num | 0x7E00u | num2));
		}

		private static ushort RoundPackToHalf(bool sign, short exp, ushort sig)
		{
			int num = sig & 0xF;
			if ((uint)exp >= 29u)
			{
				if (exp < 0)
				{
					sig = (ushort)ShiftRightJam(sig, -exp);
					exp = 0;
					num = sig & 0xF;
				}
				else if (exp > 29 || sig + 8 >= 32768)
				{
					if (!sign)
					{
						return 31744;
					}
					return 64512;
				}
			}
			sig = (ushort)(sig + 8 >> 4);
			sig &= (ushort)(~((((num ^ 8) == 0) ? 1 : 0) & 1));
			if (sig == 0)
			{
				exp = 0;
			}
			return new Half(sign, (ushort)exp, sig)._value;
		}

		private static uint ShiftRightJam(uint i, int dist)
		{
			if (dist >= 31)
			{
				if (i == 0)
				{
					return 0u;
				}
				return 1u;
			}
			return (i >> dist) | ((i << -dist != 0) ? 1u : 0u);
		}

		private static ulong ShiftRightJam(ulong l, int dist)
		{
			if (dist >= 63)
			{
				if (l == 0L)
				{
					return 0uL;
				}
				return 1uL;
			}
			return (l >> dist) | (ulong)((l << -dist != 0L) ? 1 : 0);
		}

		private static float CreateSingleNaN(bool sign, ulong significand)
		{
			uint num = (uint)((sign ? 1 : 0) << 31);
			uint num2 = (uint)(significand >> 41);
			return BitConverter.UInt32BitsToSingle(num | 0x7FC00000u | num2);
		}

		private static double CreateDoubleNaN(bool sign, ulong significand)
		{
			ulong num = (ulong)((long)(sign ? 1 : 0) << 63);
			ulong num2 = significand >> 12;
			return BitConverter.UInt64BitsToDouble(num | 0x7FF8000000000000uL | num2);
		}

		private static float CreateSingle(bool sign, byte exp, uint sig)
		{
			return BitConverter.UInt32BitsToSingle((uint)(((sign ? 1 : 0) << 31) + (exp << 23)) + sig);
		}

		private static double CreateDouble(bool sign, ushort exp, ulong sig)
		{
			return BitConverter.UInt64BitsToDouble((ulong)(((long)(sign ? 1 : 0) << 63) + (long)((ulong)exp << 52)) + sig);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IAdditionOperators<Half, Half, Half>.op_Addition(Half left, Half right)
		{
			return (Half)((float)left + (float)right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<Half>.IsPow2(Half value)
		{
			uint num = BitConverter.HalfToUInt16Bits(value);
			uint num2 = (num >> 10) & 0x1Fu;
			uint num3 = num & 0x3FFu;
			if (value > PositiveZero && num2 != 0 && num2 != 31)
			{
				return num3 == 0;
			}
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IBinaryNumber<Half>.Log2(Half value)
		{
			return (Half)MathF.Log2((float)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IBitwiseOperators<Half, Half, Half>.op_BitwiseAnd(Half left, Half right)
		{
			ushort value = (ushort)(BitConverter.HalfToUInt16Bits(left) & BitConverter.HalfToUInt16Bits(right));
			return BitConverter.UInt16BitsToHalf(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IBitwiseOperators<Half, Half, Half>.op_BitwiseOr(Half left, Half right)
		{
			ushort value = (ushort)(BitConverter.HalfToUInt16Bits(left) | BitConverter.HalfToUInt16Bits(right));
			return BitConverter.UInt16BitsToHalf(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IBitwiseOperators<Half, Half, Half>.op_ExclusiveOr(Half left, Half right)
		{
			ushort value = (ushort)(BitConverter.HalfToUInt16Bits(left) ^ BitConverter.HalfToUInt16Bits(right));
			return BitConverter.UInt16BitsToHalf(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IBitwiseOperators<Half, Half, Half>.op_OnesComplement(Half value)
		{
			ushort value2 = (ushort)(~BitConverter.HalfToUInt16Bits(value));
			return BitConverter.UInt16BitsToHalf(value2);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<Half, Half>.op_LessThan(Half left, Half right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<Half, Half>.op_LessThanOrEqual(Half left, Half right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<Half, Half>.op_GreaterThan(Half left, Half right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<Half, Half>.op_GreaterThanOrEqual(Half left, Half right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IDecrementOperators<Half>.op_Decrement(Half value)
		{
			float num = (float)value;
			num -= 1f;
			return (Half)num;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<Half, Half>.op_Equality(Half left, Half right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<Half, Half>.op_Inequality(Half left, Half right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IDivisionOperators<Half, Half, Half>.op_Division(Half left, Half right)
		{
			return (Half)((float)left / (float)right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Acos(Half x)
		{
			return (Half)MathF.Acos((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Acosh(Half x)
		{
			return (Half)MathF.Acosh((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Asin(Half x)
		{
			return (Half)MathF.Asin((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Asinh(Half x)
		{
			return (Half)MathF.Asinh((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Atan(Half x)
		{
			return (Half)MathF.Atan((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Atan2(Half y, Half x)
		{
			return (Half)MathF.Atan2((float)y, (float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Atanh(Half x)
		{
			return (Half)MathF.Atanh((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.BitIncrement(Half x)
		{
			ushort num = BitConverter.HalfToUInt16Bits(x);
			if ((num & 0x7C00) >= 31744)
			{
				if (num != 64512)
				{
					return x;
				}
				return MinValue;
			}
			if (num == 32768)
			{
				return Epsilon;
			}
			num += (ushort)((num >= 0) ? 1 : (-1));
			return BitConverter.UInt16BitsToHalf(num);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.BitDecrement(Half x)
		{
			ushort num = BitConverter.HalfToUInt16Bits(x);
			if ((num & 0x7C00) >= 31744)
			{
				if (num != 31744)
				{
					return x;
				}
				return MaxValue;
			}
			if (num == 0)
			{
				return new Half(32769);
			}
			num += (ushort)((num < 0) ? 1 : (-1));
			return BitConverter.UInt16BitsToHalf(num);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Cbrt(Half x)
		{
			return (Half)MathF.Cbrt((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Ceiling(Half x)
		{
			return (Half)MathF.Ceiling((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.CopySign(Half x, Half y)
		{
			return (Half)MathF.CopySign((float)x, (float)y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Cos(Half x)
		{
			return (Half)MathF.Cos((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Cosh(Half x)
		{
			return (Half)MathF.Cosh((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Exp(Half x)
		{
			return (Half)MathF.Exp((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Floor(Half x)
		{
			return (Half)MathF.Floor((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.FusedMultiplyAdd(Half left, Half right, Half addend)
		{
			return (Half)MathF.FusedMultiplyAdd((float)left, (float)right, (float)addend);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.IEEERemainder(Half left, Half right)
		{
			return (Half)MathF.IEEERemainder((float)left, (float)right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TInteger IFloatingPoint<Half>.ILogB<TInteger>(Half x)
		{
			return TInteger.Create(MathF.ILogB((float)x));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Log(Half x)
		{
			return (Half)MathF.Log((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Log(Half x, Half newBase)
		{
			return (Half)MathF.Log((float)x, (float)newBase);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Log2(Half x)
		{
			return (Half)MathF.Log2((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Log10(Half x)
		{
			return (Half)MathF.Log10((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.MaxMagnitude(Half x, Half y)
		{
			return (Half)MathF.MaxMagnitude((float)x, (float)y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.MinMagnitude(Half x, Half y)
		{
			return (Half)MathF.MinMagnitude((float)x, (float)y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Pow(Half x, Half y)
		{
			return (Half)MathF.Pow((float)x, (float)y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Round(Half x)
		{
			return (Half)MathF.Round((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Round<TInteger>(Half x, TInteger digits)
		{
			return (Half)MathF.Round((float)x, int.Create(digits));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Round(Half x, MidpointRounding mode)
		{
			return (Half)MathF.Round((float)x, mode);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Round<TInteger>(Half x, TInteger digits, MidpointRounding mode)
		{
			return (Half)MathF.Round((float)x, int.Create(digits), mode);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.ScaleB<TInteger>(Half x, TInteger n)
		{
			return (Half)MathF.ScaleB((float)x, int.Create(n));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Sin(Half x)
		{
			return (Half)MathF.Sin((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Sinh(Half x)
		{
			return (Half)MathF.Sinh((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Sqrt(Half x)
		{
			return (Half)MathF.Sqrt((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Tan(Half x)
		{
			return (Half)MathF.Tan((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Tanh(Half x)
		{
			return (Half)MathF.Tanh((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IFloatingPoint<Half>.Truncate(Half x)
		{
			return (Half)MathF.Truncate((float)x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<Half>.IsFinite(Half x)
		{
			return IsFinite(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<Half>.IsInfinity(Half x)
		{
			return IsInfinity(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<Half>.IsNaN(Half x)
		{
			return IsNaN(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<Half>.IsNegative(Half x)
		{
			return IsNegative(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<Half>.IsNegativeInfinity(Half x)
		{
			return IsNegativeInfinity(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<Half>.IsNormal(Half x)
		{
			return IsNormal(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<Half>.IsPositiveInfinity(Half x)
		{
			return IsPositiveInfinity(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<Half>.IsSubnormal(Half x)
		{
			return IsSubnormal(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IIncrementOperators<Half>.op_Increment(Half value)
		{
			float num = (float)value;
			num += 1f;
			return (Half)num;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IModulusOperators<Half, Half, Half>.op_Modulus(Half left, Half right)
		{
			return (Half)((float)left % (float)right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IMultiplyOperators<Half, Half, Half>.op_Multiply(Half left, Half right)
		{
			return (Half)((float)left * (float)right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Abs(Half value)
		{
			return (Half)MathF.Abs((float)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Clamp(Half value, Half min, Half max)
		{
			return (Half)Math.Clamp((float)value, (float)min, (float)max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (Half)(int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (Half)(int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (Half)(float)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (Half)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (Half)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (Half)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (Half)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (Half)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (Half)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (Half)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (Half)(int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (Half)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (Half)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (Half)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return default(Half);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (Half)(int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (Half)(int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (Half)(float)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (Half)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (Half)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (Half)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (Half)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (Half)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (Half)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (Half)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (Half)(int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (Half)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (Half)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (Half)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return default(Half);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (Half)(int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (Half)(int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (Half)(float)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (Half)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (Half)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (Half)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (Half)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (Half)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (Half)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (Half)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (Half)(int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (Half)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (Half)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (Half)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return default(Half);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (Half Quotient, Half Remainder) INumber<Half>.DivRem(Half left, Half right)
		{
			return ((Half)((float)left / (float)right), (Half)((float)left % (float)right));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Max(Half x, Half y)
		{
			return (Half)MathF.Max((float)x, (float)y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Min(Half x, Half y)
		{
			return (Half)MathF.Min((float)x, (float)y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half INumber<Half>.Sign(Half value)
		{
			return (Half)MathF.Sign((float)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<Half>.TryCreate<TOther>(TOther value, out Half result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (Half)(int)(byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (Half)(int)(char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				result = (Half)(float)(decimal)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				result = (Half)(double)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				result = (Half)(short)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				result = (Half)(int)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				result = (Half)(long)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				result = (Half)(nint)(IntPtr)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (Half)(sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				result = (Half)(float)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (Half)(int)(ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				result = (Half)(uint)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				result = (Half)(ulong)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				result = (Half)(nuint)(UIntPtr)(object)value;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = default(Half);
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<Half>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out Half result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<Half>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Half result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IParseable<Half>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<Half>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out Half result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half ISpanParseable<Half>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<Half>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out Half result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half ISubtractionOperators<Half, Half, Half>.op_Subtraction(Half left, Half right)
		{
			return (Half)((float)left - (float)right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IUnaryNegationOperators<Half, Half>.op_UnaryNegation(Half value)
		{
			return (Half)(0f - (float)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static Half IUnaryPlusOperators<Half, Half>.op_UnaryPlus(Half value)
		{
			return value;
		}
	}
	public struct HashCode
	{
		private static readonly uint s_seed = GenerateGlobalSeed();

		private uint _v1;

		private uint _v2;

		private uint _v3;

		private uint _v4;

		private uint _queue1;

		private uint _queue2;

		private uint _queue3;

		private uint _length;

		private unsafe static uint GenerateGlobalSeed()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out uint result);
			Interop.GetRandomBytes((byte*)(&result), 4);
			return result;
		}

		public static int Combine<T1>(T1 value1)
		{
			uint queuedValue = (uint)(value1?.GetHashCode() ?? 0);
			uint num = MixEmptyState();
			num += 4;
			num = QueueRound(num, queuedValue);
			return (int)MixFinal(num);
		}

		public static int Combine<T1, T2>(T1 value1, T2 value2)
		{
			uint queuedValue = (uint)(value1?.GetHashCode() ?? 0);
			uint queuedValue2 = (uint)(value2?.GetHashCode() ?? 0);
			uint num = MixEmptyState();
			num += 8;
			num = QueueRound(num, queuedValue);
			num = QueueRound(num, queuedValue2);
			return (int)MixFinal(num);
		}

		public static int Combine<T1, T2, T3>(T1 value1, T2 value2, T3 value3)
		{
			uint queuedValue = (uint)(value1?.GetHashCode() ?? 0);
			uint queuedValue2 = (uint)(value2?.GetHashCode() ?? 0);
			uint queuedValue3 = (uint)(value3?.GetHashCode() ?? 0);
			uint num = MixEmptyState();
			num += 12;
			num = QueueRound(num, queuedValue);
			num = QueueRound(num, queuedValue2);
			num = QueueRound(num, queuedValue3);
			return (int)MixFinal(num);
		}

		public static int Combine<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4)
		{
			uint input = (uint)(value1?.GetHashCode() ?? 0);
			uint input2 = (uint)(value2?.GetHashCode() ?? 0);
			uint input3 = (uint)(value3?.GetHashCode() ?? 0);
			uint input4 = (uint)(value4?.GetHashCode() ?? 0);
			Initialize(out var v, out var v2, out var v3, out var v4);
			v = Round(v, input);
			v2 = Round(v2, input2);
			v3 = Round(v3, input3);
			v4 = Round(v4, input4);
			uint num = MixState(v, v2, v3, v4);
			num += 16;
			return (int)MixFinal(num);
		}

		public static int Combine<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5)
		{
			uint input = (uint)(value1?.GetHashCode() ?? 0);
			uint input2 = (uint)(value2?.GetHashCode() ?? 0);
			uint input3 = (uint)(value3?.GetHashCode() ?? 0);
			uint input4 = (uint)(value4?.GetHashCode() ?? 0);
			uint queuedValue = (uint)(value5?.GetHashCode() ?? 0);
			Initialize(out var v, out var v2, out var v3, out var v4);
			v = Round(v, input);
			v2 = Round(v2, input2);
			v3 = Round(v3, input3);
			v4 = Round(v4, input4);
			uint num = MixState(v, v2, v3, v4);
			num += 20;
			num = QueueRound(num, queuedValue);
			return (int)MixFinal(num);
		}

		public static int Combine<T1, T2, T3, T4, T5, T6>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6)
		{
			uint input = (uint)(value1?.GetHashCode() ?? 0);
			uint input2 = (uint)(value2?.GetHashCode() ?? 0);
			uint input3 = (uint)(value3?.GetHashCode() ?? 0);
			uint input4 = (uint)(value4?.GetHashCode() ?? 0);
			uint queuedValue = (uint)(value5?.GetHashCode() ?? 0);
			uint queuedValue2 = (uint)(value6?.GetHashCode() ?? 0);
			Initialize(out var v, out var v2, out var v3, out var v4);
			v = Round(v, input);
			v2 = Round(v2, input2);
			v3 = Round(v3, input3);
			v4 = Round(v4, input4);
			uint num = MixState(v, v2, v3, v4);
			num += 24;
			num = QueueRound(num, queuedValue);
			num = QueueRound(num, queuedValue2);
			return (int)MixFinal(num);
		}

		public static int Combine<T1, T2, T3, T4, T5, T6, T7>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7)
		{
			uint input = (uint)(value1?.GetHashCode() ?? 0);
			uint input2 = (uint)(value2?.GetHashCode() ?? 0);
			uint input3 = (uint)(value3?.GetHashCode() ?? 0);
			uint input4 = (uint)(value4?.GetHashCode() ?? 0);
			uint queuedValue = (uint)(value5?.GetHashCode() ?? 0);
			uint queuedValue2 = (uint)(value6?.GetHashCode() ?? 0);
			uint queuedValue3 = (uint)(value7?.GetHashCode() ?? 0);
			Initialize(out var v, out var v2, out var v3, out var v4);
			v = Round(v, input);
			v2 = Round(v2, input2);
			v3 = Round(v3, input3);
			v4 = Round(v4, input4);
			uint num = MixState(v, v2, v3, v4);
			num += 28;
			num = QueueRound(num, queuedValue);
			num = QueueRound(num, queuedValue2);
			num = QueueRound(num, queuedValue3);
			return (int)MixFinal(num);
		}

		public static int Combine<T1, T2, T3, T4, T5, T6, T7, T8>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8)
		{
			uint input = (uint)(value1?.GetHashCode() ?? 0);
			uint input2 = (uint)(value2?.GetHashCode() ?? 0);
			uint input3 = (uint)(value3?.GetHashCode() ?? 0);
			uint input4 = (uint)(value4?.GetHashCode() ?? 0);
			uint input5 = (uint)(value5?.GetHashCode() ?? 0);
			uint input6 = (uint)(value6?.GetHashCode() ?? 0);
			uint input7 = (uint)(value7?.GetHashCode() ?? 0);
			uint input8 = (uint)(value8?.GetHashCode() ?? 0);
			Initialize(out var v, out var v2, out var v3, out var v4);
			v = Round(v, input);
			v2 = Round(v2, input2);
			v3 = Round(v3, input3);
			v4 = Round(v4, input4);
			v = Round(v, input5);
			v2 = Round(v2, input6);
			v3 = Round(v3, input7);
			v4 = Round(v4, input8);
			uint num = MixState(v, v2, v3, v4);
			num += 32;
			return (int)MixFinal(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void Initialize(out uint v1, out uint v2, out uint v3, out uint v4)
		{
			v1 = (uint)((int)s_seed + -1640531535 + -2048144777);
			v2 = s_seed + 2246822519u;
			v3 = s_seed;
			v4 = s_seed - 2654435761u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint Round(uint hash, uint input)
		{
			return BitOperations.RotateLeft(hash + (uint)((int)input * -2048144777), 13) * 2654435761u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint QueueRound(uint hash, uint queuedValue)
		{
			return BitOperations.RotateLeft(hash + (uint)((int)queuedValue * -1028477379), 17) * 668265263;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint MixState(uint v1, uint v2, uint v3, uint v4)
		{
			return BitOperations.RotateLeft(v1, 1) + BitOperations.RotateLeft(v2, 7) + BitOperations.RotateLeft(v3, 12) + BitOperations.RotateLeft(v4, 18);
		}

		private static uint MixEmptyState()
		{
			return s_seed + 374761393;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint MixFinal(uint hash)
		{
			hash ^= hash >> 15;
			hash *= 2246822519u;
			hash ^= hash >> 13;
			hash *= 3266489917u;
			hash ^= hash >> 16;
			return hash;
		}

		public void Add<T>(T value)
		{
			Add(value?.GetHashCode() ?? 0);
		}

		public void Add<T>(T value, IEqualityComparer<T>? comparer)
		{
			Add((value != null) ? (comparer?.GetHashCode(value) ?? value.GetHashCode()) : 0);
		}

		public void AddBytes(ReadOnlySpan<byte> value)
		{
			ref byte reference = ref MemoryMarshal.GetReference(value);
			ref byte reference2 = ref Unsafe.Add(ref reference, value.Length);
			while ((nint)Unsafe.ByteOffset(ref reference, ref reference2) >= 4)
			{
				Add(Unsafe.ReadUnaligned<int>(ref reference));
				reference = ref Unsafe.Add(ref reference, 4);
			}
			while (Unsafe.IsAddressLessThan(ref reference, ref reference2))
			{
				Add((int)reference);
				reference = ref Unsafe.Add(ref reference, 1);
			}
		}

		private void Add(int value)
		{
			uint num = _length++;
			switch (num % 4)
			{
			case 0u:
				_queue1 = (uint)value;
				return;
			case 1u:
				_queue2 = (uint)value;
				return;
			case 2u:
				_queue3 = (uint)value;
				return;
			}
			if (num == 3)
			{
				Initialize(out _v1, out _v2, out _v3, out _v4);
			}
			_v1 = Round(_v1, _queue1);
			_v2 = Round(_v2, _queue2);
			_v3 = Round(_v3, _queue3);
			_v4 = Round(_v4, (uint)value);
		}

		public int ToHashCode()
		{
			uint length = _length;
			uint num = length % 4;
			uint num2 = ((length < 4) ? MixEmptyState() : MixState(_v1, _v2, _v3, _v4));
			num2 += length * 4;
			if (num != 0)
			{
				num2 = QueueRound(num2, _queue1);
				if (num > 1)
				{
					num2 = QueueRound(num2, _queue2);
					if (num > 2)
					{
						num2 = QueueRound(num2, _queue3);
					}
				}
			}
			return (int)MixFinal(num2);
		}

		[Obsolete("HashCode is a mutable struct and should not be compared with other HashCodes. Use ToHashCode to retrieve the computed hash code.", true)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			throw new NotSupportedException(SR.HashCode_HashCodeNotSupported);
		}

		[Obsolete("HashCode is a mutable struct and should not be compared with other HashCodes.", true)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object? obj)
		{
			throw new NotSupportedException(SR.HashCode_EqualityNotSupported);
		}
	}
	public interface IAsyncDisposable
	{
		ValueTask DisposeAsync();
	}
	public interface IAsyncResult
	{
		bool IsCompleted { get; }

		WaitHandle AsyncWaitHandle { get; }

		object? AsyncState { get; }

		bool CompletedSynchronously { get; }
	}
	public interface ICloneable
	{
		object Clone();
	}
	public interface IComparable
	{
		int CompareTo(object? obj);
	}
	public interface IComparable<in T>
	{
		int CompareTo(T? other);
	}
	[CLSCompliant(false)]
	public interface IConvertible
	{
		TypeCode GetTypeCode();

		bool ToBoolean(IFormatProvider? provider);

		char ToChar(IFormatProvider? provider);

		sbyte ToSByte(IFormatProvider? provider);

		byte ToByte(IFormatProvider? provider);

		short ToInt16(IFormatProvider? provider);

		ushort ToUInt16(IFormatProvider? provider);

		int ToInt32(IFormatProvider? provider);

		uint ToUInt32(IFormatProvider? provider);

		long ToInt64(IFormatProvider? provider);

		ulong ToUInt64(IFormatProvider? provider);

		float ToSingle(IFormatProvider? provider);

		double ToDouble(IFormatProvider? provider);

		decimal ToDecimal(IFormatProvider? provider);

		DateTime ToDateTime(IFormatProvider? provider);

		string ToString(IFormatProvider? provider);

		object ToType(Type conversionType, IFormatProvider? provider);
	}
	public interface ICustomFormatter
	{
		string Format(string? format, object? arg, IFormatProvider? formatProvider);
	}
	public interface IDisposable
	{
		void Dispose();
	}
	public interface IEquatable<T>
	{
		bool Equals(T? other);
	}
	public interface IFormatProvider
	{
		object? GetFormat(Type? formatType);
	}
	public interface IFormattable
	{
		string ToString(string? format, IFormatProvider? formatProvider);
	}
	public readonly struct Index : IEquatable<Index>
	{
		private readonly int _value;

		public static Index Start => new Index(0);

		public static Index End => new Index(-1);

		public int Value
		{
			get
			{
				if (_value < 0)
				{
					return ~_value;
				}
				return _value;
			}
		}

		public bool IsFromEnd => _value < 0;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Index(int value, bool fromEnd = false)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			if (fromEnd)
			{
				_value = ~value;
			}
			else
			{
				_value = value;
			}
		}

		private Index(int value)
		{
			_value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Index FromStart(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return new Index(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Index FromEnd(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return new Index(~value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int GetOffset(int length)
		{
			int num = _value;
			if (IsFromEnd)
			{
				num += length + 1;
			}
			return num;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is Index)
			{
				return _value == ((Index)value)._value;
			}
			return false;
		}

		public bool Equals(Index other)
		{
			return _value == other._value;
		}

		public override int GetHashCode()
		{
			return _value;
		}

		public static implicit operator Index(int value)
		{
			return FromStart(value);
		}

		public override string ToString()
		{
			if (IsFromEnd)
			{
				return ToStringFromEnd();
			}
			return ((uint)Value).ToString();
		}

		private string ToStringFromEnd()
		{
			Span<char> span = stackalloc char[11];
			int charsWritten;
			bool flag = ((uint)Value).TryFormat(span.Slice(1), out charsWritten);
			span[0] = '^';
			return new string(span.Slice(0, charsWritten + 1));
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class IndexOutOfRangeException : SystemException
	{
		public IndexOutOfRangeException()
			: base(SR.Arg_IndexOutOfRangeException)
		{
			base.HResult = -2146233080;
		}

		public IndexOutOfRangeException(string? message)
			: base(message)
		{
			base.HResult = -2146233080;
		}

		public IndexOutOfRangeException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233080;
		}

		private IndexOutOfRangeException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class InsufficientExecutionStackException : SystemException
	{
		public InsufficientExecutionStackException()
			: base(SR.Arg_InsufficientExecutionStackException)
		{
			base.HResult = -2146232968;
		}

		public InsufficientExecutionStackException(string? message)
			: base(message)
		{
			base.HResult = -2146232968;
		}

		public InsufficientExecutionStackException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146232968;
		}

		private InsufficientExecutionStackException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class InsufficientMemoryException : OutOfMemoryException
	{
		public InsufficientMemoryException()
			: base(Exception.GetMessageFromNativeResources(ExceptionMessageKind.OutOfMemory))
		{
			base.HResult = -2146233027;
		}

		public InsufficientMemoryException(string? message)
			: base(message)
		{
			base.HResult = -2146233027;
		}

		public InsufficientMemoryException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233027;
		}

		private InsufficientMemoryException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Int16 : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<short>, IEquatable<short>, IBinaryInteger<short>, IBinaryNumber<short>, IBitwiseOperators<short, short, short>, INumber<short>, IAdditionOperators<short, short, short>, IAdditiveIdentity<short, short>, IComparisonOperators<short, short>, IEqualityOperators<short, short>, IDecrementOperators<short>, IDivisionOperators<short, short, short>, IIncrementOperators<short>, IModulusOperators<short, short, short>, IMultiplicativeIdentity<short, short>, IMultiplyOperators<short, short, short>, ISpanParseable<short>, IParseable<short>, ISubtractionOperators<short, short, short>, IUnaryNegationOperators<short, short>, IUnaryPlusOperators<short, short>, IShiftOperators<short, short>, IMinMaxValue<short>, ISignedNumber<short>
	{
		private readonly short m_value;

		public const short MaxValue = 32767;

		public const short MinValue = -32768;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IAdditiveIdentity<short, short>.AdditiveIdentity => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IMinMaxValue<short>.MinValue => short.MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IMinMaxValue<short>.MaxValue => short.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IMultiplicativeIdentity<short, short>.MultiplicativeIdentity => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.One => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Zero => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short ISignedNumber<short>.NegativeOne => -1;

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is short)
			{
				return this - (short)value;
			}
			throw new ArgumentException(SR.Arg_MustBeInt16);
		}

		public int CompareTo(short value)
		{
			return this - value;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is short))
			{
				return false;
			}
			return this == (short)obj;
		}

		[NonVersionable]
		public bool Equals(short obj)
		{
			return this == obj;
		}

		public override int GetHashCode()
		{
			return this;
		}

		public override string ToString()
		{
			return Number.Int32ToDecStr(this);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.FormatInt32(this, 0, null, provider);
		}

		public string ToString(string? format)
		{
			return ToString(format, null);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatInt32(this, 65535, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatInt32(this, 65535, format, provider, destination, out charsWritten);
		}

		public static short Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
		}

		public static short Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.CurrentInfo);
		}

		public static short Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
		}

		public static short Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static short Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Parse(s, style, NumberFormatInfo.GetInstance(provider));
		}

		private static short Parse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info)
		{
			int result;
			Number.ParsingStatus parsingStatus = Number.TryParseInt32(s, style, info, out result);
			if (parsingStatus != 0)
			{
				Number.ThrowOverflowOrFormatException(parsingStatus, TypeCode.Int16);
			}
			if ((uint)(result - -32768 - ((int)(style & NumberStyles.AllowHexSpecifier) << 6)) > 65535u)
			{
				Number.ThrowOverflowException(TypeCode.Int16);
			}
			return (short)result;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out short result)
		{
			if (s == null)
			{
				result = 0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out short result)
		{
			return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out short result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				result = 0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out short result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out short result)
		{
			if (Number.TryParseInt32(s, style, info, out var result2) != 0 || (uint)(result2 - -32768 - ((int)(style & NumberStyles.AllowHexSpecifier) << 6)) > 65535u)
			{
				result = 0;
				return false;
			}
			result = (short)result2;
			return true;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Int16;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return this;
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int16", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IAdditionOperators<short, short, short>.op_Addition(short left, short right)
		{
			return (short)(left + right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBinaryInteger<short>.LeadingZeroCount(short value)
		{
			return (short)(BitOperations.LeadingZeroCount((ushort)value) - 16);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBinaryInteger<short>.PopCount(short value)
		{
			return (short)BitOperations.PopCount((ushort)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBinaryInteger<short>.RotateLeft(short value, int rotateAmount)
		{
			return (short)((value << (rotateAmount & 0xF)) | ((ushort)value >> ((16 - rotateAmount) & 0xF)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBinaryInteger<short>.RotateRight(short value, int rotateAmount)
		{
			return (short)(((ushort)value >> (rotateAmount & 0xF)) | (value << ((16 - rotateAmount) & 0xF)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBinaryInteger<short>.TrailingZeroCount(short value)
		{
			return (byte)(BitOperations.TrailingZeroCount(value << 16) - 16);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<short>.IsPow2(short value)
		{
			return BitOperations.IsPow2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBinaryNumber<short>.Log2(short value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return (short)BitOperations.Log2((ushort)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBitwiseOperators<short, short, short>.op_BitwiseAnd(short left, short right)
		{
			return (short)(left & right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBitwiseOperators<short, short, short>.op_BitwiseOr(short left, short right)
		{
			return (short)(left | right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBitwiseOperators<short, short, short>.op_ExclusiveOr(short left, short right)
		{
			return (short)(left ^ right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IBitwiseOperators<short, short, short>.op_OnesComplement(short value)
		{
			return (short)(~value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<short, short>.op_LessThan(short left, short right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<short, short>.op_LessThanOrEqual(short left, short right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<short, short>.op_GreaterThan(short left, short right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<short, short>.op_GreaterThanOrEqual(short left, short right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IDecrementOperators<short>.op_Decrement(short value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IDivisionOperators<short, short, short>.op_Division(short left, short right)
		{
			return (short)(left / right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<short, short>.op_Equality(short left, short right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<short, short>.op_Inequality(short left, short right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IIncrementOperators<short>.op_Increment(short value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IModulusOperators<short, short, short>.op_Modulus(short left, short right)
		{
			return (short)(left % right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IMultiplyOperators<short, short, short>.op_Multiply(short left, short right)
		{
			return (short)(left * right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Abs(short value)
		{
			return Math.Abs(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Clamp(short value, short min, short max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(char))
				{
					return (short)(char)(object)value;
				}
				if (typeof(TOther) == typeof(decimal))
				{
					return (short)(decimal)(object)value;
				}
				if (typeof(TOther) == typeof(double))
				{
					return (short)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (short)(int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (short)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (short)(nint)(IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (short)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (short)(ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (short)(uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (short)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (short)(nuint)(UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				char c = (char)(object)value;
				if (c <= '翿')
				{
					return (short)c;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 32767m))
				{
					if (!(num < -32768m))
					{
						return (short)num;
					}
					return short.MinValue;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 32767.0))
				{
					if (!(num2 < -32768.0))
					{
						return (short)num2;
					}
					return short.MinValue;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num3 = (int)(object)value;
				if (num3 <= 32767)
				{
					if (num3 >= -32768)
					{
						return (short)num3;
					}
					return short.MinValue;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num4 = (long)(object)value;
				if (num4 <= 32767)
				{
					if (num4 >= -32768)
					{
						return (short)num4;
					}
					return short.MinValue;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr <= 32767)
				{
					if ((nint)intPtr >= -32768)
					{
						return (short)(nint)intPtr;
					}
					return short.MinValue;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num5 = (float)(object)value;
				if (!(num5 > 32767f))
				{
					if (!(num5 < -32768f))
					{
						return (short)num5;
					}
					return short.MinValue;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				ushort num6 = (ushort)(object)value;
				if (num6 <= 32767)
				{
					return (short)num6;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num7 = (uint)(object)value;
				if ((long)num7 <= 32767L)
				{
					return (short)num7;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num8 = (ulong)(object)value;
				if (num8 <= 32767)
				{
					return (short)num8;
				}
				return short.MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr <= 32767)
				{
					return (short)(nuint)uIntPtr;
				}
				return short.MaxValue;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (short)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (short)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (short)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (short)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (short)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (short)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (short)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (short)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (short)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (short)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (short)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (short Quotient, short Remainder) INumber<short>.DivRem(short left, short right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Max(short x, short y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Min(short x, short y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short INumber<short>.Sign(short value)
		{
			return (short)Math.Sign(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<short>.TryCreate<TOther>(TOther value, out short result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				char c = (char)(object)value;
				if (c > '翿')
				{
					result = 0;
					return false;
				}
				result = (short)c;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < -32768m || num > 32767m)
				{
					result = 0;
					return false;
				}
				result = (short)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < -32768.0 || num2 > 32767.0)
				{
					result = 0;
					return false;
				}
				result = (short)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				result = (short)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num3 = (int)(object)value;
				if (num3 < -32768 || num3 > 32767)
				{
					result = 0;
					return false;
				}
				result = (short)num3;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num4 = (long)(object)value;
				if (num4 < -32768 || num4 > 32767)
				{
					result = 0;
					return false;
				}
				result = (short)num4;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < -32768 || (nint)intPtr > 32767)
				{
					result = 0;
					return false;
				}
				result = (short)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num5 = (float)(object)value;
				if (num5 < -32768f || num5 > 32767f)
				{
					result = 0;
					return false;
				}
				result = (short)num5;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				ushort num6 = (ushort)(object)value;
				if (num6 > 32767)
				{
					result = 0;
					return false;
				}
				result = (short)num6;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num7 = (uint)(object)value;
				if ((long)num7 > 32767L)
				{
					result = 0;
					return false;
				}
				result = (short)num7;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num8 = (ulong)(object)value;
				if (num8 > 32767)
				{
					result = 0;
					return false;
				}
				result = (short)num8;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr > 32767)
				{
					result = 0;
					return false;
				}
				result = (short)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<short>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out short result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<short>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out short result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IParseable<short>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<short>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out short result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IShiftOperators<short, short>.op_LeftShift(short value, int shiftAmount)
		{
			return (short)(value << shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IShiftOperators<short, short>.op_RightShift(short value, int shiftAmount)
		{
			return (short)(value >> shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short ISpanParseable<short>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<short>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out short result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short ISubtractionOperators<short, short, short>.op_Subtraction(short left, short right)
		{
			return (short)(left - right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IUnaryNegationOperators<short, short>.op_UnaryNegation(short value)
		{
			return (short)(-value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static short IUnaryPlusOperators<short, short>.op_UnaryPlus(short value)
		{
			return value;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Int32 : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<int>, IEquatable<int>, IBinaryInteger<int>, IBinaryNumber<int>, IBitwiseOperators<int, int, int>, INumber<int>, IAdditionOperators<int, int, int>, IAdditiveIdentity<int, int>, IComparisonOperators<int, int>, IEqualityOperators<int, int>, IDecrementOperators<int>, IDivisionOperators<int, int, int>, IIncrementOperators<int>, IModulusOperators<int, int, int>, IMultiplicativeIdentity<int, int>, IMultiplyOperators<int, int, int>, ISpanParseable<int>, IParseable<int>, ISubtractionOperators<int, int, int>, IUnaryNegationOperators<int, int>, IUnaryPlusOperators<int, int>, IShiftOperators<int, int>, IMinMaxValue<int>, ISignedNumber<int>
	{
		private readonly int m_value;

		public const int MaxValue = 2147483647;

		public const int MinValue = -2147483648;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IAdditiveIdentity<int, int>.AdditiveIdentity => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IMinMaxValue<int>.MinValue => int.MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IMinMaxValue<int>.MaxValue => int.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IMultiplicativeIdentity<int, int>.MultiplicativeIdentity => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.One => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Zero => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int ISignedNumber<int>.NegativeOne => -1;

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is int num)
			{
				if (this < num)
				{
					return -1;
				}
				if (this > num)
				{
					return 1;
				}
				return 0;
			}
			throw new ArgumentException(SR.Arg_MustBeInt32);
		}

		public int CompareTo(int value)
		{
			if (this < value)
			{
				return -1;
			}
			if (this > value)
			{
				return 1;
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is int))
			{
				return false;
			}
			return this == (int)obj;
		}

		[NonVersionable]
		public bool Equals(int obj)
		{
			return this == obj;
		}

		public override int GetHashCode()
		{
			return this;
		}

		public override string ToString()
		{
			return Number.Int32ToDecStr(this);
		}

		public string ToString(string? format)
		{
			return ToString(format, null);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.FormatInt32(this, 0, null, provider);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatInt32(this, -1, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatInt32(this, -1, format, provider, destination, out charsWritten);
		}

		public static int Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
		}

		public static int Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseInt32(s, style, NumberFormatInfo.CurrentInfo);
		}

		public static int Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
		}

		public static int Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseInt32(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static int Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Number.ParseInt32(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out int result)
		{
			if (s == null)
			{
				result = 0;
				return false;
			}
			return Number.TryParseInt32IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, out int result)
		{
			return Number.TryParseInt32IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out int result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				result = 0;
				return false;
			}
			return Number.TryParseInt32(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out int result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Number.TryParseInt32(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Int32;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return this;
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int32", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IAdditionOperators<int, int, int>.op_Addition(int left, int right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBinaryInteger<int>.LeadingZeroCount(int value)
		{
			return BitOperations.LeadingZeroCount((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBinaryInteger<int>.PopCount(int value)
		{
			return BitOperations.PopCount((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBinaryInteger<int>.RotateLeft(int value, int rotateAmount)
		{
			return (int)BitOperations.RotateLeft((uint)value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBinaryInteger<int>.RotateRight(int value, int rotateAmount)
		{
			return (int)BitOperations.RotateRight((uint)value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBinaryInteger<int>.TrailingZeroCount(int value)
		{
			return BitOperations.TrailingZeroCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<int>.IsPow2(int value)
		{
			return BitOperations.IsPow2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBinaryNumber<int>.Log2(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return BitOperations.Log2((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBitwiseOperators<int, int, int>.op_BitwiseAnd(int left, int right)
		{
			return left & right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBitwiseOperators<int, int, int>.op_BitwiseOr(int left, int right)
		{
			return left | right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBitwiseOperators<int, int, int>.op_ExclusiveOr(int left, int right)
		{
			return left ^ right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IBitwiseOperators<int, int, int>.op_OnesComplement(int value)
		{
			return ~value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<int, int>.op_LessThan(int left, int right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<int, int>.op_LessThanOrEqual(int left, int right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<int, int>.op_GreaterThan(int left, int right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<int, int>.op_GreaterThanOrEqual(int left, int right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IDecrementOperators<int>.op_Decrement(int value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IDivisionOperators<int, int, int>.op_Division(int left, int right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<int, int>.op_Equality(int left, int right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<int, int>.op_Inequality(int left, int right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IIncrementOperators<int>.op_Increment(int value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IModulusOperators<int, int, int>.op_Modulus(int left, int right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IMultiplyOperators<int, int, int>.op_Multiply(int left, int right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Abs(int value)
		{
			return Math.Abs(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Clamp(int value, int min, int max)
		{
			return Math.Clamp(value, min, max);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		internal static int Create<TOther>(TOther value) where TOther : INumber<TOther>
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (int)(decimal)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(double))
				{
					return (int)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (int)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (int)(IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (int)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (int)(uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (int)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (int)(nuint)(UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Create<TOther>(TOther value)
		{
			return Create(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 2147483647m))
				{
					if (!(num < -2147483648m))
					{
						return (int)num;
					}
					return int.MinValue;
				}
				return int.MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 2147483647.0))
				{
					if (!(num2 < -2147483648.0))
					{
						return (int)num2;
					}
					return int.MinValue;
				}
				return int.MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num3 = (long)(object)value;
				if (num3 <= int.MaxValue)
				{
					if (num3 >= int.MinValue)
					{
						return (int)num3;
					}
					return int.MinValue;
				}
				return int.MaxValue;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr <= int.MaxValue)
				{
					if ((nint)intPtr >= int.MinValue)
					{
						return (int)(nint)intPtr;
					}
					return int.MinValue;
				}
				return int.MaxValue;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num4 = (float)(object)value;
				if (!(num4 > 2.1474836E+09f))
				{
					if (!(num4 < -2.1474836E+09f))
					{
						return (int)num4;
					}
					return int.MinValue;
				}
				return int.MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num5 = (uint)(object)value;
				if (num5 <= int.MaxValue)
				{
					return (int)num5;
				}
				return int.MaxValue;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num6 = (ulong)(object)value;
				if (num6 <= int.MaxValue)
				{
					return (int)num6;
				}
				return int.MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr <= int.MaxValue)
				{
					return (int)(nuint)uIntPtr;
				}
				return int.MaxValue;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (int)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (int)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (int)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (int)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (int)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (int)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (int)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (int)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (int Quotient, int Remainder) INumber<int>.DivRem(int left, int right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Max(int x, int y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Min(int x, int y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int INumber<int>.Sign(int value)
		{
			return Math.Sign(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<int>.TryCreate<TOther>(TOther value, out int result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < -2147483648m || num > 2147483647m)
				{
					result = 0;
					return false;
				}
				result = (int)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < -2147483648.0 || num2 > 2147483647.0)
				{
					result = 0;
					return false;
				}
				result = (int)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				result = (short)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				result = (int)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num3 = (long)(object)value;
				if (num3 < int.MinValue || num3 > int.MaxValue)
				{
					result = 0;
					return false;
				}
				result = (int)num3;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < int.MinValue || (nint)intPtr > int.MaxValue)
				{
					result = 0;
					return false;
				}
				result = (int)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num4 = (float)(object)value;
				if (num4 < -2.1474836E+09f || num4 > 2.1474836E+09f)
				{
					result = 0;
					return false;
				}
				result = (int)num4;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num5 = (uint)(object)value;
				if (num5 > int.MaxValue)
				{
					result = 0;
					return false;
				}
				result = (int)num5;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num6 = (ulong)(object)value;
				if (num6 > int.MaxValue)
				{
					result = 0;
					return false;
				}
				result = (int)num6;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr > int.MaxValue)
				{
					result = 0;
					return false;
				}
				result = (int)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<int>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out int result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<int>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out int result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IParseable<int>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<int>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out int result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IShiftOperators<int, int>.op_LeftShift(int value, int shiftAmount)
		{
			return value << shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IShiftOperators<int, int>.op_RightShift(int value, int shiftAmount)
		{
			return value >> shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int ISpanParseable<int>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<int>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out int result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int ISubtractionOperators<int, int, int>.op_Subtraction(int left, int right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IUnaryNegationOperators<int, int>.op_UnaryNegation(int value)
		{
			return -value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static int IUnaryPlusOperators<int, int>.op_UnaryPlus(int value)
		{
			return value;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Int64 : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<long>, IEquatable<long>, IBinaryInteger<long>, IBinaryNumber<long>, IBitwiseOperators<long, long, long>, INumber<long>, IAdditionOperators<long, long, long>, IAdditiveIdentity<long, long>, IComparisonOperators<long, long>, IEqualityOperators<long, long>, IDecrementOperators<long>, IDivisionOperators<long, long, long>, IIncrementOperators<long>, IModulusOperators<long, long, long>, IMultiplicativeIdentity<long, long>, IMultiplyOperators<long, long, long>, ISpanParseable<long>, IParseable<long>, ISubtractionOperators<long, long, long>, IUnaryNegationOperators<long, long>, IUnaryPlusOperators<long, long>, IShiftOperators<long, long>, IMinMaxValue<long>, ISignedNumber<long>
	{
		private readonly long m_value;

		public const long MaxValue = 9223372036854775807L;

		public const long MinValue = -9223372036854775808L;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IAdditiveIdentity<long, long>.AdditiveIdentity => 0L;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IMinMaxValue<long>.MinValue => long.MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IMinMaxValue<long>.MaxValue => long.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IMultiplicativeIdentity<long, long>.MultiplicativeIdentity => 1L;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.One => 1L;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Zero => 0L;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long ISignedNumber<long>.NegativeOne => -1L;

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is long num)
			{
				if (this < num)
				{
					return -1;
				}
				if (this > num)
				{
					return 1;
				}
				return 0;
			}
			throw new ArgumentException(SR.Arg_MustBeInt64);
		}

		public int CompareTo(long value)
		{
			if (this < value)
			{
				return -1;
			}
			if (this > value)
			{
				return 1;
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is long))
			{
				return false;
			}
			return this == (long)obj;
		}

		[NonVersionable]
		public bool Equals(long obj)
		{
			return this == obj;
		}

		public override int GetHashCode()
		{
			return (int)this ^ (int)(this >> 32);
		}

		public override string ToString()
		{
			return Number.Int64ToDecStr(this);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.FormatInt64(this, null, provider);
		}

		public string ToString(string? format)
		{
			return Number.FormatInt64(this, format, null);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatInt64(this, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatInt64(this, format, provider, destination, out charsWritten);
		}

		public static long Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
		}

		public static long Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseInt64(s, style, NumberFormatInfo.CurrentInfo);
		}

		public static long Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
		}

		public static long Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseInt64(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static long Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Number.ParseInt64(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out long result)
		{
			if (s == null)
			{
				result = 0L;
				return false;
			}
			return Number.TryParseInt64IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, out long result)
		{
			return Number.TryParseInt64IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out long result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				result = 0L;
				return false;
			}
			return Number.TryParseInt64(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out long result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Number.TryParseInt64(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Int64;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return this;
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int64", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IAdditionOperators<long, long, long>.op_Addition(long left, long right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBinaryInteger<long>.LeadingZeroCount(long value)
		{
			return BitOperations.LeadingZeroCount((ulong)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBinaryInteger<long>.PopCount(long value)
		{
			return BitOperations.PopCount((ulong)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBinaryInteger<long>.RotateLeft(long value, int rotateAmount)
		{
			return (long)BitOperations.RotateLeft((ulong)value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBinaryInteger<long>.RotateRight(long value, int rotateAmount)
		{
			return (long)BitOperations.RotateRight((ulong)value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBinaryInteger<long>.TrailingZeroCount(long value)
		{
			return BitOperations.TrailingZeroCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<long>.IsPow2(long value)
		{
			return BitOperations.IsPow2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBinaryNumber<long>.Log2(long value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return BitOperations.Log2((ulong)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBitwiseOperators<long, long, long>.op_BitwiseAnd(long left, long right)
		{
			return left & right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBitwiseOperators<long, long, long>.op_BitwiseOr(long left, long right)
		{
			return left | right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBitwiseOperators<long, long, long>.op_ExclusiveOr(long left, long right)
		{
			return left ^ right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IBitwiseOperators<long, long, long>.op_OnesComplement(long value)
		{
			return ~value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<long, long>.op_LessThan(long left, long right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<long, long>.op_LessThanOrEqual(long left, long right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<long, long>.op_GreaterThan(long left, long right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<long, long>.op_GreaterThanOrEqual(long left, long right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IDecrementOperators<long>.op_Decrement(long value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IDivisionOperators<long, long, long>.op_Division(long left, long right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<long, long>.op_Equality(long left, long right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<long, long>.op_Inequality(long left, long right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IIncrementOperators<long>.op_Increment(long value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IModulusOperators<long, long, long>.op_Modulus(long left, long right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IMultiplyOperators<long, long, long>.op_Multiply(long left, long right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Abs(long value)
		{
			return Math.Abs(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Clamp(long value, long min, long max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (long)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return checked((long)(double)(object)value);
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (long)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(float))
				{
					return (long)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (long)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (long)(nuint)(UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0L;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 9223372036854775807m))
				{
					if (!(num < -9223372036854775808m))
					{
						return (long)num;
					}
					return long.MinValue;
				}
				return long.MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 9.223372036854776E+18))
				{
					if (!(num2 < -9.223372036854776E+18))
					{
						return (long)num2;
					}
					return long.MinValue;
				}
				return long.MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (long)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num3 = (float)(object)value;
				if (!(num3 > 9.223372E+18f))
				{
					if (!(num3 < -9.223372E+18f))
					{
						return (long)num3;
					}
					return long.MinValue;
				}
				return long.MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num4 = (ulong)(object)value;
				if (num4 <= long.MaxValue)
				{
					return (long)num4;
				}
				return long.MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((ulong)(nuint)uIntPtr <= 9223372036854775807uL)
				{
					return (long)(nuint)uIntPtr;
				}
				return long.MaxValue;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0L;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (long)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (long)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (long)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (long)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (long)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (long)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0L;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (long Quotient, long Remainder) INumber<long>.DivRem(long left, long right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Max(long x, long y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Min(long x, long y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long INumber<long>.Sign(long value)
		{
			return Math.Sign(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<long>.TryCreate<TOther>(TOther value, out long result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < -9223372036854775808m || num > 9223372036854775807m)
				{
					result = 0L;
					return false;
				}
				result = (long)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < -9.223372036854776E+18 || num2 > 9.223372036854776E+18)
				{
					result = 0L;
					return false;
				}
				result = (long)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				result = (short)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				result = (int)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				result = (long)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				result = (long)(IntPtr)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num3 = (float)(object)value;
				if (num3 < -9.223372E+18f || num3 > 9.223372E+18f)
				{
					result = 0L;
					return false;
				}
				result = (long)num3;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				result = (uint)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num4 = (ulong)(object)value;
				if (num4 > long.MaxValue)
				{
					result = 0L;
					return false;
				}
				result = (long)num4;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((ulong)(nuint)uIntPtr > 9223372036854775807uL)
				{
					result = 0L;
					return false;
				}
				result = (long)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0L;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<long>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out long result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<long>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out long result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IParseable<long>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<long>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out long result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IShiftOperators<long, long>.op_LeftShift(long value, int shiftAmount)
		{
			return value << shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IShiftOperators<long, long>.op_RightShift(long value, int shiftAmount)
		{
			return value >> shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long ISpanParseable<long>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<long>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out long result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long ISubtractionOperators<long, long, long>.op_Subtraction(long left, long right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IUnaryNegationOperators<long, long>.op_UnaryNegation(long value)
		{
			return -value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static long IUnaryPlusOperators<long, long>.op_UnaryPlus(long value)
		{
			return value;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct IntPtr : IEquatable<nint>, IComparable, IComparable<nint>, ISpanFormattable, IFormattable, ISerializable, IBinaryInteger<nint>, IBinaryNumber<nint>, IBitwiseOperators<nint, nint, nint>, INumber<nint>, IAdditionOperators<nint, nint, nint>, IAdditiveIdentity<nint, nint>, IComparisonOperators<nint, nint>, IEqualityOperators<nint, nint>, IDecrementOperators<nint>, IDivisionOperators<nint, nint, nint>, IIncrementOperators<nint>, IModulusOperators<nint, nint, nint>, IMultiplicativeIdentity<nint, nint>, IMultiplyOperators<nint, nint, nint>, ISpanParseable<nint>, IParseable<nint>, ISubtractionOperators<nint, nint, nint>, IUnaryNegationOperators<nint, nint>, IUnaryPlusOperators<nint, nint>, IShiftOperators<nint, nint>, IMinMaxValue<nint>, ISignedNumber<nint>
	{
		private unsafe readonly void* _value;

		[Intrinsic]
		public static readonly IntPtr Zero;

		public static int Size
		{
			[NonVersionable]
			get
			{
				return 4;
			}
		}

		public static IntPtr MaxValue
		{
			[NonVersionable]
			get
			{
				return (IntPtr)int.MaxValue;
			}
		}

		public static IntPtr MinValue
		{
			[NonVersionable]
			get
			{
				return (IntPtr)int.MinValue;
			}
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IAdditiveIdentity<IntPtr, IntPtr>.AdditiveIdentity => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IMinMaxValue<IntPtr>.MinValue => MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IMinMaxValue<IntPtr>.MaxValue => MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IMultiplicativeIdentity<IntPtr, IntPtr>.MultiplicativeIdentity => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.One => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Zero => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint ISignedNumber<IntPtr>.NegativeOne => -1;

		[NonVersionable]
		public unsafe IntPtr(int value)
		{
			_value = (void*)value;
		}

		[NonVersionable]
		public unsafe IntPtr(long value)
		{
			_value = (void*)checked((int)value);
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public unsafe IntPtr(void* value)
		{
			_value = value;
		}

		private unsafe IntPtr(SerializationInfo info, StreamingContext context)
		{
			long @int = info.GetInt64("value");
			_ = Size;
			if (@int > int.MaxValue || @int < int.MinValue)
			{
				throw new ArgumentException(SR.Serialization_InvalidPtrValue);
			}
			_value = (void*)@int;
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("value", ToInt64());
		}

		public unsafe override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is IntPtr intPtr)
			{
				return _value == intPtr._value;
			}
			return false;
		}

		public unsafe override int GetHashCode()
		{
			return (int)_value;
		}

		[NonVersionable]
		public unsafe int ToInt32()
		{
			return (int)_value;
		}

		[NonVersionable]
		public unsafe long ToInt64()
		{
			return (nint)_value;
		}

		[NonVersionable]
		public static explicit operator IntPtr(int value)
		{
			return new IntPtr(value);
		}

		[NonVersionable]
		public static explicit operator IntPtr(long value)
		{
			return new IntPtr(value);
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public unsafe static explicit operator IntPtr(void* value)
		{
			return new IntPtr(value);
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public unsafe static explicit operator void*(IntPtr value)
		{
			return value._value;
		}

		[NonVersionable]
		public unsafe static explicit operator int(IntPtr value)
		{
			return (int)value._value;
		}

		[NonVersionable]
		public unsafe static explicit operator long(IntPtr value)
		{
			return (nint)value._value;
		}

		[NonVersionable]
		public unsafe static bool operator ==(IntPtr value1, IntPtr value2)
		{
			return value1._value == value2._value;
		}

		[NonVersionable]
		public unsafe static bool operator !=(IntPtr value1, IntPtr value2)
		{
			return value1._value != value2._value;
		}

		[NonVersionable]
		public static IntPtr Add(IntPtr pointer, int offset)
		{
			return pointer + offset;
		}

		[NonVersionable]
		public unsafe static IntPtr operator +(IntPtr pointer, int offset)
		{
			return (nint)((byte*)pointer._value + offset);
		}

		[NonVersionable]
		public static IntPtr Subtract(IntPtr pointer, int offset)
		{
			return pointer - offset;
		}

		[NonVersionable]
		public unsafe static IntPtr operator -(IntPtr pointer, int offset)
		{
			return (nint)((byte*)pointer._value - offset);
		}

		[CLSCompliant(false)]
		[NonVersionable]
		public unsafe void* ToPointer()
		{
			return _value;
		}

		public unsafe int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is IntPtr intPtr)
			{
				if ((nint)_value < (nint)intPtr)
				{
					return -1;
				}
				if ((nint)_value > (nint)intPtr)
				{
					return 1;
				}
				return 0;
			}
			throw new ArgumentException(SR.Arg_MustBeIntPtr);
		}

		public unsafe int CompareTo(IntPtr value)
		{
			return ((int)_value).CompareTo((int)value);
		}

		[NonVersionable]
		public unsafe bool Equals(IntPtr other)
		{
			return (int)_value == (int)other;
		}

		public unsafe override string ToString()
		{
			return ((int)_value).ToString();
		}

		public unsafe string ToString(string? format)
		{
			return ((int)_value).ToString(format);
		}

		public unsafe string ToString(IFormatProvider? provider)
		{
			return ((int)_value).ToString(provider);
		}

		public unsafe string ToString(string? format, IFormatProvider? provider)
		{
			return ((int)_value).ToString(format, provider);
		}

		public unsafe bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return ((int)_value).TryFormat(destination, out charsWritten, format, provider);
		}

		public static IntPtr Parse(string s)
		{
			return (IntPtr)int.Parse(s);
		}

		public static IntPtr Parse(string s, NumberStyles style)
		{
			return (IntPtr)int.Parse(s, style);
		}

		public static IntPtr Parse(string s, IFormatProvider? provider)
		{
			return (IntPtr)int.Parse(s, provider);
		}

		public static IntPtr Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			return (IntPtr)int.Parse(s, style, provider);
		}

		public static IntPtr Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			return (IntPtr)int.Parse(s, style, provider);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out IntPtr result)
		{
			Unsafe.SkipInit<IntPtr>(out result);
			return int.TryParse(s, out Unsafe.As<IntPtr, int>(ref result));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out IntPtr result)
		{
			Unsafe.SkipInit<IntPtr>(out result);
			return int.TryParse(s, style, provider, out Unsafe.As<IntPtr, int>(ref result));
		}

		public static bool TryParse(ReadOnlySpan<char> s, out IntPtr result)
		{
			Unsafe.SkipInit<IntPtr>(out result);
			return int.TryParse(s, out Unsafe.As<IntPtr, int>(ref result));
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out IntPtr result)
		{
			Unsafe.SkipInit<IntPtr>(out result);
			return int.TryParse(s, style, provider, out Unsafe.As<IntPtr, int>(ref result));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IAdditionOperators<IntPtr, IntPtr, IntPtr>.op_Addition(nint left, nint right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBinaryInteger<IntPtr>.LeadingZeroCount(nint value)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return BitOperations.LeadingZeroCount((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBinaryInteger<IntPtr>.PopCount(nint value)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return BitOperations.PopCount((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBinaryInteger<IntPtr>.RotateLeft(nint value, int rotateAmount)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return (nint)BitOperations.RotateLeft((uint)value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBinaryInteger<IntPtr>.RotateRight(nint value, int rotateAmount)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return (nint)BitOperations.RotateRight((uint)value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBinaryInteger<IntPtr>.TrailingZeroCount(nint value)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return BitOperations.TrailingZeroCount((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<IntPtr>.IsPow2(nint value)
		{
			return BitOperations.IsPow2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBinaryNumber<IntPtr>.Log2(nint value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			if (Environment.Is64BitProcess)
			{
			}
			return BitOperations.Log2((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBitwiseOperators<IntPtr, IntPtr, IntPtr>.op_BitwiseAnd(nint left, nint right)
		{
			return left & right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBitwiseOperators<IntPtr, IntPtr, IntPtr>.op_BitwiseOr(nint left, nint right)
		{
			return left | right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBitwiseOperators<IntPtr, IntPtr, IntPtr>.op_ExclusiveOr(nint left, nint right)
		{
			return left ^ right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IBitwiseOperators<IntPtr, IntPtr, IntPtr>.op_OnesComplement(nint value)
		{
			return ~value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<IntPtr, IntPtr>.op_LessThan(nint left, nint right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<IntPtr, IntPtr>.op_LessThanOrEqual(nint left, nint right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<IntPtr, IntPtr>.op_GreaterThan(nint left, nint right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<IntPtr, IntPtr>.op_GreaterThanOrEqual(nint left, nint right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IDecrementOperators<IntPtr>.op_Decrement(nint value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IDivisionOperators<IntPtr, IntPtr, IntPtr>.op_Division(nint left, nint right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<IntPtr, IntPtr>.op_Equality(nint left, nint right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<IntPtr, IntPtr>.op_Inequality(nint left, nint right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IIncrementOperators<IntPtr>.op_Increment(nint value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IModulusOperators<IntPtr, IntPtr, IntPtr>.op_Modulus(nint left, nint right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IMultiplyOperators<IntPtr, IntPtr, IntPtr>.op_Multiply(nint left, nint right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Abs(nint value)
		{
			return Math.Abs(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Clamp(nint value, nint min, nint max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(decimal))
				{
					return (nint)(long)(decimal)(object)value;
				}
				if (typeof(TOther) == typeof(double))
				{
					return (nint)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (nint)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (nint)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (nint)(uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (nint)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (nint)(nuint)(UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > (decimal)(long)MaxValue))
				{
					if (!(num < (decimal)(long)MinValue))
					{
						return (nint)(long)num;
					}
					return MinValue;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > (double)(nint)MaxValue))
				{
					if (!(num2 < (double)(nint)MinValue))
					{
						return (nint)num2;
					}
					return MinValue;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num3 = (long)(object)value;
				if (num3 <= (nint)MaxValue)
				{
					if (num3 >= (nint)MinValue)
					{
						return (nint)num3;
					}
					return MinValue;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num4 = (float)(object)value;
				if (!(num4 > (float)(nint)MaxValue))
				{
					if (!(num4 < (float)(nint)MinValue))
					{
						return (nint)num4;
					}
					return MinValue;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num5 = (uint)(object)value;
				if (num5 <= (nint)MaxValue)
				{
					return (nint)num5;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num6 = (ulong)(object)value;
				if (num6 <= (nuint)(nint)MaxValue)
				{
					return (nint)num6;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr <= (nuint)(nint)MaxValue)
				{
					return (nint)(nuint)uIntPtr;
				}
				return MaxValue;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (nint)(long)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (nint)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (nint)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (nint)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (nint)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (nint)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (nint)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (nint Quotient, nint Remainder) INumber<IntPtr>.DivRem(nint left, nint right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Max(nint x, nint y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Min(nint x, nint y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint INumber<IntPtr>.Sign(nint value)
		{
			return Math.Sign(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<IntPtr>.TryCreate<TOther>(TOther value, out nint result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < (decimal)(long)MinValue || num > (decimal)(long)MaxValue)
				{
					result = 0;
					return false;
				}
				result = (nint)(long)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < (double)(nint)MinValue || num2 > (double)(nint)MaxValue)
				{
					result = 0;
					return false;
				}
				result = (nint)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				result = (short)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				result = (int)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num3 = (long)(object)value;
				if (num3 < (nint)MinValue || num3 > (nint)MaxValue)
				{
					result = 0;
					return false;
				}
				result = (nint)num3;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				result = (IntPtr)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num4 = (float)(object)value;
				if (num4 < (float)(nint)MinValue || num4 > (float)(nint)MaxValue)
				{
					result = 0;
					return false;
				}
				result = (nint)num4;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num5 = (uint)(object)value;
				if (num5 > (nint)MaxValue)
				{
					result = 0;
					return false;
				}
				result = (nint)num5;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num6 = (ulong)(object)value;
				if (num6 > (nuint)(nint)MaxValue)
				{
					result = 0;
					return false;
				}
				result = (nint)num6;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr > (nuint)(nint)MaxValue)
				{
					result = 0;
					return false;
				}
				result = (nint)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<IntPtr>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out nint result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<IntPtr>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out nint result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IParseable<IntPtr>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<IntPtr>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out nint result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IShiftOperators<IntPtr, IntPtr>.op_LeftShift(nint value, int shiftAmount)
		{
			return value << shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IShiftOperators<IntPtr, IntPtr>.op_RightShift(nint value, int shiftAmount)
		{
			return value >> shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint ISpanParseable<IntPtr>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<IntPtr>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out nint result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint ISubtractionOperators<IntPtr, IntPtr, IntPtr>.op_Subtraction(nint left, nint right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IUnaryNegationOperators<IntPtr, IntPtr>.op_UnaryNegation(nint value)
		{
			return -value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nint IUnaryPlusOperators<IntPtr, IntPtr>.op_UnaryPlus(nint value)
		{
			return value;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class InvalidCastException : SystemException
	{
		public InvalidCastException()
			: base(SR.Arg_InvalidCastException)
		{
			base.HResult = -2147467262;
		}

		public InvalidCastException(string? message)
			: base(message)
		{
			base.HResult = -2147467262;
		}

		public InvalidCastException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147467262;
		}

		public InvalidCastException(string? message, int errorCode)
			: base(message)
		{
			base.HResult = errorCode;
		}

		protected InvalidCastException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class InvalidOperationException : SystemException
	{
		public InvalidOperationException()
			: base(SR.Arg_InvalidOperationException)
		{
			base.HResult = -2146233079;
		}

		public InvalidOperationException(string? message)
			: base(message)
		{
			base.HResult = -2146233079;
		}

		public InvalidOperationException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233079;
		}

		protected InvalidOperationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class InvalidProgramException : SystemException
	{
		public InvalidProgramException()
			: base(SR.InvalidProgram_Default)
		{
			base.HResult = -2146233030;
		}

		public InvalidProgramException(string? message)
			: base(message)
		{
			base.HResult = -2146233030;
		}

		public InvalidProgramException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233030;
		}

		private InvalidProgramException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class InvalidTimeZoneException : Exception
	{
		public InvalidTimeZoneException()
		{
		}

		public InvalidTimeZoneException(string? message)
			: base(message)
		{
		}

		public InvalidTimeZoneException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		protected InvalidTimeZoneException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public interface IObservable<out T>
	{
		IDisposable Subscribe(IObserver<T> observer);
	}
	public interface IObserver<in T>
	{
		void OnNext(T value);

		void OnError(Exception error);

		void OnCompleted();
	}
	public interface IProgress<in T>
	{
		void Report(T value);
	}
	public interface ISpanFormattable : IFormattable
	{
		bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider);
	}
	internal enum LazyState
	{
		NoneViaConstructor,
		NoneViaFactory,
		NoneException,
		PublicationOnlyViaConstructor,
		PublicationOnlyViaFactory,
		PublicationOnlyWait,
		PublicationOnlyException,
		ExecutionAndPublicationViaConstructor,
		ExecutionAndPublicationViaFactory,
		ExecutionAndPublicationException
	}
	internal sealed class LazyHelper
	{
		internal static readonly LazyHelper NoneViaConstructor = new LazyHelper(LazyState.NoneViaConstructor);

		internal static readonly LazyHelper NoneViaFactory = new LazyHelper(LazyState.NoneViaFactory);

		internal static readonly LazyHelper PublicationOnlyViaConstructor = new LazyHelper(LazyState.PublicationOnlyViaConstructor);

		internal static readonly LazyHelper PublicationOnlyViaFactory = new LazyHelper(LazyState.PublicationOnlyViaFactory);

		internal static readonly LazyHelper PublicationOnlyWaitForOtherThreadToPublish = new LazyHelper(LazyState.PublicationOnlyWait);

		private readonly ExceptionDispatchInfo _exceptionDispatch;

		internal LazyState State { get; }

		internal LazyHelper(LazyState state)
		{
			State = state;
		}

		internal LazyHelper(LazyThreadSafetyMode mode, Exception exception)
		{
			switch (mode)
			{
			case LazyThreadSafetyMode.ExecutionAndPublication:
				State = LazyState.ExecutionAndPublicationException;
				break;
			case LazyThreadSafetyMode.None:
				State = LazyState.NoneException;
				break;
			case LazyThreadSafetyMode.PublicationOnly:
				State = LazyState.PublicationOnlyException;
				break;
			}
			_exceptionDispatch = ExceptionDispatchInfo.Capture(exception);
		}

		[DoesNotReturn]
		internal void ThrowException()
		{
			_exceptionDispatch.Throw();
		}

		private LazyThreadSafetyMode GetMode()
		{
			switch (State)
			{
			case LazyState.NoneViaConstructor:
			case LazyState.NoneViaFactory:
			case LazyState.NoneException:
				return LazyThreadSafetyMode.None;
			case LazyState.PublicationOnlyViaConstructor:
			case LazyState.PublicationOnlyViaFactory:
			case LazyState.PublicationOnlyWait:
			case LazyState.PublicationOnlyException:
				return LazyThreadSafetyMode.PublicationOnly;
			case LazyState.ExecutionAndPublicationViaConstructor:
			case LazyState.ExecutionAndPublicationViaFactory:
			case LazyState.ExecutionAndPublicationException:
				return LazyThreadSafetyMode.ExecutionAndPublication;
			default:
				return LazyThreadSafetyMode.None;
			}
		}

		internal static LazyThreadSafetyMode? GetMode(LazyHelper state)
		{
			return state?.GetMode();
		}

		internal static bool GetIsValueFaulted(LazyHelper state)
		{
			return state?._exceptionDispatch != null;
		}

		internal static LazyHelper Create(LazyThreadSafetyMode mode, bool useDefaultConstructor)
		{
			switch (mode)
			{
			case LazyThreadSafetyMode.None:
				if (!useDefaultConstructor)
				{
					return NoneViaFactory;
				}
				return NoneViaConstructor;
			case LazyThreadSafetyMode.PublicationOnly:
				if (!useDefaultConstructor)
				{
					return PublicationOnlyViaFactory;
				}
				return PublicationOnlyViaConstructor;
			case LazyThreadSafetyMode.ExecutionAndPublication:
			{
				LazyState state = (useDefaultConstructor ? LazyState.ExecutionAndPublicationViaConstructor : LazyState.ExecutionAndPublicationViaFactory);
				return new LazyHelper(state);
			}
			default:
				throw new ArgumentOutOfRangeException("mode", SR.Lazy_ctor_ModeInvalid);
			}
		}

		internal static T CreateViaDefaultConstructor<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>()
		{
			try
			{
				return Activator.CreateInstance<T>();
			}
			catch (MissingMethodException)
			{
				throw new MissingMemberException(SR.Lazy_CreateValue_NoParameterlessCtorForT);
			}
		}

		internal static LazyThreadSafetyMode GetModeFromIsThreadSafe(bool isThreadSafe)
		{
			if (!isThreadSafe)
			{
				return LazyThreadSafetyMode.None;
			}
			return LazyThreadSafetyMode.ExecutionAndPublication;
		}
	}
	[DebuggerTypeProxy(typeof(LazyDebugView<>))]
	[DebuggerDisplay("ThreadSafetyMode={Mode}, IsValueCreated={IsValueCreated}, IsValueFaulted={IsValueFaulted}, Value={ValueForDebugDisplay}")]
	public class Lazy<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>
	{
		private volatile LazyHelper _state;

		private Func<T> _factory;

		private T _value;

		internal T? ValueForDebugDisplay
		{
			get
			{
				if (!IsValueCreated)
				{
					return default(T);
				}
				return _value;
			}
		}

		internal LazyThreadSafetyMode? Mode => LazyHelper.GetMode(_state);

		internal bool IsValueFaulted => LazyHelper.GetIsValueFaulted(_state);

		public bool IsValueCreated => _state == null;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public T Value
		{
			get
			{
				if (_state != null)
				{
					return CreateValue();
				}
				return _value;
			}
		}

		private static T CreateViaDefaultConstructor()
		{
			return LazyHelper.CreateViaDefaultConstructor<T>();
		}

		public Lazy()
			: this((Func<T>)null, LazyThreadSafetyMode.ExecutionAndPublication, useDefaultConstructor: true)
		{
		}

		public Lazy(T value)
		{
			_value = value;
		}

		public Lazy(Func<T> valueFactory)
			: this(valueFactory, LazyThreadSafetyMode.ExecutionAndPublication, useDefaultConstructor: false)
		{
		}

		public Lazy(bool isThreadSafe)
			: this((Func<T>)null, LazyHelper.GetModeFromIsThreadSafe(isThreadSafe), useDefaultConstructor: true)
		{
		}

		public Lazy(LazyThreadSafetyMode mode)
			: this((Func<T>)null, mode, useDefaultConstructor: true)
		{
		}

		public Lazy(Func<T> valueFactory, bool isThreadSafe)
			: this(valueFactory, LazyHelper.GetModeFromIsThreadSafe(isThreadSafe), useDefaultConstructor: false)
		{
		}

		public Lazy(Func<T> valueFactory, LazyThreadSafetyMode mode)
			: this(valueFactory, mode, useDefaultConstructor: false)
		{
		}

		private Lazy(Func<T> valueFactory, LazyThreadSafetyMode mode, bool useDefaultConstructor)
		{
			if (valueFactory == null && !useDefaultConstructor)
			{
				throw new ArgumentNullException("valueFactory");
			}
			_factory = valueFactory;
			_state = LazyHelper.Create(mode, useDefaultConstructor);
		}

		private void ViaConstructor()
		{
			_value = CreateViaDefaultConstructor();
			_state = null;
		}

		private void ViaFactory(LazyThreadSafetyMode mode)
		{
			try
			{
				Func<T> factory = _factory;
				if (factory == null)
				{
					throw new InvalidOperationException(SR.Lazy_Value_RecursiveCallsToValue);
				}
				_factory = null;
				_value = factory();
				_state = null;
			}
			catch (Exception exception)
			{
				_state = new LazyHelper(mode, exception);
				throw;
			}
		}

		private void ExecutionAndPublication(LazyHelper executionAndPublication, bool useDefaultConstructor)
		{
			lock (executionAndPublication)
			{
				if (_state == executionAndPublication)
				{
					if (useDefaultConstructor)
					{
						ViaConstructor();
					}
					else
					{
						ViaFactory(LazyThreadSafetyMode.ExecutionAndPublication);
					}
				}
			}
		}

		private void PublicationOnly(LazyHelper publicationOnly, T possibleValue)
		{
			LazyHelper lazyHelper = Interlocked.CompareExchange(ref _state, LazyHelper.PublicationOnlyWaitForOtherThreadToPublish, publicationOnly);
			if (lazyHelper == publicationOnly)
			{
				_factory = null;
				_value = possibleValue;
				_state = null;
			}
		}

		private void PublicationOnlyViaConstructor(LazyHelper initializer)
		{
			PublicationOnly(initializer, CreateViaDefaultConstructor());
		}

		private void PublicationOnlyViaFactory(LazyHelper initializer)
		{
			Func<T> factory = _factory;
			if (factory == null)
			{
				PublicationOnlyWaitForOtherThreadToPublish();
			}
			else
			{
				PublicationOnly(initializer, factory());
			}
		}

		private void PublicationOnlyWaitForOtherThreadToPublish()
		{
			SpinWait spinWait = default(SpinWait);
			while (_state != null)
			{
				spinWait.SpinOnce();
			}
		}

		private T CreateValue()
		{
			LazyHelper state = _state;
			if (state != null)
			{
				switch (state.State)
				{
				case LazyState.NoneViaConstructor:
					ViaConstructor();
					break;
				case LazyState.NoneViaFactory:
					ViaFactory(LazyThreadSafetyMode.None);
					break;
				case LazyState.PublicationOnlyViaConstructor:
					PublicationOnlyViaConstructor(state);
					break;
				case LazyState.PublicationOnlyViaFactory:
					PublicationOnlyViaFactory(state);
					break;
				case LazyState.PublicationOnlyWait:
					PublicationOnlyWaitForOtherThreadToPublish();
					break;
				case LazyState.ExecutionAndPublicationViaConstructor:
					ExecutionAndPublication(state, useDefaultConstructor: true);
					break;
				case LazyState.ExecutionAndPublicationViaFactory:
					ExecutionAndPublication(state, useDefaultConstructor: false);
					break;
				default:
					state.ThrowException();
					break;
				}
			}
			return Value;
		}

		public override string? ToString()
		{
			if (!IsValueCreated)
			{
				return SR.Lazy_ToString_ValueNotCreated;
			}
			return Value.ToString();
		}
	}
	internal sealed class LazyDebugView<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>
	{
		private readonly Lazy<T> _lazy;

		public bool IsValueCreated => _lazy.IsValueCreated;

		public T Value => _lazy.ValueForDebugDisplay;

		public LazyThreadSafetyMode? Mode => _lazy.Mode;

		public bool IsValueFaulted => _lazy.IsValueFaulted;

		public LazyDebugView(Lazy<T> lazy)
		{
			_lazy = lazy;
		}
	}
	public class Lazy<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T, TMetadata> : Lazy<T>
	{
		private readonly TMetadata _metadata;

		public TMetadata Metadata => _metadata;

		public Lazy(Func<T> valueFactory, TMetadata metadata)
			: base(valueFactory)
		{
			_metadata = metadata;
		}

		public Lazy(TMetadata metadata)
		{
			_metadata = metadata;
		}

		public Lazy(TMetadata metadata, bool isThreadSafe)
			: base(isThreadSafe)
		{
			_metadata = metadata;
		}

		public Lazy(Func<T> valueFactory, TMetadata metadata, bool isThreadSafe)
			: base(valueFactory, isThreadSafe)
		{
			_metadata = metadata;
		}

		public Lazy(TMetadata metadata, LazyThreadSafetyMode mode)
			: base(mode)
		{
			_metadata = metadata;
		}

		public Lazy(Func<T> valueFactory, TMetadata metadata, LazyThreadSafetyMode mode)
			: base(valueFactory, mode)
		{
			_metadata = metadata;
		}
	}
	public enum LoaderOptimization
	{
		[Obsolete("LoaderOptimization.DisallowBindings has been deprecated and is not supported.")]
		DisallowBindings = 4,
		[Obsolete("LoaderOptimization.DomainMask has been deprecated and is not supported.")]
		DomainMask = 3,
		MultiDomain = 2,
		MultiDomainHost = 3,
		NotSpecified = 0,
		SingleDomain = 1
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class LoaderOptimizationAttribute : Attribute
	{
		private readonly byte _val;

		public LoaderOptimization Value => (LoaderOptimization)_val;

		public LoaderOptimizationAttribute(byte value)
		{
			_val = value;
		}

		public LoaderOptimizationAttribute(LoaderOptimization value)
		{
			_val = (byte)value;
		}
	}
	internal static class LocalAppContextSwitches
	{
		private static int s_enableUnsafeUTF7Encoding;

		private static int s_enforceJapaneseEraYearRanges;

		private static int s_formatJapaneseFirstYearAsANumber;

		private static int s_enforceLegacyJapaneseDateParsing;

		private static int s_preserveEventListnerObjectIdentity;

		private static int s_serializationGuard;

		private static int s_showILOffset;

		public static bool EnableUnsafeUTF7Encoding
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return GetCachedSwitchValue("System.Text.Encoding.EnableUnsafeUTF7Encoding", ref s_enableUnsafeUTF7Encoding);
			}
		}

		public static bool EnforceJapaneseEraYearRanges
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return GetCachedSwitchValue("Switch.System.Globalization.EnforceJapaneseEraYearRanges", ref s_enforceJapaneseEraYearRanges);
			}
		}

		public static bool FormatJapaneseFirstYearAsANumber
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return GetCachedSwitchValue("Switch.System.Globalization.FormatJapaneseFirstYearAsANumber", ref s_formatJapaneseFirstYearAsANumber);
			}
		}

		public static bool EnforceLegacyJapaneseDateParsing
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return GetCachedSwitchValue("Switch.System.Globalization.EnforceLegacyJapaneseDateParsing", ref s_enforceLegacyJapaneseDateParsing);
			}
		}

		public static bool PreserveEventListnerObjectIdentity
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return GetCachedSwitchValue("Switch.System.Diagnostics.EventSource.PreserveEventListnerObjectIdentity", ref s_preserveEventListnerObjectIdentity);
			}
		}

		public static bool SerializationGuard
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return GetCachedSwitchValue("Switch.System.Runtime.Serialization.SerializationGuard", ref s_serializationGuard);
			}
		}

		public static bool ShowILOffsets
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return GetDefaultShowILOffsetSetting();
			}
		}

		private static bool GetDefaultShowILOffsetSetting()
		{
			if (s_showILOffset < 0)
			{
				return false;
			}
			if (s_showILOffset > 0)
			{
				return true;
			}
			bool booleanConfig = AppContextConfigHelper.GetBooleanConfig("Switch.System.Diagnostics.StackTrace.ShowILOffsets", defaultValue: false);
			s_showILOffset = (booleanConfig ? 1 : (-1));
			return booleanConfig;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool GetCachedSwitchValue(string switchName, ref int cachedSwitchValue)
		{
			if (cachedSwitchValue < 0)
			{
				return false;
			}
			if (cachedSwitchValue > 0)
			{
				return true;
			}
			return GetCachedSwitchValueInternal(switchName, ref cachedSwitchValue);
		}

		private static bool GetCachedSwitchValueInternal(string switchName, ref int cachedSwitchValue)
		{
			if (!AppContext.TryGetSwitch(switchName, out var isEnabled))
			{
				isEnabled = GetSwitchDefaultValue(switchName);
			}
			AppContext.TryGetSwitch("TestSwitch.LocalAppContext.DisableCaching", out var isEnabled2);
			if (!isEnabled2)
			{
				cachedSwitchValue = (isEnabled ? 1 : (-1));
			}
			return isEnabled;
		}

		private static bool GetSwitchDefaultValue(string switchName)
		{
			if (switchName == "Switch.System.Runtime.Serialization.SerializationGuard")
			{
				return true;
			}
			if (switchName == "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization")
			{
				return true;
			}
			return false;
		}
	}
	public sealed class LocalDataStoreSlot
	{
		internal ThreadLocal<object?> Data { get; private set; }

		internal LocalDataStoreSlot(ThreadLocal<object> data)
		{
			Data = data;
			GC.SuppressFinalize(this);
		}

		~LocalDataStoreSlot()
		{
		}
	}
	[ClassInterface(ClassInterfaceType.AutoDispatch)]
	[ComVisible(true)]
	public abstract class MarshalByRefObject
	{
		[Obsolete("This Remoting API is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0010", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public object GetLifetimeService()
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_Remoting);
		}

		[Obsolete("This Remoting API is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0010", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public virtual object InitializeLifetimeService()
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_Remoting);
		}

		protected MarshalByRefObject MemberwiseClone(bool cloneIdentity)
		{
			return (MarshalByRefObject)MemberwiseClone();
		}
	}
	internal static class Marvin
	{
		public static ulong DefaultSeed { get; } = GenerateSeed();


		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ComputeHash32(ReadOnlySpan<byte> data, ulong seed)
		{
			return ComputeHash32(ref MemoryMarshal.GetReference(data), (uint)data.Length, (uint)seed, (uint)(seed >> 32));
		}

		public static int ComputeHash32(ref byte data, uint count, uint p0, uint p1)
		{
			uint num;
			if (count < 8)
			{
				if (count < 4)
				{
					_ = BitConverter.IsLittleEndian;
					num = 128u;
					if ((count & (true ? 1u : 0u)) != 0)
					{
						num = Unsafe.AddByteOffset(ref data, (nuint)count & (nuint)2u);
						_ = BitConverter.IsLittleEndian;
						num |= 0x8000u;
					}
					if ((count & 2u) != 0)
					{
						_ = BitConverter.IsLittleEndian;
						num <<= 16;
						num |= Unsafe.ReadUnaligned<ushort>(ref data);
					}
					goto IL_00a6;
				}
			}
			else
			{
				uint num2 = count / 8;
				do
				{
					p0 += Unsafe.ReadUnaligned<uint>(ref data);
					uint num3 = Unsafe.ReadUnaligned<uint>(ref Unsafe.AddByteOffset(ref data, 4u));
					Block(ref p0, ref p1);
					p0 += num3;
					Block(ref p0, ref p1);
					data = ref Unsafe.AddByteOffset(ref data, 8u);
				}
				while (--num2 != 0);
				if ((count & 4) == 0)
				{
					goto IL_006a;
				}
			}
			p0 += Unsafe.ReadUnaligned<uint>(ref data);
			Block(ref p0, ref p1);
			goto IL_006a;
			IL_006a:
			num = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref Unsafe.AddByteOffset(ref data, (nuint)count & (nuint)7u), -4));
			count = ~count << 3;
			_ = BitConverter.IsLittleEndian;
			num >>= 8;
			num |= 0x80000000u;
			num >>= (int)(count & 0x1F);
			goto IL_00a6;
			IL_00a6:
			p0 += num;
			Block(ref p0, ref p1);
			Block(ref p0, ref p1);
			return (int)(p1 ^ p0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void Block(ref uint rp0, ref uint rp1)
		{
			uint num = rp0;
			uint num2 = rp1;
			num2 ^= num;
			num = BitOperations.RotateLeft(num, 20);
			num += num2;
			num2 = BitOperations.RotateLeft(num2, 9);
			num2 ^= num;
			num = BitOperations.RotateLeft(num, 27);
			num += num2;
			num2 = BitOperations.RotateLeft(num2, 19);
			rp0 = num;
			rp1 = num2;
		}

		private unsafe static ulong GenerateSeed()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out ulong result);
			Interop.GetRandomBytes((byte*)(&result), 8);
			return result;
		}

		public static int ComputeHash32OrdinalIgnoreCase(ref char data, int count, uint p0, uint p1)
		{
			uint num = (uint)count;
			nuint num2 = 0u;
			while (true)
			{
				if (num >= 2)
				{
					uint value = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref data, num2)));
					if (!Utf16Utility.AllCharsInUInt32AreAscii(value))
					{
						break;
					}
					p0 += Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(value);
					Block(ref p0, ref p1);
					num2 += 4;
					num -= 2;
					continue;
				}
				if (num != 0)
				{
					uint value = Unsafe.AddByteOffset(ref data, num2);
					if (value > 127)
					{
						break;
					}
					_ = BitConverter.IsLittleEndian;
					p0 += Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(value) + 8388480;
				}
				_ = BitConverter.IsLittleEndian;
				p0 += 128;
				Block(ref p0, ref p1);
				Block(ref p0, ref p1);
				return (int)(p1 ^ p0);
			}
			return ComputeHash32OrdinalIgnoreCaseSlow(ref Unsafe.AddByteOffset(ref data, num2), (int)num, p0, p1);
		}

		private static int ComputeHash32OrdinalIgnoreCaseSlow(ref char data, int count, uint p0, uint p1)
		{
			char[] array = null;
			Span<char> span = (((uint)count > 64u) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(count))) : stackalloc char[64]);
			Span<char> span2 = span;
			int num = Ordinal.ToUpperOrdinal(new ReadOnlySpan<char>(ref data, count), span2);
			int result = ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(span2)), (uint)(num * 2), p0, p1);
			if (array != null)
			{
				ArrayPool<char>.Shared.Return(array);
			}
			return result;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class MemberAccessException : SystemException
	{
		public MemberAccessException()
			: base(SR.Arg_AccessException)
		{
			base.HResult = -2146233062;
		}

		public MemberAccessException(string? message)
			: base(message)
		{
			base.HResult = -2146233062;
		}

		public MemberAccessException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233062;
		}

		protected MemberAccessException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[DebuggerTypeProxy(typeof(MemoryDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	public readonly struct Memory<T> : IEquatable<Memory<T>>
	{
		private readonly object _object;

		private readonly int _index;

		private readonly int _length;

		public static Memory<T> Empty => default(Memory<T>);

		public int Length => _length;

		public bool IsEmpty => _length == 0;

		public unsafe Span<T> Span
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				ref T ptr = ref Unsafe.NullRef<T>();
				int length = 0;
				object @object = _object;
				if (@object != null)
				{
					if (typeof(T) == typeof(char) && @object.GetType() == typeof(string))
					{
						ptr = ref Unsafe.As<char, T>(ref Unsafe.As<string>(@object).GetRawStringData());
						length = Unsafe.As<string>(@object).Length;
					}
					else if (RuntimeHelpers.ObjectHasComponentSize(@object))
					{
						ptr = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(@object));
						length = Unsafe.As<T[]>(@object).Length;
					}
					else
					{
						Span<T> span = Unsafe.As<MemoryManager<T>>(@object).GetSpan();
						ptr = ref MemoryMarshal.GetReference(span);
						length = span.Length;
					}
					nuint num = (uint)_index & 0x7FFFFFFFu;
					int length2 = _length;
					if ((uint)num > (uint)length || (uint)length2 > (uint)(length - (int)num))
					{
						ThrowHelper.ThrowArgumentOutOfRangeException();
					}
					ptr = ref Unsafe.Add(ref ptr, (IntPtr)(void*)num);
					length = length2;
				}
				return new Span<T>(ref ptr, length);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Memory(T[]? array)
		{
			if (array == null)
			{
				this = default(Memory<T>);
				return;
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			_object = array;
			_index = 0;
			_length = array.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Memory(T[] array, int start)
		{
			if (array == null)
			{
				if (start != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				this = default(Memory<T>);
				return;
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = array;
			_index = start;
			_length = array.Length - start;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Memory(T[]? array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				this = default(Memory<T>);
				return;
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = array;
			_index = start;
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Memory(MemoryManager<T> manager, int length)
		{
			if (length < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = manager;
			_index = 0;
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Memory(MemoryManager<T> manager, int start, int length)
		{
			if (length < 0 || start < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = manager;
			_index = start;
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Memory(object obj, int start, int length)
		{
			_object = obj;
			_index = start;
			_length = length;
		}

		public static implicit operator Memory<T>(T[]? array)
		{
			return new Memory<T>(array);
		}

		public static implicit operator Memory<T>(ArraySegment<T> segment)
		{
			return new Memory<T>(segment.Array, segment.Offset, segment.Count);
		}

		public static implicit operator ReadOnlyMemory<T>(Memory<T> memory)
		{
			return Unsafe.As<Memory<T>, ReadOnlyMemory<T>>(ref memory);
		}

		public override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				if (!(_object is string text))
				{
					return Span.ToString();
				}
				return text.Substring(_index, _length);
			}
			return $"System.Memory<{typeof(T).Name}>[{_length}]";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Memory<T> Slice(int start)
		{
			if ((uint)start > (uint)_length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new Memory<T>(_object, _index + start, _length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Memory<T> Slice(int start, int length)
		{
			if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new Memory<T>(_object, _index + start, length);
		}

		public void CopyTo(Memory<T> destination)
		{
			Span.CopyTo(destination.Span);
		}

		public bool TryCopyTo(Memory<T> destination)
		{
			return Span.TryCopyTo(destination.Span);
		}

		public unsafe MemoryHandle Pin()
		{
			object @object = _object;
			if (@object != null)
			{
				if (typeof(T) == typeof(char) && @object is string text)
				{
					GCHandle handle = GCHandle.Alloc(@object, GCHandleType.Pinned);
					return new MemoryHandle(Unsafe.AsPointer(ref Unsafe.Add(ref text.GetRawStringData(), _index)), handle);
				}
				if (RuntimeHelpers.ObjectHasComponentSize(@object))
				{
					if (_index < 0)
					{
						void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(@object))), _index & 0x7FFFFFFF);
						return new MemoryHandle(pointer);
					}
					GCHandle handle2 = GCHandle.Alloc(@object, GCHandleType.Pinned);
					void* pointer2 = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(@object))), _index);
					return new MemoryHandle(pointer2, handle2);
				}
				return Unsafe.As<MemoryManager<T>>(@object).Pin(_index);
			}
			return default(MemoryHandle);
		}

		public T[] ToArray()
		{
			return Span.ToArray();
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is ReadOnlyMemory<T> readOnlyMemory)
			{
				return readOnlyMemory.Equals(this);
			}
			if (obj is Memory<T> other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(Memory<T> other)
		{
			if (_object == other._object && _index == other._index)
			{
				return _length == other._length;
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			if (_object == null)
			{
				return 0;
			}
			return HashCode.Combine(RuntimeHelpers.GetHashCode(_object), _index, _length);
		}
	}
	internal sealed class MemoryDebugView<T>
	{
		private readonly ReadOnlyMemory<T> _memory;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items => _memory.ToArray();

		public MemoryDebugView(Memory<T> memory)
		{
			_memory = memory;
		}

		public MemoryDebugView(ReadOnlyMemory<T> memory)
		{
			_memory = memory;
		}
	}
	public static class MemoryExtensions
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		[InterpolatedStringHandler]
		public ref struct TryWriteInterpolatedStringHandler
		{
			private readonly Span<char> _destination;

			private readonly IFormatProvider _provider;

			internal int _pos;

			internal bool _success;

			private readonly bool _hasCustomFormatter;

			public TryWriteInterpolatedStringHandler(int literalLength, int formattedCount, Span<char> destination, out bool shouldAppend)
			{
				_destination = destination;
				_provider = null;
				_pos = 0;
				_success = (shouldAppend = destination.Length >= literalLength);
				_hasCustomFormatter = false;
			}

			public TryWriteInterpolatedStringHandler(int literalLength, int formattedCount, Span<char> destination, IFormatProvider? provider, out bool shouldAppend)
			{
				_destination = destination;
				_provider = provider;
				_pos = 0;
				_success = (shouldAppend = destination.Length >= literalLength);
				_hasCustomFormatter = provider != null && DefaultInterpolatedStringHandler.HasCustomFormatter(provider);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool AppendLiteral(string value)
			{
				if (value.Length == 1)
				{
					Span<char> destination = _destination;
					int pos = _pos;
					if ((uint)pos < (uint)destination.Length)
					{
						destination[pos] = value[0];
						_pos = pos + 1;
						return true;
					}
					return Fail();
				}
				if (value.Length == 2)
				{
					Span<char> destination2 = _destination;
					int pos2 = _pos;
					if ((uint)pos2 < destination2.Length - 1)
					{
						Unsafe.WriteUnaligned(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(destination2), pos2)), Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref value.GetRawStringData())));
						_pos = pos2 + 2;
						return true;
					}
					return Fail();
				}
				return AppendStringDirect(value);
			}

			private bool AppendStringDirect(string value)
			{
				if (value.TryCopyTo(_destination.Slice(_pos)))
				{
					_pos += value.Length;
					return true;
				}
				return Fail();
			}

			public bool AppendFormatted<T>(T value)
			{
				if (_hasCustomFormatter)
				{
					return AppendCustomFormatter(value, null);
				}
				string text;
				if (value is IFormattable)
				{
					if (value is ISpanFormattable)
					{
						if (((ISpanFormattable)(object)value).TryFormat(_destination.Slice(_pos), out var charsWritten, default(ReadOnlySpan<char>), _provider))
						{
							_pos += charsWritten;
							return true;
						}
						return Fail();
					}
					text = ((IFormattable)(object)value).ToString(null, _provider);
				}
				else
				{
					text = value?.ToString();
				}
				if (text != null)
				{
					return AppendStringDirect(text);
				}
				return true;
			}

			public bool AppendFormatted<T>(T value, string? format)
			{
				if (_hasCustomFormatter)
				{
					return AppendCustomFormatter(value, format);
				}
				string text;
				if (value is IFormattable)
				{
					if (value is ISpanFormattable)
					{
						if (((ISpanFormattable)(object)value).TryFormat(_destination.Slice(_pos), out var charsWritten, format, _provider))
						{
							_pos += charsWritten;
							return true;
						}
						return Fail();
					}
					text = ((IFormattable)(object)value).ToString(format, _provider);
				}
				else
				{
					text = value?.ToString();
				}
				if (text != null)
				{
					return AppendStringDirect(text);
				}
				return true;
			}

			public bool AppendFormatted<T>(T value, int alignment)
			{
				int pos = _pos;
				if (AppendFormatted(value))
				{
					if (alignment != 0)
					{
						return TryAppendOrInsertAlignmentIfNeeded(pos, alignment);
					}
					return true;
				}
				return Fail();
			}

			public bool AppendFormatted<T>(T value, int alignment, string? format)
			{
				int pos = _pos;
				if (AppendFormatted(value, format))
				{
					if (alignment != 0)
					{
						return TryAppendOrInsertAlignmentIfNeeded(pos, alignment);
					}
					return true;
				}
				return Fail();
			}

			public bool AppendFormatted(ReadOnlySpan<char> value)
			{
				if (value.TryCopyTo(_destination.Slice(_pos)))
				{
					_pos += value.Length;
					return true;
				}
				return Fail();
			}

			public bool AppendFormatted(ReadOnlySpan<char> value, int alignment = 0, string? format = null)
			{
				bool flag = false;
				if (alignment < 0)
				{
					flag = true;
					alignment = -alignment;
				}
				int num = alignment - value.Length;
				if (num <= 0)
				{
					return AppendFormatted(value);
				}
				if (alignment <= _destination.Length - _pos)
				{
					if (flag)
					{
						value.CopyTo(_destination.Slice(_pos));
						_pos += value.Length;
						_destination.Slice(_pos, num).Fill(' ');
						_pos += num;
					}
					else
					{
						_destination.Slice(_pos, num).Fill(' ');
						_pos += num;
						value.CopyTo(_destination.Slice(_pos));
						_pos += value.Length;
					}
					return true;
				}
				return Fail();
			}

			public bool AppendFormatted(string? value)
			{
				if (_hasCustomFormatter)
				{
					return AppendCustomFormatter(value, null);
				}
				if (value == null)
				{
					return true;
				}
				if (value.TryCopyTo(_destination.Slice(_pos)))
				{
					_pos += value.Length;
					return true;
				}
				return Fail();
			}

			public bool AppendFormatted(string? value, int alignment = 0, string? format = null)
			{
				return this.AppendFormatted<string>(value, alignment, format);
			}

			public bool AppendFormatted(object? value, int alignment = 0, string? format = null)
			{
				return this.AppendFormatted<object>(value, alignment, format);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private bool AppendCustomFormatter<T>(T value, string format)
			{
				ICustomFormatter customFormatter = (ICustomFormatter)_provider.GetFormat(typeof(ICustomFormatter));
				if (customFormatter != null)
				{
					string text = customFormatter.Format(format, value, _provider);
					if (text != null)
					{
						return AppendStringDirect(text);
					}
				}
				return true;
			}

			private bool TryAppendOrInsertAlignmentIfNeeded(int startingPos, int alignment)
			{
				int num = _pos - startingPos;
				bool flag = false;
				if (alignment < 0)
				{
					flag = true;
					alignment = -alignment;
				}
				int num2 = alignment - num;
				if (num2 <= 0)
				{
					return true;
				}
				if (num2 <= _destination.Length - _pos)
				{
					if (flag)
					{
						_destination.Slice(_pos, num2).Fill(' ');
					}
					else
					{
						_destination.Slice(startingPos, num).CopyTo(_destination.Slice(startingPos + num2));
						_destination.Slice(startingPos, num2).Fill(' ');
					}
					_pos += num2;
					return true;
				}
				return Fail();
			}

			private bool Fail()
			{
				_success = false;
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[]? array, int start)
		{
			if (array == null)
			{
				if (start != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				return default(Span<T>);
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start), array.Length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[]? array, Index startIndex)
		{
			if (array == null)
			{
				if (!startIndex.Equals(Index.Start))
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				return default(Span<T>);
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			int offset = startIndex.GetOffset(array.Length);
			if ((uint)offset > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)offset), array.Length - offset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[]? array, Range range)
		{
			if (array == null)
			{
				Index start = range.Start;
				Index end = range.End;
				if (!start.Equals(Index.Start) || !end.Equals(Index.Start))
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				return default(Span<T>);
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			var (num, length) = range.GetOffsetAndLength(array.Length);
			return new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)num), length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<char> AsSpan(this string? text)
		{
			if (text == null)
			{
				return default(ReadOnlySpan<char>);
			}
			return new ReadOnlySpan<char>(ref text.GetRawStringData(), text.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<char> AsSpan(this string? text, int start)
		{
			if (text == null)
			{
				if (start != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
				}
				return default(ReadOnlySpan<char>);
			}
			if ((uint)start > (uint)text.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetRawStringData(), (nint)(uint)start), text.Length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<char> AsSpan(this string? text, int start, int length)
		{
			if (text == null)
			{
				if (start != 0 || length != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
				}
				return default(ReadOnlySpan<char>);
			}
			if ((uint)start > (uint)text.Length || (uint)length > (uint)(text.Length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetRawStringData(), (nint)(uint)start), length);
		}

		public static ReadOnlyMemory<char> AsMemory(this string? text)
		{
			if (text == null)
			{
				return default(ReadOnlyMemory<char>);
			}
			return new ReadOnlyMemory<char>(text, 0, text.Length);
		}

		public static ReadOnlyMemory<char> AsMemory(this string? text, int start)
		{
			if (text == null)
			{
				if (start != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
				}
				return default(ReadOnlyMemory<char>);
			}
			if ((uint)start > (uint)text.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new ReadOnlyMemory<char>(text, start, text.Length - start);
		}

		public static ReadOnlyMemory<char> AsMemory(this string? text, Index startIndex)
		{
			if (text == null)
			{
				if (!startIndex.Equals(Index.Start))
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.text);
				}
				return default(ReadOnlyMemory<char>);
			}
			int offset = startIndex.GetOffset(text.Length);
			if ((uint)offset > (uint)text.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new ReadOnlyMemory<char>(text, offset, text.Length - offset);
		}

		public static ReadOnlyMemory<char> AsMemory(this string? text, int start, int length)
		{
			if (text == null)
			{
				if (start != 0 || length != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
				}
				return default(ReadOnlyMemory<char>);
			}
			if ((uint)start > (uint)text.Length || (uint)length > (uint)(text.Length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new ReadOnlyMemory<char>(text, start, length);
		}

		public static ReadOnlyMemory<char> AsMemory(this string? text, Range range)
		{
			if (text == null)
			{
				Index start = range.Start;
				Index end = range.End;
				if (!start.Equals(Index.Start) || !end.Equals(Index.Start))
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.text);
				}
				return default(ReadOnlyMemory<char>);
			}
			var (start2, length) = range.GetOffsetAndLength(text.Length);
			return new ReadOnlyMemory<char>(text, start2, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Contains<T>(this Span<T> span, T value) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.Contains(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.Contains(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
				}
			}
			return SpanHelpers.Contains(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Contains<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.Contains(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.Contains(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
				}
			}
			return SpanHelpers.Contains(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this Span<T> span, T value) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.IndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.IndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
				}
			}
			return SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.IndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), value.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.IndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)), value.Length);
				}
			}
			return SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOf<T>(this Span<T> span, T value) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.LastIndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.LastIndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
				}
			}
			return SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			if (Unsafe.SizeOf<T>() == 1 && RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				return SpanHelpers.LastIndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), value.Length);
			}
			return SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool SequenceEqual<T>(this Span<T> span, ReadOnlySpan<T> other) where T : IEquatable<T>
		{
			int length = span.Length;
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				nuint num = (nuint)Unsafe.SizeOf<T>();
				if (length == other.Length)
				{
					return SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), (uint)length * num);
				}
				return false;
			}
			if (length == other.Length)
			{
				return SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other), length);
			}
			return false;
		}

		public static int SequenceCompareTo<T>(this Span<T> span, ReadOnlySpan<T> other) where T : IComparable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return SpanHelpers.SequenceCompareTo(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return SpanHelpers.SequenceCompareTo(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			return SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(other), other.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.IndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.IndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
				}
			}
			return SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.IndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), value.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.IndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)), value.Length);
				}
			}
			return SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.LastIndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.LastIndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
				}
			}
			return SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			if (Unsafe.SizeOf<T>() == 1 && RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				return SpanHelpers.LastIndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), value.Length);
			}
			return SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this Span<T> span, T value0, T value1) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.IndexOfAny(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value0), Unsafe.As<T, char>(ref value1), span.Length);
				}
			}
			return SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this Span<T> span, T value0, T value1, T value2) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), Unsafe.As<T, byte>(ref value2), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.IndexOfAny(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value0), Unsafe.As<T, char>(ref value1), Unsafe.As<T, char>(ref value2), span.Length);
				}
			}
			return SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
		{
			return ((ReadOnlySpan<T>)span).IndexOfAny(values);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.IndexOfAny(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value0), Unsafe.As<T, char>(ref value1), span.Length);
				}
			}
			return SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					return SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), Unsafe.As<T, byte>(ref value2), span.Length);
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					return SpanHelpers.IndexOfAny(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value0), Unsafe.As<T, char>(ref value1), Unsafe.As<T, char>(ref value2), span.Length);
				}
			}
			return SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
		{
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				if (Unsafe.SizeOf<T>() == 1)
				{
					ref byte reference = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values));
					if (values.Length == 2)
					{
						return SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), reference, Unsafe.Add(ref reference, 1), span.Length);
					}
					if (values.Length == 3)
					{
						return SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), reference, Unsafe.Add(ref reference, 1), Unsafe.Add(ref reference, 2), span.Length);
					}
				}
				if (Unsafe.SizeOf<T>() == 2)
				{
					ref char reference2 = ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(values));
					if (values.Length == 5)
					{
						return SpanHelpers.IndexOfAny(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), reference2, Unsafe.Add(ref reference2, 1), Unsafe.Add(ref reference2, 2), Unsafe.Add(ref reference2, 3), Unsafe.Add(ref reference2, 4), span.Length);
					}
					if (values.Length == 2)
					{
						return SpanHelpers.IndexOfAny(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), reference2, Unsafe.Add(ref reference2, 1), span.Length);
					}
					if (values.Length == 4)
					{
						return SpanHelpers.IndexOfAny(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), reference2, Unsafe.Add(ref reference2, 1), Unsafe.Add(ref reference2, 2), Unsafe.Add(ref reference2, 3), span.Length);
					}
					if (values.Length == 3)
					{
						return SpanHelpers.IndexOfAny(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), reference2, Unsafe.Add(ref reference2, 1), Unsafe.Add(ref reference2, 2), span.Length);
					}
					if (values.Length == 1)
					{
						return SpanHelpers.IndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), reference2, span.Length);
					}
				}
			}
			return SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1) where T : IEquatable<T>
		{
			if (Unsafe.SizeOf<T>() == 1 && RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				return SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), span.Length);
			}
			return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1, T value2) where T : IEquatable<T>
		{
			if (Unsafe.SizeOf<T>() == 1 && RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				return SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), Unsafe.As<T, byte>(ref value2), span.Length);
			}
			return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
		{
			if (Unsafe.SizeOf<T>() == 1 && RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				return SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)), values.Length);
			}
			return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>
		{
			if (Unsafe.SizeOf<T>() == 1 && RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				return SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), span.Length);
			}
			return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>
		{
			if (Unsafe.SizeOf<T>() == 1 && RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				return SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), Unsafe.As<T, byte>(ref value2), span.Length);
			}
			return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
		{
			return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool SequenceEqual<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other) where T : IEquatable<T>
		{
			int length = span.Length;
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				nuint num = (nuint)Unsafe.SizeOf<T>();
				if (length == other.Length)
				{
					return SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), (uint)length * num);
				}
				return false;
			}
			if (length == other.Length)
			{
				return SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other), length);
			}
			return false;
		}

		public static bool SequenceEqual<T>(this Span<T> span, ReadOnlySpan<T> other, IEqualityComparer<T>? comparer = null)
		{
			return ((ReadOnlySpan<T>)span).SequenceEqual(other, comparer);
		}

		public static bool SequenceEqual<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, IEqualityComparer<T>? comparer = null)
		{
			if (span.Length != other.Length)
			{
				return false;
			}
			if (typeof(T).IsValueType && (comparer == null || comparer == EqualityComparer<T>.Default))
			{
				if (RuntimeHelpers.IsBitwiseEquatable<T>())
				{
					nuint num = (nuint)Unsafe.SizeOf<T>();
					return SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), (uint)span.Length * num);
				}
				for (int i = 0; i < span.Length; i++)
				{
					if (!EqualityComparer<T>.Default.Equals(span[i], other[i]))
					{
						return false;
					}
				}
				return true;
			}
			if (comparer == null)
			{
				comparer = EqualityComparer<T>.Default;
			}
			for (int j = 0; j < span.Length; j++)
			{
				if (!comparer.Equals(span[j], other[j]))
				{
					return false;
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SequenceCompareTo<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other) where T : IComparable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return SpanHelpers.SequenceCompareTo(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return SpanHelpers.SequenceCompareTo(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			return SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(other), other.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool StartsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			int length = value.Length;
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				nuint num = (nuint)Unsafe.SizeOf<T>();
				if (length <= span.Length)
				{
					return SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (uint)length * num);
				}
				return false;
			}
			if (length <= span.Length)
			{
				return SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), length);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			int length = value.Length;
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				nuint num = (nuint)Unsafe.SizeOf<T>();
				if (length <= span.Length)
				{
					return SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (uint)length * num);
				}
				return false;
			}
			if (length <= span.Length)
			{
				return SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), length);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EndsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			int length = span.Length;
			int length2 = value.Length;
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				nuint num = (nuint)Unsafe.SizeOf<T>();
				if (length2 <= length)
				{
					return SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)(uint)(length - length2))), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (uint)length2 * num);
				}
				return false;
			}
			if (length2 <= length)
			{
				return SpanHelpers.SequenceEqual(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)(uint)(length - length2)), ref MemoryMarshal.GetReference(value), length2);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EndsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			int length = span.Length;
			int length2 = value.Length;
			if (RuntimeHelpers.IsBitwiseEquatable<T>())
			{
				nuint num = (nuint)Unsafe.SizeOf<T>();
				if (length2 <= length)
				{
					return SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)(uint)(length - length2))), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (uint)length2 * num);
				}
				return false;
			}
			if (length2 <= length)
			{
				return SpanHelpers.SequenceEqual(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)(uint)(length - length2)), ref MemoryMarshal.GetReference(value), length2);
			}
			return false;
		}

		public static void Reverse<T>(this Span<T> span)
		{
			if (span.Length > 1)
			{
				ref T reference = ref MemoryMarshal.GetReference(span);
				ref T reference2 = ref Unsafe.Add(ref Unsafe.Add(ref reference, span.Length), -1);
				do
				{
					T val = reference;
					reference = reference2;
					reference2 = val;
					reference = ref Unsafe.Add(ref reference, 1);
					reference2 = ref Unsafe.Add(ref reference2, -1);
				}
				while (Unsafe.IsAddressLessThan(ref reference, ref reference2));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[]? array)
		{
			return new Span<T>(array);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[]? array, int start, int length)
		{
			return new Span<T>(array, start, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this ArraySegment<T> segment)
		{
			return new Span<T>(segment.Array, segment.Offset, segment.Count);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this ArraySegment<T> segment, int start)
		{
			if ((uint)start > (uint)segment.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new Span<T>(segment.Array, segment.Offset + start, segment.Count - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this ArraySegment<T> segment, Index startIndex)
		{
			int offset = startIndex.GetOffset(segment.Count);
			return segment.AsSpan(offset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this ArraySegment<T> segment, int start, int length)
		{
			if ((uint)start > (uint)segment.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			if ((uint)length > (uint)(segment.Count - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
			}
			return new Span<T>(segment.Array, segment.Offset + start, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this ArraySegment<T> segment, Range range)
		{
			var (num, length) = range.GetOffsetAndLength(segment.Count);
			return new Span<T>(segment.Array, segment.Offset + num, length);
		}

		public static Memory<T> AsMemory<T>(this T[]? array)
		{
			return new Memory<T>(array);
		}

		public static Memory<T> AsMemory<T>(this T[]? array, int start)
		{
			return new Memory<T>(array, start);
		}

		public static Memory<T> AsMemory<T>(this T[]? array, Index startIndex)
		{
			if (array == null)
			{
				if (!startIndex.Equals(Index.Start))
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				return default(Memory<T>);
			}
			int offset = startIndex.GetOffset(array.Length);
			return new Memory<T>(array, offset);
		}

		public static Memory<T> AsMemory<T>(this T[]? array, int start, int length)
		{
			return new Memory<T>(array, start, length);
		}

		public static Memory<T> AsMemory<T>(this T[]? array, Range range)
		{
			if (array == null)
			{
				Index start = range.Start;
				Index end = range.End;
				if (!start.Equals(Index.Start) || !end.Equals(Index.Start))
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				return default(Memory<T>);
			}
			var (start2, length) = range.GetOffsetAndLength(array.Length);
			return new Memory<T>(array, start2, length);
		}

		public static Memory<T> AsMemory<T>(this ArraySegment<T> segment)
		{
			return new Memory<T>(segment.Array, segment.Offset, segment.Count);
		}

		public static Memory<T> AsMemory<T>(this ArraySegment<T> segment, int start)
		{
			if ((uint)start > (uint)segment.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new Memory<T>(segment.Array, segment.Offset + start, segment.Count - start);
		}

		public static Memory<T> AsMemory<T>(this ArraySegment<T> segment, int start, int length)
		{
			if ((uint)start > (uint)segment.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			if ((uint)length > (uint)(segment.Count - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
			}
			return new Memory<T>(segment.Array, segment.Offset + start, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void CopyTo<T>(this T[]? source, Span<T> destination)
		{
			new ReadOnlySpan<T>(source).CopyTo(destination);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void CopyTo<T>(this T[]? source, Memory<T> destination)
		{
			source.CopyTo(destination.Span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Overlaps<T>(this Span<T> span, ReadOnlySpan<T> other)
		{
			return ((ReadOnlySpan<T>)span).Overlaps(other);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Overlaps<T>(this Span<T> span, ReadOnlySpan<T> other, out int elementOffset)
		{
			return ((ReadOnlySpan<T>)span).Overlaps(other, out elementOffset);
		}

		public static bool Overlaps<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other)
		{
			if (span.IsEmpty || other.IsEmpty)
			{
				return false;
			}
			IntPtr intPtr = Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other));
			if (Unsafe.SizeOf<IntPtr>() == 4)
			{
				if ((uint)(int)intPtr >= (uint)(span.Length * Unsafe.SizeOf<T>()))
				{
					return (uint)(int)intPtr > (uint)(-(other.Length * Unsafe.SizeOf<T>()));
				}
				return true;
			}
			if ((ulong)(long)intPtr >= (ulong)((long)span.Length * (long)Unsafe.SizeOf<T>()))
			{
				return (ulong)(long)intPtr > (ulong)(-((long)other.Length * (long)Unsafe.SizeOf<T>()));
			}
			return true;
		}

		public static bool Overlaps<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, out int elementOffset)
		{
			if (span.IsEmpty || other.IsEmpty)
			{
				elementOffset = 0;
				return false;
			}
			IntPtr intPtr = Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other));
			if (Unsafe.SizeOf<IntPtr>() == 4)
			{
				if ((uint)(int)intPtr < (uint)(span.Length * Unsafe.SizeOf<T>()) || (uint)(int)intPtr > (uint)(-(other.Length * Unsafe.SizeOf<T>())))
				{
					if ((int)intPtr % Unsafe.SizeOf<T>() != 0)
					{
						ThrowHelper.ThrowArgumentException_OverlapAlignmentMismatch();
					}
					elementOffset = (int)intPtr / Unsafe.SizeOf<T>();
					return true;
				}
				elementOffset = 0;
				return false;
			}
			if ((ulong)(long)intPtr < (ulong)((long)span.Length * (long)Unsafe.SizeOf<T>()) || (ulong)(long)intPtr > (ulong)(-((long)other.Length * (long)Unsafe.SizeOf<T>())))
			{
				if ((long)intPtr % Unsafe.SizeOf<T>() != 0L)
				{
					ThrowHelper.ThrowArgumentException_OverlapAlignmentMismatch();
				}
				elementOffset = (int)((long)intPtr / Unsafe.SizeOf<T>());
				return true;
			}
			elementOffset = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T>(this Span<T> span, IComparable<T> comparable)
		{
			return span.BinarySearch<T, IComparable<T>>(comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparable>(this Span<T> span, TComparable comparable) where TComparable : IComparable<T>
		{
			return BinarySearch((ReadOnlySpan<T>)span, comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparer>(this Span<T> span, T value, TComparer comparer) where TComparer : IComparer<T>
		{
			return ((ReadOnlySpan<T>)span).BinarySearch(value, comparer);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T>(this ReadOnlySpan<T> span, IComparable<T> comparable)
		{
			return MemoryExtensions.BinarySearch<T, IComparable<T>>(span, comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparable>(this ReadOnlySpan<T> span, TComparable comparable) where TComparable : IComparable<T>
		{
			return SpanHelpers.BinarySearch(span, comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparer>(this ReadOnlySpan<T> span, T value, TComparer comparer) where TComparer : IComparer<T>
		{
			if (comparer == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparer);
			}
			SpanHelpers.ComparerComparable<T, TComparer> comparable = new SpanHelpers.ComparerComparable<T, TComparer>(value, comparer);
			return BinarySearch(span, comparable);
		}

		public static void Sort<T>(this Span<T> span)
		{
			span.Sort((IComparer<T>)null);
		}

		public static void Sort<T, TComparer>(this Span<T> span, TComparer comparer) where TComparer : IComparer<T>?
		{
			if (span.Length > 1)
			{
				ArraySortHelper<T>.Default.Sort(span, comparer);
			}
		}

		public static void Sort<T>(this Span<T> span, Comparison<T> comparison)
		{
			if (comparison == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparison);
			}
			if (span.Length > 1)
			{
				ArraySortHelper<T>.Sort(span, comparison);
			}
		}

		public static void Sort<TKey, TValue>(this Span<TKey> keys, Span<TValue> items)
		{
			keys.Sort<TKey, TValue, IComparer<TKey>>(items, null);
		}

		public static void Sort<TKey, TValue, TComparer>(this Span<TKey> keys, Span<TValue> items, TComparer comparer) where TComparer : IComparer<TKey>?
		{
			if (keys.Length != items.Length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_SpansMustHaveSameLength);
			}
			if (keys.Length > 1)
			{
				ArraySortHelper<TKey, TValue>.Default.Sort(keys, items, comparer);
			}
		}

		public static void Sort<TKey, TValue>(this Span<TKey> keys, Span<TValue> items, Comparison<TKey> comparison)
		{
			if (comparison == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparison);
			}
			if (keys.Length != items.Length)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_SpansMustHaveSameLength);
			}
			if (keys.Length > 1)
			{
				ArraySortHelper<TKey, TValue>.Default.Sort(keys, items, new ComparisonComparer<TKey>(comparison));
			}
		}

		public static bool TryWrite(this Span<char> destination, [InterpolatedStringHandlerArgument("destination")] ref TryWriteInterpolatedStringHandler handler, out int charsWritten)
		{
			if (handler._success)
			{
				charsWritten = handler._pos;
				return true;
			}
			charsWritten = 0;
			return false;
		}

		public static bool TryWrite(this Span<char> destination, IFormatProvider? provider, [InterpolatedStringHandlerArgument(new string[] { "destination", "provider" })] ref TryWriteInterpolatedStringHandler handler, out int charsWritten)
		{
			return destination.TryWrite(ref handler, out charsWritten);
		}

		public static bool IsWhiteSpace(this ReadOnlySpan<char> span)
		{
			for (int i = 0; i < span.Length; i++)
			{
				if (!char.IsWhiteSpace(span[i]))
				{
					return false;
				}
			}
			return true;
		}

		public static bool Contains(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			return span.IndexOf(value, comparisonType) >= 0;
		}

		public static bool Equals(this ReadOnlySpan<char> span, ReadOnlySpan<char> other, StringComparison comparisonType)
		{
			string.CheckStringComparison(comparisonType);
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.Compare(span, other, string.GetCaseCompareOfComparisonCulture(comparisonType)) == 0;
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.Compare(span, other, string.GetCaseCompareOfComparisonCulture(comparisonType)) == 0;
			case StringComparison.Ordinal:
				return span.EqualsOrdinal(other);
			default:
				return span.EqualsOrdinalIgnoreCase(other);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EqualsOrdinal(this ReadOnlySpan<char> span, ReadOnlySpan<char> value)
		{
			if (span.Length != value.Length)
			{
				return false;
			}
			if (value.Length == 0)
			{
				return true;
			}
			return span.SequenceEqual(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EqualsOrdinalIgnoreCase(this ReadOnlySpan<char> span, ReadOnlySpan<char> value)
		{
			if (span.Length != value.Length)
			{
				return false;
			}
			if (value.Length == 0)
			{
				return true;
			}
			return Ordinal.EqualsIgnoreCase(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), span.Length);
		}

		public static int CompareTo(this ReadOnlySpan<char> span, ReadOnlySpan<char> other, StringComparison comparisonType)
		{
			string.CheckStringComparison(comparisonType);
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.Compare(span, other, string.GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.Compare(span, other, string.GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				if (span.Length == 0 || other.Length == 0)
				{
					return span.Length - other.Length;
				}
				return string.CompareOrdinal(span, other);
			default:
				return Ordinal.CompareStringIgnoreCase(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(other), other.Length);
			}
		}

		public static int IndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			string.CheckStringComparison(comparisonType);
			switch (comparisonType)
			{
			case StringComparison.Ordinal:
				return SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.IndexOf(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.IndexOf(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType));
			default:
				return Ordinal.IndexOfOrdinalIgnoreCase(span, value);
			}
		}

		public static int LastIndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			string.CheckStringComparison(comparisonType);
			switch (comparisonType)
			{
			case StringComparison.Ordinal:
				return SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.LastIndexOf(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.LastIndexOf(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType));
			default:
				return Ordinal.LastIndexOfOrdinalIgnoreCase(span, value);
			}
		}

		public static int ToLower(this ReadOnlySpan<char> source, Span<char> destination, CultureInfo? culture)
		{
			if (source.Overlaps(destination))
			{
				throw new InvalidOperationException(SR.InvalidOperation_SpanOverlappedOperation);
			}
			if (culture == null)
			{
				culture = CultureInfo.CurrentCulture;
			}
			if (destination.Length < source.Length)
			{
				return -1;
			}
			if (GlobalizationMode.Invariant)
			{
				InvariantModeCasing.ToLower(source, destination);
			}
			else
			{
				culture.TextInfo.ChangeCaseToLower(source, destination);
			}
			return source.Length;
		}

		public static int ToLowerInvariant(this ReadOnlySpan<char> source, Span<char> destination)
		{
			if (source.Overlaps(destination))
			{
				throw new InvalidOperationException(SR.InvalidOperation_SpanOverlappedOperation);
			}
			if (destination.Length < source.Length)
			{
				return -1;
			}
			if (GlobalizationMode.Invariant)
			{
				InvariantModeCasing.ToLower(source, destination);
			}
			else
			{
				TextInfo.Invariant.ChangeCaseToLower(source, destination);
			}
			return source.Length;
		}

		public static int ToUpper(this ReadOnlySpan<char> source, Span<char> destination, CultureInfo? culture)
		{
			if (source.Overlaps(destination))
			{
				throw new InvalidOperationException(SR.InvalidOperation_SpanOverlappedOperation);
			}
			if (culture == null)
			{
				culture = CultureInfo.CurrentCulture;
			}
			if (destination.Length < source.Length)
			{
				return -1;
			}
			if (GlobalizationMode.Invariant)
			{
				InvariantModeCasing.ToUpper(source, destination);
			}
			else
			{
				culture.TextInfo.ChangeCaseToUpper(source, destination);
			}
			return source.Length;
		}

		public static int ToUpperInvariant(this ReadOnlySpan<char> source, Span<char> destination)
		{
			if (source.Overlaps(destination))
			{
				throw new InvalidOperationException(SR.InvalidOperation_SpanOverlappedOperation);
			}
			if (destination.Length < source.Length)
			{
				return -1;
			}
			if (GlobalizationMode.Invariant)
			{
				InvariantModeCasing.ToUpper(source, destination);
			}
			else
			{
				TextInfo.Invariant.ChangeCaseToUpper(source, destination);
			}
			return source.Length;
		}

		public static bool EndsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			string.CheckStringComparison(comparisonType);
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.IsSuffix(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.IsSuffix(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				return span.EndsWith(value);
			default:
				return span.EndsWithOrdinalIgnoreCase(value);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EndsWithOrdinalIgnoreCase(this ReadOnlySpan<char> span, ReadOnlySpan<char> value)
		{
			if (value.Length <= span.Length)
			{
				return Ordinal.EqualsIgnoreCase(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), span.Length - value.Length), ref MemoryMarshal.GetReference(value), value.Length);
			}
			return false;
		}

		public static bool StartsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			string.CheckStringComparison(comparisonType);
			switch (comparisonType)
			{
			case StringComparison.CurrentCulture:
			case StringComparison.CurrentCultureIgnoreCase:
				return CultureInfo.CurrentCulture.CompareInfo.IsPrefix(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.InvariantCulture:
			case StringComparison.InvariantCultureIgnoreCase:
				return CompareInfo.Invariant.IsPrefix(span, value, string.GetCaseCompareOfComparisonCulture(comparisonType));
			case StringComparison.Ordinal:
				return span.StartsWith(value);
			default:
				return span.StartsWithOrdinalIgnoreCase(value);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool StartsWithOrdinalIgnoreCase(this ReadOnlySpan<char> span, ReadOnlySpan<char> value)
		{
			if (value.Length <= span.Length)
			{
				return Ordinal.EqualsIgnoreCase(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), value.Length);
			}
			return false;
		}

		public static SpanRuneEnumerator EnumerateRunes(this ReadOnlySpan<char> span)
		{
			return new SpanRuneEnumerator(span);
		}

		public static SpanRuneEnumerator EnumerateRunes(this Span<char> span)
		{
			return new SpanRuneEnumerator(span);
		}

		public static SpanLineEnumerator EnumerateLines(this ReadOnlySpan<char> span)
		{
			return new SpanLineEnumerator(span);
		}

		public static SpanLineEnumerator EnumerateLines(this Span<char> span)
		{
			return new SpanLineEnumerator(span);
		}

		public static Memory<T> Trim<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>
		{
			ReadOnlySpan<T> span = memory.Span;
			int start = ClampStart(span, trimElement);
			int length = ClampEnd(span, start, trimElement);
			return memory.Slice(start, length);
		}

		public static Memory<T> TrimStart<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>
		{
			return memory.Slice(ClampStart(memory.Span, trimElement));
		}

		public static Memory<T> TrimEnd<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>
		{
			return memory.Slice(0, ClampEnd(memory.Span, 0, trimElement));
		}

		public static ReadOnlyMemory<T> Trim<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>
		{
			ReadOnlySpan<T> span = memory.Span;
			int start = ClampStart(span, trimElement);
			int length = ClampEnd(span, start, trimElement);
			return memory.Slice(start, length);
		}

		public static ReadOnlyMemory<T> TrimStart<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>
		{
			return memory.Slice(ClampStart(memory.Span, trimElement));
		}

		public static ReadOnlyMemory<T> TrimEnd<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>
		{
			return memory.Slice(0, ClampEnd(memory.Span, 0, trimElement));
		}

		public static Span<T> Trim<T>(this Span<T> span, T trimElement) where T : IEquatable<T>
		{
			int start = ClampStart(span, trimElement);
			int length = ClampEnd(span, start, trimElement);
			return span.Slice(start, length);
		}

		public static Span<T> TrimStart<T>(this Span<T> span, T trimElement) where T : IEquatable<T>
		{
			return span.Slice(ClampStart(span, trimElement));
		}

		public static Span<T> TrimEnd<T>(this Span<T> span, T trimElement) where T : IEquatable<T>
		{
			return span.Slice(0, ClampEnd(span, 0, trimElement));
		}

		public static ReadOnlySpan<T> Trim<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>
		{
			int start = ClampStart(span, trimElement);
			int length = ClampEnd(span, start, trimElement);
			return span.Slice(start, length);
		}

		public static ReadOnlySpan<T> TrimStart<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>
		{
			return span.Slice(ClampStart(span, trimElement));
		}

		public static ReadOnlySpan<T> TrimEnd<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>
		{
			return span.Slice(0, ClampEnd(span, 0, trimElement));
		}

		private static int ClampStart<T>(ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>
		{
			int i = 0;
			if (trimElement != null)
			{
				for (; i < span.Length && trimElement.Equals(span[i]); i++)
				{
				}
			}
			else
			{
				for (; i < span.Length && span[i] == null; i++)
				{
				}
			}
			return i;
		}

		private static int ClampEnd<T>(ReadOnlySpan<T> span, int start, T trimElement) where T : IEquatable<T>
		{
			int num = span.Length - 1;
			if (trimElement != null)
			{
				while (num >= start && trimElement.Equals(span[num]))
				{
					num--;
				}
			}
			else
			{
				while (num >= start && span[num] == null)
				{
					num--;
				}
			}
			return num - start + 1;
		}

		public static Memory<T> Trim<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				ReadOnlySpan<T> span = memory.Span;
				int start = ClampStart<T>(span, trimElements);
				int length = ClampEnd<T>(span, start, trimElements);
				return memory.Slice(start, length);
			}
			if (trimElements.Length == 1)
			{
				return memory.Trim(trimElements[0]);
			}
			return memory;
		}

		public static Memory<T> TrimStart<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				return memory.Slice(ClampStart(memory.Span, trimElements));
			}
			if (trimElements.Length == 1)
			{
				return memory.TrimStart(trimElements[0]);
			}
			return memory;
		}

		public static Memory<T> TrimEnd<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				return memory.Slice(0, ClampEnd(memory.Span, 0, trimElements));
			}
			if (trimElements.Length == 1)
			{
				return memory.TrimEnd(trimElements[0]);
			}
			return memory;
		}

		public static ReadOnlyMemory<T> Trim<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				ReadOnlySpan<T> span = memory.Span;
				int start = ClampStart<T>(span, trimElements);
				int length = ClampEnd<T>(span, start, trimElements);
				return memory.Slice(start, length);
			}
			if (trimElements.Length == 1)
			{
				return memory.Trim(trimElements[0]);
			}
			return memory;
		}

		public static ReadOnlyMemory<T> TrimStart<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				return memory.Slice(ClampStart(memory.Span, trimElements));
			}
			if (trimElements.Length == 1)
			{
				return memory.TrimStart(trimElements[0]);
			}
			return memory;
		}

		public static ReadOnlyMemory<T> TrimEnd<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				return memory.Slice(0, ClampEnd(memory.Span, 0, trimElements));
			}
			if (trimElements.Length == 1)
			{
				return memory.TrimEnd(trimElements[0]);
			}
			return memory;
		}

		public static Span<T> Trim<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				int start = ClampStart(span, trimElements);
				int length = ClampEnd(span, start, trimElements);
				return span.Slice(start, length);
			}
			if (trimElements.Length == 1)
			{
				return span.Trim(trimElements[0]);
			}
			return span;
		}

		public static Span<T> TrimStart<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				return span.Slice(ClampStart(span, trimElements));
			}
			if (trimElements.Length == 1)
			{
				return span.TrimStart(trimElements[0]);
			}
			return span;
		}

		public static Span<T> TrimEnd<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				return span.Slice(0, ClampEnd(span, 0, trimElements));
			}
			if (trimElements.Length == 1)
			{
				return span.TrimEnd(trimElements[0]);
			}
			return span;
		}

		public static ReadOnlySpan<T> Trim<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				int start = ClampStart(span, trimElements);
				int length = ClampEnd(span, start, trimElements);
				return span.Slice(start, length);
			}
			if (trimElements.Length == 1)
			{
				return span.Trim(trimElements[0]);
			}
			return span;
		}

		public static ReadOnlySpan<T> TrimStart<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				return span.Slice(ClampStart(span, trimElements));
			}
			if (trimElements.Length == 1)
			{
				return span.TrimStart(trimElements[0]);
			}
			return span;
		}

		public static ReadOnlySpan<T> TrimEnd<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			if (trimElements.Length > 1)
			{
				return span.Slice(0, ClampEnd(span, 0, trimElements));
			}
			if (trimElements.Length == 1)
			{
				return span.TrimEnd(trimElements[0]);
			}
			return span;
		}

		private static int ClampStart<T>(ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			int i;
			for (i = 0; i < span.Length && trimElements.Contains(span[i]); i++)
			{
			}
			return i;
		}

		private static int ClampEnd<T>(ReadOnlySpan<T> span, int start, ReadOnlySpan<T> trimElements) where T : IEquatable<T>
		{
			int num = span.Length - 1;
			while (num >= start && trimElements.Contains(span[num]))
			{
				num--;
			}
			return num - start + 1;
		}

		public static Memory<char> Trim(this Memory<char> memory)
		{
			ReadOnlySpan<char> span = memory.Span;
			int start = ClampStart(span);
			int length = ClampEnd(span, start);
			return memory.Slice(start, length);
		}

		public static Memory<char> TrimStart(this Memory<char> memory)
		{
			return memory.Slice(ClampStart(memory.Span));
		}

		public static Memory<char> TrimEnd(this Memory<char> memory)
		{
			return memory.Slice(0, ClampEnd(memory.Span, 0));
		}

		public static ReadOnlyMemory<char> Trim(this ReadOnlyMemory<char> memory)
		{
			ReadOnlySpan<char> span = memory.Span;
			int start = ClampStart(span);
			int length = ClampEnd(span, start);
			return memory.Slice(start, length);
		}

		public static ReadOnlyMemory<char> TrimStart(this ReadOnlyMemory<char> memory)
		{
			return memory.Slice(ClampStart(memory.Span));
		}

		public static ReadOnlyMemory<char> TrimEnd(this ReadOnlyMemory<char> memory)
		{
			return memory.Slice(0, ClampEnd(memory.Span, 0));
		}

		public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span)
		{
			int i;
			for (i = 0; i < span.Length && char.IsWhiteSpace(span[i]); i++)
			{
			}
			int num = span.Length - 1;
			while (num > i && char.IsWhiteSpace(span[num]))
			{
				num--;
			}
			return span.Slice(i, num - i + 1);
		}

		public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span)
		{
			int i;
			for (i = 0; i < span.Length && char.IsWhiteSpace(span[i]); i++)
			{
			}
			return span.Slice(i);
		}

		public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span)
		{
			int num = span.Length - 1;
			while (num >= 0 && char.IsWhiteSpace(span[num]))
			{
				num--;
			}
			return span.Slice(0, num + 1);
		}

		public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, char trimChar)
		{
			int i;
			for (i = 0; i < span.Length && span[i] == trimChar; i++)
			{
			}
			int num = span.Length - 1;
			while (num > i && span[num] == trimChar)
			{
				num--;
			}
			return span.Slice(i, num - i + 1);
		}

		public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, char trimChar)
		{
			int i;
			for (i = 0; i < span.Length && span[i] == trimChar; i++)
			{
			}
			return span.Slice(i);
		}

		public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, char trimChar)
		{
			int num = span.Length - 1;
			while (num >= 0 && span[num] == trimChar)
			{
				num--;
			}
			return span.Slice(0, num + 1);
		}

		public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
		{
			return span.TrimStart(trimChars).TrimEnd(trimChars);
		}

		public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
		{
			if (trimChars.IsEmpty)
			{
				return span.TrimStart();
			}
			int i;
			for (i = 0; i < span.Length; i++)
			{
				int num = 0;
				while (num < trimChars.Length)
				{
					if (span[i] != trimChars[num])
					{
						num++;
						continue;
					}
					goto IL_003c;
				}
				break;
				IL_003c:;
			}
			return span.Slice(i);
		}

		public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
		{
			if (trimChars.IsEmpty)
			{
				return span.TrimEnd();
			}
			int num;
			for (num = span.Length - 1; num >= 0; num--)
			{
				int num2 = 0;
				while (num2 < trimChars.Length)
				{
					if (span[num] != trimChars[num2])
					{
						num2++;
						continue;
					}
					goto IL_0044;
				}
				break;
				IL_0044:;
			}
			return span.Slice(0, num + 1);
		}

		public static Span<char> Trim(this Span<char> span)
		{
			int start = ClampStart(span);
			int length = ClampEnd(span, start);
			return span.Slice(start, length);
		}

		public static Span<char> TrimStart(this Span<char> span)
		{
			return span.Slice(ClampStart(span));
		}

		public static Span<char> TrimEnd(this Span<char> span)
		{
			return span.Slice(0, ClampEnd(span, 0));
		}

		private static int ClampStart(ReadOnlySpan<char> span)
		{
			int i;
			for (i = 0; i < span.Length && char.IsWhiteSpace(span[i]); i++)
			{
			}
			return i;
		}

		private static int ClampEnd(ReadOnlySpan<char> span, int start)
		{
			int num = span.Length - 1;
			while (num >= start && char.IsWhiteSpace(span[num]))
			{
				num--;
			}
			return num - start + 1;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class MethodAccessException : MemberAccessException
	{
		public MethodAccessException()
			: base(SR.Arg_MethodAccessException)
		{
			base.HResult = -2146233072;
		}

		public MethodAccessException(string? message)
			: base(message)
		{
			base.HResult = -2146233072;
		}

		public MethodAccessException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233072;
		}

		protected MethodAccessException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public enum MidpointRounding
	{
		ToEven,
		AwayFromZero,
		ToZero,
		ToNegativeInfinity,
		ToPositiveInfinity
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class MissingFieldException : MissingMemberException, ISerializable
	{
		public override string Message
		{
			get
			{
				if (ClassName == null)
				{
					return base.Message;
				}
				return SR.Format(SR.MissingField_Name, ((Signature != null) ? (MissingMemberException.FormatSignature(Signature) + " ") : "") + ClassName + "." + MemberName);
			}
		}

		public MissingFieldException()
			: base(SR.Arg_MissingFieldException)
		{
			base.HResult = -2146233071;
		}

		public MissingFieldException(string? message)
			: base(message)
		{
			base.HResult = -2146233071;
		}

		public MissingFieldException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233071;
		}

		public MissingFieldException(string? className, string? fieldName)
		{
			ClassName = className;
			MemberName = fieldName;
		}

		protected MissingFieldException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class MissingMethodException : MissingMemberException
	{
		public override string Message
		{
			get
			{
				if (ClassName != null)
				{
					return SR.Format(SR.MissingMethod_Name, ClassName + "." + MemberName + ((Signature != null) ? (" " + MissingMemberException.FormatSignature(Signature)) : string.Empty));
				}
				return base.Message;
			}
		}

		public MissingMethodException()
			: base(SR.Arg_MissingMethodException)
		{
			base.HResult = -2146233069;
		}

		public MissingMethodException(string? message)
			: base(message)
		{
			base.HResult = -2146233069;
		}

		public MissingMethodException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233069;
		}

		public MissingMethodException(string? className, string? methodName)
		{
			ClassName = className;
			MemberName = methodName;
		}

		protected MissingMethodException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class MulticastNotSupportedException : SystemException
	{
		public MulticastNotSupportedException()
			: base(SR.Arg_MulticastNotSupportedException)
		{
			base.HResult = -2146233068;
		}

		public MulticastNotSupportedException(string? message)
			: base(message)
		{
			base.HResult = -2146233068;
		}

		public MulticastNotSupportedException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233068;
		}

		private MulticastNotSupportedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Field, Inherited = false)]
	public sealed class NonSerializedAttribute : Attribute
	{
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class NotFiniteNumberException : ArithmeticException
	{
		private readonly double _offendingNumber;

		public double OffendingNumber => _offendingNumber;

		public NotFiniteNumberException()
			: base(SR.Arg_NotFiniteNumberException)
		{
			_offendingNumber = 0.0;
			base.HResult = -2146233048;
		}

		public NotFiniteNumberException(double offendingNumber)
		{
			_offendingNumber = offendingNumber;
			base.HResult = -2146233048;
		}

		public NotFiniteNumberException(string? message)
			: base(message)
		{
			_offendingNumber = 0.0;
			base.HResult = -2146233048;
		}

		public NotFiniteNumberException(string? message, double offendingNumber)
			: base(message)
		{
			_offendingNumber = offendingNumber;
			base.HResult = -2146233048;
		}

		public NotFiniteNumberException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233048;
		}

		public NotFiniteNumberException(string? message, double offendingNumber, Exception? innerException)
			: base(message, innerException)
		{
			_offendingNumber = offendingNumber;
			base.HResult = -2146233048;
		}

		protected NotFiniteNumberException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_offendingNumber = info.GetDouble("OffendingNumber");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("OffendingNumber", _offendingNumber, typeof(double));
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class NotImplementedException : SystemException
	{
		public NotImplementedException()
			: base(SR.Arg_NotImplementedException)
		{
			base.HResult = -2147467263;
		}

		public NotImplementedException(string? message)
			: base(message)
		{
			base.HResult = -2147467263;
		}

		public NotImplementedException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147467263;
		}

		protected NotImplementedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class NotSupportedException : SystemException
	{
		public NotSupportedException()
			: base(SR.Arg_NotSupportedException)
		{
			base.HResult = -2146233067;
		}

		public NotSupportedException(string? message)
			: base(message)
		{
			base.HResult = -2146233067;
		}

		public NotSupportedException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233067;
		}

		protected NotSupportedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[NonVersionable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct Nullable<T> where T : struct
	{
		private readonly bool hasValue;

		internal T value;

		public readonly bool HasValue
		{
			[NonVersionable]
			get
			{
				return hasValue;
			}
		}

		public readonly T Value
		{
			get
			{
				if (!hasValue)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_NoValue();
				}
				return value;
			}
		}

		[NonVersionable]
		public Nullable(T value)
		{
			this.value = value;
			hasValue = true;
		}

		[NonVersionable]
		public readonly T GetValueOrDefault()
		{
			return value;
		}

		[NonVersionable]
		public readonly T GetValueOrDefault(T defaultValue)
		{
			if (!hasValue)
			{
				return defaultValue;
			}
			return value;
		}

		public override bool Equals(object? other)
		{
			if (!hasValue)
			{
				return other == null;
			}
			if (other == null)
			{
				return false;
			}
			return value.Equals(other);
		}

		public override int GetHashCode()
		{
			if (!hasValue)
			{
				return 0;
			}
			return value.GetHashCode();
		}

		public override string? ToString()
		{
			if (!hasValue)
			{
				return "";
			}
			return value.ToString();
		}

		[NonVersionable]
		public static implicit operator T?(T value)
		{
			return value;
		}

		[NonVersionable]
		public static explicit operator T(T? value)
		{
			return value.Value;
		}
	}
	public static class Nullable
	{
		public static int Compare<T>(T? n1, T? n2) where T : struct
		{
			if (n1.HasValue)
			{
				if (n2.HasValue)
				{
					return Comparer<T>.Default.Compare(n1.value, n2.value);
				}
				return 1;
			}
			if (n2.HasValue)
			{
				return -1;
			}
			return 0;
		}

		public static bool Equals<T>(T? n1, T? n2) where T : struct
		{
			if (n1.HasValue)
			{
				if (n2.HasValue)
				{
					return EqualityComparer<T>.Default.Equals(n1.value, n2.value);
				}
				return false;
			}
			if (n2.HasValue)
			{
				return false;
			}
			return true;
		}

		public static Type? GetUnderlyingType(Type nullableType)
		{
			if ((object)nullableType == null)
			{
				throw new ArgumentNullException("nullableType");
			}
			if (nullableType.IsGenericType && !nullableType.IsGenericTypeDefinition)
			{
				Type genericTypeDefinition = nullableType.GetGenericTypeDefinition();
				if ((object)genericTypeDefinition == typeof(Nullable<>))
				{
					return nullableType.GetGenericArguments()[0];
				}
			}
			return null;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class NullReferenceException : SystemException
	{
		public NullReferenceException()
			: base(SR.Arg_NullReferenceException)
		{
			base.HResult = -2147467261;
		}

		public NullReferenceException(string? message)
			: base(message)
		{
			base.HResult = -2147467261;
		}

		public NullReferenceException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147467261;
		}

		protected NullReferenceException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal static class Number
	{
		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		internal ref struct BigInteger
		{
			private static readonly uint[] s_Pow10UInt32Table = new uint[10] { 1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u, 10000000u, 100000000u, 1000000000u };

			private static readonly int[] s_Pow10BigNumTableIndices = new int[8] { 0, 2, 5, 10, 18, 33, 61, 116 };

			private static readonly uint[] s_Pow10BigNumTable = new uint[234]
			{
				1u, 100000000u, 2u, 1874919424u, 2328306u, 4u, 0u, 2242703233u, 762134875u, 1262u,
				7u, 0u, 0u, 3211403009u, 1849224548u, 3668416493u, 3913284084u, 1593091u, 14u, 0u,
				0u, 0u, 0u, 781532673u, 64985353u, 253049085u, 594863151u, 3553621484u, 3288652808u, 3167596762u,
				2788392729u, 3911132675u, 590u, 27u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 2553183233u, 3201533787u, 3638140786u, 303378311u, 1809731782u, 3477761648u, 3583367183u, 649228654u,
				2915460784u, 487929380u, 1011012442u, 1677677582u, 3428152256u, 1710878487u, 1438394610u, 2161952759u, 4100910556u, 1608314830u,
				349175u, 54u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 4234999809u, 2012377703u,
				2408924892u, 1570150255u, 3090844311u, 3273530073u, 1187251475u, 2498123591u, 3364452033u, 1148564857u, 687371067u, 2854068671u,
				1883165473u, 505794538u, 2988060450u, 3159489326u, 2531348317u, 3215191468u, 849106862u, 3892080979u, 3288073877u, 2242451748u,
				4183778142u, 2995818208u, 2477501924u, 325481258u, 2487842652u, 1774082830u, 1933815724u, 2962865281u, 1168579910u, 2724829000u,
				2360374019u, 2315984659u, 2360052375u, 3251779801u, 1664357844u, 28u, 107u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 689565697u,
				4116392818u, 1853628763u, 516071302u, 2568769159u, 365238920u, 336250165u, 1283268122u, 3425490969u, 248595470u, 2305176814u,
				2111925499u, 507770399u, 2681111421u, 589114268u, 591287751u, 1708941527u, 4098957707u, 475844916u, 3378731398u, 2452339615u,
				2817037361u, 2678008327u, 1656645978u, 2383430340u, 73103988u, 448667107u, 2329420453u, 3124020241u, 3625235717u, 3208634035u,
				2412059158u, 2981664444u, 4117622508u, 838560765u, 3069470027u, 270153238u, 1802868219u, 3692709886u, 2161737865u, 2159912357u,
				2585798786u, 837488486u, 4237238160u, 2540319504u, 3798629246u, 3748148874u, 1021550776u, 2386715342u, 1973637538u, 1823520457u,
				1146713475u, 833971519u, 3277251466u, 905620390u, 26278816u, 2680483154u, 2294040859u, 373297482u, 5996609u, 4109575006u,
				512575049u, 917036550u, 1942311753u, 2816916778u, 3248920332u, 1192784020u, 3537586671u, 2456567643u, 2925660628u, 759380297u,
				888447942u, 3559939476u, 3654687237u, 805u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u
			};

			private int _length;

			private unsafe fixed uint _blocks[116];

			public unsafe static void Add(ref BigInteger lhs, ref BigInteger rhs, out BigInteger result)
			{
				ref BigInteger reference = ref lhs._length < rhs._length ? ref rhs : ref lhs;
				ref BigInteger reference2 = ref lhs._length < rhs._length ? ref lhs : ref rhs;
				int length = reference._length;
				int length2 = reference2._length;
				result._length = length;
				ulong num = 0uL;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				while (num3 < length2)
				{
					ulong num5 = num + reference._blocks[num2] + reference2._blocks[num3];
					num = num5 >> 32;
					result._blocks[num4] = (uint)num5;
					num2++;
					num3++;
					num4++;
				}
				while (num2 < length)
				{
					ulong num6 = num + reference._blocks[num2];
					num = num6 >> 32;
					result._blocks[num4] = (uint)num6;
					num2++;
					num4++;
				}
				int num7 = length;
				if (num != 0L)
				{
					if ((uint)num7 >= 116u)
					{
						SetZero(out result);
						return;
					}
					result._blocks[num4] = 1u;
					result._length++;
				}
			}

			public unsafe static int Compare(ref BigInteger lhs, ref BigInteger rhs)
			{
				int length = lhs._length;
				int length2 = rhs._length;
				int num = length - length2;
				if (num != 0)
				{
					return num;
				}
				if (length == 0)
				{
					return 0;
				}
				for (int num2 = length - 1; num2 >= 0; num2--)
				{
					long num3 = (long)lhs._blocks[num2] - (long)rhs._blocks[num2];
					if (num3 != 0L)
					{
						if (num3 <= 0)
						{
							return -1;
						}
						return 1;
					}
				}
				return 0;
			}

			public static uint CountSignificantBits(uint value)
			{
				return (uint)(32 - BitOperations.LeadingZeroCount(value));
			}

			public static uint CountSignificantBits(ulong value)
			{
				return (uint)(64 - BitOperations.LeadingZeroCount(value));
			}

			public unsafe static uint CountSignificantBits(ref BigInteger value)
			{
				if (value.IsZero())
				{
					return 0u;
				}
				uint num = (uint)(value._length - 1);
				return num * 32 + CountSignificantBits(value._blocks[num]);
			}

			public unsafe static void DivRem(ref BigInteger lhs, ref BigInteger rhs, out BigInteger quo, out BigInteger rem)
			{
				if (lhs.IsZero())
				{
					SetZero(out quo);
					SetZero(out rem);
					return;
				}
				int length = lhs._length;
				int length2 = rhs._length;
				if (length == 1 && length2 == 1)
				{
					var (value, value2) = Math.DivRem(lhs._blocks[0], rhs._blocks[0]);
					SetUInt32(out quo, value);
					SetUInt32(out rem, value2);
					return;
				}
				if (length2 == 1)
				{
					int num = length;
					ulong right = rhs._blocks[0];
					ulong num2 = 0uL;
					for (int num3 = num - 1; num3 >= 0; num3--)
					{
						ulong left = (num2 << 32) | lhs._blocks[num3];
						ulong num4;
						(num4, num2) = Math.DivRem(left, right);
						if (num4 == 0L && num3 == num - 1)
						{
							num--;
						}
						else
						{
							quo._blocks[num3] = (uint)num4;
						}
					}
					quo._length = num;
					SetUInt32(out rem, (uint)num2);
					return;
				}
				if (length2 > length)
				{
					SetZero(out quo);
					SetValue(out rem, ref lhs);
					return;
				}
				int num5 = length - length2 + 1;
				SetValue(out rem, ref lhs);
				int num6 = length;
				uint num7 = rhs._blocks[length2 - 1];
				uint num8 = rhs._blocks[length2 - 2];
				int num9 = BitOperations.LeadingZeroCount(num7);
				int num10 = 32 - num9;
				if (num9 > 0)
				{
					num7 = (num7 << num9) | (num8 >> num10);
					num8 <<= num9;
					if (length2 > 2)
					{
						num8 |= rhs._blocks[length2 - 3] >> num10;
					}
				}
				for (int num11 = length; num11 >= length2; num11--)
				{
					int num12 = num11 - length2;
					uint num13 = ((num11 < length) ? rem._blocks[num11] : 0u);
					ulong num14 = ((ulong)num13 << 32) | rem._blocks[num11 - 1];
					uint num15 = ((num11 > 1) ? rem._blocks[num11 - 2] : 0u);
					if (num9 > 0)
					{
						num14 = (num14 << num9) | (num15 >> num10);
						num15 <<= num9;
						if (num11 > 2)
						{
							num15 |= rem._blocks[num11 - 3] >> num10;
						}
					}
					ulong num16 = num14 / num7;
					if (num16 > uint.MaxValue)
					{
						num16 = 4294967295uL;
					}
					while (DivideGuessTooBig(num16, num14, num15, num7, num8))
					{
						num16--;
					}
					if (num16 != 0)
					{
						uint num17 = SubtractDivisor(ref rem, num12, ref rhs, num16);
						if (num17 != num13)
						{
							num17 = AddDivisor(ref rem, num12, ref rhs);
							num16--;
						}
					}
					if (num5 != 0)
					{
						if (num16 == 0L && num12 == num5 - 1)
						{
							num5--;
						}
						else
						{
							quo._blocks[num12] = (uint)num16;
						}
					}
					if (num11 < num6)
					{
						num6--;
					}
				}
				quo._length = num5;
				for (int num18 = num6 - 1; num18 >= 0; num18--)
				{
					if (rem._blocks[num18] == 0)
					{
						num6--;
					}
				}
				rem._length = num6;
			}

			public unsafe static uint HeuristicDivide(ref BigInteger dividend, ref BigInteger divisor)
			{
				int num = divisor._length;
				if (dividend._length < num)
				{
					return 0u;
				}
				int num2 = num - 1;
				uint num3 = dividend._blocks[num2] / (divisor._blocks[num2] + 1);
				if (num3 != 0)
				{
					int num4 = 0;
					ulong num5 = 0uL;
					ulong num6 = 0uL;
					do
					{
						ulong num7 = (ulong)((long)divisor._blocks[num4] * (long)num3) + num6;
						num6 = num7 >> 32;
						ulong num8 = (ulong)((long)dividend._blocks[num4] - (long)(uint)num7) - num5;
						num5 = (num8 >> 32) & 1;
						dividend._blocks[num4] = (uint)num8;
						num4++;
					}
					while (num4 < num);
					while (num > 0 && dividend._blocks[num - 1] == 0)
					{
						num--;
					}
					dividend._length = num;
				}
				if (Compare(ref dividend, ref divisor) >= 0)
				{
					num3++;
					int num9 = 0;
					ulong num10 = 0uL;
					do
					{
						ulong num11 = (ulong)((long)dividend._blocks[num9] - (long)divisor._blocks[num9]) - num10;
						num10 = (num11 >> 32) & 1;
						dividend._blocks[num9] = (uint)num11;
						num9++;
					}
					while (num9 < num);
					while (num > 0 && dividend._blocks[num - 1] == 0)
					{
						num--;
					}
					dividend._length = num;
				}
				return num3;
			}

			public unsafe static void Multiply(ref BigInteger lhs, uint value, out BigInteger result)
			{
				if (lhs._length <= 1)
				{
					SetUInt64(out result, (ulong)lhs.ToUInt32() * (ulong)value);
					return;
				}
				switch (value)
				{
				case 0u:
					SetZero(out result);
					return;
				case 1u:
					SetValue(out result, ref lhs);
					return;
				}
				int length = lhs._length;
				int i = 0;
				uint num = 0u;
				for (; i < length; i++)
				{
					ulong num2 = (ulong)((long)lhs._blocks[i] * (long)value + num);
					result._blocks[i] = (uint)num2;
					num = (uint)(num2 >> 32);
				}
				int num3 = length;
				if (num != 0)
				{
					if ((uint)num3 >= 116u)
					{
						SetZero(out result);
						return;
					}
					result._blocks[i] = num;
					num3++;
				}
				result._length = num3;
			}

			public unsafe static void Multiply(ref BigInteger lhs, ref BigInteger rhs, out BigInteger result)
			{
				if (lhs._length <= 1)
				{
					Multiply(ref rhs, lhs.ToUInt32(), out result);
					return;
				}
				if (rhs._length <= 1)
				{
					Multiply(ref lhs, rhs.ToUInt32(), out result);
					return;
				}
				ref BigInteger reference = ref lhs;
				int length = lhs._length;
				ref BigInteger reference2 = ref rhs;
				int length2 = rhs._length;
				if (length < length2)
				{
					reference = ref rhs;
					length = rhs._length;
					reference2 = ref lhs;
					length2 = lhs._length;
				}
				int num = length2 + length;
				if ((uint)num > 116u)
				{
					SetZero(out result);
					return;
				}
				result._length = num;
				result.Clear((uint)num);
				int num2 = 0;
				int num3 = 0;
				while (num2 < length2)
				{
					if (reference2._blocks[num2] != 0)
					{
						int num4 = 0;
						int num5 = num3;
						ulong num6 = 0uL;
						do
						{
							ulong num7 = (ulong)(result._blocks[num5] + (long)reference2._blocks[num2] * (long)reference._blocks[num4]) + num6;
							num6 = num7 >> 32;
							result._blocks[num5] = (uint)num7;
							num5++;
							num4++;
						}
						while (num4 < length);
						result._blocks[num5] = (uint)num6;
					}
					num2++;
					num3++;
				}
				if (num > 0 && result._blocks[num - 1] == 0)
				{
					result._length--;
				}
			}

			public unsafe static void Pow2(uint exponent, out BigInteger result)
			{
				uint remainder;
				uint num = DivRem32(exponent, out remainder);
				result._length = (int)(num + 1);
				if ((uint)result._length > 116u)
				{
					SetZero(out result);
					return;
				}
				if (num != 0)
				{
					result.Clear(num);
				}
				result._blocks[num] = (uint)(1 << (int)remainder);
			}

			public unsafe static void Pow10(uint exponent, out BigInteger result)
			{
				SetUInt32(out var result2, s_Pow10UInt32Table[exponent & 7]);
				ref BigInteger reference = ref result2;
				SetZero(out var result3);
				ref BigInteger reference2 = ref result3;
				exponent >>= 3;
				uint num = 0u;
				while (exponent != 0)
				{
					if ((exponent & (true ? 1u : 0u)) != 0)
					{
						fixed (uint* ptr = &s_Pow10BigNumTable[s_Pow10BigNumTableIndices[num]])
						{
							Multiply(ref reference, ref *(BigInteger*)ptr, out reference2);
						}
						ref BigInteger reference3 = ref reference2;
						reference2 = ref reference;
						reference = ref reference3;
					}
					num++;
					exponent >>= 1;
				}
				SetValue(out result, ref reference);
			}

			private unsafe static uint AddDivisor(ref BigInteger lhs, int lhsStartIndex, ref BigInteger rhs)
			{
				int length = lhs._length;
				int length2 = rhs._length;
				ulong num = 0uL;
				for (int i = 0; i < length2; i++)
				{
					ref uint reference = ref lhs._blocks[lhsStartIndex + i];
					ulong num2 = reference + num + rhs._blocks[i];
					reference = (uint)num2;
					num = num2 >> 32;
				}
				return (uint)num;
			}

			private static bool DivideGuessTooBig(ulong q, ulong valHi, uint valLo, uint divHi, uint divLo)
			{
				ulong num = divHi * q;
				ulong num2 = divLo * q;
				num += num2 >> 32;
				num2 &= 0xFFFFFFFFu;
				if (num < valHi)
				{
					return false;
				}
				if (num > valHi)
				{
					return true;
				}
				if (num2 < valLo)
				{
					return false;
				}
				if (num2 > valLo)
				{
					return true;
				}
				return false;
			}

			private unsafe static uint SubtractDivisor(ref BigInteger lhs, int lhsStartIndex, ref BigInteger rhs, ulong q)
			{
				int num = lhs._length - lhsStartIndex;
				int length = rhs._length;
				ulong num2 = 0uL;
				for (int i = 0; i < length; i++)
				{
					num2 += rhs._blocks[i] * q;
					uint num3 = (uint)num2;
					num2 >>= 32;
					ref uint reference = ref lhs._blocks[lhsStartIndex + i];
					if (reference < num3)
					{
						num2++;
					}
					reference -= num3;
				}
				return (uint)num2;
			}

			public unsafe void Add(uint value)
			{
				int length = _length;
				if (length == 0)
				{
					SetUInt32(out this, value);
					return;
				}
				_blocks[0] += value;
				if (_blocks[0] >= value)
				{
					return;
				}
				for (int i = 1; i < length; i++)
				{
					ref uint reference = ref _blocks[i];
					reference++;
					if (_blocks[i] != 0)
					{
						return;
					}
				}
				if ((uint)length >= 116u)
				{
					SetZero(out this);
					return;
				}
				_blocks[length] = 1u;
				_length = length + 1;
			}

			public unsafe uint GetBlock(uint index)
			{
				return _blocks[index];
			}

			public int GetLength()
			{
				return _length;
			}

			public bool IsZero()
			{
				return _length == 0;
			}

			public void Multiply(uint value)
			{
				Multiply(ref this, value, out this);
			}

			public void Multiply(ref BigInteger value)
			{
				if (value._length <= 1)
				{
					Multiply(ref this, value.ToUInt32(), out this);
					return;
				}
				SetValue(out var result, ref this);
				Multiply(ref result, ref value, out this);
			}

			public unsafe void Multiply10()
			{
				if (IsZero())
				{
					return;
				}
				int num = 0;
				int length = _length;
				ulong num2 = 0uL;
				do
				{
					ulong num3 = _blocks[num];
					ulong num4 = (num3 << 3) + (num3 << 1) + num2;
					num2 = num4 >> 32;
					_blocks[num] = (uint)num4;
					num++;
				}
				while (num < length);
				if (num2 != 0L)
				{
					if ((uint)length >= 116u)
					{
						SetZero(out this);
						return;
					}
					_blocks[num] = (uint)num2;
					_length = length + 1;
				}
			}

			public void MultiplyPow10(uint exponent)
			{
				if (exponent <= 9)
				{
					Multiply(s_Pow10UInt32Table[exponent]);
				}
				else if (!IsZero())
				{
					Pow10(exponent, out var result);
					Multiply(ref result);
				}
			}

			public unsafe static void SetUInt32(out BigInteger result, uint value)
			{
				if (value == 0)
				{
					SetZero(out result);
					return;
				}
				result._blocks[0] = value;
				result._length = 1;
			}

			public unsafe static void SetUInt64(out BigInteger result, ulong value)
			{
				if (value <= uint.MaxValue)
				{
					SetUInt32(out result, (uint)value);
					return;
				}
				result._blocks[0] = (uint)value;
				result._blocks[1] = (uint)(value >> 32);
				result._length = 2;
			}

			public unsafe static void SetValue(out BigInteger result, ref BigInteger value)
			{
				Buffer.Memmove(elementCount: (nuint)(result._length = value._length), destination: ref result._blocks[0], source: ref value._blocks[0]);
			}

			public static void SetZero(out BigInteger result)
			{
				result._length = 0;
			}

			public unsafe void ShiftLeft(uint shift)
			{
				int length = _length;
				if (length == 0 || shift == 0)
				{
					return;
				}
				uint remainder;
				uint num = DivRem32(shift, out remainder);
				int num2 = length - 1;
				int num3 = num2 + (int)num;
				if (remainder == 0)
				{
					if ((uint)length >= 116u)
					{
						SetZero(out this);
						return;
					}
					while (num2 >= 0)
					{
						_blocks[num3] = _blocks[num2];
						num2--;
						num3--;
					}
					_length += (int)num;
					Clear(num);
					return;
				}
				num3++;
				if ((uint)length >= 116u)
				{
					SetZero(out this);
					return;
				}
				_length = num3 + 1;
				uint num4 = 32 - remainder;
				uint num5 = 0u;
				uint num6 = _blocks[num2];
				uint num7 = num6 >> (int)num4;
				while (num2 > 0)
				{
					_blocks[num3] = num5 | num7;
					num5 = num6 << (int)remainder;
					num2--;
					num3--;
					num6 = _blocks[num2];
					num7 = num6 >> (int)num4;
				}
				_blocks[num3] = num5 | num7;
				_blocks[num3 - 1] = num6 << (int)remainder;
				Clear(num);
				if (_blocks[_length - 1] == 0)
				{
					_length--;
				}
			}

			public unsafe uint ToUInt32()
			{
				if (_length > 0)
				{
					return _blocks[0];
				}
				return 0u;
			}

			public unsafe ulong ToUInt64()
			{
				if (_length > 1)
				{
					return ((ulong)_blocks[1] << 32) + _blocks[0];
				}
				if (_length > 0)
				{
					return _blocks[0];
				}
				return 0uL;
			}

			private unsafe void Clear(uint length)
			{
				Buffer.ZeroMemory((byte*)Unsafe.AsPointer(ref _blocks[0]), length * 4);
			}

			private static uint DivRem32(uint value, out uint remainder)
			{
				remainder = value & 0x1Fu;
				return value >> 5;
			}
		}

		internal readonly ref struct DiyFp
		{
			public readonly ulong f;

			public readonly int e;

			public static DiyFp CreateAndGetBoundaries(double value, out DiyFp mMinus, out DiyFp mPlus)
			{
				DiyFp result = new DiyFp(value);
				result.GetBoundaries(52, out mMinus, out mPlus);
				return result;
			}

			public static DiyFp CreateAndGetBoundaries(float value, out DiyFp mMinus, out DiyFp mPlus)
			{
				DiyFp result = new DiyFp(value);
				result.GetBoundaries(23, out mMinus, out mPlus);
				return result;
			}

			public static DiyFp CreateAndGetBoundaries(Half value, out DiyFp mMinus, out DiyFp mPlus)
			{
				DiyFp result = new DiyFp(value);
				result.GetBoundaries(10, out mMinus, out mPlus);
				return result;
			}

			public DiyFp(double value)
			{
				f = ExtractFractionAndBiasedExponent(value, out e);
			}

			public DiyFp(float value)
			{
				f = ExtractFractionAndBiasedExponent(value, out e);
			}

			public DiyFp(Half value)
			{
				f = ExtractFractionAndBiasedExponent(value, out e);
			}

			public DiyFp(ulong f, int e)
			{
				this.f = f;
				this.e = e;
			}

			public DiyFp Multiply(in DiyFp other)
			{
				uint num = (uint)(f >> 32);
				uint num2 = (uint)f;
				uint num3 = (uint)(other.f >> 32);
				uint num4 = (uint)other.f;
				ulong num5 = (ulong)num * (ulong)num3;
				ulong num6 = (ulong)num2 * (ulong)num3;
				ulong num7 = (ulong)num * (ulong)num4;
				ulong num8 = (ulong)num2 * (ulong)num4;
				ulong num9 = (num8 >> 32) + (uint)num7 + (uint)num6;
				num9 += 2147483648u;
				return new DiyFp(num5 + (num7 >> 32) + (num6 >> 32) + (num9 >> 32), e + other.e + 64);
			}

			public DiyFp Normalize()
			{
				int num = BitOperations.LeadingZeroCount(f);
				return new DiyFp(f << num, e - num);
			}

			public DiyFp Subtract(in DiyFp other)
			{
				return new DiyFp(f - other.f, e);
			}

			private void GetBoundaries(int implicitBitIndex, out DiyFp mMinus, out DiyFp mPlus)
			{
				mPlus = new DiyFp((f << 1) + 1, e - 1).Normalize();
				if (f == (ulong)(1L << implicitBitIndex))
				{
					mMinus = new DiyFp((f << 2) - 1, e - 2);
				}
				else
				{
					mMinus = new DiyFp((f << 1) - 1, e - 1);
				}
				mMinus = new DiyFp(mMinus.f << mMinus.e - mPlus.e, mPlus.e);
			}
		}

		internal static class Grisu3
		{
			private static readonly short[] s_CachedPowersBinaryExponent = new short[87]
			{
				-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,
				-954, -927, -901, -874, -847, -821, -794, -768, -741, -715,
				-688, -661, -635, -608, -582, -555, -529, -502, -475, -449,
				-422, -396, -369, -343, -316, -289, -263, -236, -210, -183,
				-157, -130, -103, -77, -50, -24, 3, 30, 56, 83,
				109, 136, 162, 189, 216, 242, 269, 295, 322, 348,
				375, 402, 428, 455, 481, 508, 534, 561, 588, 614,
				641, 667, 694, 720, 747, 774, 800, 827, 853, 880,
				907, 933, 960, 986, 1013, 1039, 1066
			};

			private static readonly short[] s_CachedPowersDecimalExponent = new short[87]
			{
				-348, -340, -332, -324, -316, -308, -300, -292, -284, -276,
				-268, -260, -252, -244, -236, -228, -220, -212, -204, -196,
				-188, -180, -172, -164, -156, -148, -140, -132, -124, -116,
				-108, -100, -92, -84, -76, -68, -60, -52, -44, -36,
				-28, -20, -12, -4, 4, 12, 20, 28, 36, 44,
				52, 60, 68, 76, 84, 92, 100, 108, 116, 124,
				132, 140, 148, 156, 164, 172, 180, 188, 196, 204,
				212, 220, 228, 236, 244, 252, 260, 268, 276, 284,
				292, 300, 308, 316, 324, 332, 340
			};

			private static readonly ulong[] s_CachedPowersSignificand = new ulong[87]
			{
				18054884314459144840uL, 13451937075301367670uL, 10022474136428063862uL, 14934650266808366570uL, 11127181549972568877uL, 16580792590934885855uL, 12353653155963782858uL, 18408377700990114895uL, 13715310171984221708uL, 10218702384817765436uL,
				15227053142812498563uL, 11345038669416679861uL, 16905424996341287883uL, 12595523146049147757uL, 9384396036005875287uL, 13983839803942852151uL, 10418772551374772303uL, 15525180923007089351uL, 11567161174868858868uL, 17236413322193710309uL,
				12842128665889583758uL, 9568131466127621947uL, 14257626930069360058uL, 10622759856335341974uL, 15829145694278690180uL, 11793632577567316726uL, 17573882009934360870uL, 13093562431584567480uL, 9755464219737475723uL, 14536774485912137811uL,
				10830740992659433045uL, 16139061738043178685uL, 12024538023802026127uL, 17917957937422433684uL, 13349918974505688015uL, 9946464728195732843uL, 14821387422376473014uL, 11042794154864902060uL, 16455045573212060422uL, 12259964326927110867uL,
				18268770466636286478uL, 13611294676837538539uL, 10141204801825835212uL, 15111572745182864684uL, 11258999068426240000uL, 16777216000000000000uL, 12500000000000000000uL, 9313225746154785156uL, 13877787807814456755uL, 10339757656912845936uL,
				15407439555097886824uL, 11479437019748901445uL, 17105694144590052135uL, 12744735289059618216uL, 9495567745759798747uL, 14149498560666738074uL, 10542197943230523224uL, 15709099088952724970uL, 11704190886730495818uL, 17440603504673385349uL,
				12994262207056124023uL, 9681479787123295682uL, 14426529090290212157uL, 10748601772107342003uL, 16016664761464807395uL, 11933345169920330789uL, 17782069995880619868uL, 13248674568444952270uL, 9871031767461413346uL, 14708983551653345445uL,
				10959046745042015199uL, 16330252207878254650uL, 12166986024289022870uL, 18130221999122236476uL, 13508068024458167312uL, 10064294952495520794uL, 14996968138956309548uL, 11173611982879273257uL, 16649979327439178909uL, 12405201291620119593uL,
				9242595204427927429uL, 13772540099066387757uL, 10261342003245940623uL, 15290591125556738113uL, 11392378155556871081uL, 16975966327722178521uL, 12648080533535911531uL
			};

			private static readonly uint[] s_SmallPowersOfTen = new uint[10] { 1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u, 10000000u, 100000000u, 1000000000u };

			public static bool TryRunDouble(double value, int requestedDigits, ref NumberBuffer number)
			{
				double value2 = (double.IsNegative(value) ? (0.0 - value) : value);
				DiyFp diyFp;
				bool flag;
				int length;
				int decimalExponent;
				if (requestedDigits == -1)
				{
					diyFp = DiyFp.CreateAndGetBoundaries(value2, out var mMinus, out var mPlus);
					DiyFp w = diyFp.Normalize();
					flag = TryRunShortest(in mMinus, in w, in mPlus, number.Digits, out length, out decimalExponent);
				}
				else
				{
					diyFp = new DiyFp(value2);
					DiyFp w2 = diyFp.Normalize();
					flag = TryRunCounted(in w2, requestedDigits, number.Digits, out length, out decimalExponent);
				}
				if (flag)
				{
					number.Scale = length + decimalExponent;
					number.Digits[length] = 0;
					number.DigitsCount = length;
				}
				return flag;
			}

			public static bool TryRunHalf(Half value, int requestedDigits, ref NumberBuffer number)
			{
				Half value2 = (Half.IsNegative(value) ? Half.Negate(value) : value);
				DiyFp diyFp;
				bool flag;
				int length;
				int decimalExponent;
				if (requestedDigits == -1)
				{
					diyFp = DiyFp.CreateAndGetBoundaries(value2, out var mMinus, out var mPlus);
					DiyFp w = diyFp.Normalize();
					flag = TryRunShortest(in mMinus, in w, in mPlus, number.Digits, out length, out decimalExponent);
				}
				else
				{
					diyFp = new DiyFp(value2);
					DiyFp w2 = diyFp.Normalize();
					flag = TryRunCounted(in w2, requestedDigits, number.Digits, out length, out decimalExponent);
				}
				if (flag)
				{
					number.Scale = length + decimalExponent;
					number.Digits[length] = 0;
					number.DigitsCount = length;
				}
				return flag;
			}

			public static bool TryRunSingle(float value, int requestedDigits, ref NumberBuffer number)
			{
				float value2 = (float.IsNegative(value) ? (0f - value) : value);
				DiyFp diyFp;
				bool flag;
				int length;
				int decimalExponent;
				if (requestedDigits == -1)
				{
					diyFp = DiyFp.CreateAndGetBoundaries(value2, out var mMinus, out var mPlus);
					DiyFp w = diyFp.Normalize();
					flag = TryRunShortest(in mMinus, in w, in mPlus, number.Digits, out length, out decimalExponent);
				}
				else
				{
					diyFp = new DiyFp(value2);
					DiyFp w2 = diyFp.Normalize();
					flag = TryRunCounted(in w2, requestedDigits, number.Digits, out length, out decimalExponent);
				}
				if (flag)
				{
					number.Scale = length + decimalExponent;
					number.Digits[length] = 0;
					number.DigitsCount = length;
				}
				return flag;
			}

			private static bool TryRunCounted(in DiyFp w, int requestedDigits, Span<byte> buffer, out int length, out int decimalExponent)
			{
				int minExponent = -60 - (w.e + 64);
				int maxExponent = -32 - (w.e + 64);
				int decimalExponent2;
				DiyFp other = GetCachedPowerForBinaryExponentRange(minExponent, maxExponent, out decimalExponent2);
				DiyFp w2 = w.Multiply(in other);
				int kappa;
				bool result = TryDigitGenCounted(in w2, requestedDigits, buffer, out length, out kappa);
				decimalExponent = -decimalExponent2 + kappa;
				return result;
			}

			private static bool TryRunShortest(in DiyFp boundaryMinus, in DiyFp w, in DiyFp boundaryPlus, Span<byte> buffer, out int length, out int decimalExponent)
			{
				int minExponent = -60 - (w.e + 64);
				int maxExponent = -32 - (w.e + 64);
				int decimalExponent2;
				DiyFp other = GetCachedPowerForBinaryExponentRange(minExponent, maxExponent, out decimalExponent2);
				DiyFp w2 = w.Multiply(in other);
				DiyFp low = boundaryMinus.Multiply(in other);
				DiyFp high = boundaryPlus.Multiply(in other);
				int kappa;
				bool result = TryDigitGenShortest(in low, in w2, in high, buffer, out length, out kappa);
				decimalExponent = -decimalExponent2 + kappa;
				return result;
			}

			private static uint BiggestPowerTen(uint number, int numberBits, out int exponentPlusOne)
			{
				int num = (numberBits + 1) * 1233 >> 12;
				uint num2 = s_SmallPowersOfTen[num];
				if (number < num2)
				{
					num--;
					num2 = s_SmallPowersOfTen[num];
				}
				exponentPlusOne = num + 1;
				return num2;
			}

			private static bool TryDigitGenCounted(in DiyFp w, int requestedDigits, Span<byte> buffer, out int length, out int kappa)
			{
				ulong num = 1uL;
				DiyFp diyFp = new DiyFp((ulong)(1L << -w.e), w.e);
				uint num2 = (uint)(w.f >> -diyFp.e);
				ulong num3 = w.f & (diyFp.f - 1);
				if (num3 == 0L && (requestedDigits >= 11 || num2 < s_SmallPowersOfTen[requestedDigits - 1]))
				{
					length = 0;
					kappa = 0;
					return false;
				}
				uint num4 = BiggestPowerTen(num2, 64 - -diyFp.e, out kappa);
				length = 0;
				while (kappa > 0)
				{
					uint num5;
					(num5, num2) = Math.DivRem(num2, num4);
					buffer[length] = (byte)(48 + num5);
					length++;
					requestedDigits--;
					kappa--;
					if (requestedDigits == 0)
					{
						break;
					}
					num4 /= 10;
				}
				if (requestedDigits == 0)
				{
					ulong rest = ((ulong)num2 << -diyFp.e) + num3;
					return TryRoundWeedCounted(buffer, length, rest, (ulong)num4 << -diyFp.e, num, ref kappa);
				}
				while (requestedDigits > 0 && num3 > num)
				{
					num3 *= 10;
					num *= 10;
					uint num6 = (uint)(num3 >> -diyFp.e);
					buffer[length] = (byte)(48 + num6);
					length++;
					requestedDigits--;
					kappa--;
					num3 &= diyFp.f - 1;
				}
				if (requestedDigits != 0)
				{
					buffer[0] = 0;
					length = 0;
					kappa = 0;
					return false;
				}
				return TryRoundWeedCounted(buffer, length, num3, diyFp.f, num, ref kappa);
			}

			private static bool TryDigitGenShortest(in DiyFp low, in DiyFp w, in DiyFp high, Span<byte> buffer, out int length, out int kappa)
			{
				ulong num = 1uL;
				DiyFp other = new DiyFp(low.f - num, low.e);
				DiyFp diyFp = new DiyFp(high.f + num, high.e);
				DiyFp diyFp2 = diyFp.Subtract(in other);
				DiyFp diyFp3 = new DiyFp((ulong)(1L << -w.e), w.e);
				uint num2 = (uint)(diyFp.f >> -diyFp3.e);
				ulong num3 = diyFp.f & (diyFp3.f - 1);
				uint num4 = BiggestPowerTen(num2, 64 - -diyFp3.e, out kappa);
				length = 0;
				while (kappa > 0)
				{
					uint num5;
					(num5, num2) = Math.DivRem(num2, num4);
					buffer[length] = (byte)(48 + num5);
					length++;
					kappa--;
					ulong num6 = ((ulong)num2 << -diyFp3.e) + num3;
					if (num6 < diyFp2.f)
					{
						return TryRoundWeedShortest(buffer, length, diyFp.Subtract(in w).f, diyFp2.f, num6, (ulong)num4 << -diyFp3.e, num);
					}
					num4 /= 10;
				}
				do
				{
					num3 *= 10;
					num *= 10;
					diyFp2 = new DiyFp(diyFp2.f * 10, diyFp2.e);
					uint num7 = (uint)(num3 >> -diyFp3.e);
					buffer[length] = (byte)(48 + num7);
					length++;
					kappa--;
					num3 &= diyFp3.f - 1;
				}
				while (num3 >= diyFp2.f);
				return TryRoundWeedShortest(buffer, length, diyFp.Subtract(in w).f * num, diyFp2.f, num3, diyFp3.f, num);
			}

			private static DiyFp GetCachedPowerForBinaryExponentRange(int minExponent, int maxExponent, out int decimalExponent)
			{
				double num = Math.Ceiling((double)(minExponent + 64 - 1) * 0.3010299956639812);
				int num2 = (348 + (int)num - 1) / 8 + 1;
				decimalExponent = s_CachedPowersDecimalExponent[num2];
				return new DiyFp(s_CachedPowersSignificand[num2], s_CachedPowersBinaryExponent[num2]);
			}

			private static bool TryRoundWeedCounted(Span<byte> buffer, int length, ulong rest, ulong tenKappa, ulong unit, ref int kappa)
			{
				if (unit >= tenKappa || tenKappa - unit <= unit)
				{
					return false;
				}
				if (tenKappa - rest > rest && tenKappa - 2 * rest >= 2 * unit)
				{
					return true;
				}
				if (rest > unit && (tenKappa <= rest - unit || tenKappa - (rest - unit) <= rest - unit))
				{
					buffer[length - 1]++;
					int num = length - 1;
					while (num > 0 && buffer[num] == 58)
					{
						buffer[num] = 48;
						buffer[num - 1]++;
						num--;
					}
					if (buffer[0] == 58)
					{
						buffer[0] = 49;
						kappa++;
					}
					return true;
				}
				return false;
			}

			private static bool TryRoundWeedShortest(Span<byte> buffer, int length, ulong distanceTooHighW, ulong unsafeInterval, ulong rest, ulong tenKappa, ulong unit)
			{
				ulong num = distanceTooHighW - unit;
				ulong num2 = distanceTooHighW + unit;
				while (rest < num && unsafeInterval - rest >= tenKappa && (rest + tenKappa < num || num - rest >= rest + tenKappa - num))
				{
					buffer[length - 1]--;
					rest += tenKappa;
				}
				if (rest < num2 && unsafeInterval - rest >= tenKappa && (rest + tenKappa < num2 || num2 - rest > rest + tenKappa - num2))
				{
					return false;
				}
				if (2 * unit <= rest)
				{
					return rest <= unsafeInterval - 4 * unit;
				}
				return false;
			}
		}

		internal ref struct NumberBuffer
		{
			public int DigitsCount;

			public int Scale;

			public bool IsNegative;

			public bool HasNonZeroTail;

			public NumberBufferKind Kind;

			public Span<byte> Digits;

			public unsafe NumberBuffer(NumberBufferKind kind, byte* digits, int digitsLength)
			{
				DigitsCount = 0;
				Scale = 0;
				IsNegative = false;
				HasNonZeroTail = false;
				Kind = kind;
				Digits = new Span<byte>(digits, digitsLength);
				Digits[0] = 0;
			}

			public unsafe byte* GetDigitsPointer()
			{
				return (byte*)Unsafe.AsPointer(ref Digits[0]);
			}

			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append('[');
				stringBuilder.Append('"');
				for (int i = 0; i < Digits.Length; i++)
				{
					byte b = Digits[i];
					if (b == 0)
					{
						break;
					}
					stringBuilder.Append((char)b);
				}
				stringBuilder.Append('"');
				stringBuilder.Append(", Length = ").Append(DigitsCount);
				stringBuilder.Append(", Scale = ").Append(Scale);
				stringBuilder.Append(", IsNegative = ").Append(IsNegative);
				stringBuilder.Append(", HasNonZeroTail = ").Append(HasNonZeroTail);
				stringBuilder.Append(", Kind = ").Append(Kind);
				stringBuilder.Append(']');
				return stringBuilder.ToString();
			}
		}

		internal enum NumberBufferKind : byte
		{
			Unknown,
			Integer,
			Decimal,
			FloatingPoint
		}

		public readonly struct FloatingPointInfo
		{
			public static readonly FloatingPointInfo Double = new FloatingPointInfo(52, 11, 1023, 1023, 9218868437227405312uL);

			public static readonly FloatingPointInfo Single = new FloatingPointInfo(23, 8, 127, 127, 2139095040uL);

			public static readonly FloatingPointInfo Half = new FloatingPointInfo(10, 5, 15, 15, 31744uL);

			[CompilerGenerated]
			private readonly ushort <ExponentBits>k__BackingField;

			public ulong ZeroBits { get; }

			public ulong InfinityBits { get; }

			public ulong NormalMantissaMask { get; }

			public ulong DenormalMantissaMask { get; }

			public int MinBinaryExponent { get; }

			public int MaxBinaryExponent { get; }

			public int ExponentBias { get; }

			public int OverflowDecimalExponent { get; }

			public ushort NormalMantissaBits { get; }

			public ushort DenormalMantissaBits { get; }

			public FloatingPointInfo(ushort denormalMantissaBits, ushort exponentBits, int maxBinaryExponent, int exponentBias, ulong infinityBits)
			{
				<ExponentBits>k__BackingField = exponentBits;
				DenormalMantissaBits = denormalMantissaBits;
				NormalMantissaBits = (ushort)(denormalMantissaBits + 1);
				OverflowDecimalExponent = (maxBinaryExponent + 2 * NormalMantissaBits) / 3;
				ExponentBias = exponentBias;
				MaxBinaryExponent = maxBinaryExponent;
				MinBinaryExponent = 1 - maxBinaryExponent;
				DenormalMantissaMask = (ulong)((1L << (int)denormalMantissaBits) - 1);
				NormalMantissaMask = (ulong)((1L << (int)NormalMantissaBits) - 1);
				InfinityBits = infinityBits;
				ZeroBits = 0uL;
			}
		}

		internal enum ParsingStatus
		{
			OK,
			Failed,
			Overflow
		}

		private static readonly string[] s_singleDigitStringCache = new string[10] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };

		private static readonly string[] s_posCurrencyFormats = new string[4] { "$#", "#$", "$ #", "# $" };

		private static readonly string[] s_negCurrencyFormats = new string[17]
		{
			"($#)", "-$#", "$-#", "$#-", "(#$)", "-#$", "#-$", "#$-", "-# $", "-$ #",
			"# $-", "$ #-", "$ -#", "#- $", "($ #)", "(# $)", "$- #"
		};

		private static readonly string[] s_posPercentFormats = new string[4] { "# %", "#%", "%#", "% #" };

		private static readonly string[] s_negPercentFormats = new string[12]
		{
			"-# %", "-#%", "-%#", "%-#", "%#-", "#-%", "#%-", "-% #", "# %-", "% #-",
			"% -#", "#- %"
		};

		private static readonly string[] s_negNumberFormats = new string[5] { "(#)", "-#", "- #", "#-", "# -" };

		private static readonly float[] s_Pow10SingleTable = new float[11]
		{
			1f, 10f, 100f, 1000f, 10000f, 100000f, 1000000f, 10000000f, 100000000f, 1E+09f,
			1E+10f
		};

		private static readonly double[] s_Pow10DoubleTable = new double[23]
		{
			1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
			10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 1E+17, 1E+18, 1E+19,
			1E+20, 1E+21, 1E+22
		};

		public static void Dragon4Double(double value, int cutoffNumber, bool isSignificantDigits, ref NumberBuffer number)
		{
			double num = (double.IsNegative(value) ? (0.0 - value) : value);
			int exponent;
			ulong num2 = ExtractFractionAndBiasedExponent(value, out exponent);
			bool hasUnequalMargins = false;
			uint mantissaHighBitIdx;
			if (num2 >> 52 != 0L)
			{
				mantissaHighBitIdx = 52u;
				hasUnequalMargins = num2 == 4503599627370496L;
			}
			else
			{
				mantissaHighBitIdx = (uint)BitOperations.Log2(num2);
			}
			int decimalExponent;
			int num3 = (int)Dragon4(num2, exponent, mantissaHighBitIdx, hasUnequalMargins, cutoffNumber, isSignificantDigits, number.Digits, out decimalExponent);
			number.Scale = decimalExponent + 1;
			number.Digits[num3] = 0;
			number.DigitsCount = num3;
		}

		public static void Dragon4Half(Half value, int cutoffNumber, bool isSignificantDigits, ref NumberBuffer number)
		{
			Half half = (Half.IsNegative(value) ? Half.Negate(value) : value);
			int exponent;
			ushort num = ExtractFractionAndBiasedExponent(value, out exponent);
			bool hasUnequalMargins = false;
			uint mantissaHighBitIdx;
			if (num >> 10 != 0)
			{
				mantissaHighBitIdx = 10u;
				hasUnequalMargins = num == 1024;
			}
			else
			{
				mantissaHighBitIdx = (uint)BitOperations.Log2(num);
			}
			int decimalExponent;
			int num2 = (int)Dragon4(num, exponent, mantissaHighBitIdx, hasUnequalMargins, cutoffNumber, isSignificantDigits, number.Digits, out decimalExponent);
			number.Scale = decimalExponent + 1;
			number.Digits[num2] = 0;
			number.DigitsCount = num2;
		}

		public static void Dragon4Single(float value, int cutoffNumber, bool isSignificantDigits, ref NumberBuffer number)
		{
			float num = (float.IsNegative(value) ? (0f - value) : value);
			int exponent;
			uint num2 = ExtractFractionAndBiasedExponent(value, out exponent);
			bool hasUnequalMargins = false;
			uint mantissaHighBitIdx;
			if (num2 >> 23 != 0)
			{
				mantissaHighBitIdx = 23u;
				hasUnequalMargins = num2 == 8388608;
			}
			else
			{
				mantissaHighBitIdx = (uint)BitOperations.Log2(num2);
			}
			int decimalExponent;
			int num3 = (int)Dragon4(num2, exponent, mantissaHighBitIdx, hasUnequalMargins, cutoffNumber, isSignificantDigits, number.Digits, out decimalExponent);
			number.Scale = decimalExponent + 1;
			number.Digits[num3] = 0;
			number.DigitsCount = num3;
		}

		private unsafe static uint Dragon4(ulong mantissa, int exponent, uint mantissaHighBitIdx, bool hasUnequalMargins, int cutoffNumber, bool isSignificantDigits, Span<byte> buffer, out int decimalExponent)
		{
			int num = 0;
			BigInteger result;
			BigInteger result2;
			BigInteger result3;
			BigInteger* ptr;
			if (hasUnequalMargins)
			{
				BigInteger result4;
				if (exponent > 0)
				{
					BigInteger.SetUInt64(out result, 4 * mantissa);
					result.ShiftLeft((uint)exponent);
					BigInteger.SetUInt32(out result2, 4u);
					BigInteger.Pow2((uint)exponent, out result3);
					BigInteger.Pow2((uint)(exponent + 1), out result4);
				}
				else
				{
					BigInteger.SetUInt64(out result, 4 * mantissa);
					BigInteger.Pow2((uint)(-exponent + 2), out result2);
					BigInteger.SetUInt32(out result3, 1u);
					BigInteger.SetUInt32(out result4, 2u);
				}
				ptr = &result4;
			}
			else
			{
				if (exponent > 0)
				{
					BigInteger.SetUInt64(out result, 2 * mantissa);
					result.ShiftLeft((uint)exponent);
					BigInteger.SetUInt32(out result2, 2u);
					BigInteger.Pow2((uint)exponent, out result3);
				}
				else
				{
					BigInteger.SetUInt64(out result, 2 * mantissa);
					BigInteger.Pow2((uint)(-exponent + 1), out result2);
					BigInteger.SetUInt32(out result3, 1u);
				}
				ptr = &result3;
			}
			int num2 = (int)Math.Ceiling((double)((int)mantissaHighBitIdx + exponent) * 0.3010299956639812 - 0.69);
			if (num2 > 0)
			{
				result2.MultiplyPow10((uint)num2);
			}
			else if (num2 < 0)
			{
				BigInteger.Pow10((uint)(-num2), out var result5);
				result.Multiply(ref result5);
				result3.Multiply(ref result5);
				if (ptr != &result3)
				{
					BigInteger.Multiply(ref result3, 2u, out *ptr);
				}
			}
			bool flag = mantissa % 2 == 0;
			bool flag2 = false;
			if (cutoffNumber == -1)
			{
				BigInteger.Add(ref result, ref *ptr, out var result6);
				int num3 = BigInteger.Compare(ref result6, ref result2);
				flag2 = (flag ? (num3 >= 0) : (num3 > 0));
			}
			else
			{
				flag2 = BigInteger.Compare(ref result, ref result2) >= 0;
			}
			if (flag2)
			{
				num2++;
			}
			else
			{
				result.Multiply10();
				result3.Multiply10();
				if (ptr != &result3)
				{
					BigInteger.Multiply(ref result3, 2u, out *ptr);
				}
			}
			int num4 = num2 - buffer.Length;
			if (cutoffNumber != -1)
			{
				int num5 = 0;
				num5 = ((!isSignificantDigits) ? (-cutoffNumber) : (num2 - cutoffNumber));
				if (num5 > num4)
				{
					num4 = num5;
				}
			}
			num2 = (decimalExponent = num2 - 1);
			uint block = result2.GetBlock((uint)(result2.GetLength() - 1));
			if (block < 8 || block > 429496729)
			{
				uint num6 = (uint)BitOperations.Log2(block);
				uint shift = (59 - num6) % 32;
				result2.ShiftLeft(shift);
				result.ShiftLeft(shift);
				result3.ShiftLeft(shift);
				if (ptr != &result3)
				{
					BigInteger.Multiply(ref result3, 2u, out *ptr);
				}
			}
			bool flag3;
			bool flag4;
			uint num7;
			if (cutoffNumber == -1)
			{
				while (true)
				{
					num7 = BigInteger.HeuristicDivide(ref result, ref result2);
					BigInteger.Add(ref result, ref *ptr, out var result7);
					int num8 = BigInteger.Compare(ref result, ref result3);
					int num9 = BigInteger.Compare(ref result7, ref result2);
					if (flag)
					{
						flag3 = num8 <= 0;
						flag4 = num9 >= 0;
					}
					else
					{
						flag3 = num8 < 0;
						flag4 = num9 > 0;
					}
					if (flag3 || flag4 || num2 == num4)
					{
						break;
					}
					buffer[num] = (byte)(48 + num7);
					num++;
					result.Multiply10();
					result3.Multiply10();
					if (ptr != &result3)
					{
						BigInteger.Multiply(ref result3, 2u, out *ptr);
					}
					num2--;
				}
			}
			else
			{
				if (num2 < num4)
				{
					num7 = BigInteger.HeuristicDivide(ref result, ref result2);
					if (num7 > 5 || (num7 == 5 && !result.IsZero()))
					{
						decimalExponent++;
						num7 = 1u;
					}
					buffer[num] = (byte)(48 + num7);
					return (uint)(num + 1);
				}
				flag3 = false;
				flag4 = false;
				while (true)
				{
					num7 = BigInteger.HeuristicDivide(ref result, ref result2);
					if (result.IsZero() || num2 <= num4)
					{
						break;
					}
					buffer[num] = (byte)(48 + num7);
					num++;
					result.Multiply10();
					num2--;
				}
			}
			bool flag5 = flag3;
			if (flag3 == flag4)
			{
				result.ShiftLeft(1u);
				int num10 = BigInteger.Compare(ref result, ref result2);
				flag5 = num10 < 0;
				if (num10 == 0)
				{
					flag5 = (num7 & 1) == 0;
				}
			}
			if (flag5)
			{
				buffer[num] = (byte)(48 + num7);
				num++;
			}
			else if (num7 == 9)
			{
				while (true)
				{
					if (num == 0)
					{
						buffer[num] = 49;
						num++;
						decimalExponent++;
						break;
					}
					num--;
					if (buffer[num] != 57)
					{
						buffer[num]++;
						num++;
						break;
					}
				}
			}
			else
			{
				buffer[num] = (byte)(48 + num7 + 1);
				num++;
			}
			return (uint)num;
		}

		public unsafe static string FormatDecimal(decimal value, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[31];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Decimal, digits2, 31);
			DecimalToNumber(ref value, ref number);
			char* pointer = stackalloc char[32];
			ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
			if (c != 0)
			{
				NumberToString(ref sb, ref number, c, digits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return sb.ToString();
		}

		public unsafe static bool TryFormatDecimal(decimal value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten)
		{
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[31];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Decimal, digits2, 31);
			DecimalToNumber(ref value, ref number);
			char* pointer = stackalloc char[32];
			ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
			if (c != 0)
			{
				NumberToString(ref sb, ref number, c, digits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return sb.TryCopyTo(destination, out charsWritten);
		}

		internal unsafe static void DecimalToNumber(ref decimal d, ref NumberBuffer number)
		{
			byte* digitsPointer = number.GetDigitsPointer();
			number.DigitsCount = 29;
			number.IsNegative = d.IsNegative;
			byte* bufferEnd = digitsPointer + 29;
			while ((d.Mid | d.High) != 0)
			{
				bufferEnd = UInt32ToDecChars(bufferEnd, decimal.DecDivMod1E9(ref d), 9);
			}
			bufferEnd = UInt32ToDecChars(bufferEnd, d.Low, 0);
			int num = (number.DigitsCount = (int)(digitsPointer + 29 - bufferEnd));
			number.Scale = num - d.Scale;
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(bufferEnd++);
			}
			*digitsPointer2 = 0;
		}

		public static string FormatDouble(double value, string format, NumberFormatInfo info)
		{
			Span<char> initialBuffer = stackalloc char[32];
			ValueStringBuilder sb = new ValueStringBuilder(initialBuffer);
			return FormatDouble(ref sb, value, format, info) ?? sb.ToString();
		}

		public static bool TryFormatDouble(double value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten)
		{
			Span<char> initialBuffer = stackalloc char[32];
			ValueStringBuilder sb = new ValueStringBuilder(initialBuffer);
			string text = FormatDouble(ref sb, value, format, info);
			if (text == null)
			{
				return sb.TryCopyTo(destination, out charsWritten);
			}
			return TryCopyTo(text, destination, out charsWritten);
		}

		private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int precision, NumberFormatInfo info, out bool isSignificantDigits)
		{
			if (fmt == '\0')
			{
				isSignificantDigits = true;
				return precision;
			}
			int result = precision;
			switch (fmt)
			{
			case 'C':
			case 'c':
				if (precision == -1)
				{
					precision = info.CurrencyDecimalDigits;
				}
				isSignificantDigits = false;
				break;
			case 'E':
			case 'e':
				if (precision == -1)
				{
					precision = 6;
				}
				precision++;
				isSignificantDigits = true;
				break;
			case 'F':
			case 'N':
			case 'f':
			case 'n':
				if (precision == -1)
				{
					precision = info.NumberDecimalDigits;
				}
				isSignificantDigits = false;
				break;
			case 'G':
			case 'g':
				if (precision == 0)
				{
					precision = -1;
				}
				isSignificantDigits = true;
				break;
			case 'P':
			case 'p':
				if (precision == -1)
				{
					precision = info.PercentDecimalDigits;
				}
				precision += 2;
				isSignificantDigits = false;
				break;
			case 'R':
			case 'r':
				precision = -1;
				isSignificantDigits = true;
				break;
			default:
				throw new FormatException(SR.Argument_BadFormatSpecifier);
			}
			return result;
		}

		private unsafe static string FormatDouble(ref ValueStringBuilder sb, double value, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			if (!double.IsFinite(value))
			{
				if (double.IsNaN(value))
				{
					return info.NaNSymbol;
				}
				if (!double.IsNegative(value))
				{
					return info.PositiveInfinitySymbol;
				}
				return info.NegativeInfinitySymbol;
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[769];
			if (c == '\0')
			{
				digits = 15;
			}
			NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits2, 769);
			number.IsNegative = double.IsNegative(value);
			bool isSignificantDigits;
			int nMaxDigits = GetFloatingPointMaxDigitsAndPrecision(c, ref digits, info, out isSignificantDigits);
			if (value != 0.0 && (!isSignificantDigits || !Grisu3.TryRunDouble(value, digits, ref number)))
			{
				Dragon4Double(value, digits, isSignificantDigits, ref number);
			}
			if (c != 0)
			{
				if (digits == -1)
				{
					nMaxDigits = Math.Max(number.DigitsCount, 17);
				}
				NumberToString(ref sb, ref number, c, nMaxDigits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return null;
		}

		public static string FormatSingle(float value, string format, NumberFormatInfo info)
		{
			Span<char> initialBuffer = stackalloc char[32];
			ValueStringBuilder sb = new ValueStringBuilder(initialBuffer);
			return FormatSingle(ref sb, value, format, info) ?? sb.ToString();
		}

		public static bool TryFormatSingle(float value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten)
		{
			Span<char> initialBuffer = stackalloc char[32];
			ValueStringBuilder sb = new ValueStringBuilder(initialBuffer);
			string text = FormatSingle(ref sb, value, format, info);
			if (text == null)
			{
				return sb.TryCopyTo(destination, out charsWritten);
			}
			return TryCopyTo(text, destination, out charsWritten);
		}

		private unsafe static string FormatSingle(ref ValueStringBuilder sb, float value, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			if (!float.IsFinite(value))
			{
				if (float.IsNaN(value))
				{
					return info.NaNSymbol;
				}
				if (!float.IsNegative(value))
				{
					return info.PositiveInfinitySymbol;
				}
				return info.NegativeInfinitySymbol;
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[114];
			if (c == '\0')
			{
				digits = 7;
			}
			NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits2, 114);
			number.IsNegative = float.IsNegative(value);
			bool isSignificantDigits;
			int nMaxDigits = GetFloatingPointMaxDigitsAndPrecision(c, ref digits, info, out isSignificantDigits);
			if (value != 0f && (!isSignificantDigits || !Grisu3.TryRunSingle(value, digits, ref number)))
			{
				Dragon4Single(value, digits, isSignificantDigits, ref number);
			}
			if (c != 0)
			{
				if (digits == -1)
				{
					nMaxDigits = Math.Max(number.DigitsCount, 9);
				}
				NumberToString(ref sb, ref number, c, nMaxDigits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return null;
		}

		public static string FormatHalf(Half value, string format, NumberFormatInfo info)
		{
			Span<char> initialBuffer = stackalloc char[32];
			ValueStringBuilder sb = new ValueStringBuilder(initialBuffer);
			return FormatHalf(ref sb, value, format, info) ?? sb.ToString();
		}

		private unsafe static string FormatHalf(ref ValueStringBuilder sb, Half value, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			if (!Half.IsFinite(value))
			{
				if (Half.IsNaN(value))
				{
					return info.NaNSymbol;
				}
				if (!Half.IsNegative(value))
				{
					return info.PositiveInfinitySymbol;
				}
				return info.NegativeInfinitySymbol;
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[21];
			if (c == '\0')
			{
				digits = 5;
			}
			NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits2, 21);
			number.IsNegative = Half.IsNegative(value);
			bool isSignificantDigits;
			int nMaxDigits = GetFloatingPointMaxDigitsAndPrecision(c, ref digits, info, out isSignificantDigits);
			if (value != default(Half) && (!isSignificantDigits || !Grisu3.TryRunHalf(value, digits, ref number)))
			{
				Dragon4Half(value, digits, isSignificantDigits, ref number);
			}
			if (c != 0)
			{
				if (digits == -1)
				{
					nMaxDigits = Math.Max(number.DigitsCount, 5);
				}
				NumberToString(ref sb, ref number, c, nMaxDigits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return null;
		}

		public static bool TryFormatHalf(Half value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten)
		{
			Span<char> initialBuffer = stackalloc char[32];
			ValueStringBuilder sb = new ValueStringBuilder(initialBuffer);
			string text = FormatHalf(ref sb, value, format, info);
			if (text == null)
			{
				return sb.TryCopyTo(destination, out charsWritten);
			}
			return TryCopyTo(text, destination, out charsWritten);
		}

		private static bool TryCopyTo(string source, Span<char> destination, out int charsWritten)
		{
			if (source.TryCopyTo(destination))
			{
				charsWritten = source.Length;
				return true;
			}
			charsWritten = 0;
			return false;
		}

		private static char GetHexBase(char fmt)
		{
			return (char)(fmt - 33);
		}

		public static string FormatInt32(int value, int hexMask, string format, IFormatProvider provider)
		{
			if (string.IsNullOrEmpty(format))
			{
				if (value < 0)
				{
					return NegativeInt32ToDecStr(value, -1, NumberFormatInfo.GetInstance(provider).NegativeSign);
				}
				return UInt32ToDecStr((uint)value);
			}
			return FormatInt32Slow(value, hexMask, format, provider);
			unsafe static string FormatInt32Slow(int value, int hexMask, string format, IFormatProvider provider)
			{
				ReadOnlySpan<char> format2 = format;
				int digits;
				char c = ParseFormatSpecifier(format2, out digits);
				char c2 = (char)(c & 0xFFDFu);
				if ((c2 == 'G') ? (digits < 1) : (c2 == 'D'))
				{
					if (value < 0)
					{
						return NegativeInt32ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign);
					}
					return UInt32ToDecStr((uint)value, digits);
				}
				if (c2 == 'X')
				{
					return Int32ToHexStr(value & hexMask, GetHexBase(c), digits);
				}
				NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
				byte* digits2 = stackalloc byte[11];
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11);
				Int32ToNumber(value, ref number);
				char* pointer = stackalloc char[32];
				ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
				if (c != 0)
				{
					NumberToString(ref sb, ref number, c, digits, instance);
				}
				else
				{
					NumberToStringFormat(ref sb, ref number, format2, instance);
				}
				return sb.ToString();
			}
		}

		public static bool TryFormatInt32(int value, int hexMask, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
		{
			if (format.Length == 0)
			{
				if (value < 0)
				{
					return TryNegativeInt32ToDecStr(value, -1, NumberFormatInfo.GetInstance(provider).NegativeSign, destination, out charsWritten);
				}
				return TryUInt32ToDecStr((uint)value, -1, destination, out charsWritten);
			}
			return TryFormatInt32Slow(value, hexMask, format, provider, destination, out charsWritten);
			unsafe static bool TryFormatInt32Slow(int value, int hexMask, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
			{
				int digits;
				char c = ParseFormatSpecifier(format, out digits);
				char c2 = (char)(c & 0xFFDFu);
				if ((c2 == 'G') ? (digits < 1) : (c2 == 'D'))
				{
					if (value < 0)
					{
						return TryNegativeInt32ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign, destination, out charsWritten);
					}
					return TryUInt32ToDecStr((uint)value, digits, destination, out charsWritten);
				}
				if (c2 == 'X')
				{
					return TryInt32ToHexStr(value & hexMask, GetHexBase(c), digits, destination, out charsWritten);
				}
				NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
				byte* digits2 = stackalloc byte[11];
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11);
				Int32ToNumber(value, ref number);
				char* pointer = stackalloc char[32];
				ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
				if (c != 0)
				{
					NumberToString(ref sb, ref number, c, digits, instance);
				}
				else
				{
					NumberToStringFormat(ref sb, ref number, format, instance);
				}
				return sb.TryCopyTo(destination, out charsWritten);
			}
		}

		public static string FormatUInt32(uint value, string format, IFormatProvider provider)
		{
			if (string.IsNullOrEmpty(format))
			{
				return UInt32ToDecStr(value);
			}
			return FormatUInt32Slow(value, format, provider);
			unsafe static string FormatUInt32Slow(uint value, string format, IFormatProvider provider)
			{
				ReadOnlySpan<char> format2 = format;
				int digits;
				char c = ParseFormatSpecifier(format2, out digits);
				char c2 = (char)(c & 0xFFDFu);
				if ((c2 == 'G') ? (digits < 1) : (c2 == 'D'))
				{
					return UInt32ToDecStr(value, digits);
				}
				if (c2 == 'X')
				{
					return Int32ToHexStr((int)value, GetHexBase(c), digits);
				}
				NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
				byte* digits2 = stackalloc byte[11];
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11);
				UInt32ToNumber(value, ref number);
				char* pointer = stackalloc char[32];
				ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
				if (c != 0)
				{
					NumberToString(ref sb, ref number, c, digits, instance);
				}
				else
				{
					NumberToStringFormat(ref sb, ref number, format2, instance);
				}
				return sb.ToString();
			}
		}

		public static bool TryFormatUInt32(uint value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
		{
			if (format.Length == 0)
			{
				return TryUInt32ToDecStr(value, -1, destination, out charsWritten);
			}
			return TryFormatUInt32Slow(value, format, provider, destination, out charsWritten);
			unsafe static bool TryFormatUInt32Slow(uint value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
			{
				int digits;
				char c = ParseFormatSpecifier(format, out digits);
				char c2 = (char)(c & 0xFFDFu);
				if ((c2 == 'G') ? (digits < 1) : (c2 == 'D'))
				{
					return TryUInt32ToDecStr(value, digits, destination, out charsWritten);
				}
				if (c2 == 'X')
				{
					return TryInt32ToHexStr((int)value, GetHexBase(c), digits, destination, out charsWritten);
				}
				NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
				byte* digits2 = stackalloc byte[11];
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11);
				UInt32ToNumber(value, ref number);
				char* pointer = stackalloc char[32];
				ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
				if (c != 0)
				{
					NumberToString(ref sb, ref number, c, digits, instance);
				}
				else
				{
					NumberToStringFormat(ref sb, ref number, format, instance);
				}
				return sb.TryCopyTo(destination, out charsWritten);
			}
		}

		public static string FormatInt64(long value, string format, IFormatProvider provider)
		{
			if (string.IsNullOrEmpty(format))
			{
				if (value < 0)
				{
					return NegativeInt64ToDecStr(value, -1, NumberFormatInfo.GetInstance(provider).NegativeSign);
				}
				return UInt64ToDecStr((ulong)value, -1);
			}
			return FormatInt64Slow(value, format, provider);
			unsafe static string FormatInt64Slow(long value, string format, IFormatProvider provider)
			{
				ReadOnlySpan<char> format2 = format;
				int digits;
				char c = ParseFormatSpecifier(format2, out digits);
				char c2 = (char)(c & 0xFFDFu);
				if ((c2 == 'G') ? (digits < 1) : (c2 == 'D'))
				{
					if (value < 0)
					{
						return NegativeInt64ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign);
					}
					return UInt64ToDecStr((ulong)value, digits);
				}
				if (c2 == 'X')
				{
					return Int64ToHexStr(value, GetHexBase(c), digits);
				}
				NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
				byte* digits2 = stackalloc byte[20];
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 20);
				Int64ToNumber(value, ref number);
				char* pointer = stackalloc char[32];
				ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
				if (c != 0)
				{
					NumberToString(ref sb, ref number, c, digits, instance);
				}
				else
				{
					NumberToStringFormat(ref sb, ref number, format2, instance);
				}
				return sb.ToString();
			}
		}

		public static bool TryFormatInt64(long value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
		{
			if (format.Length == 0)
			{
				if (value < 0)
				{
					return TryNegativeInt64ToDecStr(value, -1, NumberFormatInfo.GetInstance(provider).NegativeSign, destination, out charsWritten);
				}
				return TryUInt64ToDecStr((ulong)value, -1, destination, out charsWritten);
			}
			return TryFormatInt64Slow(value, format, provider, destination, out charsWritten);
			unsafe static bool TryFormatInt64Slow(long value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
			{
				int digits;
				char c = ParseFormatSpecifier(format, out digits);
				char c2 = (char)(c & 0xFFDFu);
				if ((c2 == 'G') ? (digits < 1) : (c2 == 'D'))
				{
					if (value < 0)
					{
						return TryNegativeInt64ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign, destination, out charsWritten);
					}
					return TryUInt64ToDecStr((ulong)value, digits, destination, out charsWritten);
				}
				if (c2 == 'X')
				{
					return TryInt64ToHexStr(value, GetHexBase(c), digits, destination, out charsWritten);
				}
				NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
				byte* digits2 = stackalloc byte[20];
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 20);
				Int64ToNumber(value, ref number);
				char* pointer = stackalloc char[32];
				ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
				if (c != 0)
				{
					NumberToString(ref sb, ref number, c, digits, instance);
				}
				else
				{
					NumberToStringFormat(ref sb, ref number, format, instance);
				}
				return sb.TryCopyTo(destination, out charsWritten);
			}
		}

		public static string FormatUInt64(ulong value, string format, IFormatProvider provider)
		{
			if (string.IsNullOrEmpty(format))
			{
				return UInt64ToDecStr(value, -1);
			}
			return FormatUInt64Slow(value, format, provider);
			unsafe static string FormatUInt64Slow(ulong value, string format, IFormatProvider provider)
			{
				ReadOnlySpan<char> format2 = format;
				int digits;
				char c = ParseFormatSpecifier(format2, out digits);
				char c2 = (char)(c & 0xFFDFu);
				if ((c2 == 'G') ? (digits < 1) : (c2 == 'D'))
				{
					return UInt64ToDecStr(value, digits);
				}
				if (c2 == 'X')
				{
					return Int64ToHexStr((long)value, GetHexBase(c), digits);
				}
				NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
				byte* digits2 = stackalloc byte[21];
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 21);
				UInt64ToNumber(value, ref number);
				char* pointer = stackalloc char[32];
				ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
				if (c != 0)
				{
					NumberToString(ref sb, ref number, c, digits, instance);
				}
				else
				{
					NumberToStringFormat(ref sb, ref number, format2, instance);
				}
				return sb.ToString();
			}
		}

		public static bool TryFormatUInt64(ulong value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
		{
			if (format.Length == 0)
			{
				return TryUInt64ToDecStr(value, -1, destination, out charsWritten);
			}
			return TryFormatUInt64Slow(value, format, provider, destination, out charsWritten);
			unsafe static bool TryFormatUInt64Slow(ulong value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
			{
				int digits;
				char c = ParseFormatSpecifier(format, out digits);
				char c2 = (char)(c & 0xFFDFu);
				if ((c2 == 'G') ? (digits < 1) : (c2 == 'D'))
				{
					return TryUInt64ToDecStr(value, digits, destination, out charsWritten);
				}
				if (c2 == 'X')
				{
					return TryInt64ToHexStr((long)value, GetHexBase(c), digits, destination, out charsWritten);
				}
				NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
				byte* digits2 = stackalloc byte[21];
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 21);
				UInt64ToNumber(value, ref number);
				char* pointer = stackalloc char[32];
				ValueStringBuilder sb = new ValueStringBuilder(new Span<char>(pointer, 32));
				if (c != 0)
				{
					NumberToString(ref sb, ref number, c, digits, instance);
				}
				else
				{
					NumberToStringFormat(ref sb, ref number, format, instance);
				}
				return sb.TryCopyTo(destination, out charsWritten);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static void Int32ToNumber(int value, ref NumberBuffer number)
		{
			number.DigitsCount = 10;
			if (value >= 0)
			{
				number.IsNegative = false;
			}
			else
			{
				number.IsNegative = true;
				value = -value;
			}
			byte* digitsPointer = number.GetDigitsPointer();
			byte* ptr = UInt32ToDecChars(digitsPointer + 10, (uint)value, 0);
			int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 10 - ptr)));
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(ptr++);
			}
			*digitsPointer2 = 0;
		}

		public static string Int32ToDecStr(int value)
		{
			if (value < 0)
			{
				return NegativeInt32ToDecStr(value, -1, NumberFormatInfo.CurrentInfo.NegativeSign);
			}
			return UInt32ToDecStr((uint)value);
		}

		private unsafe static string NegativeInt32ToDecStr(int value, int digits, string sNegative)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, FormattingHelpers.CountDigits((uint)(-value))) + sNegative.Length;
			string text = string.FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* ptr2 = UInt32ToDecChars(ptr + num, (uint)(-value), digits);
				for (int num2 = sNegative.Length - 1; num2 >= 0; num2--)
				{
					*(--ptr2) = sNegative[num2];
				}
			}
			return text;
		}

		private unsafe static bool TryNegativeInt32ToDecStr(int value, int digits, string sNegative, Span<char> destination, out int charsWritten)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, FormattingHelpers.CountDigits((uint)(-value))) + sNegative.Length;
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* ptr2 = UInt32ToDecChars(ptr + num, (uint)(-value), digits);
				for (int num2 = sNegative.Length - 1; num2 >= 0; num2--)
				{
					*(--ptr2) = sNegative[num2];
				}
			}
			return true;
		}

		private unsafe static string Int32ToHexStr(int value, char hexBase, int digits)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, FormattingHelpers.CountHexDigits((uint)value));
			string text = string.FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* ptr2 = Int32ToHexChars(ptr + num, (uint)value, hexBase, digits);
			}
			return text;
		}

		private unsafe static bool TryInt32ToHexStr(int value, char hexBase, int digits, Span<char> destination, out int charsWritten)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, FormattingHelpers.CountHexDigits((uint)value));
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* ptr2 = Int32ToHexChars(ptr + num, (uint)value, hexBase, digits);
			}
			return true;
		}

		private unsafe static char* Int32ToHexChars(char* buffer, uint value, int hexBase, int digits)
		{
			while (--digits >= 0 || value != 0)
			{
				byte b = (byte)(value & 0xFu);
				*(--buffer) = (char)(b + ((b < 10) ? 48 : hexBase));
				value >>= 4;
			}
			return buffer;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static void UInt32ToNumber(uint value, ref NumberBuffer number)
		{
			number.DigitsCount = 10;
			number.IsNegative = false;
			byte* digitsPointer = number.GetDigitsPointer();
			byte* ptr = UInt32ToDecChars(digitsPointer + 10, value, 0);
			int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 10 - ptr)));
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(ptr++);
			}
			*digitsPointer2 = 0;
		}

		internal unsafe static byte* UInt32ToDecChars(byte* bufferEnd, uint value, int digits)
		{
			while (--digits >= 0 || value != 0)
			{
				uint num;
				(value, num) = Math.DivRem(value, 10u);
				*(--bufferEnd) = (byte)(num + 48);
			}
			return bufferEnd;
		}

		internal unsafe static char* UInt32ToDecChars(char* bufferEnd, uint value, int digits)
		{
			while (--digits >= 0 || value != 0)
			{
				uint num;
				(value, num) = Math.DivRem(value, 10u);
				*(--bufferEnd) = (char)(num + 48);
			}
			return bufferEnd;
		}

		internal unsafe static string UInt32ToDecStr(uint value)
		{
			int num = FormattingHelpers.CountDigits(value);
			if (num == 1)
			{
				return s_singleDigitStringCache[value];
			}
			string text = string.FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* ptr2 = ptr + num;
				do
				{
					uint num2;
					(value, num2) = Math.DivRem(value, 10u);
					*(--ptr2) = (char)(num2 + 48);
				}
				while (value != 0);
			}
			return text;
		}

		private unsafe static string UInt32ToDecStr(uint value, int digits)
		{
			if (digits <= 1)
			{
				return UInt32ToDecStr(value);
			}
			int num = Math.Max(digits, FormattingHelpers.CountDigits(value));
			string text = string.FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* bufferEnd = ptr + num;
				bufferEnd = UInt32ToDecChars(bufferEnd, value, digits);
			}
			return text;
		}

		private unsafe static bool TryUInt32ToDecStr(uint value, int digits, Span<char> destination, out int charsWritten)
		{
			int num = Math.Max(digits, FormattingHelpers.CountDigits(value));
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* ptr2 = ptr + num;
				if (digits <= 1)
				{
					do
					{
						uint num2;
						(value, num2) = Math.DivRem(value, 10u);
						*(--ptr2) = (char)(num2 + 48);
					}
					while (value != 0);
				}
				else
				{
					ptr2 = UInt32ToDecChars(ptr2, value, digits);
				}
			}
			return true;
		}

		private unsafe static void Int64ToNumber(long input, ref NumberBuffer number)
		{
			ulong value = (ulong)input;
			number.IsNegative = input < 0;
			number.DigitsCount = 19;
			if (number.IsNegative)
			{
				value = (ulong)(-input);
			}
			byte* digitsPointer = number.GetDigitsPointer();
			byte* bufferEnd = digitsPointer + 19;
			while (High32(value) != 0)
			{
				bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
			}
			bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), 0);
			int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 19 - bufferEnd)));
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(bufferEnd++);
			}
			*digitsPointer2 = 0;
		}

		public static string Int64ToDecStr(long value)
		{
			if (value < 0)
			{
				return NegativeInt64ToDecStr(value, -1, NumberFormatInfo.CurrentInfo.NegativeSign);
			}
			return UInt64ToDecStr((ulong)value, -1);
		}

		private unsafe static string NegativeInt64ToDecStr(long input, int digits, string sNegative)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			ulong value = (ulong)(-input);
			int num = Math.Max(digits, FormattingHelpers.CountDigits(value)) + sNegative.Length;
			string text = string.FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* bufferEnd = ptr + num;
				while (High32(value) != 0)
				{
					bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
					digits -= 9;
				}
				bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits);
				for (int num2 = sNegative.Length - 1; num2 >= 0; num2--)
				{
					*(--bufferEnd) = sNegative[num2];
				}
			}
			return text;
		}

		private unsafe static bool TryNegativeInt64ToDecStr(long input, int digits, string sNegative, Span<char> destination, out int charsWritten)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			ulong value = (ulong)(-input);
			int num = Math.Max(digits, FormattingHelpers.CountDigits((ulong)(-input))) + sNegative.Length;
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* bufferEnd = ptr + num;
				while (High32(value) != 0)
				{
					bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
					digits -= 9;
				}
				bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits);
				for (int num2 = sNegative.Length - 1; num2 >= 0; num2--)
				{
					*(--bufferEnd) = sNegative[num2];
				}
			}
			return true;
		}

		private unsafe static string Int64ToHexStr(long value, char hexBase, int digits)
		{
			int num = Math.Max(digits, FormattingHelpers.CountHexDigits((ulong)value));
			string text = string.FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* buffer = ptr + num;
				if (High32((ulong)value) != 0)
				{
					buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, 8);
					buffer = Int32ToHexChars(buffer, High32((ulong)value), hexBase, digits - 8);
				}
				else
				{
					buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, Math.Max(digits, 1));
				}
			}
			return text;
		}

		private unsafe static bool TryInt64ToHexStr(long value, char hexBase, int digits, Span<char> destination, out int charsWritten)
		{
			int num = Math.Max(digits, FormattingHelpers.CountHexDigits((ulong)value));
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* buffer = ptr + num;
				if (High32((ulong)value) != 0)
				{
					buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, 8);
					buffer = Int32ToHexChars(buffer, High32((ulong)value), hexBase, digits - 8);
				}
				else
				{
					buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, Math.Max(digits, 1));
				}
			}
			return true;
		}

		private unsafe static void UInt64ToNumber(ulong value, ref NumberBuffer number)
		{
			number.DigitsCount = 20;
			number.IsNegative = false;
			byte* digitsPointer = number.GetDigitsPointer();
			byte* bufferEnd = digitsPointer + 20;
			while (High32(value) != 0)
			{
				bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
			}
			bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), 0);
			int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 20 - bufferEnd)));
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(bufferEnd++);
			}
			*digitsPointer2 = 0;
		}

		internal unsafe static string UInt64ToDecStr(ulong value, int digits)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, FormattingHelpers.CountDigits(value));
			if (num == 1)
			{
				return s_singleDigitStringCache[value];
			}
			string text = string.FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* bufferEnd = ptr + num;
				while (High32(value) != 0)
				{
					bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
					digits -= 9;
				}
				bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits);
			}
			return text;
		}

		private unsafe static bool TryUInt64ToDecStr(ulong value, int digits, Span<char> destination, out int charsWritten)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, FormattingHelpers.CountDigits(value));
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* bufferEnd = ptr + num;
				while (High32(value) != 0)
				{
					bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
					digits -= 9;
				}
				bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits);
			}
			return true;
		}

		internal static char ParseFormatSpecifier(ReadOnlySpan<char> format, out int digits)
		{
			char c = '\0';
			if (format.Length > 0)
			{
				c = format[0];
				if ((uint)(c - 65) <= 25u || (uint)(c - 97) <= 25u)
				{
					if (format.Length == 1)
					{
						digits = -1;
						return c;
					}
					if (format.Length == 2)
					{
						int num = format[1] - 48;
						if ((uint)num < 10u)
						{
							digits = num;
							return c;
						}
					}
					else if (format.Length == 3)
					{
						int num2 = format[1] - 48;
						int num3 = format[2] - 48;
						if ((uint)num2 < 10u && (uint)num3 < 10u)
						{
							digits = num2 * 10 + num3;
							return c;
						}
					}
					int num4 = 0;
					int num5 = 1;
					while (num5 < format.Length && (uint)(format[num5] - 48) < 10u)
					{
						int num6 = num4 * 10 + format[num5++] - 48;
						if (num6 < num4)
						{
							throw new FormatException(SR.Argument_BadFormatSpecifier);
						}
						num4 = num6;
					}
					if (num5 == format.Length || format[num5] == '\0')
					{
						digits = num4;
						return c;
					}
				}
			}
			digits = -1;
			if (format.Length != 0 && c != 0)
			{
				return '\0';
			}
			return 'G';
		}

		internal static void NumberToString(ref ValueStringBuilder sb, ref NumberBuffer number, char format, int nMaxDigits, NumberFormatInfo info)
		{
			bool isCorrectlyRounded = number.Kind == NumberBufferKind.FloatingPoint;
			bool bSuppressScientific;
			switch (format)
			{
			case 'C':
			case 'c':
				if (nMaxDigits < 0)
				{
					nMaxDigits = info.CurrencyDecimalDigits;
				}
				RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded);
				FormatCurrency(ref sb, ref number, nMaxDigits, info);
				return;
			case 'F':
			case 'f':
				if (nMaxDigits < 0)
				{
					nMaxDigits = info.NumberDecimalDigits;
				}
				RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded);
				if (number.IsNegative)
				{
					sb.Append(info.NegativeSign);
				}
				FormatFixed(ref sb, ref number, nMaxDigits, null, info.NumberDecimalSeparator, null);
				return;
			case 'N':
			case 'n':
				if (nMaxDigits < 0)
				{
					nMaxDigits = info.NumberDecimalDigits;
				}
				RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded);
				FormatNumber(ref sb, ref number, nMaxDigits, info);
				return;
			case 'E':
			case 'e':
				if (nMaxDigits < 0)
				{
					nMaxDigits = 6;
				}
				nMaxDigits++;
				RoundNumber(ref number, nMaxDigits, isCorrectlyRounded);
				if (number.IsNegative)
				{
					sb.Append(info.NegativeSign);
				}
				FormatScientific(ref sb, ref number, nMaxDigits, info, format);
				return;
			case 'G':
			case 'g':
				bSuppressScientific = false;
				if (nMaxDigits < 1)
				{
					if (number.Kind == NumberBufferKind.Decimal && nMaxDigits == -1)
					{
						bSuppressScientific = true;
						if (number.Digits[0] != 0)
						{
							goto IL_0189;
						}
						goto IL_019e;
					}
					nMaxDigits = number.DigitsCount;
				}
				RoundNumber(ref number, nMaxDigits, isCorrectlyRounded);
				goto IL_0189;
			case 'P':
			case 'p':
				if (nMaxDigits < 0)
				{
					nMaxDigits = info.PercentDecimalDigits;
				}
				number.Scale += 2;
				RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded);
				FormatPercent(ref sb, ref number, nMaxDigits, info);
				return;
			case 'R':
			case 'r':
				{
					if (number.Kind != NumberBufferKind.FloatingPoint)
					{
						break;
					}
					format = (char)(format - 11);
					goto case 'G';
				}
				IL_0189:
				if (number.IsNegative)
				{
					sb.Append(info.NegativeSign);
				}
				goto IL_019e;
				IL_019e:
				FormatGeneral(ref sb, ref number, nMaxDigits, info, (char)(format - 2), bSuppressScientific);
				return;
			}
			throw new FormatException(SR.Argument_BadFormatSpecifier);
		}

		internal unsafe static void NumberToStringFormat(ref ValueStringBuilder sb, ref NumberBuffer number, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			int num = 0;
			byte* digitsPointer = number.GetDigitsPointer();
			int num2 = FindSection(format, (*digitsPointer == 0) ? 2 : (number.IsNegative ? 1 : 0));
			int num3;
			int num4;
			bool flag;
			bool flag2;
			int num5;
			int num6;
			int num9;
			while (true)
			{
				num3 = 0;
				num4 = -1;
				num5 = int.MaxValue;
				num6 = 0;
				flag = false;
				int num7 = -1;
				flag2 = false;
				int num8 = 0;
				num9 = num2;
				fixed (char* ptr = &MemoryMarshal.GetReference(format))
				{
					char c;
					while (num9 < format.Length && (c = ptr[num9++]) != 0)
					{
						switch (c)
						{
						case ';':
							break;
						case '#':
							num3++;
							continue;
						case '0':
							if (num5 == int.MaxValue)
							{
								num5 = num3;
							}
							num3++;
							num6 = num3;
							continue;
						case '.':
							if (num4 < 0)
							{
								num4 = num3;
							}
							continue;
						case ',':
							if (num3 <= 0 || num4 >= 0)
							{
								continue;
							}
							if (num7 >= 0)
							{
								if (num7 == num3)
								{
									num++;
									continue;
								}
								flag2 = true;
							}
							num7 = num3;
							num = 1;
							continue;
						case '%':
							num8 += 2;
							continue;
						case '‰':
							num8 += 3;
							continue;
						case '"':
						case '\'':
							while (num9 < format.Length && ptr[num9] != 0 && ptr[num9++] != c)
							{
							}
							continue;
						case '\\':
							if (num9 < format.Length && ptr[num9] != 0)
							{
								num9++;
							}
							continue;
						case 'E':
						case 'e':
							if ((num9 < format.Length && ptr[num9] == '0') || (num9 + 1 < format.Length && (ptr[num9] == '+' || ptr[num9] == '-') && ptr[num9 + 1] == '0'))
							{
								while (++num9 < format.Length && ptr[num9] == '0')
								{
								}
								flag = true;
							}
							continue;
						default:
							continue;
						}
						break;
					}
				}
				if (num4 < 0)
				{
					num4 = num3;
				}
				if (num7 >= 0)
				{
					if (num7 == num4)
					{
						num8 -= num * 3;
					}
					else
					{
						flag2 = true;
					}
				}
				if (*digitsPointer != 0)
				{
					number.Scale += num8;
					int pos = (flag ? num3 : (number.Scale + num3 - num4));
					RoundNumber(ref number, pos, isCorrectlyRounded: false);
					if (*digitsPointer != 0)
					{
						break;
					}
					num9 = FindSection(format, 2);
					if (num9 == num2)
					{
						break;
					}
					num2 = num9;
					continue;
				}
				if (number.Kind != NumberBufferKind.FloatingPoint)
				{
					number.IsNegative = false;
				}
				number.Scale = 0;
				break;
			}
			num5 = ((num5 < num4) ? (num4 - num5) : 0);
			num6 = ((num6 > num4) ? (num4 - num6) : 0);
			int num10;
			int num11;
			if (flag)
			{
				num10 = num4;
				num11 = 0;
			}
			else
			{
				num10 = ((number.Scale > num4) ? number.Scale : num4);
				num11 = number.Scale - num4;
			}
			num9 = num2;
			Span<int> span = stackalloc int[4];
			int num12 = -1;
			if (flag2 && info.NumberGroupSeparator.Length > 0)
			{
				int[] numberGroupSizes = info._numberGroupSizes;
				int num13 = 0;
				int i = 0;
				int num14 = numberGroupSizes.Length;
				if (num14 != 0)
				{
					i = numberGroupSizes[num13];
				}
				int num15 = i;
				int num16 = num10 + ((num11 < 0) ? num11 : 0);
				for (int num17 = ((num5 > num16) ? num5 : num16); num17 > i; i += num15)
				{
					if (num15 == 0)
					{
						break;
					}
					num12++;
					if (num12 >= span.Length)
					{
						int[] array = new int[span.Length * 2];
						span.CopyTo(array);
						span = array;
					}
					span[num12] = i;
					if (num13 < num14 - 1)
					{
						num13++;
						num15 = numberGroupSizes[num13];
					}
				}
			}
			if (number.IsNegative && num2 == 0 && number.Scale != 0)
			{
				sb.Append(info.NegativeSign);
			}
			bool flag3 = false;
			fixed (char* ptr3 = &MemoryMarshal.GetReference(format))
			{
				byte* ptr2 = digitsPointer;
				char c;
				while (num9 < format.Length && (c = ptr3[num9++]) != 0 && c != ';')
				{
					if (num11 > 0 && (c == '#' || c == '.' || c == '0'))
					{
						while (num11 > 0)
						{
							sb.Append((char)((*ptr2 != 0) ? (*(ptr2++)) : 48));
							if (flag2 && num10 > 1 && num12 >= 0 && num10 == span[num12] + 1)
							{
								sb.Append(info.NumberGroupSeparator);
								num12--;
							}
							num10--;
							num11--;
						}
					}
					switch (c)
					{
					case '#':
					case '0':
						if (num11 < 0)
						{
							num11++;
							c = ((num10 <= num5) ? '0' : '\0');
						}
						else
						{
							c = ((*ptr2 != 0) ? ((char)(*(ptr2++))) : ((num10 > num6) ? '0' : '\0'));
						}
						if (c != 0)
						{
							sb.Append(c);
							if (flag2 && num10 > 1 && num12 >= 0 && num10 == span[num12] + 1)
							{
								sb.Append(info.NumberGroupSeparator);
								num12--;
							}
						}
						num10--;
						break;
					case '.':
						if (!(num10 != 0 || flag3) && (num6 < 0 || (num4 < num3 && *ptr2 != 0)))
						{
							sb.Append(info.NumberDecimalSeparator);
							flag3 = true;
						}
						break;
					case '‰':
						sb.Append(info.PerMilleSymbol);
						break;
					case '%':
						sb.Append(info.PercentSymbol);
						break;
					case '"':
					case '\'':
						while (num9 < format.Length && ptr3[num9] != 0 && ptr3[num9] != c)
						{
							sb.Append(ptr3[num9++]);
						}
						if (num9 < format.Length && ptr3[num9] != 0)
						{
							num9++;
						}
						break;
					case '\\':
						if (num9 < format.Length && ptr3[num9] != 0)
						{
							sb.Append(ptr3[num9++]);
						}
						break;
					case 'E':
					case 'e':
					{
						bool positiveSign = false;
						int num18 = 0;
						if (flag)
						{
							if (num9 < format.Length && ptr3[num9] == '0')
							{
								num18++;
							}
							else if (num9 + 1 < format.Length && ptr3[num9] == '+' && ptr3[num9 + 1] == '0')
							{
								positiveSign = true;
							}
							else if (num9 + 1 >= format.Length || ptr3[num9] != '-' || ptr3[num9 + 1] != '0')
							{
								sb.Append(c);
								break;
							}
							while (++num9 < format.Length && ptr3[num9] == '0')
							{
								num18++;
							}
							if (num18 > 10)
							{
								num18 = 10;
							}
							int value = ((*digitsPointer != 0) ? (number.Scale - num4) : 0);
							FormatExponent(ref sb, info, value, c, num18, positiveSign);
							flag = false;
							break;
						}
						sb.Append(c);
						if (num9 < format.Length)
						{
							if (ptr3[num9] == '+' || ptr3[num9] == '-')
							{
								sb.Append(ptr3[num9++]);
							}
							while (num9 < format.Length && ptr3[num9] == '0')
							{
								sb.Append(ptr3[num9++]);
							}
						}
						break;
					}
					default:
						sb.Append(c);
						break;
					case ',':
						break;
					}
				}
			}
			if (number.IsNegative && num2 == 0 && number.Scale == 0 && sb.Length > 0)
			{
				sb.Insert(0, info.NegativeSign);
			}
		}

		private static void FormatCurrency(ref ValueStringBuilder sb, ref NumberBuffer number, int nMaxDigits, NumberFormatInfo info)
		{
			string text = (number.IsNegative ? s_negCurrencyFormats[info.CurrencyNegativePattern] : s_posCurrencyFormats[info.CurrencyPositivePattern]);
			string text2 = text;
			foreach (char c in text2)
			{
				switch (c)
				{
				case '#':
					FormatFixed(ref sb, ref number, nMaxDigits, info._currencyGroupSizes, info.CurrencyDecimalSeparator, info.CurrencyGroupSeparator);
					break;
				case '-':
					sb.Append(info.NegativeSign);
					break;
				case '$':
					sb.Append(info.CurrencySymbol);
					break;
				default:
					sb.Append(c);
					break;
				}
			}
		}

		private unsafe static void FormatFixed(ref ValueStringBuilder sb, ref NumberBuffer number, int nMaxDigits, int[] groupDigits, string sDecimal, string sGroup)
		{
			int num = number.Scale;
			byte* ptr = number.GetDigitsPointer();
			if (num > 0)
			{
				if (groupDigits != null)
				{
					int num2 = 0;
					int num3 = num;
					int num4 = 0;
					if (groupDigits.Length != 0)
					{
						int num5 = groupDigits[num2];
						while (num > num5 && groupDigits[num2] != 0)
						{
							num3 += sGroup.Length;
							if (num2 < groupDigits.Length - 1)
							{
								num2++;
							}
							num5 += groupDigits[num2];
							if (num5 < 0 || num3 < 0)
							{
								throw new ArgumentOutOfRangeException();
							}
						}
						num4 = ((num5 != 0) ? groupDigits[0] : 0);
					}
					num2 = 0;
					int num6 = 0;
					int digitsCount = number.DigitsCount;
					int num7 = ((num < digitsCount) ? num : digitsCount);
					fixed (char* ptr2 = &MemoryMarshal.GetReference(sb.AppendSpan(num3)))
					{
						char* ptr3 = ptr2 + num3 - 1;
						for (int num8 = num - 1; num8 >= 0; num8--)
						{
							*(ptr3--) = (char)((num8 < num7) ? ptr[num8] : 48);
							if (num4 > 0)
							{
								num6++;
								if (num6 == num4 && num8 != 0)
								{
									for (int num9 = sGroup.Length - 1; num9 >= 0; num9--)
									{
										*(ptr3--) = sGroup[num9];
									}
									if (num2 < groupDigits.Length - 1)
									{
										num2++;
										num4 = groupDigits[num2];
									}
									num6 = 0;
								}
							}
						}
						ptr += num7;
					}
				}
				else
				{
					do
					{
						sb.Append((char)((*ptr != 0) ? (*(ptr++)) : 48));
					}
					while (--num > 0);
				}
			}
			else
			{
				sb.Append('0');
			}
			if (nMaxDigits > 0)
			{
				sb.Append(sDecimal);
				if (num < 0 && nMaxDigits > 0)
				{
					int num10 = Math.Min(-num, nMaxDigits);
					sb.Append('0', num10);
					num += num10;
					nMaxDigits -= num10;
				}
				while (nMaxDigits > 0)
				{
					sb.Append((char)((*ptr != 0) ? (*(ptr++)) : 48));
					nMaxDigits--;
				}
			}
		}

		private static void FormatNumber(ref ValueStringBuilder sb, ref NumberBuffer number, int nMaxDigits, NumberFormatInfo info)
		{
			string text = (number.IsNegative ? s_negNumberFormats[info.NumberNegativePattern] : "#");
			string text2 = text;
			foreach (char c in text2)
			{
				switch (c)
				{
				case '#':
					FormatFixed(ref sb, ref number, nMaxDigits, info._numberGroupSizes, info.NumberDecimalSeparator, info.NumberGroupSeparator);
					break;
				case '-':
					sb.Append(info.NegativeSign);
					break;
				default:
					sb.Append(c);
					break;
				}
			}
		}

		private unsafe static void FormatScientific(ref ValueStringBuilder sb, ref NumberBuffer number, int nMaxDigits, NumberFormatInfo info, char expChar)
		{
			byte* digitsPointer = number.GetDigitsPointer();
			sb.Append((char)((*digitsPointer != 0) ? (*(digitsPointer++)) : 48));
			if (nMaxDigits != 1)
			{
				sb.Append(info.NumberDecimalSeparator);
			}
			while (--nMaxDigits > 0)
			{
				sb.Append((char)((*digitsPointer != 0) ? (*(digitsPointer++)) : 48));
			}
			int value = ((number.Digits[0] != 0) ? (number.Scale - 1) : 0);
			FormatExponent(ref sb, info, value, expChar, 3, positiveSign: true);
		}

		private unsafe static void FormatExponent(ref ValueStringBuilder sb, NumberFormatInfo info, int value, char expChar, int minDigits, bool positiveSign)
		{
			sb.Append(expChar);
			if (value < 0)
			{
				sb.Append(info.NegativeSign);
				value = -value;
			}
			else if (positiveSign)
			{
				sb.Append(info.PositiveSign);
			}
			char* ptr = stackalloc char[10];
			char* ptr2 = UInt32ToDecChars(ptr + 10, (uint)value, minDigits);
			sb.Append(ptr2, (int)(ptr + 10 - ptr2));
		}

		private unsafe static void FormatGeneral(ref ValueStringBuilder sb, ref NumberBuffer number, int nMaxDigits, NumberFormatInfo info, char expChar, bool bSuppressScientific)
		{
			int i = number.Scale;
			bool flag = false;
			if (!bSuppressScientific && (i > nMaxDigits || i < -3))
			{
				i = 1;
				flag = true;
			}
			byte* digitsPointer = number.GetDigitsPointer();
			if (i > 0)
			{
				do
				{
					sb.Append((char)((*digitsPointer != 0) ? (*(digitsPointer++)) : 48));
				}
				while (--i > 0);
			}
			else
			{
				sb.Append('0');
			}
			if (*digitsPointer != 0 || i < 0)
			{
				sb.Append(info.NumberDecimalSeparator);
				for (; i < 0; i++)
				{
					sb.Append('0');
				}
				while (*digitsPointer != 0)
				{
					sb.Append((char)(*(digitsPointer++)));
				}
			}
			if (flag)
			{
				FormatExponent(ref sb, info, number.Scale - 1, expChar, 2, positiveSign: true);
			}
		}

		private static void FormatPercent(ref ValueStringBuilder sb, ref NumberBuffer number, int nMaxDigits, NumberFormatInfo info)
		{
			string text = (number.IsNegative ? s_negPercentFormats[info.PercentNegativePattern] : s_posPercentFormats[info.PercentPositivePattern]);
			string text2 = text;
			foreach (char c in text2)
			{
				switch (c)
				{
				case '#':
					FormatFixed(ref sb, ref number, nMaxDigits, info._percentGroupSizes, info.PercentDecimalSeparator, info.PercentGroupSeparator);
					break;
				case '-':
					sb.Append(info.NegativeSign);
					break;
				case '%':
					sb.Append(info.PercentSymbol);
					break;
				default:
					sb.Append(c);
					break;
				}
			}
		}

		internal unsafe static void RoundNumber(ref NumberBuffer number, int pos, bool isCorrectlyRounded)
		{
			byte* digitsPointer = number.GetDigitsPointer();
			int j;
			for (j = 0; j < pos && digitsPointer[j] != 0; j++)
			{
			}
			if (j == pos && ShouldRoundUp(digitsPointer, j, number.Kind, isCorrectlyRounded))
			{
				while (j > 0 && digitsPointer[j - 1] == 57)
				{
					j--;
				}
				if (j > 0)
				{
					byte* num = digitsPointer + (j - 1);
					(*num)++;
				}
				else
				{
					number.Scale++;
					*digitsPointer = 49;
					j = 1;
				}
			}
			else
			{
				while (j > 0 && digitsPointer[j - 1] == 48)
				{
					j--;
				}
			}
			if (j == 0)
			{
				if (number.Kind != NumberBufferKind.FloatingPoint)
				{
					number.IsNegative = false;
				}
				number.Scale = 0;
			}
			digitsPointer[j] = 0;
			number.DigitsCount = j;
			unsafe static bool ShouldRoundUp(byte* dig, int i, NumberBufferKind numberKind, bool isCorrectlyRounded)
			{
				byte b = dig[i];
				if (b == 0 || isCorrectlyRounded)
				{
					return false;
				}
				return b >= 53;
			}
		}

		private unsafe static int FindSection(ReadOnlySpan<char> format, int section)
		{
			if (section == 0)
			{
				return 0;
			}
			fixed (char* ptr = &MemoryMarshal.GetReference(format))
			{
				int num = 0;
				while (true)
				{
					if (num >= format.Length)
					{
						return 0;
					}
					char c;
					char c2 = (c = ptr[num++]);
					if ((uint)c2 <= 34u)
					{
						if (c2 == '\0')
						{
							break;
						}
						if (c2 != '"')
						{
							continue;
						}
					}
					else if (c2 != '\'')
					{
						switch (c2)
						{
						default:
							continue;
						case '\\':
							if (num < format.Length && ptr[num] != 0)
							{
								num++;
							}
							continue;
						case ';':
							break;
						}
						if (--section == 0)
						{
							if (num >= format.Length || ptr[num] == '\0' || ptr[num] == ';')
							{
								break;
							}
							return num;
						}
						continue;
					}
					while (num < format.Length && ptr[num] != 0 && ptr[num++] != c)
					{
					}
				}
				return 0;
			}
		}

		private static uint Low32(ulong value)
		{
			return (uint)value;
		}

		private static uint High32(ulong value)
		{
			return (uint)((value & 0xFFFFFFFF00000000uL) >> 32);
		}

		private static uint Int64DivMod1E9(ref ulong value)
		{
			uint result = (uint)(value % 1000000000);
			value /= 1000000000uL;
			return result;
		}

		private static ulong ExtractFractionAndBiasedExponent(double value, out int exponent)
		{
			ulong num = BitConverter.DoubleToUInt64Bits(value);
			ulong num2 = num & 0xFFFFFFFFFFFFFuL;
			exponent = (int)(num >> 52) & 0x7FF;
			if (exponent != 0)
			{
				num2 |= 0x10000000000000uL;
				exponent -= 1075;
			}
			else
			{
				exponent = -1074;
			}
			return num2;
		}

		private static ushort ExtractFractionAndBiasedExponent(Half value, out int exponent)
		{
			ushort num = BitConverter.HalfToUInt16Bits(value);
			ushort num2 = (ushort)(num & 0x3FFu);
			exponent = (num >> 10) & 0x1F;
			if (exponent != 0)
			{
				num2 = (ushort)(num2 | 0x400u);
				exponent -= 25;
			}
			else
			{
				exponent = -24;
			}
			return num2;
		}

		private static uint ExtractFractionAndBiasedExponent(float value, out int exponent)
		{
			uint num = BitConverter.SingleToUInt32Bits(value);
			uint num2 = num & 0x7FFFFFu;
			exponent = (int)((num >> 23) & 0xFF);
			if (exponent != 0)
			{
				num2 |= 0x800000u;
				exponent -= 150;
			}
			else
			{
				exponent = -149;
			}
			return num2;
		}

		private unsafe static void AccumulateDecimalDigitsIntoBigInteger(ref NumberBuffer number, uint firstIndex, uint lastIndex, out BigInteger result)
		{
			BigInteger.SetZero(out result);
			byte* ptr = number.GetDigitsPointer() + firstIndex;
			uint num = lastIndex - firstIndex;
			while (num != 0)
			{
				uint num2 = Math.Min(num, 9u);
				uint value = DigitsToUInt32(ptr, (int)num2);
				result.MultiplyPow10(num2);
				result.Add(value);
				ptr += num2;
				num -= num2;
			}
		}

		private static ulong AssembleFloatingPointBits(in FloatingPointInfo info, ulong initialMantissa, int initialExponent, bool hasZeroTail)
		{
			uint num = BigInteger.CountSignificantBits(initialMantissa);
			int num2 = (int)(info.NormalMantissaBits - num);
			int num3 = initialExponent - num2;
			ulong num4 = initialMantissa;
			int num5 = num3;
			if (num3 > info.MaxBinaryExponent)
			{
				return info.InfinityBits;
			}
			if (num3 < info.MinBinaryExponent)
			{
				int num6 = num2 + num3 + info.ExponentBias - 1;
				num5 = -info.ExponentBias;
				if (num6 < 0)
				{
					num4 = RightShiftWithRounding(num4, -num6, hasZeroTail);
					if (num4 == 0L)
					{
						return info.ZeroBits;
					}
					if (num4 > info.DenormalMantissaMask)
					{
						num5 = initialExponent - (num6 + 1) - num2;
					}
				}
				else
				{
					num4 <<= num6;
				}
			}
			else if (num2 < 0)
			{
				num4 = RightShiftWithRounding(num4, -num2, hasZeroTail);
				if (num4 > info.NormalMantissaMask)
				{
					num4 >>= 1;
					num5++;
					if (num5 > info.MaxBinaryExponent)
					{
						return info.InfinityBits;
					}
				}
			}
			else if (num2 > 0)
			{
				num4 <<= num2;
			}
			num4 &= info.DenormalMantissaMask;
			ulong num7 = (ulong)((long)(num5 + info.ExponentBias) << (int)info.DenormalMantissaBits);
			return num7 | num4;
		}

		private static ulong ConvertBigIntegerToFloatingPointBits(ref BigInteger value, in FloatingPointInfo info, uint integerBitsOfPrecision, bool hasNonZeroFractionalPart)
		{
			int denormalMantissaBits = info.DenormalMantissaBits;
			if (integerBitsOfPrecision <= 64)
			{
				return AssembleFloatingPointBits(in info, value.ToUInt64(), denormalMantissaBits, !hasNonZeroFractionalPart);
			}
			(uint Quotient, uint Remainder) tuple = Math.DivRem(integerBitsOfPrecision, 32u);
			uint item = tuple.Quotient;
			uint item2 = tuple.Remainder;
			uint num = item - 1;
			uint num2 = num - 1;
			int num3 = denormalMantissaBits + (int)(num2 * 32);
			bool flag = !hasNonZeroFractionalPart;
			ulong initialMantissa;
			if (item2 == 0)
			{
				initialMantissa = ((ulong)value.GetBlock(num) << 32) + value.GetBlock(num2);
			}
			else
			{
				int num4 = (int)item2;
				int num5 = 64 - num4;
				int num6 = num5 - 32;
				num3 += (int)item2;
				uint block = value.GetBlock(num2);
				uint num7 = block >> num4;
				ulong num8 = (ulong)value.GetBlock(num) << num6;
				ulong num9 = (ulong)value.GetBlock(item) << num5;
				initialMantissa = num9 + num8 + num7;
				uint num10 = (uint)((1 << (int)item2) - 1);
				flag = flag && (block & num10) == 0;
			}
			for (uint num11 = 0u; num11 != num2; num11++)
			{
				flag &= value.GetBlock(num11) == 0;
			}
			return AssembleFloatingPointBits(in info, initialMantissa, num3, flag);
		}

		private unsafe static uint DigitsToUInt32(byte* p, int count)
		{
			byte* ptr = p + count;
			uint num = (uint)(*p - 48);
			for (p++; p < ptr; p++)
			{
				num = 10 * num + *p - 48;
			}
			return num;
		}

		private unsafe static ulong DigitsToUInt64(byte* p, int count)
		{
			byte* ptr = p + count;
			ulong num = (ulong)(*p - 48);
			for (p++; p < ptr; p++)
			{
				num = 10 * num + *p - 48;
			}
			return num;
		}

		private unsafe static ulong NumberToDoubleFloatingPointBits(ref NumberBuffer number, in FloatingPointInfo info)
		{
			uint digitsCount = (uint)number.DigitsCount;
			uint num = (uint)Math.Max(0, number.Scale);
			uint num2 = Math.Min(num, digitsCount);
			uint num3 = digitsCount - num2;
			uint num4 = (uint)Math.Abs(number.Scale - num2 - num3);
			byte* digitsPointer = number.GetDigitsPointer();
			if (digitsCount <= 15 && num4 <= 22)
			{
				double num5 = DigitsToUInt64(digitsPointer, (int)digitsCount);
				double num6 = s_Pow10DoubleTable[num4];
				num5 = ((num3 == 0) ? (num5 * num6) : (num5 / num6));
				return BitConverter.DoubleToUInt64Bits(num5);
			}
			return NumberToFloatingPointBitsSlow(ref number, in info, num, num2, num3);
		}

		private unsafe static ushort NumberToHalfFloatingPointBits(ref NumberBuffer number, in FloatingPointInfo info)
		{
			uint digitsCount = (uint)number.DigitsCount;
			uint num = (uint)Math.Max(0, number.Scale);
			uint num2 = Math.Min(num, digitsCount);
			uint num3 = digitsCount - num2;
			uint num4 = (uint)Math.Abs(number.Scale - num2 - num3);
			byte* digitsPointer = number.GetDigitsPointer();
			if (digitsCount <= 7 && num4 <= 10)
			{
				float num5 = DigitsToUInt32(digitsPointer, (int)digitsCount);
				float num6 = s_Pow10SingleTable[num4];
				num5 = ((num3 == 0) ? (num5 * num6) : (num5 / num6));
				return BitConverter.HalfToUInt16Bits((Half)num5);
			}
			if (digitsCount <= 15 && num4 <= 22)
			{
				double num7 = DigitsToUInt64(digitsPointer, (int)digitsCount);
				double num8 = s_Pow10DoubleTable[num4];
				num7 = ((num3 == 0) ? (num7 * num8) : (num7 / num8));
				return BitConverter.HalfToUInt16Bits((Half)num7);
			}
			return (ushort)NumberToFloatingPointBitsSlow(ref number, in info, num, num2, num3);
		}

		private unsafe static uint NumberToSingleFloatingPointBits(ref NumberBuffer number, in FloatingPointInfo info)
		{
			uint digitsCount = (uint)number.DigitsCount;
			uint num = (uint)Math.Max(0, number.Scale);
			uint num2 = Math.Min(num, digitsCount);
			uint num3 = digitsCount - num2;
			uint num4 = (uint)Math.Abs(number.Scale - num2 - num3);
			byte* digitsPointer = number.GetDigitsPointer();
			if (digitsCount <= 7 && num4 <= 10)
			{
				float num5 = DigitsToUInt32(digitsPointer, (int)digitsCount);
				float num6 = s_Pow10SingleTable[num4];
				num5 = ((num3 == 0) ? (num5 * num6) : (num5 / num6));
				return BitConverter.SingleToUInt32Bits(num5);
			}
			if (digitsCount <= 15 && num4 <= 22)
			{
				double num7 = DigitsToUInt64(digitsPointer, (int)digitsCount);
				double num8 = s_Pow10DoubleTable[num4];
				num7 = ((num3 == 0) ? (num7 * num8) : (num7 / num8));
				return BitConverter.SingleToUInt32Bits((float)num7);
			}
			return (uint)NumberToFloatingPointBitsSlow(ref number, in info, num, num2, num3);
		}

		private static ulong NumberToFloatingPointBitsSlow(ref NumberBuffer number, in FloatingPointInfo info, uint positiveExponent, uint integerDigitsPresent, uint fractionalDigitsPresent)
		{
			uint num = (uint)(info.NormalMantissaBits + 1);
			uint digitsCount = (uint)number.DigitsCount;
			uint num2 = positiveExponent - integerDigitsPresent;
			uint lastIndex = digitsCount;
			AccumulateDecimalDigitsIntoBigInteger(ref number, 0u, integerDigitsPresent, out var result);
			if (num2 != 0)
			{
				if (num2 > info.OverflowDecimalExponent)
				{
					return info.InfinityBits;
				}
				result.MultiplyPow10(num2);
			}
			uint num3 = BigInteger.CountSignificantBits(ref result);
			if (num3 >= num || fractionalDigitsPresent == 0)
			{
				return ConvertBigIntegerToFloatingPointBits(ref result, in info, num3, fractionalDigitsPresent != 0);
			}
			uint num4 = fractionalDigitsPresent;
			if (number.Scale < 0)
			{
				num4 += (uint)(-number.Scale);
			}
			if (num3 == 0 && num4 - (int)digitsCount > info.OverflowDecimalExponent)
			{
				return info.ZeroBits;
			}
			AccumulateDecimalDigitsIntoBigInteger(ref number, integerDigitsPresent, lastIndex, out var result2);
			if (result2.IsZero())
			{
				return ConvertBigIntegerToFloatingPointBits(ref result, in info, num3, fractionalDigitsPresent != 0);
			}
			BigInteger.Pow10(num4, out var result3);
			uint num5 = BigInteger.CountSignificantBits(ref result2);
			uint num6 = BigInteger.CountSignificantBits(ref result3);
			uint num7 = 0u;
			if (num6 > num5)
			{
				num7 = num6 - num5;
			}
			if (num7 != 0)
			{
				result2.ShiftLeft(num7);
			}
			uint num8 = num - num3;
			uint num9 = num8;
			if (num3 != 0)
			{
				if (num7 > num9)
				{
					return ConvertBigIntegerToFloatingPointBits(ref result, in info, num3, fractionalDigitsPresent != 0);
				}
				num9 -= num7;
			}
			uint num10 = num7;
			if (BigInteger.Compare(ref result2, ref result3) < 0)
			{
				num10++;
			}
			result2.ShiftLeft(num9);
			BigInteger.DivRem(ref result2, ref result3, out var quo, out var rem);
			ulong num11 = quo.ToUInt64();
			bool flag = !number.HasNonZeroTail && rem.IsZero();
			uint num12 = BigInteger.CountSignificantBits(num11);
			if (num12 > num8)
			{
				int num13 = (int)(num12 - num8);
				flag = flag && (num11 & (ulong)((1L << num13) - 1)) == 0;
				num11 >>= num13;
			}
			ulong num14 = result.ToUInt64();
			ulong initialMantissa = (num14 << (int)num8) + num11;
			int initialExponent = (int)((num3 != 0) ? (num3 - 2) : (0 - num10 - 1));
			return AssembleFloatingPointBits(in info, initialMantissa, initialExponent, flag);
		}

		private static ulong RightShiftWithRounding(ulong value, int shift, bool hasZeroTail)
		{
			if (shift >= 64)
			{
				return 0uL;
			}
			ulong num = (ulong)((1L << shift - 1) - 1);
			ulong num2 = (ulong)(1L << shift - 1);
			ulong num3 = (ulong)(1L << shift);
			bool lsbBit = (value & num3) != 0;
			bool roundBit = (value & num2) != 0;
			bool hasTailBits = !hasZeroTail || (value & num) != 0;
			return (value >> shift) + (ulong)(ShouldRoundUp(lsbBit, roundBit, hasTailBits) ? 1 : 0);
		}

		private static bool ShouldRoundUp(bool lsbBit, bool roundBit, bool hasTailBits)
		{
			if (roundBit)
			{
				return hasTailBits || lsbBit;
			}
			return false;
		}

		private unsafe static bool TryNumberToInt32(ref NumberBuffer number, ref int value)
		{
			int num = number.Scale;
			if (num > 10 || num < number.DigitsCount)
			{
				return false;
			}
			byte* digitsPointer = number.GetDigitsPointer();
			int num2 = 0;
			while (--num >= 0)
			{
				if ((uint)num2 > 214748364u)
				{
					return false;
				}
				num2 *= 10;
				if (*digitsPointer != 0)
				{
					num2 += *(digitsPointer++) - 48;
				}
			}
			if (number.IsNegative)
			{
				num2 = -num2;
				if (num2 > 0)
				{
					return false;
				}
			}
			else if (num2 < 0)
			{
				return false;
			}
			value = num2;
			return true;
		}

		private unsafe static bool TryNumberToInt64(ref NumberBuffer number, ref long value)
		{
			int num = number.Scale;
			if (num > 19 || num < number.DigitsCount)
			{
				return false;
			}
			byte* digitsPointer = number.GetDigitsPointer();
			long num2 = 0L;
			while (--num >= 0)
			{
				if ((ulong)num2 > 922337203685477580uL)
				{
					return false;
				}
				num2 *= 10;
				if (*digitsPointer != 0)
				{
					num2 += *(digitsPointer++) - 48;
				}
			}
			if (number.IsNegative)
			{
				num2 = -num2;
				if (num2 > 0)
				{
					return false;
				}
			}
			else if (num2 < 0)
			{
				return false;
			}
			value = num2;
			return true;
		}

		private unsafe static bool TryNumberToUInt32(ref NumberBuffer number, ref uint value)
		{
			int num = number.Scale;
			if (num > 10 || num < number.DigitsCount || number.IsNegative)
			{
				return false;
			}
			byte* digitsPointer = number.GetDigitsPointer();
			uint num2 = 0u;
			while (--num >= 0)
			{
				if (num2 > 429496729)
				{
					return false;
				}
				num2 *= 10;
				if (*digitsPointer != 0)
				{
					uint num3 = num2 + (uint)(*(digitsPointer++) - 48);
					if (num3 < num2)
					{
						return false;
					}
					num2 = num3;
				}
			}
			value = num2;
			return true;
		}

		private unsafe static bool TryNumberToUInt64(ref NumberBuffer number, ref ulong value)
		{
			int num = number.Scale;
			if (num > 20 || num < number.DigitsCount || number.IsNegative)
			{
				return false;
			}
			byte* digitsPointer = number.GetDigitsPointer();
			ulong num2 = 0uL;
			while (--num >= 0)
			{
				if (num2 > 1844674407370955161L)
				{
					return false;
				}
				num2 *= 10;
				if (*digitsPointer != 0)
				{
					ulong num3 = num2 + (ulong)(*(digitsPointer++) - 48);
					if (num3 < num2)
					{
						return false;
					}
					num2 = num3;
				}
			}
			value = num2;
			return true;
		}

		internal static int ParseInt32(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info)
		{
			int result;
			ParsingStatus parsingStatus = TryParseInt32(value, styles, info, out result);
			if (parsingStatus != 0)
			{
				ThrowOverflowOrFormatException(parsingStatus, TypeCode.Int32);
			}
			return result;
		}

		internal static long ParseInt64(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info)
		{
			long result;
			ParsingStatus parsingStatus = TryParseInt64(value, styles, info, out result);
			if (parsingStatus != 0)
			{
				ThrowOverflowOrFormatException(parsingStatus, TypeCode.Int64);
			}
			return result;
		}

		internal static uint ParseUInt32(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info)
		{
			uint result;
			ParsingStatus parsingStatus = TryParseUInt32(value, styles, info, out result);
			if (parsingStatus != 0)
			{
				ThrowOverflowOrFormatException(parsingStatus, TypeCode.UInt32);
			}
			return result;
		}

		internal static ulong ParseUInt64(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info)
		{
			ulong result;
			ParsingStatus parsingStatus = TryParseUInt64(value, styles, info, out result);
			if (parsingStatus != 0)
			{
				ThrowOverflowOrFormatException(parsingStatus, TypeCode.UInt64);
			}
			return result;
		}

		private unsafe static bool TryParseNumber(ref char* str, char* strEnd, NumberStyles styles, ref NumberBuffer number, NumberFormatInfo info)
		{
			string text = null;
			bool flag = false;
			string value;
			string value2;
			if ((styles & NumberStyles.AllowCurrencySymbol) != 0)
			{
				text = info.CurrencySymbol;
				value = info.CurrencyDecimalSeparator;
				value2 = info.CurrencyGroupSeparator;
				flag = true;
			}
			else
			{
				value = info.NumberDecimalSeparator;
				value2 = info.NumberGroupSeparator;
			}
			int num = 0;
			char* ptr = str;
			char c = ((ptr < strEnd) ? (*ptr) : '\0');
			while (true)
			{
				if (!IsWhite(c) || (styles & NumberStyles.AllowLeadingWhite) == 0 || (((uint)num & (true ? 1u : 0u)) != 0 && (num & 0x20) == 0 && info.NumberNegativePattern != 2))
				{
					char* ptr2;
					if ((styles & NumberStyles.AllowLeadingSign) != 0 && (num & 1) == 0 && ((ptr2 = MatchChars(ptr, strEnd, info.PositiveSign)) != null || ((ptr2 = MatchNegativeSignChars(ptr, strEnd, info)) != null && (number.IsNegative = true))))
					{
						num |= 1;
						ptr = ptr2 - 1;
					}
					else if (c == '(' && (styles & NumberStyles.AllowParentheses) != 0 && (num & 1) == 0)
					{
						num |= 3;
						number.IsNegative = true;
					}
					else
					{
						if (text == null || (ptr2 = MatchChars(ptr, strEnd, text)) == null)
						{
							break;
						}
						num |= 0x20;
						text = null;
						ptr = ptr2 - 1;
					}
				}
				c = ((++ptr < strEnd) ? (*ptr) : '\0');
			}
			int num2 = 0;
			int num3 = 0;
			int num4 = number.Digits.Length - 1;
			int num5 = 0;
			while (true)
			{
				char* ptr2;
				if (IsDigit(c))
				{
					num |= 4;
					if (c != '0' || ((uint)num & 8u) != 0)
					{
						if (num2 < num4)
						{
							number.Digits[num2] = (byte)c;
							if (c != '0' || number.Kind != NumberBufferKind.Integer)
							{
								num3 = num2 + 1;
							}
						}
						else if (c != '0')
						{
							number.HasNonZeroTail = true;
						}
						if ((num & 0x10) == 0)
						{
							number.Scale++;
						}
						if (num2 < num4)
						{
							num5 = ((c == '0') ? (num5 + 1) : 0);
						}
						num2++;
						num |= 8;
					}
					else if (((uint)num & 0x10u) != 0)
					{
						number.Scale--;
					}
				}
				else if ((styles & NumberStyles.AllowDecimalPoint) != 0 && (num & 0x10) == 0 && ((ptr2 = MatchChars(ptr, strEnd, value)) != null || (flag && (num & 0x20) == 0 && (ptr2 = MatchChars(ptr, strEnd, info.NumberDecimalSeparator)) != null)))
				{
					num |= 0x10;
					ptr = ptr2 - 1;
				}
				else
				{
					if ((styles & NumberStyles.AllowThousands) == 0 || (num & 4) == 0 || ((uint)num & 0x10u) != 0 || ((ptr2 = MatchChars(ptr, strEnd, value2)) == null && (!flag || ((uint)num & 0x20u) != 0 || (ptr2 = MatchChars(ptr, strEnd, info.NumberGroupSeparator)) == null)))
					{
						break;
					}
					ptr = ptr2 - 1;
				}
				c = ((++ptr < strEnd) ? (*ptr) : '\0');
			}
			bool flag2 = false;
			number.DigitsCount = num3;
			number.Digits[num3] = 0;
			if (((uint)num & 4u) != 0)
			{
				if ((c == 'E' || c == 'e') && (styles & NumberStyles.AllowExponent) != 0)
				{
					char* ptr3 = ptr;
					c = ((++ptr < strEnd) ? (*ptr) : '\0');
					char* ptr2;
					if ((ptr2 = MatchChars(ptr, strEnd, info._positiveSign)) != null)
					{
						c = (((ptr = ptr2) < strEnd) ? (*ptr) : '\0');
					}
					else if ((ptr2 = MatchNegativeSignChars(ptr, strEnd, info)) != null)
					{
						c = (((ptr = ptr2) < strEnd) ? (*ptr) : '\0');
						flag2 = true;
					}
					if (IsDigit(c))
					{
						int num6 = 0;
						do
						{
							num6 = num6 * 10 + (c - 48);
							c = ((++ptr < strEnd) ? (*ptr) : '\0');
							if (num6 > 1000)
							{
								num6 = 9999;
								while (IsDigit(c))
								{
									c = ((++ptr < strEnd) ? (*ptr) : '\0');
								}
							}
						}
						while (IsDigit(c));
						if (flag2)
						{
							num6 = -num6;
						}
						number.Scale += num6;
					}
					else
					{
						ptr = ptr3;
						c = ((ptr < strEnd) ? (*ptr) : '\0');
					}
				}
				if (number.Kind == NumberBufferKind.FloatingPoint && !number.HasNonZeroTail)
				{
					int num7 = num3 - number.Scale;
					if (num7 > 0)
					{
						num5 = Math.Min(num5, num7);
						number.DigitsCount = num3 - num5;
						number.Digits[number.DigitsCount] = 0;
					}
				}
				while (true)
				{
					if (!IsWhite(c) || (styles & NumberStyles.AllowTrailingWhite) == 0)
					{
						char* ptr2;
						if ((styles & NumberStyles.AllowTrailingSign) != 0 && (num & 1) == 0 && ((ptr2 = MatchChars(ptr, strEnd, info.PositiveSign)) != null || ((ptr2 = MatchNegativeSignChars(ptr, strEnd, info)) != null && (number.IsNegative = true))))
						{
							num |= 1;
							ptr = ptr2 - 1;
						}
						else if (c == ')' && ((uint)num & 2u) != 0)
						{
							num &= -3;
						}
						else
						{
							if (text == null || (ptr2 = MatchChars(ptr, strEnd, text)) == null)
							{
								break;
							}
							text = null;
							ptr = ptr2 - 1;
						}
					}
					c = ((++ptr < strEnd) ? (*ptr) : '\0');
				}
				if ((num & 2) == 0)
				{
					if ((num & 8) == 0)
					{
						if (number.Kind != NumberBufferKind.Decimal)
						{
							number.Scale = 0;
						}
						if (number.Kind == NumberBufferKind.Integer && (num & 0x10) == 0)
						{
							number.IsNegative = false;
						}
					}
					str = ptr;
					return true;
				}
			}
			str = ptr;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ParsingStatus TryParseInt32(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out int result)
		{
			if ((styles & ~NumberStyles.Integer) == 0)
			{
				return TryParseInt32IntegerStyle(value, styles, info, out result);
			}
			if ((styles & NumberStyles.AllowHexSpecifier) != 0)
			{
				result = 0;
				return TryParseUInt32HexNumberStyle(value, styles, out Unsafe.As<int, uint>(ref result));
			}
			return TryParseInt32Number(value, styles, info, out result);
		}

		private unsafe static ParsingStatus TryParseInt32Number(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out int result)
		{
			result = 0;
			byte* digits = stackalloc byte[11];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits, 11);
			if (!TryStringToNumber(value, styles, ref number, info))
			{
				return ParsingStatus.Failed;
			}
			if (!TryNumberToInt32(ref number, ref result))
			{
				return ParsingStatus.Overflow;
			}
			return ParsingStatus.OK;
		}

		internal static ParsingStatus TryParseInt32IntegerStyle(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out int result)
		{
			int i;
			int num;
			if (!value.IsEmpty)
			{
				i = 0;
				num = value[0];
				if ((styles & NumberStyles.AllowLeadingWhite) == 0 || !IsWhite(num))
				{
					goto IL_0048;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (IsWhite(num))
					{
						continue;
					}
					goto IL_0048;
				}
			}
			goto IL_0289;
			IL_027a:
			bool flag;
			if (!flag)
			{
				goto IL_027d;
			}
			goto IL_0291;
			IL_0289:
			result = 0;
			return ParsingStatus.Failed;
			IL_0299:
			if (IsWhite(num))
			{
				if ((styles & NumberStyles.AllowTrailingWhite) == 0)
				{
					goto IL_0289;
				}
				for (i++; i < value.Length && IsWhite(value[i]); i++)
				{
				}
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_027a;
				}
			}
			if (TrailingZeros(value, i))
			{
				goto IL_027a;
			}
			goto IL_0289;
			IL_027d:
			int num2;
			int num3;
			result = num2 * num3;
			return ParsingStatus.OK;
			IL_0048:
			num3 = 1;
			if ((styles & NumberStyles.AllowLeadingSign) != 0)
			{
				if (info.HasInvariantNumberSigns)
				{
					if (num == 45)
					{
						num3 = -1;
						i++;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0289;
						}
						num = value[i];
					}
					else if (num == 43)
					{
						i++;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0289;
						}
						num = value[i];
					}
				}
				else if (info.AllowHyphenDuringParsing && num == 45)
				{
					num3 = -1;
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						goto IL_0289;
					}
					num = value[i];
				}
				else
				{
					value = value.Slice(i);
					i = 0;
					string positiveSign = info.PositiveSign;
					string negativeSign = info.NegativeSign;
					if (!string.IsNullOrEmpty(positiveSign) && value.StartsWith(positiveSign))
					{
						i += positiveSign.Length;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0289;
						}
						num = value[i];
					}
					else if (!string.IsNullOrEmpty(negativeSign) && value.StartsWith(negativeSign))
					{
						num3 = -1;
						i += negativeSign.Length;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0289;
						}
						num = value[i];
					}
				}
			}
			flag = false;
			num2 = 0;
			if (IsDigit(num))
			{
				if (num != 48)
				{
					goto IL_01aa;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (num == 48)
					{
						continue;
					}
					goto IL_019f;
				}
				goto IL_027d;
			}
			goto IL_0289;
			IL_01aa:
			num2 = num - 48;
			i++;
			int num4 = 0;
			while (num4 < 8)
			{
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_027d;
				}
				num = value[i];
				if (IsDigit(num))
				{
					i++;
					num2 = 10 * num2 + num - 48;
					num4++;
					continue;
				}
				goto IL_0299;
			}
			if ((uint)i >= (uint)value.Length)
			{
				goto IL_027d;
			}
			num = value[i];
			if (IsDigit(num))
			{
				i++;
				flag = num2 > 214748364;
				num2 = num2 * 10 + num - 48;
				flag = flag || (uint)num2 > (uint)(int.MaxValue + (num3 >>> 31));
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_027a;
				}
				num = value[i];
				while (IsDigit(num))
				{
					flag = true;
					i++;
					if ((uint)i < (uint)value.Length)
					{
						num = value[i];
						continue;
					}
					goto IL_0291;
				}
			}
			goto IL_0299;
			IL_019f:
			if (IsDigit(num))
			{
				goto IL_01aa;
			}
			goto IL_0299;
			IL_0291:
			result = 0;
			return ParsingStatus.Overflow;
		}

		internal static ParsingStatus TryParseInt64IntegerStyle(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out long result)
		{
			int i;
			int num;
			if (!value.IsEmpty)
			{
				i = 0;
				num = value[0];
				if ((styles & NumberStyles.AllowLeadingWhite) == 0 || !IsWhite(num))
				{
					goto IL_0048;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (IsWhite(num))
					{
						continue;
					}
					goto IL_0048;
				}
			}
			goto IL_029f;
			IL_028f:
			bool flag;
			if (!flag)
			{
				goto IL_0292;
			}
			goto IL_02a8;
			IL_029f:
			result = 0L;
			return ParsingStatus.Failed;
			IL_02b1:
			if (IsWhite(num))
			{
				if ((styles & NumberStyles.AllowTrailingWhite) == 0)
				{
					goto IL_029f;
				}
				for (i++; i < value.Length && IsWhite(value[i]); i++)
				{
				}
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_028f;
				}
			}
			if (TrailingZeros(value, i))
			{
				goto IL_028f;
			}
			goto IL_029f;
			IL_0292:
			long num2;
			int num3;
			result = num2 * num3;
			return ParsingStatus.OK;
			IL_0048:
			num3 = 1;
			if ((styles & NumberStyles.AllowLeadingSign) != 0)
			{
				if (info.HasInvariantNumberSigns)
				{
					if (num == 45)
					{
						num3 = -1;
						i++;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_029f;
						}
						num = value[i];
					}
					else if (num == 43)
					{
						i++;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_029f;
						}
						num = value[i];
					}
				}
				else if (info.AllowHyphenDuringParsing && num == 45)
				{
					num3 = -1;
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						goto IL_029f;
					}
					num = value[i];
				}
				else
				{
					value = value.Slice(i);
					i = 0;
					string positiveSign = info.PositiveSign;
					string negativeSign = info.NegativeSign;
					if (!string.IsNullOrEmpty(positiveSign) && value.StartsWith(positiveSign))
					{
						i += positiveSign.Length;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_029f;
						}
						num = value[i];
					}
					else if (!string.IsNullOrEmpty(negativeSign) && value.StartsWith(negativeSign))
					{
						num3 = -1;
						i += negativeSign.Length;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_029f;
						}
						num = value[i];
					}
				}
			}
			flag = false;
			num2 = 0L;
			if (IsDigit(num))
			{
				if (num != 48)
				{
					goto IL_01ab;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (num == 48)
					{
						continue;
					}
					goto IL_01a0;
				}
				goto IL_0292;
			}
			goto IL_029f;
			IL_01ab:
			num2 = num - 48;
			i++;
			int num4 = 0;
			while (num4 < 17)
			{
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0292;
				}
				num = value[i];
				if (IsDigit(num))
				{
					i++;
					num2 = 10 * num2 + num - 48;
					num4++;
					continue;
				}
				goto IL_02b1;
			}
			if ((uint)i >= (uint)value.Length)
			{
				goto IL_0292;
			}
			num = value[i];
			if (IsDigit(num))
			{
				i++;
				flag = num2 > 922337203685477580L;
				num2 = num2 * 10 + num - 48;
				flag = flag || (ulong)num2 > (ulong)(long.MaxValue + (long)(uint)(num3 >>> 31));
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_028f;
				}
				num = value[i];
				while (IsDigit(num))
				{
					flag = true;
					i++;
					if ((uint)i < (uint)value.Length)
					{
						num = value[i];
						continue;
					}
					goto IL_02a8;
				}
			}
			goto IL_02b1;
			IL_01a0:
			if (IsDigit(num))
			{
				goto IL_01ab;
			}
			goto IL_02b1;
			IL_02a8:
			result = 0L;
			return ParsingStatus.Overflow;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ParsingStatus TryParseInt64(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out long result)
		{
			if ((styles & ~NumberStyles.Integer) == 0)
			{
				return TryParseInt64IntegerStyle(value, styles, info, out result);
			}
			if ((styles & NumberStyles.AllowHexSpecifier) != 0)
			{
				result = 0L;
				return TryParseUInt64HexNumberStyle(value, styles, out Unsafe.As<long, ulong>(ref result));
			}
			return TryParseInt64Number(value, styles, info, out result);
		}

		private unsafe static ParsingStatus TryParseInt64Number(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out long result)
		{
			result = 0L;
			byte* digits = stackalloc byte[20];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits, 20);
			if (!TryStringToNumber(value, styles, ref number, info))
			{
				return ParsingStatus.Failed;
			}
			if (!TryNumberToInt64(ref number, ref result))
			{
				return ParsingStatus.Overflow;
			}
			return ParsingStatus.OK;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ParsingStatus TryParseUInt32(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out uint result)
		{
			if ((styles & ~NumberStyles.Integer) == 0)
			{
				return TryParseUInt32IntegerStyle(value, styles, info, out result);
			}
			if ((styles & NumberStyles.AllowHexSpecifier) != 0)
			{
				return TryParseUInt32HexNumberStyle(value, styles, out result);
			}
			return TryParseUInt32Number(value, styles, info, out result);
		}

		private unsafe static ParsingStatus TryParseUInt32Number(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out uint result)
		{
			result = 0u;
			byte* digits = stackalloc byte[11];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits, 11);
			if (!TryStringToNumber(value, styles, ref number, info))
			{
				return ParsingStatus.Failed;
			}
			if (!TryNumberToUInt32(ref number, ref result))
			{
				return ParsingStatus.Overflow;
			}
			return ParsingStatus.OK;
		}

		internal static ParsingStatus TryParseUInt32IntegerStyle(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out uint result)
		{
			int i;
			int num;
			if (!value.IsEmpty)
			{
				i = 0;
				num = value[0];
				if ((styles & NumberStyles.AllowLeadingWhite) == 0 || !IsWhite(num))
				{
					goto IL_0048;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (IsWhite(num))
					{
						continue;
					}
					goto IL_0048;
				}
			}
			goto IL_0281;
			IL_0278:
			int num2;
			result = (uint)num2;
			return ParsingStatus.OK;
			IL_0281:
			result = 0u;
			return ParsingStatus.Failed;
			IL_0275:
			bool flag;
			if (!flag)
			{
				goto IL_0278;
			}
			goto IL_0289;
			IL_0289:
			result = 0u;
			return ParsingStatus.Overflow;
			IL_0048:
			flag = false;
			if ((styles & NumberStyles.AllowLeadingSign) != 0)
			{
				if (info.HasInvariantNumberSigns)
				{
					if (num == 43)
					{
						i++;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0281;
						}
						num = value[i];
					}
					else if (num == 45)
					{
						flag = true;
						i++;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0281;
						}
						num = value[i];
					}
				}
				else if (info.AllowHyphenDuringParsing && num == 45)
				{
					flag = true;
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						goto IL_0281;
					}
					num = value[i];
				}
				else
				{
					value = value.Slice(i);
					i = 0;
					string positiveSign = info.PositiveSign;
					string negativeSign = info.NegativeSign;
					if (!string.IsNullOrEmpty(positiveSign) && value.StartsWith(positiveSign))
					{
						i += positiveSign.Length;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0281;
						}
						num = value[i];
					}
					else if (!string.IsNullOrEmpty(negativeSign) && value.StartsWith(negativeSign))
					{
						flag = true;
						i += negativeSign.Length;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0281;
						}
						num = value[i];
					}
				}
			}
			num2 = 0;
			if (IsDigit(num))
			{
				if (num != 48)
				{
					goto IL_01a7;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (num == 48)
					{
						continue;
					}
					goto IL_019c;
				}
				goto IL_0278;
			}
			goto IL_0281;
			IL_0293:
			if (IsWhite(num))
			{
				if ((styles & NumberStyles.AllowTrailingWhite) == 0)
				{
					goto IL_0281;
				}
				for (i++; i < value.Length && IsWhite(value[i]); i++)
				{
				}
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0275;
				}
			}
			if (TrailingZeros(value, i))
			{
				goto IL_0275;
			}
			goto IL_0281;
			IL_019c:
			if (IsDigit(num))
			{
				goto IL_01a7;
			}
			flag = false;
			goto IL_0293;
			IL_01a7:
			num2 = num - 48;
			i++;
			int num3 = 0;
			while (num3 < 8)
			{
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0275;
				}
				num = value[i];
				if (IsDigit(num))
				{
					i++;
					num2 = 10 * num2 + num - 48;
					num3++;
					continue;
				}
				goto IL_0293;
			}
			if ((uint)i >= (uint)value.Length)
			{
				goto IL_0275;
			}
			num = value[i];
			if (IsDigit(num))
			{
				i++;
				flag = flag || (uint)num2 > 429496729u || (num2 == 429496729 && num > 53);
				num2 = num2 * 10 + num - 48;
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0275;
				}
				num = value[i];
				while (IsDigit(num))
				{
					flag = true;
					i++;
					if ((uint)i < (uint)value.Length)
					{
						num = value[i];
						continue;
					}
					goto IL_0289;
				}
			}
			goto IL_0293;
		}

		internal static ParsingStatus TryParseUInt32HexNumberStyle(ReadOnlySpan<char> value, NumberStyles styles, out uint result)
		{
			int i;
			int num;
			if (!value.IsEmpty)
			{
				i = 0;
				num = value[0];
				if ((styles & NumberStyles.AllowLeadingWhite) == 0 || !IsWhite(num))
				{
					goto IL_0048;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (IsWhite(num))
					{
						continue;
					}
					goto IL_0048;
				}
			}
			goto IL_011f;
			IL_0087:
			uint num2 = (uint)HexConverter.FromChar(num);
			i++;
			int num3 = 0;
			while (num3 < 7)
			{
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0116;
				}
				num = value[i];
				uint num4 = (uint)HexConverter.FromChar(num);
				if (num4 != 255)
				{
					i++;
					num2 = 16 * num2 + num4;
					num3++;
					continue;
				}
				goto IL_012f;
			}
			if ((uint)i >= (uint)value.Length)
			{
				goto IL_0116;
			}
			num = value[i];
			if (HexConverter.IsHexChar(num))
			{
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (HexConverter.IsHexChar(num))
					{
						continue;
					}
					goto IL_010f;
				}
				goto IL_0127;
			}
			goto IL_012f;
			IL_0127:
			result = 0u;
			return ParsingStatus.Overflow;
			IL_010f:
			bool flag = true;
			goto IL_012f;
			IL_011f:
			result = 0u;
			return ParsingStatus.Failed;
			IL_0048:
			flag = false;
			num2 = 0u;
			if (HexConverter.IsHexChar(num))
			{
				if (num != 48)
				{
					goto IL_0087;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (num == 48)
					{
						continue;
					}
					goto IL_007c;
				}
				goto IL_0116;
			}
			goto IL_011f;
			IL_0113:
			if (!flag)
			{
				goto IL_0116;
			}
			goto IL_0127;
			IL_012f:
			if (IsWhite(num))
			{
				if ((styles & NumberStyles.AllowTrailingWhite) == 0)
				{
					goto IL_011f;
				}
				for (i++; i < value.Length && IsWhite(value[i]); i++)
				{
				}
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0113;
				}
			}
			if (TrailingZeros(value, i))
			{
				goto IL_0113;
			}
			goto IL_011f;
			IL_0116:
			result = num2;
			return ParsingStatus.OK;
			IL_007c:
			if (HexConverter.IsHexChar(num))
			{
				goto IL_0087;
			}
			goto IL_012f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ParsingStatus TryParseUInt64(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out ulong result)
		{
			if ((styles & ~NumberStyles.Integer) == 0)
			{
				return TryParseUInt64IntegerStyle(value, styles, info, out result);
			}
			if ((styles & NumberStyles.AllowHexSpecifier) != 0)
			{
				return TryParseUInt64HexNumberStyle(value, styles, out result);
			}
			return TryParseUInt64Number(value, styles, info, out result);
		}

		private unsafe static ParsingStatus TryParseUInt64Number(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out ulong result)
		{
			result = 0uL;
			byte* digits = stackalloc byte[21];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits, 21);
			if (!TryStringToNumber(value, styles, ref number, info))
			{
				return ParsingStatus.Failed;
			}
			if (!TryNumberToUInt64(ref number, ref result))
			{
				return ParsingStatus.Overflow;
			}
			return ParsingStatus.OK;
		}

		internal static ParsingStatus TryParseUInt64IntegerStyle(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out ulong result)
		{
			int i;
			int num;
			if (!value.IsEmpty)
			{
				i = 0;
				num = value[0];
				if ((styles & NumberStyles.AllowLeadingWhite) == 0 || !IsWhite(num))
				{
					goto IL_0048;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (IsWhite(num))
					{
						continue;
					}
					goto IL_0048;
				}
			}
			goto IL_0295;
			IL_028c:
			long num2;
			result = (ulong)num2;
			return ParsingStatus.OK;
			IL_0295:
			result = 0uL;
			return ParsingStatus.Failed;
			IL_0289:
			bool flag;
			if (!flag)
			{
				goto IL_028c;
			}
			goto IL_029e;
			IL_029e:
			result = 0uL;
			return ParsingStatus.Overflow;
			IL_0048:
			flag = false;
			if ((styles & NumberStyles.AllowLeadingSign) != 0)
			{
				if (info.HasInvariantNumberSigns)
				{
					if (num == 43)
					{
						i++;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0295;
						}
						num = value[i];
					}
					else if (num == 45)
					{
						flag = true;
						i++;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0295;
						}
						num = value[i];
					}
				}
				else if (info.AllowHyphenDuringParsing && num == 45)
				{
					flag = true;
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						goto IL_0295;
					}
					num = value[i];
				}
				else
				{
					value = value.Slice(i);
					i = 0;
					string positiveSign = info.PositiveSign;
					string negativeSign = info.NegativeSign;
					if (!string.IsNullOrEmpty(positiveSign) && value.StartsWith(positiveSign))
					{
						i += positiveSign.Length;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0295;
						}
						num = value[i];
					}
					else if (!string.IsNullOrEmpty(negativeSign) && value.StartsWith(negativeSign))
					{
						flag = true;
						i += negativeSign.Length;
						if ((uint)i >= (uint)value.Length)
						{
							goto IL_0295;
						}
						num = value[i];
					}
				}
			}
			num2 = 0L;
			if (IsDigit(num))
			{
				if (num != 48)
				{
					goto IL_01a8;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (num == 48)
					{
						continue;
					}
					goto IL_019d;
				}
				goto IL_028c;
			}
			goto IL_0295;
			IL_02a9:
			if (IsWhite(num))
			{
				if ((styles & NumberStyles.AllowTrailingWhite) == 0)
				{
					goto IL_0295;
				}
				for (i++; i < value.Length && IsWhite(value[i]); i++)
				{
				}
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0289;
				}
			}
			if (TrailingZeros(value, i))
			{
				goto IL_0289;
			}
			goto IL_0295;
			IL_019d:
			if (IsDigit(num))
			{
				goto IL_01a8;
			}
			flag = false;
			goto IL_02a9;
			IL_01a8:
			num2 = num - 48;
			i++;
			int num3 = 0;
			while (num3 < 18)
			{
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0289;
				}
				num = value[i];
				if (IsDigit(num))
				{
					i++;
					num2 = 10 * num2 + num - 48;
					num3++;
					continue;
				}
				goto IL_02a9;
			}
			if ((uint)i >= (uint)value.Length)
			{
				goto IL_0289;
			}
			num = value[i];
			if (IsDigit(num))
			{
				i++;
				flag = flag || (ulong)num2 > 1844674407370955161uL || (num2 == 1844674407370955161L && num > 53);
				num2 = num2 * 10 + num - 48;
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0289;
				}
				num = value[i];
				while (IsDigit(num))
				{
					flag = true;
					i++;
					if ((uint)i < (uint)value.Length)
					{
						num = value[i];
						continue;
					}
					goto IL_029e;
				}
			}
			goto IL_02a9;
		}

		private static ParsingStatus TryParseUInt64HexNumberStyle(ReadOnlySpan<char> value, NumberStyles styles, out ulong result)
		{
			int i;
			int num;
			if (!value.IsEmpty)
			{
				i = 0;
				num = value[0];
				if ((styles & NumberStyles.AllowLeadingWhite) == 0 || !IsWhite(num))
				{
					goto IL_0048;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (IsWhite(num))
					{
						continue;
					}
					goto IL_0048;
				}
			}
			goto IL_0124;
			IL_0088:
			ulong num2 = (uint)HexConverter.FromChar(num);
			i++;
			int num3 = 0;
			while (num3 < 15)
			{
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_011b;
				}
				num = value[i];
				uint num4 = (uint)HexConverter.FromChar(num);
				if (num4 != 255)
				{
					i++;
					num2 = 16 * num2 + num4;
					num3++;
					continue;
				}
				goto IL_0136;
			}
			if ((uint)i >= (uint)value.Length)
			{
				goto IL_011b;
			}
			num = value[i];
			if (HexConverter.IsHexChar(num))
			{
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (HexConverter.IsHexChar(num))
					{
						continue;
					}
					goto IL_0114;
				}
				goto IL_012d;
			}
			goto IL_0136;
			IL_012d:
			result = 0uL;
			return ParsingStatus.Overflow;
			IL_0114:
			bool flag = true;
			goto IL_0136;
			IL_0124:
			result = 0uL;
			return ParsingStatus.Failed;
			IL_0048:
			flag = false;
			num2 = 0uL;
			if (HexConverter.IsHexChar(num))
			{
				if (num != 48)
				{
					goto IL_0088;
				}
				while (true)
				{
					i++;
					if ((uint)i >= (uint)value.Length)
					{
						break;
					}
					num = value[i];
					if (num == 48)
					{
						continue;
					}
					goto IL_007d;
				}
				goto IL_011b;
			}
			goto IL_0124;
			IL_0118:
			if (!flag)
			{
				goto IL_011b;
			}
			goto IL_012d;
			IL_0136:
			if (IsWhite(num))
			{
				if ((styles & NumberStyles.AllowTrailingWhite) == 0)
				{
					goto IL_0124;
				}
				for (i++; i < value.Length && IsWhite(value[i]); i++)
				{
				}
				if ((uint)i >= (uint)value.Length)
				{
					goto IL_0118;
				}
			}
			if (TrailingZeros(value, i))
			{
				goto IL_0118;
			}
			goto IL_0124;
			IL_011b:
			result = num2;
			return ParsingStatus.OK;
			IL_007d:
			if (HexConverter.IsHexChar(num))
			{
				goto IL_0088;
			}
			goto IL_0136;
		}

		internal static decimal ParseDecimal(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info)
		{
			decimal result;
			ParsingStatus parsingStatus = TryParseDecimal(value, styles, info, out result);
			if (parsingStatus != 0)
			{
				ThrowOverflowOrFormatException(parsingStatus, TypeCode.Decimal);
			}
			return result;
		}

		internal unsafe static bool TryNumberToDecimal(ref NumberBuffer number, ref decimal value)
		{
			byte* ptr = number.GetDigitsPointer();
			int num = number.Scale;
			bool isNegative = number.IsNegative;
			uint num2 = *ptr;
			if (num2 == 0)
			{
				value = new decimal(0, 0, 0, isNegative, (byte)Math.Clamp(-num, 0, 28));
				return true;
			}
			if (num > 29)
			{
				return false;
			}
			ulong num3 = 0uL;
			while (num > -28)
			{
				num--;
				num3 *= 10;
				num3 += num2 - 48;
				num2 = *(++ptr);
				if (num3 >= 1844674407370955161L)
				{
					break;
				}
				if (num2 != 0)
				{
					continue;
				}
				while (num > 0)
				{
					num--;
					num3 *= 10;
					if (num3 >= 1844674407370955161L)
					{
						break;
					}
				}
				break;
			}
			uint num4 = 0u;
			while ((num > 0 || (num2 != 0 && num > -28)) && (num4 < 429496729 || (num4 == 429496729 && (num3 < 11068046444225730969uL || (num3 == 11068046444225730969uL && num2 <= 53)))))
			{
				ulong num5 = (ulong)(uint)num3 * 10uL;
				ulong num6 = (ulong)((long)(uint)(num3 >> 32) * 10L) + (num5 >> 32);
				num3 = (uint)num5 + (num6 << 32);
				num4 = (uint)(int)(num6 >> 32) + num4 * 10;
				if (num2 != 0)
				{
					num2 -= 48;
					num3 += num2;
					if (num3 < num2)
					{
						num4++;
					}
					num2 = *(++ptr);
				}
				num--;
			}
			if (num2 >= 53)
			{
				if (num2 == 53 && (num3 & 1) == 0L)
				{
					num2 = *(++ptr);
					bool flag = !number.HasNonZeroTail;
					while (num2 != 0 && flag)
					{
						flag = flag && num2 == 48;
						num2 = *(++ptr);
					}
					if (flag)
					{
						goto IL_01a8;
					}
				}
				if (++num3 == 0L && ++num4 == 0)
				{
					num3 = 11068046444225730970uL;
					num4 = 429496729u;
					num++;
				}
			}
			goto IL_01a8;
			IL_01a8:
			if (num > 0)
			{
				return false;
			}
			if (num <= -29)
			{
				value = new decimal(0, 0, 0, isNegative, 28);
			}
			else
			{
				value = new decimal((int)num3, (int)(num3 >> 32), (int)num4, isNegative, (byte)(-num));
			}
			return true;
		}

		internal static double ParseDouble(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info)
		{
			if (!TryParseDouble(value, styles, info, out var result))
			{
				ThrowOverflowOrFormatException(ParsingStatus.Failed);
			}
			return result;
		}

		internal static float ParseSingle(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info)
		{
			if (!TryParseSingle(value, styles, info, out var result))
			{
				ThrowOverflowOrFormatException(ParsingStatus.Failed);
			}
			return result;
		}

		internal static Half ParseHalf(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info)
		{
			if (!TryParseHalf(value, styles, info, out var result))
			{
				ThrowOverflowOrFormatException(ParsingStatus.Failed);
			}
			return result;
		}

		internal unsafe static ParsingStatus TryParseDecimal(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out decimal result)
		{
			byte* digits = stackalloc byte[31];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Decimal, digits, 31);
			result = default(decimal);
			if (!TryStringToNumber(value, styles, ref number, info))
			{
				return ParsingStatus.Failed;
			}
			if (!TryNumberToDecimal(ref number, ref result))
			{
				return ParsingStatus.Overflow;
			}
			return ParsingStatus.OK;
		}

		internal static bool SpanStartsWith(ReadOnlySpan<char> span, char c)
		{
			if (!span.IsEmpty)
			{
				return span[0] == c;
			}
			return false;
		}

		internal unsafe static bool TryParseDouble(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out double result)
		{
			byte* digits = stackalloc byte[769];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits, 769);
			if (!TryStringToNumber(value, styles, ref number, info))
			{
				ReadOnlySpan<char> span = value.Trim();
				if (span.EqualsOrdinalIgnoreCase(info.PositiveInfinitySymbol))
				{
					result = double.PositiveInfinity;
				}
				else if (span.EqualsOrdinalIgnoreCase(info.NegativeInfinitySymbol))
				{
					result = double.NegativeInfinity;
				}
				else if (span.EqualsOrdinalIgnoreCase(info.NaNSymbol))
				{
					result = double.NaN;
				}
				else if (span.StartsWith(info.PositiveSign, StringComparison.OrdinalIgnoreCase))
				{
					span = span.Slice(info.PositiveSign.Length);
					if (span.EqualsOrdinalIgnoreCase(info.PositiveInfinitySymbol))
					{
						result = double.PositiveInfinity;
					}
					else
					{
						if (!span.EqualsOrdinalIgnoreCase(info.NaNSymbol))
						{
							result = 0.0;
							return false;
						}
						result = double.NaN;
					}
				}
				else
				{
					if ((!span.StartsWith(info.NegativeSign, StringComparison.OrdinalIgnoreCase) || !span.Slice(info.NegativeSign.Length).EqualsOrdinalIgnoreCase(info.NaNSymbol)) && (!info.AllowHyphenDuringParsing || !SpanStartsWith(span, '-') || !span.Slice(1).EqualsOrdinalIgnoreCase(info.NaNSymbol)))
					{
						result = 0.0;
						return false;
					}
					result = double.NaN;
				}
			}
			else
			{
				result = NumberToDouble(ref number);
			}
			return true;
		}

		internal unsafe static bool TryParseHalf(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out Half result)
		{
			byte* digits = stackalloc byte[21];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits, 21);
			if (!TryStringToNumber(value, styles, ref number, info))
			{
				ReadOnlySpan<char> span = value.Trim();
				if (span.EqualsOrdinalIgnoreCase(info.PositiveInfinitySymbol))
				{
					result = Half.PositiveInfinity;
				}
				else if (span.EqualsOrdinalIgnoreCase(info.NegativeInfinitySymbol))
				{
					result = Half.NegativeInfinity;
				}
				else if (span.EqualsOrdinalIgnoreCase(info.NaNSymbol))
				{
					result = Half.NaN;
				}
				else if (span.StartsWith(info.PositiveSign, StringComparison.OrdinalIgnoreCase))
				{
					span = span.Slice(info.PositiveSign.Length);
					if (!info.PositiveInfinitySymbol.StartsWith(info.PositiveSign, StringComparison.OrdinalIgnoreCase) && span.EqualsOrdinalIgnoreCase(info.PositiveInfinitySymbol))
					{
						result = Half.PositiveInfinity;
					}
					else
					{
						if (info.NaNSymbol.StartsWith(info.PositiveSign, StringComparison.OrdinalIgnoreCase) || !span.EqualsOrdinalIgnoreCase(info.NaNSymbol))
						{
							result = (Half)0f;
							return false;
						}
						result = Half.NaN;
					}
				}
				else if (span.StartsWith(info.NegativeSign, StringComparison.OrdinalIgnoreCase) && !info.NaNSymbol.StartsWith(info.NegativeSign, StringComparison.OrdinalIgnoreCase) && span.Slice(info.NegativeSign.Length).EqualsOrdinalIgnoreCase(info.NaNSymbol))
				{
					result = Half.NaN;
				}
				else
				{
					if (!info.AllowHyphenDuringParsing || !SpanStartsWith(span, '-') || info.NaNSymbol.StartsWith(info.NegativeSign, StringComparison.OrdinalIgnoreCase) || info.NaNSymbol.StartsWith('-') || !span.Slice(1).EqualsOrdinalIgnoreCase(info.NaNSymbol))
					{
						result = (Half)0f;
						return false;
					}
					result = Half.NaN;
				}
			}
			else
			{
				result = NumberToHalf(ref number);
			}
			return true;
		}

		internal unsafe static bool TryParseSingle(ReadOnlySpan<char> value, NumberStyles styles, NumberFormatInfo info, out float result)
		{
			byte* digits = stackalloc byte[114];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits, 114);
			if (!TryStringToNumber(value, styles, ref number, info))
			{
				ReadOnlySpan<char> span = value.Trim();
				if (span.EqualsOrdinalIgnoreCase(info.PositiveInfinitySymbol))
				{
					result = float.PositiveInfinity;
				}
				else if (span.EqualsOrdinalIgnoreCase(info.NegativeInfinitySymbol))
				{
					result = float.NegativeInfinity;
				}
				else if (span.EqualsOrdinalIgnoreCase(info.NaNSymbol))
				{
					result = float.NaN;
				}
				else if (span.StartsWith(info.PositiveSign, StringComparison.OrdinalIgnoreCase))
				{
					span = span.Slice(info.PositiveSign.Length);
					if (!info.PositiveInfinitySymbol.StartsWith(info.PositiveSign, StringComparison.OrdinalIgnoreCase) && span.EqualsOrdinalIgnoreCase(info.PositiveInfinitySymbol))
					{
						result = float.PositiveInfinity;
					}
					else
					{
						if (info.NaNSymbol.StartsWith(info.PositiveSign, StringComparison.OrdinalIgnoreCase) || !span.EqualsOrdinalIgnoreCase(info.NaNSymbol))
						{
							result = 0f;
							return false;
						}
						result = float.NaN;
					}
				}
				else if (span.StartsWith(info.NegativeSign, StringComparison.OrdinalIgnoreCase) && !info.NaNSymbol.StartsWith(info.NegativeSign, StringComparison.OrdinalIgnoreCase) && span.Slice(info.NegativeSign.Length).EqualsOrdinalIgnoreCase(info.NaNSymbol))
				{
					result = float.NaN;
				}
				else
				{
					if (!info.AllowHyphenDuringParsing || !SpanStartsWith(span, '-') || info.NaNSymbol.StartsWith(info.NegativeSign, StringComparison.OrdinalIgnoreCase) || info.NaNSymbol.StartsWith('-') || !span.Slice(1).EqualsOrdinalIgnoreCase(info.NaNSymbol))
					{
						result = 0f;
						return false;
					}
					result = float.NaN;
				}
			}
			else
			{
				result = NumberToSingle(ref number);
			}
			return true;
		}

		internal unsafe static bool TryStringToNumber(ReadOnlySpan<char> value, NumberStyles styles, ref NumberBuffer number, NumberFormatInfo info)
		{
			fixed (char* ptr = &MemoryMarshal.GetReference(value))
			{
				char* str = ptr;
				if (!TryParseNumber(ref str, str + value.Length, styles, ref number, info) || ((int)(str - ptr) < value.Length && !TrailingZeros(value, (int)(str - ptr))))
				{
					return false;
				}
			}
			return true;
		}

		private static bool TrailingZeros(ReadOnlySpan<char> value, int index)
		{
			for (int i = index; (uint)i < (uint)value.Length; i++)
			{
				if (value[i] != 0)
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsSpaceReplacingChar(char c)
		{
			if (c != '\u00a0')
			{
				return c == '\u202f';
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static char* MatchNegativeSignChars(char* p, char* pEnd, NumberFormatInfo info)
		{
			char* ptr = MatchChars(p, pEnd, info.NegativeSign);
			if (ptr == null && info.AllowHyphenDuringParsing && p < pEnd && *p == '-')
			{
				ptr = p + 1;
			}
			return ptr;
		}

		private unsafe static char* MatchChars(char* p, char* pEnd, string value)
		{
			fixed (char* ptr = value)
			{
				char* ptr2 = ptr;
				if (*ptr2 != 0)
				{
					while (true)
					{
						char c = ((p < pEnd) ? (*p) : '\0');
						if (c != *ptr2 && (!IsSpaceReplacingChar(*ptr2) || c != ' '))
						{
							break;
						}
						p++;
						ptr2++;
						if (*ptr2 == '\0')
						{
							return p;
						}
					}
				}
			}
			return null;
		}

		private static bool IsWhite(int ch)
		{
			if (ch != 32 && (uint)(ch - 9) > 4u)
			{
				return false;
			}
			return true;
		}

		private static bool IsDigit(int ch)
		{
			return (uint)(ch - 48) <= 9u;
		}

		[DoesNotReturn]
		internal static void ThrowOverflowOrFormatException(ParsingStatus status, TypeCode type = TypeCode.Empty)
		{
			throw GetException(status, type);
		}

		[DoesNotReturn]
		internal static void ThrowOverflowException(TypeCode type)
		{
			throw GetException(ParsingStatus.Overflow, type);
		}

		private static Exception GetException(ParsingStatus status, TypeCode type)
		{
			if (status == ParsingStatus.Failed)
			{
				return new FormatException(SR.Format_InvalidString);
			}
			return new OverflowException(type switch
			{
				TypeCode.SByte => SR.Overflow_SByte, 
				TypeCode.Byte => SR.Overflow_Byte, 
				TypeCode.Int16 => SR.Overflow_Int16, 
				TypeCode.UInt16 => SR.Overflow_UInt16, 
				TypeCode.Int32 => SR.Overflow_Int32, 
				TypeCode.UInt32 => SR.Overflow_UInt32, 
				TypeCode.Int64 => SR.Overflow_Int64, 
				TypeCode.UInt64 => SR.Overflow_UInt64, 
				_ => SR.Overflow_Decimal, 
			});
		}

		internal static double NumberToDouble(ref NumberBuffer number)
		{
			double num;
			if (number.DigitsCount == 0 || number.Scale < -324)
			{
				num = 0.0;
			}
			else if (number.Scale > 309)
			{
				num = double.PositiveInfinity;
			}
			else
			{
				ulong value = NumberToDoubleFloatingPointBits(ref number, in FloatingPointInfo.Double);
				num = BitConverter.UInt64BitsToDouble(value);
			}
			if (!number.IsNegative)
			{
				return num;
			}
			return 0.0 - num;
		}

		internal static Half NumberToHalf(ref NumberBuffer number)
		{
			Half half;
			if (number.DigitsCount == 0 || number.Scale < -8)
			{
				half = default(Half);
			}
			else if (number.Scale > 5)
			{
				half = Half.PositiveInfinity;
			}
			else
			{
				ushort value = NumberToHalfFloatingPointBits(ref number, in FloatingPointInfo.Half);
				half = new Half(value);
			}
			if (!number.IsNegative)
			{
				return half;
			}
			return Half.Negate(half);
		}

		internal static float NumberToSingle(ref NumberBuffer number)
		{
			float num;
			if (number.DigitsCount == 0 || number.Scale < -45)
			{
				num = 0f;
			}
			else if (number.Scale > 39)
			{
				num = float.PositiveInfinity;
			}
			else
			{
				uint value = NumberToSingleFloatingPointBits(ref number, in FloatingPointInfo.Single);
				num = BitConverter.UInt32BitsToSingle(value);
			}
			if (!number.IsNegative)
			{
				return num;
			}
			return 0f - num;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ObjectDisposedException : InvalidOperationException
	{
		private readonly string _objectName;

		public override string Message
		{
			get
			{
				string objectName = ObjectName;
				if (string.IsNullOrEmpty(objectName))
				{
					return base.Message;
				}
				string text = SR.Format(SR.ObjectDisposed_ObjectName_Name, objectName);
				return base.Message + "\r\n" + text;
			}
		}

		public string ObjectName => _objectName ?? string.Empty;

		private ObjectDisposedException()
			: this(null, SR.ObjectDisposed_Generic)
		{
		}

		public ObjectDisposedException(string? objectName)
			: this(objectName, SR.ObjectDisposed_Generic)
		{
		}

		public ObjectDisposedException(string? objectName, string? message)
			: base(message)
		{
			base.HResult = -2146232798;
			_objectName = objectName;
		}

		public ObjectDisposedException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146232798;
		}

		protected ObjectDisposedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_objectName = info.GetString("ObjectName");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("ObjectName", ObjectName, typeof(string));
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	public sealed class ObsoleteAttribute : Attribute
	{
		public string? Message { get; }

		public bool IsError { get; }

		public string? DiagnosticId { get; set; }

		public string? UrlFormat { get; set; }

		public ObsoleteAttribute()
		{
		}

		public ObsoleteAttribute(string? message)
		{
			Message = message;
		}

		public ObsoleteAttribute(string? message, bool error)
		{
			Message = message;
			IsError = error;
		}
	}
	public sealed class OperatingSystem : ISerializable, ICloneable
	{
		private readonly Version _version;

		private readonly PlatformID _platform;

		private readonly string _servicePack;

		private string _versionString;

		public PlatformID Platform => _platform;

		public string ServicePack => _servicePack ?? string.Empty;

		public Version Version => _version;

		public string VersionString
		{
			get
			{
				if (_versionString == null)
				{
					string value = _platform switch
					{
						PlatformID.Win32S => "Microsoft Win32S ", 
						PlatformID.Win32Windows => (_version.Major > 4 || (_version.Major == 4 && _version.Minor > 0)) ? "Microsoft Windows 98 " : "Microsoft Windows 95 ", 
						PlatformID.Win32NT => "Microsoft Windows NT ", 
						PlatformID.WinCE => "Microsoft Windows CE ", 
						PlatformID.Unix => "Unix ", 
						PlatformID.Xbox => "Xbox ", 
						PlatformID.MacOSX => "Mac OS X ", 
						PlatformID.Other => "Other ", 
						_ => "<unknown> ", 
					};
					Span<char> span = stackalloc char[128];
					string versionString;
					if (!string.IsNullOrEmpty(_servicePack))
					{
						IFormatProvider formatProvider = null;
						IFormatProvider provider = formatProvider;
						Span<char> span2 = span;
						Span<char> initialBuffer = span2;
						DefaultInterpolatedStringHandler handler = new DefaultInterpolatedStringHandler(1, 3, formatProvider, span2);
						handler.AppendFormatted(value);
						handler.AppendFormatted(_version.ToString(3));
						handler.AppendLiteral(" ");
						handler.AppendFormatted(_servicePack);
						versionString = string.Create(provider, initialBuffer, ref handler);
					}
					else
					{
						IFormatProvider formatProvider = null;
						IFormatProvider provider2 = formatProvider;
						Span<char> span2 = span;
						Span<char> initialBuffer2 = span2;
						DefaultInterpolatedStringHandler handler2 = new DefaultInterpolatedStringHandler(0, 2, formatProvider, span2);
						handler2.AppendFormatted(value);
						handler2.AppendFormatted(_version);
						versionString = string.Create(provider2, initialBuffer2, ref handler2);
					}
					_versionString = versionString;
				}
				return _versionString;
			}
		}

		public OperatingSystem(PlatformID platform, Version version)
			: this(platform, version, null)
		{
		}

		internal OperatingSystem(PlatformID platform, Version version, string servicePack)
		{
			if (platform < PlatformID.Win32S || platform > PlatformID.Other)
			{
				throw new ArgumentOutOfRangeException("platform", platform, SR.Format(SR.Arg_EnumIllegalVal, platform));
			}
			if (version == null)
			{
				throw new ArgumentNullException("version");
			}
			_platform = platform;
			_version = version;
			_servicePack = servicePack;
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public object Clone()
		{
			return new OperatingSystem(_platform, _version, _servicePack);
		}

		public override string ToString()
		{
			return VersionString;
		}

		public static bool IsOSPlatform(string platform)
		{
			if (platform == null)
			{
				throw new ArgumentNullException("platform");
			}
			return platform.Equals("WINDOWS", StringComparison.OrdinalIgnoreCase);
		}

		public static bool IsOSPlatformVersionAtLeast(string platform, int major, int minor = 0, int build = 0, int revision = 0)
		{
			if (IsOSPlatform(platform))
			{
				return IsOSVersionAtLeast(major, minor, build, revision);
			}
			return false;
		}

		public static bool IsBrowser()
		{
			return false;
		}

		public static bool IsLinux()
		{
			return false;
		}

		public static bool IsFreeBSD()
		{
			return false;
		}

		public static bool IsFreeBSDVersionAtLeast(int major, int minor = 0, int build = 0, int revision = 0)
		{
			if (IsFreeBSD())
			{
			}
			return false;
		}

		public static bool IsAndroid()
		{
			return false;
		}

		public static bool IsAndroidVersionAtLeast(int major, int minor = 0, int build = 0, int revision = 0)
		{
			if (IsAndroid())
			{
			}
			return false;
		}

		[SupportedOSPlatformGuard("maccatalyst")]
		public static bool IsIOS()
		{
			return false;
		}

		[SupportedOSPlatformGuard("maccatalyst")]
		public static bool IsIOSVersionAtLeast(int major, int minor = 0, int build = 0)
		{
			if (IsIOS())
			{
			}
			return false;
		}

		public static bool IsMacOS()
		{
			return false;
		}

		public static bool IsMacOSVersionAtLeast(int major, int minor = 0, int build = 0)
		{
			if (IsMacOS())
			{
			}
			return false;
		}

		public static bool IsMacCatalyst()
		{
			return false;
		}

		public static bool IsMacCatalystVersionAtLeast(int major, int minor = 0, int build = 0)
		{
			if (IsMacCatalyst())
			{
			}
			return false;
		}

		public static bool IsTvOS()
		{
			return false;
		}

		public static bool IsTvOSVersionAtLeast(int major, int minor = 0, int build = 0)
		{
			if (IsTvOS())
			{
			}
			return false;
		}

		public static bool IsWatchOS()
		{
			return false;
		}

		public static bool IsWatchOSVersionAtLeast(int major, int minor = 0, int build = 0)
		{
			if (IsWatchOS())
			{
			}
			return false;
		}

		public static bool IsWindows()
		{
			return true;
		}

		public static bool IsWindowsVersionAtLeast(int major, int minor = 0, int build = 0, int revision = 0)
		{
			IsWindows();
			return IsOSVersionAtLeast(major, minor, build, revision);
		}

		private static bool IsOSVersionAtLeast(int major, int minor, int build, int revision)
		{
			Version version = Environment.OSVersion.Version;
			if (version.Major != major)
			{
				return version.Major > major;
			}
			if (version.Minor != minor)
			{
				return version.Minor > minor;
			}
			if (version.Build != build)
			{
				return version.Build > build;
			}
			if (version.Revision < revision)
			{
				if (version.Revision == -1)
				{
					return revision == 0;
				}
				return false;
			}
			return true;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class OperationCanceledException : SystemException
	{
		[NonSerialized]
		private CancellationToken _cancellationToken;

		public CancellationToken CancellationToken
		{
			get
			{
				return _cancellationToken;
			}
			private set
			{
				_cancellationToken = value;
			}
		}

		public OperationCanceledException()
			: base(SR.OperationCanceled)
		{
			base.HResult = -2146233029;
		}

		public OperationCanceledException(string? message)
			: base(message)
		{
			base.HResult = -2146233029;
		}

		public OperationCanceledException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233029;
		}

		public OperationCanceledException(CancellationToken token)
			: this()
		{
			CancellationToken = token;
		}

		public OperationCanceledException(string? message, CancellationToken token)
			: this(message)
		{
			CancellationToken = token;
		}

		public OperationCanceledException(string? message, Exception? innerException, CancellationToken token)
			: this(message, innerException)
		{
			CancellationToken = token;
		}

		protected OperationCanceledException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class OutOfMemoryException : SystemException
	{
		public OutOfMemoryException()
			: base(Exception.GetMessageFromNativeResources(ExceptionMessageKind.OutOfMemory))
		{
			base.HResult = -2147024882;
		}

		public OutOfMemoryException(string? message)
			: base(message)
		{
			base.HResult = -2147024882;
		}

		public OutOfMemoryException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024882;
		}

		protected OutOfMemoryException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class OverflowException : ArithmeticException
	{
		public OverflowException()
			: base(SR.Arg_OverflowException)
		{
			base.HResult = -2146233066;
		}

		public OverflowException(string? message)
			: base(message)
		{
			base.HResult = -2146233066;
		}

		public OverflowException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233066;
		}

		protected OverflowException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	public sealed class ParamArrayAttribute : Attribute
	{
	}
	internal readonly struct ParamsArray
	{
		private static readonly object[] s_oneArgArray = new object[1];

		private static readonly object[] s_twoArgArray = new object[2];

		private static readonly object[] s_threeArgArray = new object[3];

		private readonly object _arg0;

		private readonly object _arg1;

		private readonly object _arg2;

		private readonly object[] _args;

		public int Length => _args.Length;

		public object this[int index]
		{
			get
			{
				if (index != 0)
				{
					return GetAtSlow(index);
				}
				return _arg0;
			}
		}

		public ParamsArray(object arg0)
		{
			_arg0 = arg0;
			_arg1 = null;
			_arg2 = null;
			_args = s_oneArgArray;
		}

		public ParamsArray(object arg0, object arg1)
		{
			_arg0 = arg0;
			_arg1 = arg1;
			_arg2 = null;
			_args = s_twoArgArray;
		}

		public ParamsArray(object arg0, object arg1, object arg2)
		{
			_arg0 = arg0;
			_arg1 = arg1;
			_arg2 = arg2;
			_args = s_threeArgArray;
		}

		public ParamsArray(object[] args)
		{
			int num = args.Length;
			_arg0 = ((num > 0) ? args[0] : null);
			_arg1 = ((num > 1) ? args[1] : null);
			_arg2 = ((num > 2) ? args[2] : null);
			_args = args;
		}

		private object GetAtSlow(int index)
		{
			return index switch
			{
				1 => _arg1, 
				2 => _arg2, 
				_ => _args[index], 
			};
		}
	}
	internal static class ParseNumbers
	{
		public static long StringToLong(ReadOnlySpan<char> s, int radix, int flags)
		{
			int currPos = 0;
			return StringToLong(s, radix, flags, ref currPos);
		}

		public static long StringToLong(ReadOnlySpan<char> s, int radix, int flags, ref int currPos)
		{
			int i = currPos;
			int num = ((-1 == radix) ? 10 : radix);
			if (num != 2 && num != 10 && num != 8 && num != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase, "radix");
			}
			int length = s.Length;
			if (i < 0 || i >= length)
			{
				throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_Index);
			}
			if ((flags & 0x1000) == 0 && (flags & 0x2000) == 0)
			{
				EatWhiteSpace(s, ref i);
				if (i == length)
				{
					throw new FormatException(SR.Format_EmptyInputString);
				}
			}
			int num2 = 1;
			if (s[i] == '-')
			{
				if (num != 10)
				{
					throw new ArgumentException(SR.Arg_CannotHaveNegativeValue);
				}
				if (((uint)flags & 0x200u) != 0)
				{
					throw new OverflowException(SR.Overflow_NegativeUnsigned);
				}
				num2 = -1;
				i++;
			}
			else if (s[i] == '+')
			{
				i++;
			}
			if ((radix == -1 || radix == 16) && i + 1 < length && s[i] == '0' && (s[i + 1] == 'x' || s[i + 1] == 'X'))
			{
				num = 16;
				i += 2;
			}
			int num3 = i;
			long num4 = GrabLongs(num, s, ref i, (flags & 0x200) != 0);
			if (i == num3)
			{
				throw new FormatException(SR.Format_NoParsibleDigits);
			}
			if (((uint)flags & 0x1000u) != 0 && i < length)
			{
				throw new FormatException(SR.Format_ExtraJunkAtEnd);
			}
			currPos = i;
			if (num4 == long.MinValue && num2 == 1 && num == 10 && (flags & 0x200) == 0)
			{
				Number.ThrowOverflowException(TypeCode.Int64);
			}
			if (num == 10)
			{
				num4 *= num2;
			}
			return num4;
		}

		public static int StringToInt(ReadOnlySpan<char> s, int radix, int flags)
		{
			int currPos = 0;
			return StringToInt(s, radix, flags, ref currPos);
		}

		public static int StringToInt(ReadOnlySpan<char> s, int radix, int flags, ref int currPos)
		{
			int i = currPos;
			int num = ((-1 == radix) ? 10 : radix);
			if (num != 2 && num != 10 && num != 8 && num != 16)
			{
				throw new ArgumentException(SR.Arg_InvalidBase, "radix");
			}
			int length = s.Length;
			if (i < 0 || i >= length)
			{
				throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_Index);
			}
			if ((flags & 0x1000) == 0 && (flags & 0x2000) == 0)
			{
				EatWhiteSpace(s, ref i);
				if (i == length)
				{
					throw new FormatException(SR.Format_EmptyInputString);
				}
			}
			int num2 = 1;
			if (s[i] == '-')
			{
				if (num != 10)
				{
					throw new ArgumentException(SR.Arg_CannotHaveNegativeValue);
				}
				if (((uint)flags & 0x200u) != 0)
				{
					throw new OverflowException(SR.Overflow_NegativeUnsigned);
				}
				num2 = -1;
				i++;
			}
			else if (s[i] == '+')
			{
				i++;
			}
			if ((radix == -1 || radix == 16) && i + 1 < length && s[i] == '0' && (s[i + 1] == 'x' || s[i + 1] == 'X'))
			{
				num = 16;
				i += 2;
			}
			int num3 = i;
			int num4 = GrabInts(num, s, ref i, (flags & 0x200) != 0);
			if (i == num3)
			{
				throw new FormatException(SR.Format_NoParsibleDigits);
			}
			if (((uint)flags & 0x1000u) != 0 && i < length)
			{
				throw new FormatException(SR.Format_ExtraJunkAtEnd);
			}
			currPos = i;
			if (((uint)flags & 0x400u) != 0)
			{
				if ((uint)num4 > 255u)
				{
					Number.ThrowOverflowException(TypeCode.SByte);
				}
			}
			else if (((uint)flags & 0x800u) != 0)
			{
				if ((uint)num4 > 65535u)
				{
					Number.ThrowOverflowException(TypeCode.Int16);
				}
			}
			else if (num4 == int.MinValue && num2 == 1 && num == 10 && (flags & 0x200) == 0)
			{
				Number.ThrowOverflowException(TypeCode.Int32);
			}
			if (num == 10)
			{
				num4 *= num2;
			}
			return num4;
		}

		public unsafe static string IntToString(int n, int radix, int width, char paddingChar, int flags)
		{
			Span<char> span = stackalloc char[66];
			if (radix < 2 || radix > 36)
			{
				throw new ArgumentException(SR.Arg_InvalidBase, "radix");
			}
			bool flag = false;
			uint num;
			if (n < 0)
			{
				flag = true;
				num = (uint)((10 == radix) ? (-n) : n);
			}
			else
			{
				num = (uint)n;
			}
			if (((uint)flags & 0x40u) != 0)
			{
				num &= 0xFFu;
			}
			else if (((uint)flags & 0x80u) != 0)
			{
				num &= 0xFFFFu;
			}
			int num2;
			if (num == 0)
			{
				span[0] = '0';
				num2 = 1;
			}
			else
			{
				num2 = 0;
				for (int i = 0; i < span.Length; i++)
				{
					uint num3 = num / (uint)radix;
					uint num4 = num - (uint)((int)num3 * radix);
					num = num3;
					span[i] = ((num4 < 10) ? ((char)(num4 + 48)) : ((char)(num4 + 97 - 10)));
					if (num == 0)
					{
						num2 = i + 1;
						break;
					}
				}
			}
			if (radix != 10 && ((uint)flags & 0x20u) != 0)
			{
				if (16 == radix)
				{
					span[num2++] = 'x';
					span[num2++] = '0';
				}
				else if (8 == radix)
				{
					span[num2++] = '0';
				}
			}
			if (10 == radix)
			{
				if (flag)
				{
					span[num2++] = '-';
				}
				else if (((uint)flags & 0x10u) != 0)
				{
					span[num2++] = '+';
				}
				else if (((uint)flags & 8u) != 0)
				{
					span[num2++] = ' ';
				}
			}
			string text = string.FastAllocateString(Math.Max(width, num2));
			fixed (char* ptr = text)
			{
				char* ptr2 = ptr;
				int num5 = text.Length - num2;
				if (((uint)flags & (true ? 1u : 0u)) != 0)
				{
					for (int j = 0; j < num5; j++)
					{
						*(ptr2++) = paddingChar;
					}
					for (int k = 0; k < num2; k++)
					{
						*(ptr2++) = span[num2 - k - 1];
					}
				}
				else
				{
					for (int l = 0; l < num2; l++)
					{
						*(ptr2++) = span[num2 - l - 1];
					}
					for (int m = 0; m < num5; m++)
					{
						*(ptr2++) = paddingChar;
					}
				}
			}
			return text;
		}

		public unsafe static string LongToString(long n, int radix, int width, char paddingChar, int flags)
		{
			Span<char> span = stackalloc char[67];
			if (radix < 2 || radix > 36)
			{
				throw new ArgumentException(SR.Arg_InvalidBase, "radix");
			}
			bool flag = false;
			ulong num;
			if (n < 0)
			{
				flag = true;
				num = (ulong)((10 == radix) ? (-n) : n);
			}
			else
			{
				num = (ulong)n;
			}
			if (((uint)flags & 0x40u) != 0)
			{
				num &= 0xFF;
			}
			else if (((uint)flags & 0x80u) != 0)
			{
				num &= 0xFFFF;
			}
			else if (((uint)flags & 0x100u) != 0)
			{
				num &= 0xFFFFFFFFu;
			}
			int num2;
			if (num == 0L)
			{
				span[0] = '0';
				num2 = 1;
			}
			else
			{
				num2 = 0;
				for (int i = 0; i < span.Length; i++)
				{
					ulong num3 = num / (ulong)radix;
					int num4 = (int)((long)num - (long)num3 * (long)radix);
					num = num3;
					span[i] = ((num4 < 10) ? ((char)(num4 + 48)) : ((char)(num4 + 97 - 10)));
					if (num == 0L)
					{
						num2 = i + 1;
						break;
					}
				}
			}
			if (radix != 10 && ((uint)flags & 0x20u) != 0)
			{
				if (16 == radix)
				{
					span[num2++] = 'x';
					span[num2++] = '0';
				}
				else if (8 == radix)
				{
					span[num2++] = '0';
				}
				else if (((uint)flags & 0x4000u) != 0)
				{
					span[num2++] = '#';
					span[num2++] = (char)(radix % 10 + 48);
					span[num2++] = (char)(radix / 10 + 48);
				}
			}
			if (10 == radix)
			{
				if (flag)
				{
					span[num2++] = '-';
				}
				else if (((uint)flags & 0x10u) != 0)
				{
					span[num2++] = '+';
				}
				else if (((uint)flags & 8u) != 0)
				{
					span[num2++] = ' ';
				}
			}
			string text = string.FastAllocateString(Math.Max(width, num2));
			fixed (char* ptr = text)
			{
				char* ptr2 = ptr;
				int num5 = text.Length - num2;
				if (((uint)flags & (true ? 1u : 0u)) != 0)
				{
					for (int j = 0; j < num5; j++)
					{
						*(ptr2++) = paddingChar;
					}
					for (int k = 0; k < num2; k++)
					{
						*(ptr2++) = span[num2 - k - 1];
					}
				}
				else
				{
					for (int l = 0; l < num2; l++)
					{
						*(ptr2++) = span[num2 - l - 1];
					}
					for (int m = 0; m < num5; m++)
					{
						*(ptr2++) = paddingChar;
					}
				}
			}
			return text;
		}

		private static void EatWhiteSpace(ReadOnlySpan<char> s, ref int i)
		{
			int j;
			for (j = i; j < s.Length && char.IsWhiteSpace(s[j]); j++)
			{
			}
			i = j;
		}

		private static long GrabLongs(int radix, ReadOnlySpan<char> s, ref int i, bool isUnsigned)
		{
			ulong num = 0uL;
			if (radix == 10 && !isUnsigned)
			{
				ulong num2 = 922337203685477580uL;
				int result;
				while (i < s.Length && IsDigit(s[i], radix, out result))
				{
					if (num > num2 || (long)num < 0L)
					{
						Number.ThrowOverflowException(TypeCode.Int64);
					}
					num = (ulong)((long)num * (long)radix + result);
					i++;
				}
				if ((long)num < 0L && num != 9223372036854775808uL)
				{
					Number.ThrowOverflowException(TypeCode.Int64);
				}
			}
			else
			{
				ulong num2 = radix switch
				{
					8 => 2305843009213693951uL, 
					16 => 1152921504606846975uL, 
					10 => 1844674407370955161uL, 
					_ => 9223372036854775807uL, 
				};
				int result2;
				while (i < s.Length && IsDigit(s[i], radix, out result2))
				{
					if (num > num2)
					{
						Number.ThrowOverflowException(TypeCode.UInt64);
					}
					ulong num3 = (ulong)((long)num * (long)radix + result2);
					if (num3 < num)
					{
						Number.ThrowOverflowException(TypeCode.UInt64);
					}
					num = num3;
					i++;
				}
			}
			return (long)num;
		}

		private static int GrabInts(int radix, ReadOnlySpan<char> s, ref int i, bool isUnsigned)
		{
			uint num = 0u;
			if (radix == 10 && !isUnsigned)
			{
				uint num2 = 214748364u;
				int result;
				while (i < s.Length && IsDigit(s[i], radix, out result))
				{
					if (num > num2 || (int)num < 0)
					{
						Number.ThrowOverflowException(TypeCode.Int32);
					}
					num = (uint)((int)num * radix + result);
					i++;
				}
				if ((int)num < 0 && num != 2147483648u)
				{
					Number.ThrowOverflowException(TypeCode.Int32);
				}
			}
			else
			{
				uint num2 = radix switch
				{
					8 => 536870911u, 
					16 => 268435455u, 
					10 => 429496729u, 
					_ => 2147483647u, 
				};
				int result2;
				while (i < s.Length && IsDigit(s[i], radix, out result2))
				{
					if (num > num2)
					{
						Number.ThrowOverflowException(TypeCode.UInt32);
					}
					uint num3 = (uint)((int)num * radix + result2);
					if (num3 < num)
					{
						Number.ThrowOverflowException(TypeCode.UInt32);
					}
					num = num3;
					i++;
				}
			}
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsDigit(char c, int radix, out int result)
		{
			int num;
			switch (c)
			{
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				num = (result = c - 48);
				break;
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
				num = (result = c - 65 + 10);
				break;
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
				num = (result = c - 97 + 10);
				break;
			default:
				result = -1;
				return false;
			}
			return num < radix;
		}
	}
	internal static class PasteArguments
	{
		internal static void AppendArgument(ref ValueStringBuilder stringBuilder, string argument)
		{
			if (stringBuilder.Length != 0)
			{
				stringBuilder.Append(' ');
			}
			if (argument.Length != 0 && ContainsNoWhitespaceOrQuotes(argument))
			{
				stringBuilder.Append(argument);
				return;
			}
			stringBuilder.Append('"');
			int num = 0;
			while (num < argument.Length)
			{
				char c = argument[num++];
				switch (c)
				{
				case '\\':
				{
					int num2 = 1;
					while (num < argument.Length && argument[num] == '\\')
					{
						num++;
						num2++;
					}
					if (num == argument.Length)
					{
						stringBuilder.Append('\\', num2 * 2);
					}
					else if (argument[num] == '"')
					{
						stringBuilder.Append('\\', num2 * 2 + 1);
						stringBuilder.Append('"');
						num++;
					}
					else
					{
						stringBuilder.Append('\\', num2);
					}
					break;
				}
				case '"':
					stringBuilder.Append('\\');
					stringBuilder.Append('"');
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			stringBuilder.Append('"');
		}

		private static bool ContainsNoWhitespaceOrQuotes(string s)
		{
			foreach (char c in s)
			{
				if (char.IsWhiteSpace(c) || c == '"')
				{
					return false;
				}
			}
			return true;
		}

		internal static string Paste(IEnumerable<string> arguments, bool pasteFirstArgumentUsingArgV0Rules)
		{
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder stringBuilder = new ValueStringBuilder(initialBuffer);
			foreach (string argument in arguments)
			{
				if (pasteFirstArgumentUsingArgV0Rules)
				{
					pasteFirstArgumentUsingArgV0Rules = false;
					bool flag = false;
					string text = argument;
					foreach (char c in text)
					{
						if (c == '"')
						{
							throw new ApplicationException(SR.Argv_IncludeDoubleQuote);
						}
						if (char.IsWhiteSpace(c))
						{
							flag = true;
						}
					}
					if (argument.Length == 0 || flag)
					{
						stringBuilder.Append('"');
						stringBuilder.Append(argument);
						stringBuilder.Append('"');
					}
					else
					{
						stringBuilder.Append(argument);
					}
				}
				else
				{
					AppendArgument(ref stringBuilder, argument);
				}
			}
			return stringBuilder.ToString();
		}
	}
	public enum PlatformID
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		Win32S,
		[EditorBrowsable(EditorBrowsableState.Never)]
		Win32Windows,
		Win32NT,
		[EditorBrowsable(EditorBrowsableState.Never)]
		WinCE,
		Unix,
		[EditorBrowsable(EditorBrowsableState.Never)]
		Xbox,
		[EditorBrowsable(EditorBrowsableState.Never)]
		MacOSX,
		Other
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class PlatformNotSupportedException : NotSupportedException
	{
		public PlatformNotSupportedException()
			: base(SR.Arg_PlatformNotSupported)
		{
			base.HResult = -2146233031;
		}

		public PlatformNotSupportedException(string? message)
			: base(message)
		{
			base.HResult = -2146233031;
		}

		public PlatformNotSupportedException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233031;
		}

		protected PlatformNotSupportedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public class Progress<T> : IProgress<T>
	{
		private readonly SynchronizationContext _synchronizationContext;

		private readonly Action<T> _handler;

		private readonly SendOrPostCallback _invokeHandlers;

		public event EventHandler<T>? ProgressChanged;

		public Progress()
		{
			_synchronizationContext = SynchronizationContext.Current ?? ProgressStatics.DefaultContext;
			_invokeHandlers = InvokeHandlers;
		}

		public Progress(Action<T> handler)
			: this()
		{
			_handler = handler ?? throw new ArgumentNullException("handler");
		}

		protected virtual void OnReport(T value)
		{
			Action<T> handler = _handler;
			EventHandler<T> progressChanged = this.ProgressChanged;
			if (handler != null || progressChanged != null)
			{
				_synchronizationContext.Post(_invokeHandlers, value);
			}
		}

		void IProgress<T>.Report(T value)
		{
			OnReport(value);
		}

		private void InvokeHandlers(object state)
		{
			T val = (T)state;
			Action<T> handler = _handler;
			EventHandler<T> progressChanged = this.ProgressChanged;
			handler?.Invoke(val);
			progressChanged?.Invoke(this, val);
		}
	}
	internal static class ProgressStatics
	{
		internal static readonly SynchronizationContext DefaultContext = new SynchronizationContext();
	}
	public class Random
	{
		private sealed class ThreadSafeRandom : Random
		{
			[ThreadStatic]
			private static XoshiroImpl t_random;

			private static XoshiroImpl LocalRandom => t_random ?? Create();

			public ThreadSafeRandom()
				: base(isThreadSafeRandom: true)
			{
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private static XoshiroImpl Create()
			{
				return t_random = new XoshiroImpl();
			}

			public override int Next()
			{
				return LocalRandom.Next();
			}

			public override int Next(int maxValue)
			{
				if (maxValue < 0)
				{
					ThrowMaxValueMustBeNonNegative();
				}
				return LocalRandom.Next(maxValue);
			}

			public override int Next(int minValue, int maxValue)
			{
				if (minValue > maxValue)
				{
					ThrowMinMaxValueSwapped();
				}
				return LocalRandom.Next(minValue, maxValue);
			}

			public override long NextInt64()
			{
				return LocalRandom.NextInt64();
			}

			public override long NextInt64(long maxValue)
			{
				if (maxValue < 0)
				{
					ThrowMaxValueMustBeNonNegative();
				}
				return LocalRandom.NextInt64(maxValue);
			}

			public override long NextInt64(long minValue, long maxValue)
			{
				if (minValue > maxValue)
				{
					ThrowMinMaxValueSwapped();
				}
				return LocalRandom.NextInt64(minValue, maxValue);
			}

			public override float NextSingle()
			{
				return LocalRandom.NextSingle();
			}

			public override double NextDouble()
			{
				return LocalRandom.NextDouble();
			}

			public override void NextBytes(byte[] buffer)
			{
				if (buffer == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.buffer);
				}
				LocalRandom.NextBytes(buffer);
			}

			public override void NextBytes(Span<byte> buffer)
			{
				LocalRandom.NextBytes(buffer);
			}

			protected override double Sample()
			{
				throw new NotSupportedException();
			}
		}

		internal abstract class ImplBase
		{
			public abstract double Sample();

			public abstract int Next();

			public abstract int Next(int maxValue);

			public abstract int Next(int minValue, int maxValue);

			public abstract long NextInt64();

			public abstract long NextInt64(long maxValue);

			public abstract long NextInt64(long minValue, long maxValue);

			public abstract float NextSingle();

			public abstract double NextDouble();

			public abstract void NextBytes(byte[] buffer);

			public abstract void NextBytes(Span<byte> buffer);
		}

		private sealed class Net5CompatSeedImpl : ImplBase
		{
			private CompatPrng _prng;

			public Net5CompatSeedImpl(int seed)
			{
				_prng = new CompatPrng(seed);
			}

			public override double Sample()
			{
				return _prng.Sample();
			}

			public override int Next()
			{
				return _prng.InternalSample();
			}

			public override int Next(int maxValue)
			{
				return (int)(_prng.Sample() * (double)maxValue);
			}

			public override int Next(int minValue, int maxValue)
			{
				long num = (long)maxValue - (long)minValue;
				if (num > int.MaxValue)
				{
					return (int)((long)(_prng.GetSampleForLargeRange() * (double)num) + minValue);
				}
				return (int)(_prng.Sample() * (double)num) + minValue;
			}

			public override long NextInt64()
			{
				ulong num;
				do
				{
					num = NextUInt64() >> 1;
				}
				while (num == long.MaxValue);
				return (long)num;
			}

			public override long NextInt64(long maxValue)
			{
				return NextInt64(0L, maxValue);
			}

			public override long NextInt64(long minValue, long maxValue)
			{
				ulong num = (ulong)(maxValue - minValue);
				if (num > 1)
				{
					int num2 = BitOperations.Log2Ceiling(num);
					ulong num3;
					do
					{
						num3 = NextUInt64() >> 64 - num2;
					}
					while (num3 >= num);
					return (long)num3 + minValue;
				}
				return minValue;
			}

			private ulong NextUInt64()
			{
				return (uint)Next(4194304) | ((ulong)(uint)Next(4194304) << 22) | ((ulong)(uint)Next(1048576) << 44);
			}

			public override double NextDouble()
			{
				return _prng.Sample();
			}

			public override float NextSingle()
			{
				return (float)_prng.Sample();
			}

			public override void NextBytes(byte[] buffer)
			{
				_prng.NextBytes(buffer);
			}

			public override void NextBytes(Span<byte> buffer)
			{
				_prng.NextBytes(buffer);
			}
		}

		private sealed class Net5CompatDerivedImpl : ImplBase
		{
			private readonly Random _parent;

			private CompatPrng _prng;

			public Net5CompatDerivedImpl(Random parent)
				: this(parent, Shared.Next())
			{
			}

			public Net5CompatDerivedImpl(Random parent, int seed)
			{
				_parent = parent;
				_prng = new CompatPrng(seed);
			}

			public override double Sample()
			{
				return _prng.Sample();
			}

			public override int Next()
			{
				return _prng.InternalSample();
			}

			public override int Next(int maxValue)
			{
				return (int)(_parent.Sample() * (double)maxValue);
			}

			public override int Next(int minValue, int maxValue)
			{
				long num = (long)maxValue - (long)minValue;
				if (num > int.MaxValue)
				{
					return (int)((long)(_prng.GetSampleForLargeRange() * (double)num) + minValue);
				}
				return (int)(_parent.Sample() * (double)num) + minValue;
			}

			public override long NextInt64()
			{
				ulong num;
				do
				{
					num = NextUInt64() >> 1;
				}
				while (num == long.MaxValue);
				return (long)num;
			}

			public override long NextInt64(long maxValue)
			{
				return NextInt64(0L, maxValue);
			}

			public override long NextInt64(long minValue, long maxValue)
			{
				ulong num = (ulong)(maxValue - minValue);
				if (num > 1)
				{
					int num2 = BitOperations.Log2Ceiling(num);
					ulong num3;
					do
					{
						num3 = NextUInt64() >> 64 - num2;
					}
					while (num3 >= num);
					return (long)num3 + minValue;
				}
				return minValue;
			}

			private ulong NextUInt64()
			{
				return (uint)_parent.Next(4194304) | ((ulong)(uint)_parent.Next(4194304) << 22) | ((ulong)(uint)_parent.Next(1048576) << 44);
			}

			public override double NextDouble()
			{
				return _parent.Sample();
			}

			public override float NextSingle()
			{
				return (float)_parent.Sample();
			}

			public override void NextBytes(byte[] buffer)
			{
				_prng.NextBytes(buffer);
			}

			public override void NextBytes(Span<byte> buffer)
			{
				for (int i = 0; i < buffer.Length; i++)
				{
					buffer[i] = (byte)_parent.Next();
				}
			}
		}

		private struct CompatPrng
		{
			private int[] _seedArray;

			private int _inext;

			private int _inextp;

			public CompatPrng(int seed)
			{
				int[] array = new int[56];
				int num = ((seed == int.MinValue) ? int.MaxValue : Math.Abs(seed));
				int num2 = (array[55] = 161803398 - num);
				int num3 = 1;
				int num4 = 0;
				for (int i = 1; i < 55; i++)
				{
					if ((num4 += 21) >= 55)
					{
						num4 -= 55;
					}
					array[num4] = num3;
					num3 = num2 - num3;
					if (num3 < 0)
					{
						num3 += int.MaxValue;
					}
					num2 = array[num4];
				}
				for (int j = 1; j < 5; j++)
				{
					for (int k = 1; k < 56; k++)
					{
						int num5 = k + 30;
						if (num5 >= 55)
						{
							num5 -= 55;
						}
						array[k] -= array[1 + num5];
						if (array[k] < 0)
						{
							array[k] += int.MaxValue;
						}
					}
				}
				_seedArray = array;
				_inext = 0;
				_inextp = 21;
			}

			internal double Sample()
			{
				return (double)InternalSample() * 4.656612875245797E-10;
			}

			internal void NextBytes(Span<byte> buffer)
			{
				for (int i = 0; i < buffer.Length; i++)
				{
					buffer[i] = (byte)InternalSample();
				}
			}

			internal int InternalSample()
			{
				int inext = _inext;
				if (++inext >= 56)
				{
					inext = 1;
				}
				int inextp = _inextp;
				if (++inextp >= 56)
				{
					inextp = 1;
				}
				int[] seedArray = _seedArray;
				int num = seedArray[inext] - seedArray[inextp];
				if (num == int.MaxValue)
				{
					num--;
				}
				if (num < 0)
				{
					num += int.MaxValue;
				}
				seedArray[inext] = num;
				_inext = inext;
				_inextp = inextp;
				return num;
			}

			internal double GetSampleForLargeRange()
			{
				int num = InternalSample();
				if (InternalSample() % 2 == 0)
				{
					num = -num;
				}
				double num2 = num;
				num2 += 2147483646.0;
				return num2 / 4294967293.0;
			}
		}

		internal sealed class XoshiroImpl : ImplBase
		{
			private uint _s0;

			private uint _s1;

			private uint _s2;

			private uint _s3;

			public unsafe XoshiroImpl()
			{
				uint* ptr = stackalloc uint[4];
				do
				{
					Interop.GetRandomBytes((byte*)ptr, 16);
					_s0 = *ptr;
					_s1 = ptr[1];
					_s2 = ptr[2];
					_s3 = ptr[3];
				}
				while ((_s0 | _s1 | _s2 | _s3) == 0);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal uint NextUInt32()
			{
				uint s = _s0;
				uint s2 = _s1;
				uint s3 = _s2;
				uint s4 = _s3;
				uint result = BitOperations.RotateLeft(s2 * 5, 7) * 9;
				uint num = s2 << 9;
				s3 ^= s;
				s4 ^= s2;
				s2 ^= s3;
				s ^= s4;
				s3 ^= num;
				s4 = BitOperations.RotateLeft(s4, 11);
				_s0 = s;
				_s1 = s2;
				_s2 = s3;
				_s3 = s4;
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal ulong NextUInt64()
			{
				return ((ulong)NextUInt32() << 32) | NextUInt32();
			}

			public override int Next()
			{
				uint num;
				do
				{
					num = NextUInt32() >> 1;
				}
				while (num == int.MaxValue);
				return (int)num;
			}

			public override int Next(int maxValue)
			{
				if (maxValue > 1)
				{
					int num = BitOperations.Log2Ceiling((uint)maxValue);
					uint num2;
					do
					{
						num2 = NextUInt32() >> 32 - num;
					}
					while (num2 >= (uint)maxValue);
					return (int)num2;
				}
				return 0;
			}

			public override int Next(int minValue, int maxValue)
			{
				uint num = (uint)(maxValue - minValue);
				if (num > 1)
				{
					int num2 = BitOperations.Log2Ceiling(num);
					uint num3;
					do
					{
						num3 = NextUInt32() >> 32 - num2;
					}
					while (num3 >= num);
					return (int)num3 + minValue;
				}
				return minValue;
			}

			public override long NextInt64()
			{
				ulong num;
				do
				{
					num = NextUInt64() >> 1;
				}
				while (num == long.MaxValue);
				return (long)num;
			}

			public override long NextInt64(long maxValue)
			{
				if (maxValue <= int.MaxValue)
				{
					return Next((int)maxValue);
				}
				if (maxValue > 1)
				{
					int num = BitOperations.Log2Ceiling((ulong)maxValue);
					ulong num2;
					do
					{
						num2 = NextUInt64() >> 64 - num;
					}
					while (num2 >= (ulong)maxValue);
					return (long)num2;
				}
				return 0L;
			}

			public override long NextInt64(long minValue, long maxValue)
			{
				ulong num = (ulong)(maxValue - minValue);
				if (num <= int.MaxValue)
				{
					return Next((int)num) + minValue;
				}
				if (num > 1)
				{
					int num2 = BitOperations.Log2Ceiling(num);
					ulong num3;
					do
					{
						num3 = NextUInt64() >> 64 - num2;
					}
					while (num3 >= num);
					return (long)num3 + minValue;
				}
				return minValue;
			}

			public override void NextBytes(byte[] buffer)
			{
				NextBytes((Span<byte>)buffer);
			}

			public unsafe override void NextBytes(Span<byte> buffer)
			{
				uint num = _s0;
				uint num2 = _s1;
				uint num3 = _s2;
				uint num4 = _s3;
				while (buffer.Length >= 4)
				{
					Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(buffer), BitOperations.RotateLeft(num2 * 5, 7) * 9);
					uint num5 = num2 << 9;
					num3 ^= num;
					num4 ^= num2;
					num2 ^= num3;
					num ^= num4;
					num3 ^= num5;
					num4 = BitOperations.RotateLeft(num4, 11);
					buffer = buffer.Slice(4);
				}
				if (!buffer.IsEmpty)
				{
					uint num6 = BitOperations.RotateLeft(num2 * 5, 7) * 9;
					byte* ptr = (byte*)(&num6);
					for (int i = 0; i < buffer.Length; i++)
					{
						buffer[i] = ptr[i];
					}
					uint num7 = num2 << 9;
					num3 ^= num;
					num4 ^= num2;
					num2 ^= num3;
					num ^= num4;
					num3 ^= num7;
					num4 = BitOperations.RotateLeft(num4, 11);
				}
				_s0 = num;
				_s1 = num2;
				_s2 = num3;
				_s3 = num4;
			}

			public override double NextDouble()
			{
				return (double)(NextUInt64() >> 11) * 1.1102230246251565E-16;
			}

			public override float NextSingle()
			{
				return (float)(NextUInt32() >> 8) * 5.9604645E-08f;
			}

			public override double Sample()
			{
				throw new NotSupportedException();
			}
		}

		private readonly ImplBase _impl;

		public static Random Shared { get; } = new ThreadSafeRandom();


		public Random()
		{
			_impl = ((GetType() == typeof(Random)) ? ((ImplBase)new XoshiroImpl()) : ((ImplBase)new Net5CompatDerivedImpl(this)));
		}

		public Random(int Seed)
		{
			_impl = ((GetType() == typeof(Random)) ? ((ImplBase)new Net5CompatSeedImpl(Seed)) : ((ImplBase)new Net5CompatDerivedImpl(this, Seed)));
		}

		private protected Random(bool isThreadSafeRandom)
		{
			_impl = null;
		}

		public virtual int Next()
		{
			return _impl.Next();
		}

		public virtual int Next(int maxValue)
		{
			if (maxValue < 0)
			{
				ThrowMaxValueMustBeNonNegative();
			}
			return _impl.Next(maxValue);
		}

		public virtual int Next(int minValue, int maxValue)
		{
			if (minValue > maxValue)
			{
				ThrowMinMaxValueSwapped();
			}
			return _impl.Next(minValue, maxValue);
		}

		public virtual long NextInt64()
		{
			return _impl.NextInt64();
		}

		public virtual long NextInt64(long maxValue)
		{
			if (maxValue < 0)
			{
				ThrowMaxValueMustBeNonNegative();
			}
			return _impl.NextInt64(maxValue);
		}

		public virtual long NextInt64(long minValue, long maxValue)
		{
			if (minValue > maxValue)
			{
				ThrowMinMaxValueSwapped();
			}
			return _impl.NextInt64(minValue, maxValue);
		}

		public virtual float NextSingle()
		{
			return _impl.NextSingle();
		}

		public virtual double NextDouble()
		{
			return _impl.NextDouble();
		}

		public virtual void NextBytes(byte[] buffer)
		{
			if (buffer == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.buffer);
			}
			_impl.NextBytes(buffer);
		}

		public virtual void NextBytes(Span<byte> buffer)
		{
			_impl.NextBytes(buffer);
		}

		protected virtual double Sample()
		{
			return _impl.Sample();
		}

		private static void ThrowMaxValueMustBeNonNegative()
		{
			throw new ArgumentOutOfRangeException("maxValue", SR.Format(SR.ArgumentOutOfRange_NeedNonNegNum, "maxValue"));
		}

		private static void ThrowMinMaxValueSwapped()
		{
			throw new ArgumentOutOfRangeException("minValue", SR.Format(SR.Argument_MinMaxValue, "minValue", "maxValue"));
		}
	}
	public readonly struct Range : IEquatable<Range>
	{
		public Index Start { get; }

		public Index End { get; }

		public static Range All => Index.Start..Index.End;

		public Range(Index start, Index end)
		{
			Start = start;
			End = end;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is Range range && range.Start.Equals(Start))
			{
				return range.End.Equals(End);
			}
			return false;
		}

		public bool Equals(Range other)
		{
			if (other.Start.Equals(Start))
			{
				return other.End.Equals(End);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Start.GetHashCode(), End.GetHashCode());
		}

		public override string ToString()
		{
			Span<char> span = stackalloc char[24];
			int num = 0;
			if (Start.IsFromEnd)
			{
				span[0] = '^';
				num = 1;
			}
			bool flag = ((uint)Start.Value).TryFormat(span.Slice(num), out var charsWritten);
			num += charsWritten;
			span[num++] = '.';
			span[num++] = '.';
			if (End.IsFromEnd)
			{
				span[num++] = '^';
			}
			flag = ((uint)End.Value).TryFormat(span.Slice(num), out charsWritten);
			return new string(span[..(num + charsWritten)]);
		}

		public static Range StartAt(Index start)
		{
			return start..Index.End;
		}

		public static Range EndAt(Index end)
		{
			return Index.Start..end;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (int Offset, int Length) GetOffsetAndLength(int length)
		{
			Index start = Start;
			int num = ((!start.IsFromEnd) ? start.Value : (length - start.Value));
			Index end = End;
			int num2 = ((!end.IsFromEnd) ? end.Value : (length - end.Value));
			if ((uint)num2 > (uint)length || (uint)num > (uint)num2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
			}
			return (num, num2 - num);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class RankException : SystemException
	{
		public RankException()
			: base(SR.Arg_RankException)
		{
			base.HResult = -2146233065;
		}

		public RankException(string? message)
			: base(message)
		{
			base.HResult = -2146233065;
		}

		public RankException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233065;
		}

		protected RankException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[DebuggerTypeProxy(typeof(MemoryDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	public readonly struct ReadOnlyMemory<T> : IEquatable<ReadOnlyMemory<T>>
	{
		private readonly object _object;

		private readonly int _index;

		private readonly int _length;

		internal const int RemoveFlagsBitMask = int.MaxValue;

		public static ReadOnlyMemory<T> Empty => default(ReadOnlyMemory<T>);

		public int Length => _length;

		public bool IsEmpty => _length == 0;

		public unsafe ReadOnlySpan<T> Span
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				ref T ptr = ref Unsafe.NullRef<T>();
				int length = 0;
				object @object = _object;
				if (@object != null)
				{
					if (typeof(T) == typeof(char) && @object.GetType() == typeof(string))
					{
						ptr = ref Unsafe.As<char, T>(ref Unsafe.As<string>(@object).GetRawStringData());
						length = Unsafe.As<string>(@object).Length;
					}
					else if (RuntimeHelpers.ObjectHasComponentSize(@object))
					{
						ptr = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(@object));
						length = Unsafe.As<T[]>(@object).Length;
					}
					else
					{
						Span<T> span = Unsafe.As<MemoryManager<T>>(@object).GetSpan();
						ptr = ref MemoryMarshal.GetReference(span);
						length = span.Length;
					}
					nuint num = (uint)_index & 0x7FFFFFFFu;
					int length2 = _length;
					if ((uint)num > (uint)length || (uint)length2 > (uint)(length - (int)num))
					{
						ThrowHelper.ThrowArgumentOutOfRangeException();
					}
					ptr = ref Unsafe.Add(ref ptr, (IntPtr)(void*)num);
					length = length2;
				}
				return new ReadOnlySpan<T>(ref ptr, length);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory(T[]? array)
		{
			if (array == null)
			{
				this = default(ReadOnlyMemory<T>);
				return;
			}
			_object = array;
			_index = 0;
			_length = array.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory(T[]? array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				this = default(ReadOnlyMemory<T>);
				return;
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = array;
			_index = start;
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ReadOnlyMemory(object obj, int start, int length)
		{
			_object = obj;
			_index = start;
			_length = length;
		}

		public static implicit operator ReadOnlyMemory<T>(T[]? array)
		{
			return new ReadOnlyMemory<T>(array);
		}

		public static implicit operator ReadOnlyMemory<T>(ArraySegment<T> segment)
		{
			return new ReadOnlyMemory<T>(segment.Array, segment.Offset, segment.Count);
		}

		public override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				if (!(_object is string text))
				{
					return Span.ToString();
				}
				return text.Substring(_index, _length);
			}
			return $"System.ReadOnlyMemory<{typeof(T).Name}>[{_length}]";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory<T> Slice(int start)
		{
			if ((uint)start > (uint)_length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new ReadOnlyMemory<T>(_object, _index + start, _length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory<T> Slice(int start, int length)
		{
			if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.start);
			}
			return new ReadOnlyMemory<T>(_object, _index + start, length);
		}

		public void CopyTo(Memory<T> destination)
		{
			Span.CopyTo(destination.Span);
		}

		public bool TryCopyTo(Memory<T> destination)
		{
			return Span.TryCopyTo(destination.Span);
		}

		public unsafe MemoryHandle Pin()
		{
			object @object = _object;
			if (@object != null)
			{
				if (typeof(T) == typeof(char) && @object is string text)
				{
					GCHandle handle = GCHandle.Alloc(@object, GCHandleType.Pinned);
					return new MemoryHandle(Unsafe.AsPointer(ref Unsafe.Add(ref text.GetRawStringData(), _index)), handle);
				}
				if (RuntimeHelpers.ObjectHasComponentSize(@object))
				{
					if (_index < 0)
					{
						void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(@object))), _index & 0x7FFFFFFF);
						return new MemoryHandle(pointer);
					}
					GCHandle handle2 = GCHandle.Alloc(@object, GCHandleType.Pinned);
					void* pointer2 = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(@object))), _index);
					return new MemoryHandle(pointer2, handle2);
				}
				return Unsafe.As<MemoryManager<T>>(@object).Pin(_index);
			}
			return default(MemoryHandle);
		}

		public T[] ToArray()
		{
			return Span.ToArray();
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is ReadOnlyMemory<T> other)
			{
				return Equals(other);
			}
			if (obj is Memory<T> memory)
			{
				return Equals(memory);
			}
			return false;
		}

		public bool Equals(ReadOnlyMemory<T> other)
		{
			if (_object == other._object && _index == other._index)
			{
				return _length == other._length;
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			if (_object == null)
			{
				return 0;
			}
			return HashCode.Combine(RuntimeHelpers.GetHashCode(_object), _index, _length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal object GetObjectStartLength(out int start, out int length)
		{
			start = _index;
			length = _length;
			return _object;
		}
	}
	[DebuggerTypeProxy(typeof(SpanDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	[NonVersionable]
	public readonly ref struct ReadOnlySpan<T>
	{
		public ref struct Enumerator
		{
			private readonly ReadOnlySpan<T> _span;

			private int _index;

			public ref readonly T Current
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return ref _span[_index];
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal Enumerator(ReadOnlySpan<T> span)
			{
				_span = span;
				_index = -1;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool MoveNext()
			{
				int num = _index + 1;
				if (num < _span.Length)
				{
					_index = num;
					return true;
				}
				return false;
			}
		}

		internal readonly ByReference<T> _pointer;

		private readonly int _length;

		public ref readonly T this[int index]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[Intrinsic]
			[NonVersionable]
			get
			{
				if ((uint)index >= (uint)_length)
				{
					ThrowHelper.ThrowIndexOutOfRangeException();
				}
				return ref Unsafe.Add(ref _pointer.Value, (nint)(uint)index);
			}
		}

		public int Length
		{
			[NonVersionable]
			get
			{
				return _length;
			}
		}

		public bool IsEmpty
		{
			[NonVersionable]
			get
			{
				return 0u >= (uint)_length;
			}
		}

		public static ReadOnlySpan<T> Empty => default(ReadOnlySpan<T>);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan(T[]? array)
		{
			if (array == null)
			{
				this = default(ReadOnlySpan<T>);
				return;
			}
			_pointer = new ByReference<T>(ref MemoryMarshal.GetArrayDataReference(array));
			_length = array.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan(T[]? array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				this = default(ReadOnlySpan<T>);
				return;
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_pointer = new ByReference<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start));
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public unsafe ReadOnlySpan(void* pointer, int length)
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (length < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_pointer = new ByReference<T>(ref Unsafe.As<byte, T>(ref *(byte*)pointer));
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ReadOnlySpan(ref T ptr, int length)
		{
			_pointer = new ByReference<T>(ref ptr);
			_length = length;
		}

		public static bool operator !=(ReadOnlySpan<T> left, ReadOnlySpan<T> right)
		{
			return !(left == right);
		}

		[Obsolete("Equals() on ReadOnlySpan has will always throw an exception. Use the equality operator instead.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object? obj)
		{
			throw new NotSupportedException(SR.NotSupported_CannotCallEqualsOnSpan);
		}

		[Obsolete("GetHashCode() on ReadOnlySpan will always throw an exception.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			throw new NotSupportedException(SR.NotSupported_CannotCallGetHashCodeOnSpan);
		}

		public static implicit operator ReadOnlySpan<T>(T[]? array)
		{
			return new ReadOnlySpan<T>(array);
		}

		public static implicit operator ReadOnlySpan<T>(ArraySegment<T> segment)
		{
			return new ReadOnlySpan<T>(segment.Array, segment.Offset, segment.Count);
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public ref readonly T GetPinnableReference()
		{
			ref T result = ref Unsafe.NullRef<T>();
			if (_length != 0)
			{
				result = ref _pointer.Value;
			}
			return ref result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void CopyTo(Span<T> destination)
		{
			if ((uint)_length <= (uint)destination.Length)
			{
				Buffer.Memmove<T>(ref destination._pointer.Value, ref _pointer.Value, (uint)_length);
			}
			else
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
		}

		public bool TryCopyTo(Span<T> destination)
		{
			bool result = false;
			if ((uint)_length <= (uint)destination.Length)
			{
				Buffer.Memmove<T>(ref destination._pointer.Value, ref _pointer.Value, (uint)_length);
				result = true;
			}
			return result;
		}

		public static bool operator ==(ReadOnlySpan<T> left, ReadOnlySpan<T> right)
		{
			if (left._length == right._length)
			{
				return Unsafe.AreSame(ref left._pointer.Value, ref right._pointer.Value);
			}
			return false;
		}

		public override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _pointer.Value), _length));
			}
			return $"System.ReadOnlySpan<{typeof(T).Name}>[{_length}]";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<T> Slice(int start)
		{
			if ((uint)start > (uint)_length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new ReadOnlySpan<T>(ref Unsafe.Add(ref _pointer.Value, (nint)(uint)start), _length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<T> Slice(int start, int length)
		{
			if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new ReadOnlySpan<T>(ref Unsafe.Add(ref _pointer.Value, (nint)(uint)start), length);
		}

		public T[] ToArray()
		{
			if (_length == 0)
			{
				return Array.Empty<T>();
			}
			T[] array = new T[_length];
			Buffer.Memmove(ref MemoryMarshal.GetArrayDataReference(array), ref _pointer.Value, (uint)_length);
			return array;
		}
	}
	public class ResolveEventArgs : EventArgs
	{
		public string Name { get; }

		public Assembly? RequestingAssembly { get; }

		public ResolveEventArgs(string name)
		{
			Name = name;
		}

		public ResolveEventArgs(string name, Assembly? requestingAssembly)
		{
			Name = name;
			RequestingAssembly = requestingAssembly;
		}
	}
	public delegate Assembly? ResolveEventHandler(object? sender, ResolveEventArgs args);
	[Serializable]
	[CLSCompliant(false)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct SByte : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<sbyte>, IEquatable<sbyte>, IBinaryInteger<sbyte>, IBinaryNumber<sbyte>, IBitwiseOperators<sbyte, sbyte, sbyte>, INumber<sbyte>, IAdditionOperators<sbyte, sbyte, sbyte>, IAdditiveIdentity<sbyte, sbyte>, IComparisonOperators<sbyte, sbyte>, IEqualityOperators<sbyte, sbyte>, IDecrementOperators<sbyte>, IDivisionOperators<sbyte, sbyte, sbyte>, IIncrementOperators<sbyte>, IModulusOperators<sbyte, sbyte, sbyte>, IMultiplicativeIdentity<sbyte, sbyte>, IMultiplyOperators<sbyte, sbyte, sbyte>, ISpanParseable<sbyte>, IParseable<sbyte>, ISubtractionOperators<sbyte, sbyte, sbyte>, IUnaryNegationOperators<sbyte, sbyte>, IUnaryPlusOperators<sbyte, sbyte>, IShiftOperators<sbyte, sbyte>, IMinMaxValue<sbyte>, ISignedNumber<sbyte>
	{
		private readonly sbyte m_value;

		public const sbyte MaxValue = 127;

		public const sbyte MinValue = -128;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IAdditiveIdentity<sbyte, sbyte>.AdditiveIdentity => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IMinMaxValue<sbyte>.MinValue => sbyte.MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IMinMaxValue<sbyte>.MaxValue => sbyte.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IMultiplicativeIdentity<sbyte, sbyte>.MultiplicativeIdentity => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.One => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Zero => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte ISignedNumber<sbyte>.NegativeOne => -1;

		public int CompareTo(object? obj)
		{
			if (obj == null)
			{
				return 1;
			}
			if (!(obj is sbyte))
			{
				throw new ArgumentException(SR.Arg_MustBeSByte);
			}
			return this - (sbyte)obj;
		}

		public int CompareTo(sbyte value)
		{
			return this - value;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is sbyte))
			{
				return false;
			}
			return this == (sbyte)obj;
		}

		[NonVersionable]
		public bool Equals(sbyte obj)
		{
			return this == obj;
		}

		public override int GetHashCode()
		{
			return this;
		}

		public override string ToString()
		{
			return Number.Int32ToDecStr(this);
		}

		public string ToString(string? format)
		{
			return ToString(format, null);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.FormatInt32(this, 0, null, provider);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatInt32(this, 255, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatInt32(this, 255, format, provider, destination, out charsWritten);
		}

		public static sbyte Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
		}

		public static sbyte Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.CurrentInfo);
		}

		public static sbyte Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
		}

		public static sbyte Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static sbyte Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Parse(s, style, NumberFormatInfo.GetInstance(provider));
		}

		private static sbyte Parse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info)
		{
			int result;
			Number.ParsingStatus parsingStatus = Number.TryParseInt32(s, style, info, out result);
			if (parsingStatus != 0)
			{
				Number.ThrowOverflowOrFormatException(parsingStatus, TypeCode.SByte);
			}
			if ((uint)(result - -128 - ((int)(style & NumberStyles.AllowHexSpecifier) >> 2)) > 255u)
			{
				Number.ThrowOverflowException(TypeCode.SByte);
			}
			return (sbyte)result;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out sbyte result)
		{
			if (s == null)
			{
				result = 0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out sbyte result)
		{
			return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out sbyte result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				result = 0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out sbyte result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out sbyte result)
		{
			if (Number.TryParseInt32(s, style, info, out var result2) != 0 || (uint)(result2 - -128 - ((int)(style & NumberStyles.AllowHexSpecifier) >> 2)) > 255u)
			{
				result = 0;
				return false;
			}
			result = (sbyte)result2;
			return true;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.SByte;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return this;
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return this;
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "SByte", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IAdditionOperators<sbyte, sbyte, sbyte>.op_Addition(sbyte left, sbyte right)
		{
			return (sbyte)(left + right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBinaryInteger<sbyte>.LeadingZeroCount(sbyte value)
		{
			return (sbyte)(BitOperations.LeadingZeroCount((byte)value) - 24);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBinaryInteger<sbyte>.PopCount(sbyte value)
		{
			return (sbyte)BitOperations.PopCount((byte)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBinaryInteger<sbyte>.RotateLeft(sbyte value, int rotateAmount)
		{
			return (sbyte)((value << (rotateAmount & 7)) | ((byte)value >> ((8 - rotateAmount) & 7)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBinaryInteger<sbyte>.RotateRight(sbyte value, int rotateAmount)
		{
			return (sbyte)(((byte)value >> (rotateAmount & 7)) | (value << ((8 - rotateAmount) & 7)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBinaryInteger<sbyte>.TrailingZeroCount(sbyte value)
		{
			return (sbyte)(BitOperations.TrailingZeroCount(value << 24) - 24);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<sbyte>.IsPow2(sbyte value)
		{
			return BitOperations.IsPow2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBinaryNumber<sbyte>.Log2(sbyte value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return (sbyte)BitOperations.Log2((byte)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBitwiseOperators<sbyte, sbyte, sbyte>.op_BitwiseAnd(sbyte left, sbyte right)
		{
			return (sbyte)(left & right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBitwiseOperators<sbyte, sbyte, sbyte>.op_BitwiseOr(sbyte left, sbyte right)
		{
			return (sbyte)(left | right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBitwiseOperators<sbyte, sbyte, sbyte>.op_ExclusiveOr(sbyte left, sbyte right)
		{
			return (sbyte)(left ^ right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IBitwiseOperators<sbyte, sbyte, sbyte>.op_OnesComplement(sbyte value)
		{
			return (sbyte)(~value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<sbyte, sbyte>.op_LessThan(sbyte left, sbyte right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<sbyte, sbyte>.op_LessThanOrEqual(sbyte left, sbyte right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<sbyte, sbyte>.op_GreaterThan(sbyte left, sbyte right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<sbyte, sbyte>.op_GreaterThanOrEqual(sbyte left, sbyte right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IDecrementOperators<sbyte>.op_Decrement(sbyte value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IDivisionOperators<sbyte, sbyte, sbyte>.op_Division(sbyte left, sbyte right)
		{
			return (sbyte)(left / right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<sbyte, sbyte>.op_Equality(sbyte left, sbyte right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<sbyte, sbyte>.op_Inequality(sbyte left, sbyte right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IIncrementOperators<sbyte>.op_Increment(sbyte value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IModulusOperators<sbyte, sbyte, sbyte>.op_Modulus(sbyte left, sbyte right)
		{
			return (sbyte)(left % right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IMultiplyOperators<sbyte, sbyte, sbyte>.op_Multiply(sbyte left, sbyte right)
		{
			return (sbyte)(left * right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Abs(sbyte value)
		{
			return Math.Abs(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Clamp(sbyte value, sbyte min, sbyte max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Create<TOther>(TOther value)
		{
			checked
			{
				if (typeof(TOther) == typeof(byte))
				{
					return (sbyte)(byte)(object)value;
				}
				if (typeof(TOther) == typeof(char))
				{
					return (sbyte)(char)(object)value;
				}
				if (typeof(TOther) == typeof(decimal))
				{
					return (sbyte)(decimal)(object)value;
				}
				if (typeof(TOther) == typeof(double))
				{
					return (sbyte)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (sbyte)(short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (sbyte)(int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (sbyte)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (sbyte)(nint)(IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (sbyte)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (sbyte)(ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (sbyte)(uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (sbyte)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (sbyte)(nuint)(UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				byte b = (byte)(object)value;
				if (b <= 127)
				{
					return (sbyte)b;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(char))
			{
				char c = (char)(object)value;
				if (c <= '\u007f')
				{
					return (sbyte)c;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 127m))
				{
					if (!(num < -128m))
					{
						return (sbyte)num;
					}
					return sbyte.MinValue;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 127.0))
				{
					if (!(num2 < -128.0))
					{
						return (sbyte)num2;
					}
					return sbyte.MinValue;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 <= 127)
				{
					if (num3 >= -128)
					{
						return (sbyte)num3;
					}
					return sbyte.MinValue;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 <= 127)
				{
					if (num4 >= -128)
					{
						return (sbyte)num4;
					}
					return sbyte.MinValue;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 <= 127)
				{
					if (num5 >= -128)
					{
						return (sbyte)num5;
					}
					return sbyte.MinValue;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr <= 127)
				{
					if ((nint)intPtr >= -128)
					{
						return (sbyte)(nint)intPtr;
					}
					return sbyte.MinValue;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (!(num6 > 127f))
				{
					if (!(num6 < -128f))
					{
						return (sbyte)num6;
					}
					return sbyte.MinValue;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				ushort num7 = (ushort)(object)value;
				if (num7 <= 127)
				{
					return (sbyte)num7;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num8 = (uint)(object)value;
				if ((long)num8 <= 127L)
				{
					return (sbyte)num8;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num9 = (ulong)(object)value;
				if (num9 <= 127)
				{
					return (sbyte)num9;
				}
				return sbyte.MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr <= 127)
				{
					return (sbyte)(nuint)uIntPtr;
				}
				return sbyte.MaxValue;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (sbyte)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (sbyte)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (sbyte)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (sbyte)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (sbyte)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (sbyte)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (sbyte)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (sbyte)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (sbyte)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (sbyte)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (sbyte)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (sbyte)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (sbyte)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (sbyte Quotient, sbyte Remainder) INumber<sbyte>.DivRem(sbyte left, sbyte right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Max(sbyte x, sbyte y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Min(sbyte x, sbyte y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte INumber<sbyte>.Sign(sbyte value)
		{
			return (sbyte)Math.Sign(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<sbyte>.TryCreate<TOther>(TOther value, out sbyte result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				byte b = (byte)(object)value;
				if (b > 127)
				{
					result = 0;
					return false;
				}
				result = (sbyte)b;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				char c = (char)(object)value;
				if (c > '\u007f')
				{
					result = 0;
					return false;
				}
				result = (sbyte)c;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < -128m || num > 127m)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < -128.0 || num2 > 127.0)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 < -128 || num3 > 127)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num3;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 < -128 || num4 > 127)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num4;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 < -128 || num5 > 127)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num5;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < -128 || (nint)intPtr > 127)
				{
					result = 0;
					return false;
				}
				result = (sbyte)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (num6 < -128f || num6 > 127f)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num6;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				ushort num7 = (ushort)(object)value;
				if (num7 > 127)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num7;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num8 = (uint)(object)value;
				if ((long)num8 > 127L)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num8;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num9 = (ulong)(object)value;
				if (num9 > 127)
				{
					result = 0;
					return false;
				}
				result = (sbyte)num9;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr > 127)
				{
					result = 0;
					return false;
				}
				result = (sbyte)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<sbyte>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out sbyte result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<sbyte>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out sbyte result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IParseable<sbyte>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<sbyte>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out sbyte result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IShiftOperators<sbyte, sbyte>.op_LeftShift(sbyte value, int shiftAmount)
		{
			return (sbyte)(value << shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IShiftOperators<sbyte, sbyte>.op_RightShift(sbyte value, int shiftAmount)
		{
			return (sbyte)(value >> shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte ISpanParseable<sbyte>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<sbyte>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out sbyte result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte ISubtractionOperators<sbyte, sbyte, sbyte>.op_Subtraction(sbyte left, sbyte right)
		{
			return (sbyte)(left - right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IUnaryNegationOperators<sbyte, sbyte>.op_UnaryNegation(sbyte value)
		{
			return (sbyte)(-value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static sbyte IUnaryPlusOperators<sbyte, sbyte>.op_UnaryPlus(sbyte value)
		{
			return value;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Delegate, Inherited = false)]
	public sealed class SerializableAttribute : Attribute
	{
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct Single : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<float>, IEquatable<float>, IBinaryFloatingPoint<float>, IBinaryNumber<float>, IBitwiseOperators<float, float, float>, INumber<float>, IAdditionOperators<float, float, float>, IAdditiveIdentity<float, float>, IComparisonOperators<float, float>, IEqualityOperators<float, float>, IDecrementOperators<float>, IDivisionOperators<float, float, float>, IIncrementOperators<float>, IModulusOperators<float, float, float>, IMultiplicativeIdentity<float, float>, IMultiplyOperators<float, float, float>, ISpanParseable<float>, IParseable<float>, ISubtractionOperators<float, float, float>, IUnaryNegationOperators<float, float>, IUnaryPlusOperators<float, float>, IFloatingPoint<float>, ISignedNumber<float>, IMinMaxValue<float>
	{
		private readonly float m_value;

		public const float MinValue = -3.4028235E+38f;

		public const float Epsilon = 1E-45f;

		public const float MaxValue = 3.4028235E+38f;

		public const float PositiveInfinity = 1f / 0f;

		public const float NegativeInfinity = -1f / 0f;

		public const float NaN = 0f / 0f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IAdditiveIdentity<float, float>.AdditiveIdentity => 0f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.E => (float)Math.E;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Epsilon => float.Epsilon;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.NaN => float.NaN;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.NegativeInfinity => float.NegativeInfinity;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.NegativeZero => -0f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Pi => (float)Math.PI;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.PositiveInfinity => float.PositiveInfinity;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Tau => (float)Math.PI * 2f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IMinMaxValue<float>.MinValue => float.MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IMinMaxValue<float>.MaxValue => float.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IMultiplicativeIdentity<float, float>.MultiplicativeIdentity => 1f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.One => 1f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Zero => 0f;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float ISignedNumber<float>.NegativeOne => -1f;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsFinite(float f)
		{
			int num = BitConverter.SingleToInt32Bits(f);
			return (num & 0x7FFFFFFF) < 2139095040;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsInfinity(float f)
		{
			int num = BitConverter.SingleToInt32Bits(f);
			return (num & 0x7FFFFFFF) == 2139095040;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsNaN(float f)
		{
			return f != f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsNegative(float f)
		{
			return BitConverter.SingleToInt32Bits(f) < 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsNegativeInfinity(float f)
		{
			return f == float.NegativeInfinity;
		}

		[NonVersionable]
		public static bool IsNormal(float f)
		{
			int num = BitConverter.SingleToInt32Bits(f);
			num &= 0x7FFFFFFF;
			if (num < 2139095040 && num != 0)
			{
				return (num & 0x7F800000) != 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[NonVersionable]
		public static bool IsPositiveInfinity(float f)
		{
			return f == float.PositiveInfinity;
		}

		[NonVersionable]
		public static bool IsSubnormal(float f)
		{
			int num = BitConverter.SingleToInt32Bits(f);
			num &= 0x7FFFFFFF;
			if (num < 2139095040 && num != 0)
			{
				return (num & 0x7F800000) == 0;
			}
			return false;
		}

		internal static int ExtractExponentFromBits(uint bits)
		{
			return (int)((bits >> 23) & 0xFF);
		}

		internal static uint ExtractSignificandFromBits(uint bits)
		{
			return bits & 0x7FFFFFu;
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is float num)
			{
				if (this < num)
				{
					return -1;
				}
				if (this > num)
				{
					return 1;
				}
				if (this == num)
				{
					return 0;
				}
				if (IsNaN(this))
				{
					if (!IsNaN(num))
					{
						return -1;
					}
					return 0;
				}
				return 1;
			}
			throw new ArgumentException(SR.Arg_MustBeSingle);
		}

		public int CompareTo(float value)
		{
			if (this < value)
			{
				return -1;
			}
			if (this > value)
			{
				return 1;
			}
			if (this == value)
			{
				return 0;
			}
			if (IsNaN(this))
			{
				if (!IsNaN(value))
				{
					return -1;
				}
				return 0;
			}
			return 1;
		}

		[NonVersionable]
		public static bool operator ==(float left, float right)
		{
			return left == right;
		}

		[NonVersionable]
		public static bool operator !=(float left, float right)
		{
			return left != right;
		}

		[NonVersionable]
		public static bool operator <(float left, float right)
		{
			return left < right;
		}

		[NonVersionable]
		public static bool operator >(float left, float right)
		{
			return left > right;
		}

		[NonVersionable]
		public static bool operator <=(float left, float right)
		{
			return left <= right;
		}

		[NonVersionable]
		public static bool operator >=(float left, float right)
		{
			return left >= right;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is float num))
			{
				return false;
			}
			if (num == this)
			{
				return true;
			}
			if (IsNaN(num))
			{
				return IsNaN(this);
			}
			return false;
		}

		public bool Equals(float obj)
		{
			if (obj == this)
			{
				return true;
			}
			if (IsNaN(obj))
			{
				return IsNaN(this);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode()
		{
			int num = Unsafe.As<float, int>(ref Unsafe.AsRef(in m_value));
			if (((num - 1) & 0x7FFFFFFF) >= 2139095040)
			{
				num &= 0x7F800000;
			}
			return num;
		}

		public override string ToString()
		{
			return Number.FormatSingle(this, null, NumberFormatInfo.CurrentInfo);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.FormatSingle(this, null, NumberFormatInfo.GetInstance(provider));
		}

		public string ToString(string? format)
		{
			return Number.FormatSingle(this, format, NumberFormatInfo.CurrentInfo);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatSingle(this, format, NumberFormatInfo.GetInstance(provider));
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatSingle(this, format, NumberFormatInfo.GetInstance(provider), destination, out charsWritten);
		}

		public static float Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseSingle(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo);
		}

		public static float Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseSingle(s, style, NumberFormatInfo.CurrentInfo);
		}

		public static float Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseSingle(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider));
		}

		public static float Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseSingle(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static float Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Float | NumberStyles.AllowThousands, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			return Number.ParseSingle(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out float result)
		{
			if (s == null)
			{
				result = 0f;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out float result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out float result)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			if (s == null)
			{
				result = 0f;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out float result)
		{
			NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
			return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out float result)
		{
			return Number.TryParseSingle(s, style, info, out result);
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.Single;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Single", "Char"));
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return this;
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Single", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IAdditionOperators<float, float, float>.op_Addition(float left, float right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<float>.IsPow2(float value)
		{
			uint num = BitConverter.SingleToUInt32Bits(value);
			uint num2 = (num >> 23) & 0xFFu;
			uint num3 = num & 0x7FFFFFu;
			if (value > 0f && num2 != 0 && num2 != 255)
			{
				return num3 == 0;
			}
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IBinaryNumber<float>.Log2(float value)
		{
			return MathF.Log2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IBitwiseOperators<float, float, float>.op_BitwiseAnd(float left, float right)
		{
			uint value = BitConverter.SingleToUInt32Bits(left) & BitConverter.SingleToUInt32Bits(right);
			return BitConverter.UInt32BitsToSingle(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IBitwiseOperators<float, float, float>.op_BitwiseOr(float left, float right)
		{
			uint value = BitConverter.SingleToUInt32Bits(left) | BitConverter.SingleToUInt32Bits(right);
			return BitConverter.UInt32BitsToSingle(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IBitwiseOperators<float, float, float>.op_ExclusiveOr(float left, float right)
		{
			uint value = BitConverter.SingleToUInt32Bits(left) ^ BitConverter.SingleToUInt32Bits(right);
			return BitConverter.UInt32BitsToSingle(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IBitwiseOperators<float, float, float>.op_OnesComplement(float value)
		{
			uint value2 = ~BitConverter.SingleToUInt32Bits(value);
			return BitConverter.UInt32BitsToSingle(value2);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<float, float>.op_LessThan(float left, float right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<float, float>.op_LessThanOrEqual(float left, float right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<float, float>.op_GreaterThan(float left, float right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<float, float>.op_GreaterThanOrEqual(float left, float right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IDecrementOperators<float>.op_Decrement(float value)
		{
			return value -= 1f;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IDivisionOperators<float, float, float>.op_Division(float left, float right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<float, float>.op_Equality(float left, float right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<float, float>.op_Inequality(float left, float right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Acos(float x)
		{
			return MathF.Acos(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Acosh(float x)
		{
			return MathF.Acosh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Asin(float x)
		{
			return MathF.Asin(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Asinh(float x)
		{
			return MathF.Asinh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Atan(float x)
		{
			return MathF.Atan(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Atan2(float y, float x)
		{
			return MathF.Atan2(y, x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Atanh(float x)
		{
			return MathF.Atanh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.BitIncrement(float x)
		{
			return MathF.BitIncrement(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.BitDecrement(float x)
		{
			return MathF.BitDecrement(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Cbrt(float x)
		{
			return MathF.Cbrt(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Ceiling(float x)
		{
			return MathF.Ceiling(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.CopySign(float x, float y)
		{
			return MathF.CopySign(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Cos(float x)
		{
			return MathF.Cos(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Cosh(float x)
		{
			return MathF.Cosh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Exp(float x)
		{
			return MathF.Exp(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Floor(float x)
		{
			return MathF.Floor(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.FusedMultiplyAdd(float left, float right, float addend)
		{
			return MathF.FusedMultiplyAdd(left, right, addend);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.IEEERemainder(float left, float right)
		{
			return MathF.IEEERemainder(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TInteger IFloatingPoint<float>.ILogB<TInteger>(float x)
		{
			return TInteger.Create(MathF.ILogB(x));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Log(float x)
		{
			return MathF.Log(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Log(float x, float newBase)
		{
			return MathF.Log(x, newBase);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Log2(float x)
		{
			return MathF.Log2(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Log10(float x)
		{
			return MathF.Log10(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.MaxMagnitude(float x, float y)
		{
			return MathF.MaxMagnitude(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.MinMagnitude(float x, float y)
		{
			return MathF.MinMagnitude(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Pow(float x, float y)
		{
			return MathF.Pow(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Round(float x)
		{
			return MathF.Round(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Round<TInteger>(float x, TInteger digits)
		{
			return MathF.Round(x, int.Create(digits));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Round(float x, MidpointRounding mode)
		{
			return MathF.Round(x, mode);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Round<TInteger>(float x, TInteger digits, MidpointRounding mode)
		{
			return MathF.Round(x, int.Create(digits), mode);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.ScaleB<TInteger>(float x, TInteger n)
		{
			return MathF.ScaleB(x, int.Create(n));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Sin(float x)
		{
			return MathF.Sin(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Sinh(float x)
		{
			return MathF.Sinh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Sqrt(float x)
		{
			return MathF.Sqrt(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Tan(float x)
		{
			return MathF.Tan(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Tanh(float x)
		{
			return MathF.Tanh(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IFloatingPoint<float>.Truncate(float x)
		{
			return MathF.Truncate(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<float>.IsFinite(float x)
		{
			return IsFinite(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<float>.IsInfinity(float x)
		{
			return IsInfinity(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<float>.IsNaN(float x)
		{
			return IsNaN(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<float>.IsNegative(float x)
		{
			return IsNegative(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<float>.IsNegativeInfinity(float x)
		{
			return IsNegativeInfinity(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<float>.IsNormal(float x)
		{
			return IsNormal(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<float>.IsPositiveInfinity(float x)
		{
			return IsPositiveInfinity(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IFloatingPoint<float>.IsSubnormal(float x)
		{
			return IsSubnormal(x);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IIncrementOperators<float>.op_Increment(float value)
		{
			return value += 1f;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IModulusOperators<float, float, float>.op_Modulus(float left, float right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IMultiplyOperators<float, float, float>.op_Multiply(float left, float right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Abs(float value)
		{
			return MathF.Abs(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Clamp(float value, float min, float max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (float)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (float)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (nint)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (float)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (float)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (nint)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (int)(byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (int)(char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (float)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (float)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (int)(ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (nint)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0f;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (float Quotient, float Remainder) INumber<float>.DivRem(float left, float right)
		{
			return (left / right, left % right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Max(float x, float y)
		{
			return MathF.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Min(float x, float y)
		{
			return MathF.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float INumber<float>.Sign(float value)
		{
			return MathF.Sign(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<float>.TryCreate<TOther>(TOther value, out float result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (int)(byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (int)(char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				result = (float)(decimal)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				result = (float)(double)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				result = (short)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				result = (int)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				result = (long)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				result = (nint)(IntPtr)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				result = (sbyte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				result = (float)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (int)(ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				result = (uint)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				result = (ulong)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				result = (nint)(nuint)(UIntPtr)(object)value;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0f;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<float>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out float result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<float>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out float result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IParseable<float>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<float>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out float result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float ISpanParseable<float>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<float>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out float result)
		{
			return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float ISubtractionOperators<float, float, float>.op_Subtraction(float left, float right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IUnaryNegationOperators<float, float>.op_UnaryNegation(float value)
		{
			return 0f - value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static float IUnaryPlusOperators<float, float>.op_UnaryPlus(float value)
		{
			return value;
		}
	}
	[DebuggerTypeProxy(typeof(SpanDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	[NonVersionable]
	public readonly ref struct Span<T>
	{
		public ref struct Enumerator
		{
			private readonly Span<T> _span;

			private int _index;

			public ref T Current
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return ref _span[_index];
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal Enumerator(Span<T> span)
			{
				_span = span;
				_index = -1;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool MoveNext()
			{
				int num = _index + 1;
				if (num < _span.Length)
				{
					_index = num;
					return true;
				}
				return false;
			}
		}

		internal readonly ByReference<T> _pointer;

		private readonly int _length;

		public ref T this[int index]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[Intrinsic]
			[NonVersionable]
			get
			{
				if ((uint)index >= (uint)_length)
				{
					ThrowHelper.ThrowIndexOutOfRangeException();
				}
				return ref Unsafe.Add(ref _pointer.Value, (nint)(uint)index);
			}
		}

		public int Length
		{
			[NonVersionable]
			get
			{
				return _length;
			}
		}

		public bool IsEmpty
		{
			[NonVersionable]
			get
			{
				return 0u >= (uint)_length;
			}
		}

		public static Span<T> Empty => default(Span<T>);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span(T[]? array)
		{
			if (array == null)
			{
				this = default(Span<T>);
				return;
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			_pointer = new ByReference<T>(ref MemoryMarshal.GetArrayDataReference(array));
			_length = array.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span(T[]? array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				this = default(Span<T>);
				return;
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_pointer = new ByReference<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start));
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public unsafe Span(void* pointer, int length)
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (length < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_pointer = new ByReference<T>(ref Unsafe.As<byte, T>(ref *(byte*)pointer));
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Span(ref T ptr, int length)
		{
			_pointer = new ByReference<T>(ref ptr);
			_length = length;
		}

		public static bool operator !=(Span<T> left, Span<T> right)
		{
			return !(left == right);
		}

		[Obsolete("Equals() on Span will always throw an exception. Use the equality operator instead.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object? obj)
		{
			throw new NotSupportedException(SR.NotSupported_CannotCallEqualsOnSpan);
		}

		[Obsolete("GetHashCode() on Span will always throw an exception.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			throw new NotSupportedException(SR.NotSupported_CannotCallGetHashCodeOnSpan);
		}

		public static implicit operator Span<T>(T[]? array)
		{
			return new Span<T>(array);
		}

		public static implicit operator Span<T>(ArraySegment<T> segment)
		{
			return new Span<T>(segment.Array, segment.Offset, segment.Count);
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public ref T GetPinnableReference()
		{
			ref T result = ref Unsafe.NullRef<T>();
			if (_length != 0)
			{
				result = ref _pointer.Value;
			}
			return ref result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe void Clear()
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				SpanHelpers.ClearWithReferences(ref Unsafe.As<T, IntPtr>(ref _pointer.Value), (nuint)(uint)_length * (nuint)(Unsafe.SizeOf<T>() / sizeof(UIntPtr)));
			}
			else
			{
				SpanHelpers.ClearWithoutReferences(ref Unsafe.As<T, byte>(ref _pointer.Value), (nuint)(uint)_length * (nuint)Unsafe.SizeOf<T>());
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Fill(T value)
		{
			if (Unsafe.SizeOf<T>() == 1)
			{
				Unsafe.InitBlockUnaligned(ref Unsafe.As<T, byte>(ref _pointer.Value), Unsafe.As<T, byte>(ref value), (uint)_length);
			}
			else
			{
				SpanHelpers.Fill(ref _pointer.Value, (uint)_length, value);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void CopyTo(Span<T> destination)
		{
			if ((uint)_length <= (uint)destination.Length)
			{
				Buffer.Memmove<T>(ref destination._pointer.Value, ref _pointer.Value, (uint)_length);
			}
			else
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
		}

		public bool TryCopyTo(Span<T> destination)
		{
			bool result = false;
			if ((uint)_length <= (uint)destination.Length)
			{
				Buffer.Memmove<T>(ref destination._pointer.Value, ref _pointer.Value, (uint)_length);
				result = true;
			}
			return result;
		}

		public static bool operator ==(Span<T> left, Span<T> right)
		{
			if (left._length == right._length)
			{
				return Unsafe.AreSame(ref left._pointer.Value, ref right._pointer.Value);
			}
			return false;
		}

		public static implicit operator ReadOnlySpan<T>(Span<T> span)
		{
			return new ReadOnlySpan<T>(ref span._pointer.Value, span._length);
		}

		public override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _pointer.Value), _length));
			}
			return $"System.Span<{typeof(T).Name}>[{_length}]";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span<T> Slice(int start)
		{
			if ((uint)start > (uint)_length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new Span<T>(ref Unsafe.Add(ref _pointer.Value, (nint)(uint)start), _length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span<T> Slice(int start, int length)
		{
			if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new Span<T>(ref Unsafe.Add(ref _pointer.Value, (nint)(uint)start), length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public T[] ToArray()
		{
			if (_length == 0)
			{
				return Array.Empty<T>();
			}
			T[] array = new T[_length];
			Buffer.Memmove(ref MemoryMarshal.GetArrayDataReference(array), ref _pointer.Value, (uint)_length);
			return array;
		}
	}
	internal sealed class SpanDebugView<T>
	{
		private readonly T[] _array;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items => _array;

		public SpanDebugView(Span<T> span)
		{
			_array = span.ToArray();
		}

		public SpanDebugView(ReadOnlySpan<T> span)
		{
			_array = span.ToArray();
		}
	}
	internal static class SpanHelpers
	{
		internal readonly struct ComparerComparable<T, TComparer> : IComparable<T> where TComparer : IComparer<T>
		{
			private readonly T _value;

			private readonly TComparer _comparer;

			public ComparerComparable(T value, TComparer comparer)
			{
				_value = value;
				_comparer = comparer;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public int CompareTo(T other)
			{
				return _comparer.Compare(_value, other);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparable>(this ReadOnlySpan<T> span, TComparable comparable) where TComparable : IComparable<T>
		{
			if (comparable == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparable);
			}
			return BinarySearch(ref MemoryMarshal.GetReference(span), span.Length, comparable);
		}

		public static int BinarySearch<T, TComparable>(ref T spanStart, int length, TComparable comparable) where TComparable : IComparable<T>
		{
			int num = 0;
			int num2 = length - 1;
			while (num <= num2)
			{
				int num3 = num2 + num >>> 1;
				int num4 = comparable.CompareTo(Unsafe.Add(ref spanStart, num3));
				if (num4 == 0)
				{
					return num3;
				}
				if (num4 > 0)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return ~num;
		}

		public static int IndexOf(ref byte searchSpace, int searchSpaceLength, ref byte value, int valueLength)
		{
			if (valueLength == 0)
			{
				return 0;
			}
			byte value2 = value;
			ref byte second = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = searchSpaceLength - num;
			int num3 = 0;
			while (num2 > 0)
			{
				int num4 = IndexOf(ref Unsafe.Add(ref searchSpace, num3), value2, num2);
				if (num4 == -1)
				{
					break;
				}
				num2 -= num4;
				num3 += num4;
				if (num2 <= 0)
				{
					break;
				}
				if (SequenceEqual(ref Unsafe.Add(ref searchSpace, num3 + 1), ref second, (nuint)num))
				{
					return num3;
				}
				num2--;
				num3++;
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static bool Contains(ref byte searchSpace, byte value, int length)
		{
			nuint num = 0u;
			nuint num2 = (uint)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				num2 = UnalignedCountVector(ref searchSpace);
			}
			while (true)
			{
				if (num2 >= 8)
				{
					num2 -= 8;
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 0) || value == Unsafe.AddByteOffset(ref searchSpace, num + 1) || value == Unsafe.AddByteOffset(ref searchSpace, num + 2) || value == Unsafe.AddByteOffset(ref searchSpace, num + 3) || value == Unsafe.AddByteOffset(ref searchSpace, num + 4) || value == Unsafe.AddByteOffset(ref searchSpace, num + 5) || value == Unsafe.AddByteOffset(ref searchSpace, num + 6) || value == Unsafe.AddByteOffset(ref searchSpace, num + 7))
					{
						break;
					}
					num += 8;
					continue;
				}
				if (num2 >= 4)
				{
					num2 -= 4;
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 0) || value == Unsafe.AddByteOffset(ref searchSpace, num + 1) || value == Unsafe.AddByteOffset(ref searchSpace, num + 2) || value == Unsafe.AddByteOffset(ref searchSpace, num + 3))
					{
						break;
					}
					num += 4;
				}
				while (num2 != 0)
				{
					num2--;
					if (value == Unsafe.AddByteOffset(ref searchSpace, num))
					{
						goto end_IL_00bd;
					}
					num++;
				}
				if (Vector.IsHardwareAccelerated && num < (uint)length)
				{
					num2 = ((uint)length - num) & (nuint)(~(Vector<byte>.Count - 1));
					Vector<byte> left = new Vector<byte>(value);
					for (; num2 > num; num += (nuint)Vector<byte>.Count)
					{
						Vector<byte> other = Vector.Equals(left, LoadVector(ref searchSpace, num));
						if (!Vector<byte>.Zero.Equals(other))
						{
							goto end_IL_00bd;
						}
					}
					if (num < (uint)length)
					{
						num2 = (uint)length - num;
						continue;
					}
				}
				return false;
				continue;
				end_IL_00bd:
				break;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public unsafe static int IndexOf(ref byte searchSpace, byte value, int length)
		{
			nuint num = 0u;
			nuint num2 = (uint)length;
			if (Sse2.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				if (length >= Vector128<byte>.Count * 2)
				{
					num2 = UnalignedCountVector128(ref searchSpace);
				}
			}
			else if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				num2 = UnalignedCountVector(ref searchSpace);
			}
			while (true)
			{
				if (num2 >= 8)
				{
					num2 -= 8;
					if (value == Unsafe.AddByteOffset(ref searchSpace, num))
					{
						goto IL_033c;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 1))
					{
						goto IL_033f;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 2))
					{
						goto IL_0345;
					}
					if (value != Unsafe.AddByteOffset(ref searchSpace, num + 3))
					{
						if (value != Unsafe.AddByteOffset(ref searchSpace, num + 4))
						{
							if (value != Unsafe.AddByteOffset(ref searchSpace, num + 5))
							{
								if (value != Unsafe.AddByteOffset(ref searchSpace, num + 6))
								{
									if (value == Unsafe.AddByteOffset(ref searchSpace, num + 7))
									{
										break;
									}
									num += 8;
									continue;
								}
								return (int)(num + 6);
							}
							return (int)(num + 5);
						}
						return (int)(num + 4);
					}
					goto IL_034b;
				}
				if (num2 >= 4)
				{
					num2 -= 4;
					if (value == Unsafe.AddByteOffset(ref searchSpace, num))
					{
						goto IL_033c;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 1))
					{
						goto IL_033f;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 2))
					{
						goto IL_0345;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 3))
					{
						goto IL_034b;
					}
					num += 4;
				}
				while (num2 != 0)
				{
					num2--;
					if (value != Unsafe.AddByteOffset(ref searchSpace, num))
					{
						num++;
						continue;
					}
					goto IL_033c;
				}
				if (Avx2.IsSupported)
				{
					if (num < (uint)length)
					{
						if ((((uint)Unsafe.AsPointer(ref searchSpace) + num) & (nuint)(Vector256<byte>.Count - 1)) != 0)
						{
							Vector128<byte> left = Vector128.Create(value);
							Vector128<byte> right = LoadVector128(ref searchSpace, num);
							int num3 = Sse2.MoveMask(Sse2.CompareEqual(left, right));
							if (num3 != 0)
							{
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num3));
							}
							num += (nuint)Vector128<byte>.Count;
						}
						num2 = GetByteVector256SpanLength(num, length);
						if (num2 > num)
						{
							Vector256<byte> left2 = Vector256.Create(value);
							do
							{
								Vector256<byte> right2 = LoadVector256(ref searchSpace, num);
								int num4 = Avx2.MoveMask(Avx2.CompareEqual(left2, right2));
								if (num4 == 0)
								{
									num += (nuint)Vector256<byte>.Count;
									continue;
								}
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num4));
							}
							while (num2 > num);
						}
						num2 = GetByteVector128SpanLength(num, length);
						if (num2 > num)
						{
							Vector128<byte> left3 = Vector128.Create(value);
							Vector128<byte> right3 = LoadVector128(ref searchSpace, num);
							int num5 = Sse2.MoveMask(Sse2.CompareEqual(left3, right3));
							if (num5 != 0)
							{
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num5));
							}
							num += (nuint)Vector128<byte>.Count;
						}
						if (num < (uint)length)
						{
							num2 = (uint)length - num;
							continue;
						}
					}
				}
				else if (Sse2.IsSupported)
				{
					if (num < (uint)length)
					{
						num2 = GetByteVector128SpanLength(num, length);
						Vector128<byte> left4 = Vector128.Create(value);
						for (; num2 > num; num += (nuint)Vector128<byte>.Count)
						{
							Vector128<byte> right4 = LoadVector128(ref searchSpace, num);
							int num6 = Sse2.MoveMask(Sse2.CompareEqual(left4, right4));
							if (num6 != 0)
							{
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num6));
							}
						}
						if (num < (uint)length)
						{
							num2 = (uint)length - num;
							continue;
						}
					}
				}
				else
				{
					if (AdvSimd.Arm64.IsSupported)
					{
					}
					if (Vector.IsHardwareAccelerated && num < (uint)length)
					{
						num2 = GetByteVectorSpanLength(num, length);
						Vector<byte> left5 = new Vector<byte>(value);
						for (; num2 > num; num += (nuint)Vector<byte>.Count)
						{
							Vector<byte> vector = Vector.Equals(left5, LoadVector(ref searchSpace, num));
							if (!Vector<byte>.Zero.Equals(vector))
							{
								return (int)num + LocateFirstFoundByte(vector);
							}
						}
						if (num < (uint)length)
						{
							num2 = (uint)length - num;
							continue;
						}
					}
				}
				return -1;
				IL_0345:
				return (int)(num + 2);
				IL_033f:
				return (int)(num + 1);
				IL_034b:
				return (int)(num + 3);
				IL_033c:
				return (int)num;
			}
			return (int)(num + 7);
		}

		public static int LastIndexOf(ref byte searchSpace, int searchSpaceLength, ref byte value, int valueLength)
		{
			if (valueLength == 0)
			{
				return searchSpaceLength;
			}
			byte value2 = value;
			ref byte second = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = 0;
			while (true)
			{
				int num3 = searchSpaceLength - num2 - num;
				if (num3 <= 0)
				{
					break;
				}
				int num4 = LastIndexOf(ref searchSpace, value2, num3);
				if (num4 == -1)
				{
					break;
				}
				if (SequenceEqual(ref Unsafe.Add(ref searchSpace, num4 + 1), ref second, (uint)num))
				{
					return num4;
				}
				num2 += num3 - num4;
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static int LastIndexOf(ref byte searchSpace, byte value, int length)
		{
			nuint num = (uint)length;
			nuint num2 = (uint)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				num2 = UnalignedCountVectorFromEnd(ref searchSpace, length);
			}
			while (true)
			{
				if (num2 >= 8)
				{
					num2 -= 8;
					num -= 8;
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 7))
					{
						break;
					}
					if (value != Unsafe.AddByteOffset(ref searchSpace, num + 6))
					{
						if (value != Unsafe.AddByteOffset(ref searchSpace, num + 5))
						{
							if (value != Unsafe.AddByteOffset(ref searchSpace, num + 4))
							{
								if (value != Unsafe.AddByteOffset(ref searchSpace, num + 3))
								{
									if (value != Unsafe.AddByteOffset(ref searchSpace, num + 2))
									{
										if (value != Unsafe.AddByteOffset(ref searchSpace, num + 1))
										{
											if (value != Unsafe.AddByteOffset(ref searchSpace, num))
											{
												continue;
											}
											goto IL_01ba;
										}
										goto IL_01bd;
									}
									goto IL_01c3;
								}
								goto IL_01c9;
							}
							return (int)(num + 4);
						}
						return (int)(num + 5);
					}
					return (int)(num + 6);
				}
				if (num2 >= 4)
				{
					num2 -= 4;
					num -= 4;
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 3))
					{
						goto IL_01c9;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 2))
					{
						goto IL_01c3;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, num + 1))
					{
						goto IL_01bd;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, num))
					{
						goto IL_01ba;
					}
				}
				while (num2 != 0)
				{
					num2--;
					num--;
					if (value != Unsafe.AddByteOffset(ref searchSpace, num))
					{
						continue;
					}
					goto IL_01ba;
				}
				if (Vector.IsHardwareAccelerated && num != 0)
				{
					num2 = num & (nuint)(~(Vector<byte>.Count - 1));
					Vector<byte> left = new Vector<byte>(value);
					while (num2 > (nuint)(Vector<byte>.Count - 1))
					{
						Vector<byte> vector = Vector.Equals(left, LoadVector(ref searchSpace, num - (nuint)Vector<byte>.Count));
						if (Vector<byte>.Zero.Equals(vector))
						{
							num -= (nuint)Vector<byte>.Count;
							num2 -= (nuint)Vector<byte>.Count;
							continue;
						}
						return (int)num - Vector<byte>.Count + LocateLastFoundByte(vector);
					}
					if (num != 0)
					{
						num2 = num;
						continue;
					}
				}
				return -1;
				IL_01ba:
				return (int)num;
				IL_01c3:
				return (int)(num + 2);
				IL_01c9:
				return (int)(num + 3);
				IL_01bd:
				return (int)(num + 1);
			}
			return (int)(num + 7);
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static int IndexOfAny(ref byte searchSpace, byte value0, byte value1, int length)
		{
			nuint num = 0u;
			nuint num2 = (uint)length;
			if (Sse2.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				nint num3 = (nint)length - (nint)Vector128<byte>.Count;
				if (num3 >= 0)
				{
					num2 = (nuint)num3;
					goto IL_0212;
				}
			}
			else if (Vector.IsHardwareAccelerated)
			{
				nint num4 = (nint)length - (nint)Vector<byte>.Count;
				if (num4 >= 0)
				{
					num2 = (nuint)num4;
					goto IL_0212;
				}
			}
			while (num2 >= 8)
			{
				num2 -= 8;
				uint num5 = Unsafe.AddByteOffset(ref searchSpace, num);
				if (value0 == num5 || value1 == num5)
				{
					goto IL_01e5;
				}
				num5 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
				if (value0 == num5 || value1 == num5)
				{
					goto IL_01e8;
				}
				num5 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
				if (value0 == num5 || value1 == num5)
				{
					goto IL_01ee;
				}
				num5 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
				if (value0 != num5 && value1 != num5)
				{
					num5 = Unsafe.AddByteOffset(ref searchSpace, num + 4);
					if (value0 != num5 && value1 != num5)
					{
						num5 = Unsafe.AddByteOffset(ref searchSpace, num + 5);
						if (value0 != num5 && value1 != num5)
						{
							num5 = Unsafe.AddByteOffset(ref searchSpace, num + 6);
							if (value0 != num5 && value1 != num5)
							{
								num5 = Unsafe.AddByteOffset(ref searchSpace, num + 7);
								if (value0 != num5 && value1 != num5)
								{
									num += 8;
									continue;
								}
								return (int)(num + 7);
							}
							return (int)(num + 6);
						}
						return (int)(num + 5);
					}
					return (int)(num + 4);
				}
				goto IL_01f4;
			}
			if (num2 >= 4)
			{
				num2 -= 4;
				uint num5 = Unsafe.AddByteOffset(ref searchSpace, num);
				if (value0 == num5 || value1 == num5)
				{
					goto IL_01e5;
				}
				num5 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
				if (value0 == num5 || value1 == num5)
				{
					goto IL_01e8;
				}
				num5 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
				if (value0 == num5 || value1 == num5)
				{
					goto IL_01ee;
				}
				num5 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
				if (value0 == num5 || value1 == num5)
				{
					goto IL_01f4;
				}
				num += 4;
			}
			while (num2 != 0)
			{
				uint num5 = Unsafe.AddByteOffset(ref searchSpace, num);
				if (value0 != num5 && value1 != num5)
				{
					num++;
					num2--;
					continue;
				}
				goto IL_01e5;
			}
			goto IL_01e3;
			IL_01ee:
			return (int)(num + 2);
			IL_03ec:
			Vector<byte> vector;
			num += (nuint)LocateFirstFoundByte(vector);
			goto IL_01e5;
			IL_01e3:
			return -1;
			IL_01e5:
			return (int)num;
			IL_033c:
			int num6;
			num += (nuint)BitOperations.TrailingZeroCount(num6);
			goto IL_01e5;
			IL_01e8:
			return (int)(num + 1);
			IL_0212:
			if (Sse2.IsSupported)
			{
				if (Avx2.IsSupported && num2 >= (nuint)Vector128<byte>.Count)
				{
					Vector256<byte> left = Vector256.Create(value0);
					Vector256<byte> left2 = Vector256.Create(value1);
					num2 -= (nuint)Vector128<byte>.Count;
					Vector256<byte> right;
					while (num2 > num)
					{
						right = LoadVector256(ref searchSpace, num);
						num6 = Avx2.MoveMask(Avx2.Or(Avx2.CompareEqual(left, right), Avx2.CompareEqual(left2, right)));
						if (num6 == 0)
						{
							num += (nuint)Vector256<byte>.Count;
							continue;
						}
						goto IL_033c;
					}
					right = LoadVector256(ref searchSpace, num2);
					num = num2;
					num6 = Avx2.MoveMask(Avx2.Or(Avx2.CompareEqual(left, right), Avx2.CompareEqual(left2, right)));
					if (num6 == 0)
					{
						goto IL_01e3;
					}
				}
				else
				{
					Vector128<byte> left3 = Vector128.Create(value0);
					Vector128<byte> left4 = Vector128.Create(value1);
					Vector128<byte> right2;
					while (num2 > num)
					{
						right2 = LoadVector128(ref searchSpace, num);
						num6 = Sse2.MoveMask(Sse2.Or(Sse2.CompareEqual(left3, right2), Sse2.CompareEqual(left4, right2)).AsByte());
						if (num6 == 0)
						{
							num += (nuint)Vector128<byte>.Count;
							continue;
						}
						goto IL_033c;
					}
					right2 = LoadVector128(ref searchSpace, num2);
					num = num2;
					num6 = Sse2.MoveMask(Sse2.Or(Sse2.CompareEqual(left3, right2), Sse2.CompareEqual(left4, right2)));
					if (num6 == 0)
					{
						goto IL_01e3;
					}
				}
				goto IL_033c;
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			if (!Vector.IsHardwareAccelerated)
			{
				goto IL_01e5;
			}
			Vector<byte> right3 = new Vector<byte>(value0);
			Vector<byte> right4 = new Vector<byte>(value1);
			while (num2 > num)
			{
				vector = LoadVector(ref searchSpace, num);
				vector = Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4));
				if (Vector<byte>.Zero.Equals(vector))
				{
					num += (nuint)Vector<byte>.Count;
					continue;
				}
				goto IL_03ec;
			}
			vector = LoadVector(ref searchSpace, num2);
			num = num2;
			vector = Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4));
			if (Vector<byte>.Zero.Equals(vector))
			{
				goto IL_01e3;
			}
			goto IL_03ec;
			IL_01f4:
			return (int)(num + 3);
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static int IndexOfAny(ref byte searchSpace, byte value0, byte value1, byte value2, int length)
		{
			nuint num = 0u;
			nuint num2 = (uint)length;
			if (Sse2.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				if (length >= Vector128<byte>.Count * 2)
				{
					num2 = UnalignedCountVector128(ref searchSpace);
				}
			}
			else if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				num2 = UnalignedCountVector(ref searchSpace);
			}
			while (true)
			{
				if (num2 >= 8)
				{
					num2 -= 8;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_0504;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_0507;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_050d;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
					if (value0 != num3 && value1 != num3 && value2 != num3)
					{
						num3 = Unsafe.AddByteOffset(ref searchSpace, num + 4);
						if (value0 != num3 && value1 != num3 && value2 != num3)
						{
							num3 = Unsafe.AddByteOffset(ref searchSpace, num + 5);
							if (value0 != num3 && value1 != num3 && value2 != num3)
							{
								num3 = Unsafe.AddByteOffset(ref searchSpace, num + 6);
								if (value0 != num3 && value1 != num3 && value2 != num3)
								{
									num3 = Unsafe.AddByteOffset(ref searchSpace, num + 7);
									if (value0 == num3 || value1 == num3 || value2 == num3)
									{
										break;
									}
									num += 8;
									continue;
								}
								return (int)(num + 6);
							}
							return (int)(num + 5);
						}
						return (int)(num + 4);
					}
					goto IL_0513;
				}
				if (num2 >= 4)
				{
					num2 -= 4;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_0504;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_0507;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_050d;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_0513;
					}
					num += 4;
				}
				while (num2 != 0)
				{
					num2--;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
					if (value0 != num3 && value1 != num3 && value2 != num3)
					{
						num++;
						continue;
					}
					goto IL_0504;
				}
				if (Avx2.IsSupported)
				{
					if (num < (uint)length)
					{
						num2 = GetByteVector256SpanLength(num, length);
						if (num2 > num)
						{
							Vector256<byte> left = Vector256.Create(value0);
							Vector256<byte> left2 = Vector256.Create(value1);
							Vector256<byte> left3 = Vector256.Create(value2);
							do
							{
								Vector256<byte> right = LoadVector256(ref searchSpace, num);
								Vector256<byte> left4 = Avx2.CompareEqual(left, right);
								Vector256<byte> right2 = Avx2.CompareEqual(left2, right);
								Vector256<byte> right3 = Avx2.CompareEqual(left3, right);
								int num4 = Avx2.MoveMask(Avx2.Or(Avx2.Or(left4, right2), right3));
								if (num4 == 0)
								{
									num += (nuint)Vector256<byte>.Count;
									continue;
								}
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num4));
							}
							while (num2 > num);
						}
						num2 = GetByteVector128SpanLength(num, length);
						if (num2 > num)
						{
							Vector128<byte> left5 = Vector128.Create(value0);
							Vector128<byte> left6 = Vector128.Create(value1);
							Vector128<byte> left7 = Vector128.Create(value2);
							Vector128<byte> right4 = LoadVector128(ref searchSpace, num);
							Vector128<byte> left8 = Sse2.CompareEqual(left5, right4);
							Vector128<byte> right5 = Sse2.CompareEqual(left6, right4);
							Vector128<byte> right6 = Sse2.CompareEqual(left7, right4);
							int num5 = Sse2.MoveMask(Sse2.Or(Sse2.Or(left8, right5), right6));
							if (num5 != 0)
							{
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num5));
							}
							num += (nuint)Vector128<byte>.Count;
						}
						if (num < (uint)length)
						{
							num2 = (uint)length - num;
							continue;
						}
					}
				}
				else if (Sse2.IsSupported)
				{
					if (num < (uint)length)
					{
						num2 = GetByteVector128SpanLength(num, length);
						Vector128<byte> left9 = Vector128.Create(value0);
						Vector128<byte> left10 = Vector128.Create(value1);
						Vector128<byte> left11 = Vector128.Create(value2);
						for (; num2 > num; num += (nuint)Vector128<byte>.Count)
						{
							Vector128<byte> right7 = LoadVector128(ref searchSpace, num);
							Vector128<byte> left12 = Sse2.CompareEqual(left9, right7);
							Vector128<byte> right8 = Sse2.CompareEqual(left10, right7);
							Vector128<byte> right9 = Sse2.CompareEqual(left11, right7);
							int num6 = Sse2.MoveMask(Sse2.Or(Sse2.Or(left12, right8), right9));
							if (num6 != 0)
							{
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num6));
							}
						}
						if (num < (uint)length)
						{
							num2 = (uint)length - num;
							continue;
						}
					}
				}
				else
				{
					if (AdvSimd.Arm64.IsSupported)
					{
					}
					if (Vector.IsHardwareAccelerated && num < (uint)length)
					{
						num2 = GetByteVectorSpanLength(num, length);
						Vector<byte> right10 = new Vector<byte>(value0);
						Vector<byte> right11 = new Vector<byte>(value1);
						Vector<byte> right12 = new Vector<byte>(value2);
						for (; num2 > num; num += (nuint)Vector<byte>.Count)
						{
							Vector<byte> left13 = LoadVector(ref searchSpace, num);
							Vector<byte> vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(left13, right10), Vector.Equals(left13, right11)), Vector.Equals(left13, right12));
							if (!Vector<byte>.Zero.Equals(vector))
							{
								return (int)num + LocateFirstFoundByte(vector);
							}
						}
						if (num < (uint)length)
						{
							num2 = (uint)length - num;
							continue;
						}
					}
				}
				return -1;
				IL_0507:
				return (int)(num + 1);
				IL_0513:
				return (int)(num + 3);
				IL_050d:
				return (int)(num + 2);
				IL_0504:
				return (int)num;
			}
			return (int)(num + 7);
		}

		public static int LastIndexOfAny(ref byte searchSpace, byte value0, byte value1, int length)
		{
			nuint num = (uint)length;
			nuint num2 = (uint)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				num2 = UnalignedCountVectorFromEnd(ref searchSpace, length);
			}
			while (true)
			{
				if (num2 >= 8)
				{
					num2 -= 8;
					num -= 8;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num + 7);
					if (value0 == num3 || value1 == num3)
					{
						break;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 6);
					if (value0 != num3 && value1 != num3)
					{
						num3 = Unsafe.AddByteOffset(ref searchSpace, num + 5);
						if (value0 != num3 && value1 != num3)
						{
							num3 = Unsafe.AddByteOffset(ref searchSpace, num + 4);
							if (value0 != num3 && value1 != num3)
							{
								num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
								if (value0 != num3 && value1 != num3)
								{
									num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
									if (value0 != num3 && value1 != num3)
									{
										num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
										if (value0 != num3 && value1 != num3)
										{
											num3 = Unsafe.AddByteOffset(ref searchSpace, num);
											if (value0 != num3 && value1 != num3)
											{
												continue;
											}
											goto IL_027c;
										}
										goto IL_027f;
									}
									goto IL_0285;
								}
								goto IL_028b;
							}
							return (int)(num + 4);
						}
						return (int)(num + 5);
					}
					return (int)(num + 6);
				}
				if (num2 >= 4)
				{
					num2 -= 4;
					num -= 4;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
					if (value0 == num3 || value1 == num3)
					{
						goto IL_028b;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
					if (value0 == num3 || value1 == num3)
					{
						goto IL_0285;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
					if (value0 == num3 || value1 == num3)
					{
						goto IL_027f;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num);
					if (value0 == num3 || value1 == num3)
					{
						goto IL_027c;
					}
				}
				while (num2 != 0)
				{
					num2--;
					num--;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
					if (value0 != num3 && value1 != num3)
					{
						continue;
					}
					goto IL_027c;
				}
				if (Vector.IsHardwareAccelerated && num != 0)
				{
					num2 = num & (nuint)(~(Vector<byte>.Count - 1));
					Vector<byte> right = new Vector<byte>(value0);
					Vector<byte> right2 = new Vector<byte>(value1);
					while (num2 > (nuint)(Vector<byte>.Count - 1))
					{
						Vector<byte> left = LoadVector(ref searchSpace, num - (nuint)Vector<byte>.Count);
						Vector<byte> vector = Vector.BitwiseOr(Vector.Equals(left, right), Vector.Equals(left, right2));
						if (Vector<byte>.Zero.Equals(vector))
						{
							num -= (nuint)Vector<byte>.Count;
							num2 -= (nuint)Vector<byte>.Count;
							continue;
						}
						return (int)num - Vector<byte>.Count + LocateLastFoundByte(vector);
					}
					if (num != 0)
					{
						num2 = num;
						continue;
					}
				}
				return -1;
				IL_027c:
				return (int)num;
				IL_028b:
				return (int)(num + 3);
				IL_027f:
				return (int)(num + 1);
				IL_0285:
				return (int)(num + 2);
			}
			return (int)(num + 7);
		}

		public static int LastIndexOfAny(ref byte searchSpace, byte value0, byte value1, byte value2, int length)
		{
			nuint num = (uint)length;
			nuint num2 = (uint)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				num2 = UnalignedCountVectorFromEnd(ref searchSpace, length);
			}
			while (true)
			{
				if (num2 >= 8)
				{
					num2 -= 8;
					num -= 8;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num + 7);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						break;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 6);
					if (value0 != num3 && value1 != num3 && value2 != num3)
					{
						num3 = Unsafe.AddByteOffset(ref searchSpace, num + 5);
						if (value0 != num3 && value1 != num3 && value2 != num3)
						{
							num3 = Unsafe.AddByteOffset(ref searchSpace, num + 4);
							if (value0 != num3 && value1 != num3 && value2 != num3)
							{
								num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
								if (value0 != num3 && value1 != num3 && value2 != num3)
								{
									num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
									if (value0 != num3 && value1 != num3 && value2 != num3)
									{
										num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
										if (value0 != num3 && value1 != num3 && value2 != num3)
										{
											num3 = Unsafe.AddByteOffset(ref searchSpace, num);
											if (value0 != num3 && value1 != num3 && value2 != num3)
											{
												continue;
											}
											goto IL_0310;
										}
										goto IL_0313;
									}
									goto IL_0319;
								}
								goto IL_031f;
							}
							return (int)(num + 4);
						}
						return (int)(num + 5);
					}
					return (int)(num + 6);
				}
				if (num2 >= 4)
				{
					num2 -= 4;
					num -= 4;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num + 3);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_031f;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 2);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_0319;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num + 1);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_0313;
					}
					num3 = Unsafe.AddByteOffset(ref searchSpace, num);
					if (value0 == num3 || value1 == num3 || value2 == num3)
					{
						goto IL_0310;
					}
				}
				while (num2 != 0)
				{
					num2--;
					num--;
					uint num3 = Unsafe.AddByteOffset(ref searchSpace, num);
					if (value0 != num3 && value1 != num3 && value2 != num3)
					{
						continue;
					}
					goto IL_0310;
				}
				if (Vector.IsHardwareAccelerated && num != 0)
				{
					num2 = num & (nuint)(~(Vector<byte>.Count - 1));
					Vector<byte> right = new Vector<byte>(value0);
					Vector<byte> right2 = new Vector<byte>(value1);
					Vector<byte> right3 = new Vector<byte>(value2);
					while (num2 > (nuint)(Vector<byte>.Count - 1))
					{
						Vector<byte> left = LoadVector(ref searchSpace, num - (nuint)Vector<byte>.Count);
						Vector<byte> vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(left, right), Vector.Equals(left, right2)), Vector.Equals(left, right3));
						if (Vector<byte>.Zero.Equals(vector))
						{
							num -= (nuint)Vector<byte>.Count;
							num2 -= (nuint)Vector<byte>.Count;
							continue;
						}
						return (int)num - Vector<byte>.Count + LocateLastFoundByte(vector);
					}
					if (num != 0)
					{
						num2 = num;
						continue;
					}
				}
				return -1;
				IL_0310:
				return (int)num;
				IL_031f:
				return (int)(num + 3);
				IL_0319:
				return (int)(num + 2);
				IL_0313:
				return (int)(num + 1);
			}
			return (int)(num + 7);
		}

		public unsafe static bool SequenceEqual(ref byte first, ref byte second, nuint length)
		{
			if (length < (nuint)sizeof(UIntPtr))
			{
				uint num = 0u;
				nuint num2 = length & 2;
				if (num2 != 0)
				{
					num = LoadUShort(ref first);
					num -= LoadUShort(ref second);
				}
				if ((length & 1) != 0)
				{
					num |= (uint)(Unsafe.AddByteOffset(ref first, num2) - Unsafe.AddByteOffset(ref second, num2));
				}
				return num == 0;
			}
			if (Unsafe.AreSame(ref first, ref second))
			{
				goto IL_0052;
			}
			nuint num4;
			nuint num6;
			nuint num8;
			Vector256<byte> value;
			Vector128<byte> value2;
			if (Sse2.IsSupported)
			{
				if (Avx2.IsSupported && length >= (nuint)Vector256<byte>.Count)
				{
					nuint num3 = 0u;
					num4 = length - (nuint)Vector256<byte>.Count;
					if (num4 == 0)
					{
						goto IL_00b3;
					}
					while (true)
					{
						value = Avx2.CompareEqual(LoadVector256(ref first, num3), LoadVector256(ref second, num3));
						if (Avx2.MoveMask(value) != -1)
						{
							break;
						}
						num3 += (nuint)Vector256<byte>.Count;
						if (num4 > num3)
						{
							continue;
						}
						goto IL_00b3;
					}
				}
				else
				{
					if (length < 16)
					{
						goto IL_01bd;
					}
					nuint num5 = 0u;
					num6 = length - 16;
					if (num6 == 0)
					{
						goto IL_0128;
					}
					while (true)
					{
						value2 = Sse2.CompareEqual(LoadVector128(ref first, num5), LoadVector128(ref second, num5));
						if (Sse2.MoveMask(value2) != 65535)
						{
							break;
						}
						num5 += 16;
						if (num6 > num5)
						{
							continue;
						}
						goto IL_0128;
					}
				}
			}
			else
			{
				if (!Vector.IsHardwareAccelerated || length < (nuint)Vector<byte>.Count)
				{
					goto IL_01bd;
				}
				nuint num7 = 0u;
				num8 = length - (nuint)Vector<byte>.Count;
				if (num8 == 0)
				{
					goto IL_01a1;
				}
				while (!(LoadVector(ref first, num7) != LoadVector(ref second, num7)))
				{
					num7 += (nuint)Vector<byte>.Count;
					if (num8 > num7)
					{
						continue;
					}
					goto IL_01a1;
				}
			}
			goto IL_020e;
			IL_01a1:
			if (LoadVector(ref first, num8) == LoadVector(ref second, num8))
			{
				goto IL_0052;
			}
			goto IL_020e;
			IL_01f6:
			nuint num9;
			return LoadNUInt(ref first, num9) == LoadNUInt(ref second, num9);
			IL_01bd:
			nuint num10 = 0u;
			num9 = length - (nuint)sizeof(UIntPtr);
			if (num9 == 0)
			{
				goto IL_01f6;
			}
			while (LoadNUInt(ref first, num10) == LoadNUInt(ref second, num10))
			{
				num10 += (nuint)sizeof(UIntPtr);
				if (num9 > num10)
				{
					continue;
				}
				goto IL_01f6;
			}
			goto IL_020e;
			IL_00b3:
			value = Avx2.CompareEqual(LoadVector256(ref first, num4), LoadVector256(ref second, num4));
			if (Avx2.MoveMask(value) == -1)
			{
				goto IL_0052;
			}
			goto IL_020e;
			IL_0052:
			return true;
			IL_0128:
			value2 = Sse2.CompareEqual(LoadVector128(ref first, num6), LoadVector128(ref second, num6));
			if (Sse2.MoveMask(value2) == 65535)
			{
				goto IL_0052;
			}
			goto IL_020e;
			IL_020e:
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateFirstFoundByte(Vector<byte> match)
		{
			Vector<ulong> vector = Vector.AsVectorUInt64(match);
			ulong num = 0uL;
			int i;
			for (i = 0; i < Vector<ulong>.Count; i++)
			{
				num = vector[i];
				if (num != 0L)
				{
					break;
				}
			}
			return i * 8 + LocateFirstFoundByte(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public unsafe static int SequenceCompareTo(ref byte first, int firstLength, ref byte second, int secondLength)
		{
			nuint num;
			uint num6;
			nuint num3;
			nuint num2;
			if (!Unsafe.AreSame(ref first, ref second))
			{
				num = (uint)(((uint)firstLength < (uint)secondLength) ? firstLength : secondLength);
				num2 = 0u;
				num3 = num;
				if (!Avx2.IsSupported)
				{
					if (Sse2.IsSupported)
					{
						if (num3 >= (nuint)Vector128<byte>.Count)
						{
							num3 -= (nuint)Vector128<byte>.Count;
							while (true)
							{
								uint num4;
								if (num3 > num2)
								{
									num4 = (uint)Sse2.MoveMask(Sse2.CompareEqual(LoadVector128(ref first, num2), LoadVector128(ref second, num2)));
									if (num4 == 65535)
									{
										num2 += (nuint)Vector128<byte>.Count;
										continue;
									}
								}
								else
								{
									num2 = num3;
									num4 = (uint)Sse2.MoveMask(Sse2.CompareEqual(LoadVector128(ref first, num2), LoadVector128(ref second, num2)));
									if (num4 == 65535)
									{
										break;
									}
								}
								uint value = ~num4;
								num2 += (uint)BitOperations.TrailingZeroCount(value);
								return Unsafe.AddByteOffset(ref first, num2).CompareTo(Unsafe.AddByteOffset(ref second, num2));
							}
							goto IL_0277;
						}
					}
					else if (Vector.IsHardwareAccelerated && num3 > (nuint)Vector<byte>.Count)
					{
						for (num3 -= (nuint)Vector<byte>.Count; num3 > num2 && !(LoadVector(ref first, num2) != LoadVector(ref second, num2)); num2 += (nuint)Vector<byte>.Count)
						{
						}
						goto IL_0273;
					}
					goto IL_021b;
				}
				if (num3 >= (nuint)Vector256<byte>.Count)
				{
					num3 -= (nuint)Vector256<byte>.Count;
					while (true)
					{
						uint num5;
						if (num3 > num2)
						{
							num5 = (uint)Avx2.MoveMask(Avx2.CompareEqual(LoadVector256(ref first, num2), LoadVector256(ref second, num2)));
							if (num5 == uint.MaxValue)
							{
								num2 += (nuint)Vector256<byte>.Count;
								continue;
							}
						}
						else
						{
							num2 = num3;
							num5 = (uint)Avx2.MoveMask(Avx2.CompareEqual(LoadVector256(ref first, num2), LoadVector256(ref second, num2)));
							if (num5 == uint.MaxValue)
							{
								break;
							}
						}
						uint value2 = ~num5;
						num2 += (uint)BitOperations.TrailingZeroCount(value2);
						return Unsafe.AddByteOffset(ref first, num2).CompareTo(Unsafe.AddByteOffset(ref second, num2));
					}
				}
				else
				{
					if (num3 < (nuint)Vector128<byte>.Count)
					{
						goto IL_021b;
					}
					num3 -= (nuint)Vector128<byte>.Count;
					if (num3 > num2)
					{
						num6 = (uint)Sse2.MoveMask(Sse2.CompareEqual(LoadVector128(ref first, num2), LoadVector128(ref second, num2)));
						if (num6 != 65535)
						{
							goto IL_0111;
						}
					}
					num2 = num3;
					num6 = (uint)Sse2.MoveMask(Sse2.CompareEqual(LoadVector128(ref first, num2), LoadVector128(ref second, num2)));
					if (num6 != 65535)
					{
						goto IL_0111;
					}
				}
			}
			goto IL_0277;
			IL_021b:
			if (num3 > (nuint)sizeof(UIntPtr))
			{
				for (num3 -= (nuint)sizeof(UIntPtr); num3 > num2 && LoadNUInt(ref first, num2) == LoadNUInt(ref second, num2); num2 += (nuint)sizeof(UIntPtr))
				{
				}
			}
			goto IL_0273;
			IL_0111:
			uint value3 = ~num6;
			num2 += (uint)BitOperations.TrailingZeroCount(value3);
			return Unsafe.AddByteOffset(ref first, num2).CompareTo(Unsafe.AddByteOffset(ref second, num2));
			IL_0273:
			for (; num > num2; num2++)
			{
				int num7 = Unsafe.AddByteOffset(ref first, num2).CompareTo(Unsafe.AddByteOffset(ref second, num2));
				if (num7 != 0)
				{
					return num7;
				}
			}
			goto IL_0277;
			IL_0277:
			return firstLength - secondLength;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateLastFoundByte(Vector<byte> match)
		{
			Vector<ulong> vector = Vector.AsVectorUInt64(match);
			ulong num = 0uL;
			int num2 = Vector<ulong>.Count - 1;
			for (int i = 0; i < Vector<ulong>.Count; i++)
			{
				num = vector[num2];
				if (num != 0L)
				{
					break;
				}
				num2--;
			}
			return num2 * 8 + LocateLastFoundByte(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateFirstFoundByte(ulong match)
		{
			return BitOperations.TrailingZeroCount(match) >> 3;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateLastFoundByte(ulong match)
		{
			return BitOperations.Log2(match) >> 3;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ushort LoadUShort(ref byte start)
		{
			return Unsafe.ReadUnaligned<ushort>(ref start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static nuint LoadNUInt(ref byte start, nuint offset)
		{
			return Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.AddByteOffset(ref start, offset));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector<byte> LoadVector(ref byte start, nuint offset)
		{
			return Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref start, offset));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector128<byte> LoadVector128(ref byte start, nuint offset)
		{
			return Unsafe.ReadUnaligned<Vector128<byte>>(ref Unsafe.AddByteOffset(ref start, offset));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector256<byte> LoadVector256(ref byte start, nuint offset)
		{
			return Unsafe.ReadUnaligned<Vector256<byte>>(ref Unsafe.AddByteOffset(ref start, offset));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static nuint GetByteVectorSpanLength(nuint offset, int length)
		{
			return (uint)((length - (int)offset) & ~(Vector<byte>.Count - 1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static nuint GetByteVector128SpanLength(nuint offset, int length)
		{
			return (uint)((length - (int)offset) & ~(Vector128<byte>.Count - 1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static nuint GetByteVector256SpanLength(nuint offset, int length)
		{
			return (uint)((length - (int)offset) & ~(Vector256<byte>.Count - 1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static nuint UnalignedCountVector(ref byte searchSpace)
		{
			nint num = (nint)Unsafe.AsPointer(ref searchSpace) & (nint)(Vector<byte>.Count - 1);
			return (nuint)((Vector<byte>.Count - num) & (Vector<byte>.Count - 1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static nuint UnalignedCountVector128(ref byte searchSpace)
		{
			nint num = (nint)Unsafe.AsPointer(ref searchSpace) & (nint)(Vector128<byte>.Count - 1);
			return (uint)((Vector128<byte>.Count - num) & (Vector128<byte>.Count - 1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static nuint UnalignedCountVectorFromEnd(ref byte searchSpace, int length)
		{
			nint num = (nint)Unsafe.AsPointer(ref searchSpace) & (nint)(Vector<byte>.Count - 1);
			return (uint)(((length & (Vector<byte>.Count - 1)) + num) & (Vector<byte>.Count - 1));
		}

		public static int IndexOf(ref char searchSpace, int searchSpaceLength, ref char value, int valueLength)
		{
			if (valueLength == 0)
			{
				return 0;
			}
			char value2 = value;
			ref char source = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = searchSpaceLength - num;
			int num3 = 0;
			while (num2 > 0)
			{
				int num4 = IndexOf(ref Unsafe.Add(ref searchSpace, num3), value2, num2);
				if (num4 == -1)
				{
					break;
				}
				num2 -= num4;
				num3 += num4;
				if (num2 <= 0)
				{
					break;
				}
				if (SequenceEqual(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, num3 + 1)), ref Unsafe.As<char, byte>(ref source), (nuint)(uint)num * (nuint)2u))
				{
					return num3;
				}
				num2--;
				num3++;
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public unsafe static int SequenceCompareTo(ref char first, int firstLength, ref char second, int secondLength)
		{
			int result = firstLength - secondLength;
			if (!Unsafe.AreSame(ref first, ref second))
			{
				nuint num = (uint)(((uint)firstLength < (uint)secondLength) ? firstLength : secondLength);
				nuint num2 = 0u;
				if (num >= (nuint)(sizeof(UIntPtr) / 2))
				{
					if (Vector.IsHardwareAccelerated && num >= (nuint)Vector<ushort>.Count)
					{
						nuint num3 = num - (nuint)Vector<ushort>.Count;
						while (!(Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, (nint)num2))) != Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, (nint)num2)))))
						{
							num2 += (nuint)Vector<ushort>.Count;
							if (num3 < num2)
							{
								break;
							}
						}
					}
					for (; num >= (nuint)((nint)num2 + (nint)(sizeof(UIntPtr) / 2)) && Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, (nint)num2))) == Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, (nint)num2))); num2 += (nuint)(sizeof(UIntPtr) / 2))
					{
					}
				}
				for (; num2 < num; num2++)
				{
					int num4 = Unsafe.Add(ref first, (nint)num2).CompareTo(Unsafe.Add(ref second, (nint)num2));
					if (num4 != 0)
					{
						return num4;
					}
				}
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public unsafe static bool Contains(ref char searchSpace, char value, int length)
		{
			fixed (char* ptr = &searchSpace)
			{
				char* ptr2 = ptr;
				char* ptr3 = ptr2 + length;
				if (Vector.IsHardwareAccelerated && length >= Vector<ushort>.Count * 2)
				{
					int num = ((int)ptr2 & (Unsafe.SizeOf<Vector<ushort>>() - 1)) / 2;
					length = (Vector<ushort>.Count - num) & (Vector<ushort>.Count - 1);
				}
				while (true)
				{
					if (length >= 4)
					{
						length -= 4;
						if (value == *ptr2 || value == ptr2[1] || value == ptr2[2] || value == ptr2[3])
						{
							break;
						}
						ptr2 += 4;
						continue;
					}
					while (length > 0)
					{
						length--;
						if (value == *ptr2)
						{
							goto end_IL_0079;
						}
						ptr2++;
					}
					if (Vector.IsHardwareAccelerated && ptr2 < ptr3)
					{
						length = (int)((ptr3 - ptr2) & ~(Vector<ushort>.Count - 1));
						Vector<ushort> left = new Vector<ushort>(value);
						while (length > 0)
						{
							Vector<ushort> other = Vector.Equals(left, Unsafe.Read<Vector<ushort>>(ptr2));
							if (!Vector<ushort>.Zero.Equals(other))
							{
								goto end_IL_0079;
							}
							ptr2 += Vector<ushort>.Count;
							length -= Vector<ushort>.Count;
						}
						if (ptr2 < ptr3)
						{
							length = (int)(ptr3 - ptr2);
							continue;
						}
					}
					return false;
					continue;
					end_IL_0079:
					break;
				}
				return true;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public unsafe static int IndexOf(ref char searchSpace, char value, int length)
		{
			nint num = 0;
			nint num2 = length;
			if (((int)Unsafe.AsPointer(ref searchSpace) & 1) == 0)
			{
				if (Sse2.IsSupported || AdvSimd.Arm64.IsSupported)
				{
					if (length >= Vector128<ushort>.Count * 2)
					{
						num2 = UnalignedCountVector128(ref searchSpace);
					}
				}
				else if (Vector.IsHardwareAccelerated && length >= Vector<ushort>.Count * 2)
				{
					num2 = UnalignedCountVector(ref searchSpace);
				}
			}
			while (true)
			{
				if (num2 >= 4)
				{
					ref char reference = ref Unsafe.Add(ref searchSpace, num);
					if (value == reference)
					{
						break;
					}
					if (value != Unsafe.Add(ref reference, 1))
					{
						if (value != Unsafe.Add(ref reference, 2))
						{
							if (value != Unsafe.Add(ref reference, 3))
							{
								num += 4;
								num2 -= 4;
								continue;
							}
							return (int)(num + 3);
						}
						return (int)(num + 2);
					}
					return (int)(num + 1);
				}
				while (num2 > 0)
				{
					if (value == Unsafe.Add(ref searchSpace, num))
					{
						goto end_IL_0090;
					}
					num++;
					num2--;
				}
				if (Avx2.IsSupported)
				{
					if (num < length)
					{
						if (((nuint)Unsafe.AsPointer(ref Unsafe.Add(ref searchSpace, num)) & (nuint)(Vector256<byte>.Count - 1)) != 0)
						{
							Vector128<ushort> left = Vector128.Create(value);
							Vector128<ushort> right = LoadVector128(ref searchSpace, num);
							int num3 = Sse2.MoveMask(Sse2.CompareEqual(left, right).AsByte());
							if (num3 != 0)
							{
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num3) / 2u);
							}
							num += Vector128<ushort>.Count;
						}
						num2 = GetCharVector256SpanLength(num, length);
						if (num2 > 0)
						{
							Vector256<ushort> left2 = Vector256.Create(value);
							do
							{
								Vector256<ushort> right2 = LoadVector256(ref searchSpace, num);
								int num4 = Avx2.MoveMask(Avx2.CompareEqual(left2, right2).AsByte());
								if (num4 == 0)
								{
									num += Vector256<ushort>.Count;
									num2 -= Vector256<ushort>.Count;
									continue;
								}
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num4) / 2u);
							}
							while (num2 > 0);
						}
						num2 = GetCharVector128SpanLength(num, length);
						if (num2 > 0)
						{
							Vector128<ushort> left3 = Vector128.Create(value);
							Vector128<ushort> right3 = LoadVector128(ref searchSpace, num);
							int num5 = Sse2.MoveMask(Sse2.CompareEqual(left3, right3).AsByte());
							if (num5 != 0)
							{
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num5) / 2u);
							}
							num += Vector128<ushort>.Count;
						}
						if (num < length)
						{
							num2 = length - num;
							continue;
						}
					}
				}
				else if (Sse2.IsSupported)
				{
					if (num < length)
					{
						num2 = GetCharVector128SpanLength(num, length);
						if (num2 > 0)
						{
							Vector128<ushort> left4 = Vector128.Create(value);
							do
							{
								Vector128<ushort> right4 = LoadVector128(ref searchSpace, num);
								int num6 = Sse2.MoveMask(Sse2.CompareEqual(left4, right4).AsByte());
								if (num6 == 0)
								{
									num += Vector128<ushort>.Count;
									num2 -= Vector128<ushort>.Count;
									continue;
								}
								return (int)(num + (uint)BitOperations.TrailingZeroCount(num6) / 2u);
							}
							while (num2 > 0);
						}
						if (num < length)
						{
							num2 = length - num;
							continue;
						}
					}
				}
				else
				{
					if (AdvSimd.Arm64.IsSupported)
					{
					}
					if (Vector.IsHardwareAccelerated && num < length)
					{
						num2 = GetCharVectorSpanLength(num, length);
						if (num2 > 0)
						{
							Vector<ushort> left5 = new Vector<ushort>(value);
							do
							{
								Vector<ushort> vector = Vector.Equals(left5, LoadVector(ref searchSpace, num));
								if (Vector<ushort>.Zero.Equals(vector))
								{
									num += Vector<ushort>.Count;
									num2 -= Vector<ushort>.Count;
									continue;
								}
								return (int)(num + LocateFirstFoundChar(vector));
							}
							while (num2 > 0);
						}
						if (num < length)
						{
							num2 = length - num;
							continue;
						}
					}
				}
				return -1;
				continue;
				end_IL_0090:
				break;
			}
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static int IndexOfAny(ref char searchStart, char value0, char value1, int length)
		{
			nuint num = 0u;
			nuint num2 = (uint)length;
			int num4;
			if (Sse2.IsSupported)
			{
				nint num3 = (nint)length - (nint)Vector128<ushort>.Count;
				if (num3 >= 0)
				{
					num2 = (nuint)num3;
					if (Sse2.IsSupported)
					{
						if (Avx2.IsSupported && num2 >= (nuint)Vector128<ushort>.Count)
						{
							Vector256<ushort> left = Vector256.Create(value0);
							Vector256<ushort> left2 = Vector256.Create(value1);
							num2 -= (nuint)Vector128<ushort>.Count;
							Vector256<ushort> right;
							while (num2 > num)
							{
								right = LoadVector256(ref searchStart, num);
								num4 = Avx2.MoveMask(Avx2.Or(Avx2.CompareEqual(left, right), Avx2.CompareEqual(left2, right)).AsByte());
								if (num4 == 0)
								{
									num += (nuint)Vector256<ushort>.Count;
									continue;
								}
								goto IL_0211;
							}
							right = LoadVector256(ref searchStart, num2);
							num = num2;
							num4 = Avx2.MoveMask(Avx2.Or(Avx2.CompareEqual(left, right), Avx2.CompareEqual(left2, right)).AsByte());
							if (num4 == 0)
							{
								goto IL_00c1;
							}
						}
						else
						{
							Vector128<ushort> left3 = Vector128.Create(value0);
							Vector128<ushort> left4 = Vector128.Create(value1);
							Vector128<ushort> right2;
							while (num2 > num)
							{
								right2 = LoadVector128(ref searchStart, num);
								num4 = Sse2.MoveMask(Sse2.Or(Sse2.CompareEqual(left3, right2), Sse2.CompareEqual(left4, right2)).AsByte());
								if (num4 == 0)
								{
									num += (nuint)Vector128<ushort>.Count;
									continue;
								}
								goto IL_0211;
							}
							right2 = LoadVector128(ref searchStart, num2);
							num = num2;
							num4 = Sse2.MoveMask(Sse2.Or(Sse2.CompareEqual(left3, right2), Sse2.CompareEqual(left4, right2)).AsByte());
							if (num4 == 0)
							{
								goto IL_00c1;
							}
						}
						goto IL_0211;
					}
					goto IL_0223;
				}
			}
			else if (Vector.IsHardwareAccelerated)
			{
				nint num5 = (nint)length - (nint)Vector<ushort>.Count;
				if (num5 >= 0)
				{
					num2 = (nuint)num5;
					goto IL_0223;
				}
			}
			while (num2 >= 4)
			{
				ref char reference = ref Add(ref searchStart, num);
				int num6 = reference;
				if (value0 != num6 && value1 != num6)
				{
					num6 = Unsafe.Add(ref reference, 1);
					if (value0 != num6 && value1 != num6)
					{
						num6 = Unsafe.Add(ref reference, 2);
						if (value0 != num6 && value1 != num6)
						{
							num6 = Unsafe.Add(ref reference, 3);
							if (value0 != num6 && value1 != num6)
							{
								num += 4;
								num2 -= 4;
								continue;
							}
							return (int)(num + 3);
						}
						return (int)(num + 2);
					}
					return (int)(num + 1);
				}
				goto IL_00d5;
			}
			while (num2 != 0)
			{
				int num6 = Add(ref searchStart, num);
				if (value0 != num6 && value1 != num6)
				{
					num++;
					num2--;
					continue;
				}
				goto IL_00d5;
			}
			goto IL_00c1;
			IL_0211:
			num += (nuint)(uint)BitOperations.TrailingZeroCount(num4) >> 1;
			goto IL_00d5;
			IL_00c1:
			return -1;
			IL_02c3:
			Vector<ushort> vector;
			num += (uint)LocateFirstFoundChar(vector);
			goto IL_00d5;
			IL_0223:
			if (!Sse2.IsSupported && Vector.IsHardwareAccelerated)
			{
				Vector<ushort> right3 = new Vector<ushort>(value0);
				Vector<ushort> right4 = new Vector<ushort>(value1);
				while (num2 > num)
				{
					vector = LoadVector(ref searchStart, num);
					vector = Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4));
					if (Vector<ushort>.Zero.Equals(vector))
					{
						num += (nuint)Vector<ushort>.Count;
						continue;
					}
					goto IL_02c3;
				}
				vector = LoadVector(ref searchStart, num2);
				num = num2;
				vector = Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4));
				if (!Vector<ushort>.Zero.Equals(vector))
				{
					goto IL_02c3;
				}
			}
			goto IL_00c1;
			IL_00d5:
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static int IndexOfAny(ref char searchStart, char value0, char value1, char value2, int length)
		{
			nuint num = 0u;
			nuint num2 = (uint)length;
			int num4;
			if (Sse2.IsSupported)
			{
				nint num3 = (nint)length - (nint)Vector128<ushort>.Count;
				if (num3 >= 0)
				{
					num2 = (nuint)num3;
					if (Sse2.IsSupported)
					{
						if (Avx2.IsSupported && num2 >= (nuint)Vector128<ushort>.Count)
						{
							Vector256<ushort> left = Vector256.Create(value0);
							Vector256<ushort> left2 = Vector256.Create(value1);
							Vector256<ushort> left3 = Vector256.Create(value2);
							num2 -= (nuint)Vector128<ushort>.Count;
							Vector256<ushort> right;
							while (num2 > num)
							{
								right = LoadVector256(ref searchStart, num);
								num4 = Avx2.MoveMask(Avx2.Or(Avx2.Or(Avx2.CompareEqual(left, right), Avx2.CompareEqual(left2, right)), Avx2.CompareEqual(left3, right)).AsByte());
								if (num4 == 0)
								{
									num += (nuint)Vector256<ushort>.Count;
									continue;
								}
								goto IL_027f;
							}
							right = LoadVector256(ref searchStart, num2);
							num = num2;
							num4 = Avx2.MoveMask(Avx2.Or(Avx2.Or(Avx2.CompareEqual(left, right), Avx2.CompareEqual(left2, right)), Avx2.CompareEqual(left3, right)).AsByte());
							if (num4 == 0)
							{
								goto IL_00e7;
							}
						}
						else
						{
							Vector128<ushort> left4 = Vector128.Create(value0);
							Vector128<ushort> left5 = Vector128.Create(value1);
							Vector128<ushort> left6 = Vector128.Create(value2);
							Vector128<ushort> right2;
							while (num2 > num)
							{
								right2 = LoadVector128(ref searchStart, num);
								num4 = Sse2.MoveMask(Sse2.Or(Sse2.Or(Sse2.CompareEqual(left4, right2), Sse2.CompareEqual(left5, right2)), Sse2.CompareEqual(left6, right2)).AsByte());
								if (num4 == 0)
								{
									num += (nuint)Vector128<ushort>.Count;
									continue;
								}
								goto IL_027f;
							}
							right2 = LoadVector128(ref searchStart, num2);
							num = num2;
							num4 = Sse2.MoveMask(Sse2.Or(Sse2.Or(Sse2.CompareEqual(left4, right2), Sse2.CompareEqual(left5, right2)), Sse2.CompareEqual(left6, right2)).AsByte());
							if (num4 == 0)
							{
								goto IL_00e7;
							}
						}
						goto IL_027f;
					}
					goto IL_0291;
				}
			}
			else if (Vector.IsHardwareAccelerated)
			{
				nint num5 = (nint)length - (nint)Vector<ushort>.Count;
				if (num5 >= 0)
				{
					num2 = (nuint)num5;
					goto IL_0291;
				}
			}
			while (num2 >= 4)
			{
				ref char reference = ref Add(ref searchStart, num);
				int num6 = reference;
				if (value0 != num6 && value1 != num6 && value2 != num6)
				{
					num6 = Unsafe.Add(ref reference, 1);
					if (value0 != num6 && value1 != num6 && value2 != num6)
					{
						num6 = Unsafe.Add(ref reference, 2);
						if (value0 != num6 && value1 != num6 && value2 != num6)
						{
							num6 = Unsafe.Add(ref reference, 3);
							if (value0 != num6 && value1 != num6 && value2 != num6)
							{
								num += 4;
								num2 -= 4;
								continue;
							}
							return (int)(num + 3);
						}
						return (int)(num + 2);
					}
					return (int)(num + 1);
				}
				goto IL_00fb;
			}
			while (num2 != 0)
			{
				int num6 = Add(ref searchStart, num);
				if (value0 != num6 && value1 != num6 && value2 != num6)
				{
					num++;
					num2--;
					continue;
				}
				goto IL_00fb;
			}
			goto IL_00e7;
			IL_027f:
			num += (nuint)(uint)BitOperations.TrailingZeroCount(num4) >> 1;
			goto IL_00fb;
			IL_00e7:
			return -1;
			IL_0355:
			Vector<ushort> vector;
			num += (uint)LocateFirstFoundChar(vector);
			goto IL_00fb;
			IL_0291:
			if (!Sse2.IsSupported && Vector.IsHardwareAccelerated)
			{
				Vector<ushort> right3 = new Vector<ushort>(value0);
				Vector<ushort> right4 = new Vector<ushort>(value1);
				Vector<ushort> right5 = new Vector<ushort>(value2);
				while (num2 > num)
				{
					vector = LoadVector(ref searchStart, num);
					vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4)), Vector.Equals(vector, right5));
					if (Vector<ushort>.Zero.Equals(vector))
					{
						num += (nuint)Vector<ushort>.Count;
						continue;
					}
					goto IL_0355;
				}
				vector = LoadVector(ref searchStart, num2);
				num = num2;
				vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4)), Vector.Equals(vector, right5));
				if (!Vector<ushort>.Zero.Equals(vector))
				{
					goto IL_0355;
				}
			}
			goto IL_00e7;
			IL_00fb:
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static int IndexOfAny(ref char searchStart, char value0, char value1, char value2, char value3, int length)
		{
			nuint num = 0u;
			nuint num2 = (uint)length;
			int num4;
			if (Sse2.IsSupported)
			{
				nint num3 = (nint)length - (nint)Vector128<ushort>.Count;
				if (num3 >= 0)
				{
					num2 = (nuint)num3;
					if (Sse2.IsSupported)
					{
						if (Avx2.IsSupported && num2 >= (nuint)Vector128<ushort>.Count)
						{
							Vector256<ushort> left = Vector256.Create(value0);
							Vector256<ushort> left2 = Vector256.Create(value1);
							Vector256<ushort> left3 = Vector256.Create(value2);
							Vector256<ushort> left4 = Vector256.Create(value3);
							num2 -= (nuint)Vector128<ushort>.Count;
							Vector256<ushort> right;
							while (num2 > num)
							{
								right = LoadVector256(ref searchStart, num);
								num4 = Avx2.MoveMask(Avx2.CompareEqual(left, right).AsByte());
								num4 |= Avx2.MoveMask(Avx2.CompareEqual(left2, right).AsByte());
								num4 |= Avx2.MoveMask(Avx2.CompareEqual(left3, right).AsByte());
								num4 |= Avx2.MoveMask(Avx2.CompareEqual(left4, right).AsByte());
								if (num4 == 0)
								{
									num += (nuint)Vector256<ushort>.Count;
									continue;
								}
								goto IL_036f;
							}
							right = LoadVector256(ref searchStart, num2);
							num = num2;
							num4 = Avx2.MoveMask(Avx2.CompareEqual(left, right).AsByte());
							num4 |= Avx2.MoveMask(Avx2.CompareEqual(left2, right).AsByte());
							num4 |= Avx2.MoveMask(Avx2.CompareEqual(left3, right).AsByte());
							num4 |= Avx2.MoveMask(Avx2.CompareEqual(left4, right).AsByte());
							if (num4 == 0)
							{
								goto IL_0115;
							}
						}
						else
						{
							Vector128<ushort> left5 = Vector128.Create(value0);
							Vector128<ushort> left6 = Vector128.Create(value1);
							Vector128<ushort> left7 = Vector128.Create(value2);
							Vector128<ushort> left8 = Vector128.Create(value3);
							Vector128<ushort> right2;
							while (num2 > num)
							{
								right2 = LoadVector128(ref searchStart, num);
								num4 = Sse2.MoveMask(Sse2.CompareEqual(left5, right2).AsByte());
								num4 |= Sse2.MoveMask(Sse2.CompareEqual(left6, right2).AsByte());
								num4 |= Sse2.MoveMask(Sse2.CompareEqual(left7, right2).AsByte());
								num4 |= Sse2.MoveMask(Sse2.CompareEqual(left8, right2).AsByte());
								if (num4 == 0)
								{
									num += (nuint)Vector128<ushort>.Count;
									continue;
								}
								goto IL_036f;
							}
							right2 = LoadVector128(ref searchStart, num2);
							num = num2;
							num4 = Sse2.MoveMask(Sse2.CompareEqual(left5, right2).AsByte());
							num4 |= Sse2.MoveMask(Sse2.CompareEqual(left6, right2).AsByte());
							num4 |= Sse2.MoveMask(Sse2.CompareEqual(left7, right2).AsByte());
							num4 |= Sse2.MoveMask(Sse2.CompareEqual(left8, right2).AsByte());
							if (num4 == 0)
							{
								goto IL_0115;
							}
						}
						goto IL_036f;
					}
					goto IL_0381;
				}
			}
			else if (Vector.IsHardwareAccelerated)
			{
				nint num5 = (nint)length - (nint)Vector<ushort>.Count;
				if (num5 >= 0)
				{
					num2 = (nuint)num5;
					goto IL_0381;
				}
			}
			while (num2 >= 4)
			{
				ref char reference = ref Add(ref searchStart, num);
				int num6 = reference;
				if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6)
				{
					num6 = Unsafe.Add(ref reference, 1);
					if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6)
					{
						num6 = Unsafe.Add(ref reference, 2);
						if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6)
						{
							num6 = Unsafe.Add(ref reference, 3);
							if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6)
							{
								num += 4;
								num2 -= 4;
								continue;
							}
							return (int)(num + 3);
						}
						return (int)(num + 2);
					}
					return (int)(num + 1);
				}
				goto IL_0129;
			}
			while (num2 != 0)
			{
				int num6 = Add(ref searchStart, num);
				if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6)
				{
					num++;
					num2--;
					continue;
				}
				goto IL_0129;
			}
			goto IL_0115;
			IL_036f:
			num += (nuint)(uint)BitOperations.TrailingZeroCount(num4) >> 1;
			goto IL_0129;
			IL_0115:
			return -1;
			IL_046a:
			Vector<ushort> vector;
			num += (uint)LocateFirstFoundChar(vector);
			goto IL_0129;
			IL_0381:
			if (!Sse2.IsSupported && Vector.IsHardwareAccelerated)
			{
				Vector<ushort> right3 = new Vector<ushort>(value0);
				Vector<ushort> right4 = new Vector<ushort>(value1);
				Vector<ushort> right5 = new Vector<ushort>(value2);
				Vector<ushort> right6 = new Vector<ushort>(value3);
				while (num2 > num)
				{
					vector = LoadVector(ref searchStart, num);
					vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4)), Vector.Equals(vector, right5)), Vector.Equals(vector, right6));
					if (Vector<ushort>.Zero.Equals(vector))
					{
						num += (nuint)Vector<ushort>.Count;
						continue;
					}
					goto IL_046a;
				}
				vector = LoadVector(ref searchStart, num2);
				num = num2;
				vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4)), Vector.Equals(vector, right5)), Vector.Equals(vector, right6));
				if (!Vector<ushort>.Zero.Equals(vector))
				{
					goto IL_046a;
				}
			}
			goto IL_0115;
			IL_0129:
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public static int IndexOfAny(ref char searchStart, char value0, char value1, char value2, char value3, char value4, int length)
		{
			nuint num = 0u;
			nuint num2 = (uint)length;
			int num4;
			if (Sse2.IsSupported)
			{
				nint num3 = (nint)length - (nint)Vector128<ushort>.Count;
				if (num3 >= 0)
				{
					num2 = (nuint)num3;
					if (Sse2.IsSupported)
					{
						if (Avx2.IsSupported && num2 >= (nuint)Vector128<ushort>.Count)
						{
							Vector256<ushort> left = Vector256.Create(value0);
							Vector256<ushort> left2 = Vector256.Create(value1);
							Vector256<ushort> left3 = Vector256.Create(value2);
							Vector256<ushort> left4 = Vector256.Create(value3);
							Vector256<ushort> left5 = Vector256.Create(value4);
							num2 -= (nuint)Vector128<ushort>.Count;
							Vector256<ushort> right;
							while (num2 > num)
							{
								right = LoadVector256(ref searchStart, num);
								num4 = Avx2.MoveMask(Avx2.CompareEqual(left, right).AsByte());
								num4 |= Avx2.MoveMask(Avx2.CompareEqual(left2, right).AsByte());
								num4 |= Avx2.MoveMask(Avx2.CompareEqual(left3, right).AsByte());
								num4 |= Avx2.MoveMask(Avx2.CompareEqual(left4, right).AsByte());
								num4 |= Avx2.MoveMask(Avx2.CompareEqual(left5, right).AsByte());
								if (num4 == 0)
								{
									num += (nuint)Vector256<ushort>.Count;
									continue;
								}
								goto IL_040f;
							}
							right = LoadVector256(ref searchStart, num2);
							num = num2;
							num4 = Avx2.MoveMask(Avx2.CompareEqual(left, right).AsByte());
							num4 |= Avx2.MoveMask(Avx2.CompareEqual(left2, right).AsByte());
							num4 |= Avx2.MoveMask(Avx2.CompareEqual(left3, right).AsByte());
							num4 |= Avx2.MoveMask(Avx2.CompareEqual(left4, right).AsByte());
							num4 |= Avx2.MoveMask(Avx2.CompareEqual(left5, right).AsByte());
							if (num4 == 0)
							{
								goto IL_0134;
							}
						}
						else
						{
							Vector128<ushort> left6 = Vector128.Create(value0);
							Vector128<ushort> left7 = Vector128.Create(value1);
							Vector128<ushort> left8 = Vector128.Create(value2);
							Vector128<ushort> left9 = Vector128.Create(value3);
							Vector128<ushort> left10 = Vector128.Create(value4);
							Vector128<ushort> right2;
							while (num2 > num)
							{
								right2 = LoadVector128(ref searchStart, num);
								num4 = Sse2.MoveMask(Sse2.CompareEqual(left6, right2).AsByte());
								num4 |= Sse2.MoveMask(Sse2.CompareEqual(left7, right2).AsByte());
								num4 |= Sse2.MoveMask(Sse2.CompareEqual(left8, right2).AsByte());
								num4 |= Sse2.MoveMask(Sse2.CompareEqual(left9, right2).AsByte());
								num4 |= Sse2.MoveMask(Sse2.CompareEqual(left10, right2).AsByte());
								if (num4 == 0)
								{
									num += (nuint)Vector128<ushort>.Count;
									continue;
								}
								goto IL_040f;
							}
							right2 = LoadVector128(ref searchStart, num2);
							num = num2;
							num4 = Sse2.MoveMask(Sse2.CompareEqual(left6, right2).AsByte());
							num4 |= Sse2.MoveMask(Sse2.CompareEqual(left7, right2).AsByte());
							num4 |= Sse2.MoveMask(Sse2.CompareEqual(left8, right2).AsByte());
							num4 |= Sse2.MoveMask(Sse2.CompareEqual(left9, right2).AsByte());
							num4 |= Sse2.MoveMask(Sse2.CompareEqual(left10, right2).AsByte());
							if (num4 == 0)
							{
								goto IL_0134;
							}
						}
						goto IL_040f;
					}
					goto IL_0421;
				}
			}
			else if (Vector.IsHardwareAccelerated)
			{
				nint num5 = (nint)length - (nint)Vector<ushort>.Count;
				if (num5 >= 0)
				{
					num2 = (nuint)num5;
					goto IL_0421;
				}
			}
			while (num2 >= 4)
			{
				ref char reference = ref Add(ref searchStart, num);
				int num6 = reference;
				if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6 && value4 != num6)
				{
					num6 = Unsafe.Add(ref reference, 1);
					if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6 && value4 != num6)
					{
						num6 = Unsafe.Add(ref reference, 2);
						if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6 && value4 != num6)
						{
							num6 = Unsafe.Add(ref reference, 3);
							if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6 && value4 != num6)
							{
								num += 4;
								num2 -= 4;
								continue;
							}
							return (int)(num + 3);
						}
						return (int)(num + 2);
					}
					return (int)(num + 1);
				}
				goto IL_0148;
			}
			while (num2 != 0)
			{
				int num6 = Add(ref searchStart, num);
				if (value0 != num6 && value1 != num6 && value2 != num6 && value3 != num6 && value4 != num6)
				{
					num++;
					num2--;
					continue;
				}
				goto IL_0148;
			}
			goto IL_0134;
			IL_040f:
			num += (nuint)(uint)BitOperations.TrailingZeroCount(num4) >> 1;
			goto IL_0148;
			IL_0134:
			return -1;
			IL_052f:
			Vector<ushort> vector;
			num += (uint)LocateFirstFoundChar(vector);
			goto IL_0148;
			IL_0421:
			if (!Sse2.IsSupported && Vector.IsHardwareAccelerated)
			{
				Vector<ushort> right3 = new Vector<ushort>(value0);
				Vector<ushort> right4 = new Vector<ushort>(value1);
				Vector<ushort> right5 = new Vector<ushort>(value2);
				Vector<ushort> right6 = new Vector<ushort>(value3);
				Vector<ushort> right7 = new Vector<ushort>(value4);
				while (num2 > num)
				{
					vector = LoadVector(ref searchStart, num);
					vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4)), Vector.Equals(vector, right5)), Vector.Equals(vector, right6)), Vector.Equals(vector, right7));
					if (Vector<ushort>.Zero.Equals(vector))
					{
						num += (nuint)Vector<ushort>.Count;
						continue;
					}
					goto IL_052f;
				}
				vector = LoadVector(ref searchStart, num2);
				num = num2;
				vector = Vector.BitwiseOr(Vector.BitwiseOr(Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(vector, right3), Vector.Equals(vector, right4)), Vector.Equals(vector, right5)), Vector.Equals(vector, right6)), Vector.Equals(vector, right7));
				if (!Vector<ushort>.Zero.Equals(vector))
				{
					goto IL_052f;
				}
			}
			goto IL_0134;
			IL_0148:
			return (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		public unsafe static int LastIndexOf(ref char searchSpace, char value, int length)
		{
			fixed (char* ptr = &searchSpace)
			{
				char* ptr2 = ptr + length;
				char* ptr3 = ptr;
				if (Vector.IsHardwareAccelerated && length >= Vector<ushort>.Count * 2)
				{
					length = ((int)ptr2 & (Unsafe.SizeOf<Vector<ushort>>() - 1)) / 2;
				}
				while (true)
				{
					if (length >= 4)
					{
						length -= 4;
						ptr2 -= 4;
						if (ptr2[3] == value)
						{
							break;
						}
						if (ptr2[2] != value)
						{
							if (ptr2[1] != value)
							{
								if (*ptr2 != value)
								{
									continue;
								}
								goto IL_011d;
							}
							return (int)(ptr2 - ptr3) + 1;
						}
						return (int)(ptr2 - ptr3) + 2;
					}
					while (length > 0)
					{
						length--;
						ptr2--;
						if (*ptr2 != value)
						{
							continue;
						}
						goto IL_011d;
					}
					if (Vector.IsHardwareAccelerated && ptr2 > ptr3)
					{
						length = (int)((ptr2 - ptr3) & ~(Vector<ushort>.Count - 1));
						Vector<ushort> left = new Vector<ushort>(value);
						while (length > 0)
						{
							char* ptr4 = ptr2 - Vector<ushort>.Count;
							Vector<ushort> vector = Vector.Equals(left, Unsafe.Read<Vector<ushort>>(ptr4));
							if (Vector<ushort>.Zero.Equals(vector))
							{
								ptr2 -= Vector<ushort>.Count;
								length -= Vector<ushort>.Count;
								continue;
							}
							return (int)(ptr4 - ptr3) + LocateLastFoundChar(vector);
						}
						if (ptr2 > ptr3)
						{
							length = (int)(ptr2 - ptr3);
							continue;
						}
					}
					return -1;
					IL_011d:
					return (int)(ptr2 - ptr3);
				}
				return (int)(ptr2 - ptr3) + 3;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateFirstFoundChar(Vector<ushort> match)
		{
			Vector<ulong> vector = Vector.AsVectorUInt64(match);
			ulong num = 0uL;
			int i;
			for (i = 0; i < Vector<ulong>.Count; i++)
			{
				num = vector[i];
				if (num != 0L)
				{
					break;
				}
			}
			return i * 4 + LocateFirstFoundChar(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateFirstFoundChar(ulong match)
		{
			return BitOperations.TrailingZeroCount(match) >> 4;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateLastFoundChar(Vector<ushort> match)
		{
			Vector<ulong> vector = Vector.AsVectorUInt64(match);
			ulong num = 0uL;
			int num2 = Vector<ulong>.Count - 1;
			for (int i = 0; i < Vector<ulong>.Count; i++)
			{
				num = vector[num2];
				if (num != 0L)
				{
					break;
				}
				num2--;
			}
			return num2 * 4 + LocateLastFoundChar(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateLastFoundChar(ulong match)
		{
			return BitOperations.Log2(match) >> 4;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector<ushort> LoadVector(ref char start, nint offset)
		{
			return Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref start, offset)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector<ushort> LoadVector(ref char start, nuint offset)
		{
			return Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref start, (nint)offset)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector128<ushort> LoadVector128(ref char start, nint offset)
		{
			return Unsafe.ReadUnaligned<Vector128<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref start, offset)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector128<ushort> LoadVector128(ref char start, nuint offset)
		{
			return Unsafe.ReadUnaligned<Vector128<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref start, (nint)offset)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector256<ushort> LoadVector256(ref char start, nint offset)
		{
			return Unsafe.ReadUnaligned<Vector256<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref start, offset)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector256<ushort> LoadVector256(ref char start, nuint offset)
		{
			return Unsafe.ReadUnaligned<Vector256<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref start, (nint)offset)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ref char Add(ref char start, nuint offset)
		{
			return ref Unsafe.Add(ref start, (nint)offset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static nint GetCharVectorSpanLength(nint offset, nint length)
		{
			return (length - offset) & ~(Vector<ushort>.Count - 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static nint GetCharVector128SpanLength(nint offset, nint length)
		{
			return (length - offset) & ~(Vector128<ushort>.Count - 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static nint GetCharVector256SpanLength(nint offset, nint length)
		{
			return (length - offset) & ~(Vector256<ushort>.Count - 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static nint UnalignedCountVector(ref char searchSpace)
		{
			return (nint)(uint)(-(int)Unsafe.AsPointer(ref searchSpace) / 2) & (nint)(Vector<ushort>.Count - 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static nint UnalignedCountVector128(ref char searchSpace)
		{
			return (nint)(uint)(-(int)Unsafe.AsPointer(ref searchSpace) / 2) & (nint)(Vector128<ushort>.Count - 1);
		}

		public unsafe static void ClearWithoutReferences(ref byte b, nuint byteLength)
		{
			if (byteLength == 0)
			{
				return;
			}
			ulong num = byteLength;
			ulong num2 = num - 1;
			if (num2 <= 21)
			{
				switch (num2)
				{
				case 0uL:
					b = 0;
					return;
				case 1uL:
					Unsafe.As<byte, short>(ref b) = 0;
					return;
				case 2uL:
					Unsafe.As<byte, short>(ref b) = 0;
					Unsafe.Add(ref b, 2) = 0;
					return;
				case 3uL:
					Unsafe.As<byte, int>(ref b) = 0;
					return;
				case 4uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.Add(ref b, 4) = 0;
					return;
				case 5uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 4)) = 0;
					return;
				case 6uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.Add(ref b, 6) = 0;
					return;
				case 7uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					return;
				case 8uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.Add(ref b, 8) = 0;
					return;
				case 9uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 8)) = 0;
					return;
				case 10uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.Add(ref b, 10) = 0;
					return;
				case 11uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					return;
				case 12uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.Add(ref b, 12) = 0;
					return;
				case 13uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 12)) = 0;
					return;
				case 14uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 12)) = 0;
					Unsafe.Add(ref b, 14) = 0;
					return;
				case 15uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 12)) = 0;
					return;
				case 16uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 12)) = 0;
					Unsafe.Add(ref b, 16) = 0;
					return;
				case 17uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 12)) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 16)) = 0;
					return;
				case 18uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 12)) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 16)) = 0;
					Unsafe.Add(ref b, 18) = 0;
					return;
				case 19uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 12)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 16)) = 0;
					return;
				case 20uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 12)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 16)) = 0;
					Unsafe.Add(ref b, 20) = 0;
					return;
				case 21uL:
					Unsafe.As<byte, int>(ref b) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 4)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 8)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 12)) = 0;
					Unsafe.As<byte, int>(ref Unsafe.Add(ref b, 16)) = 0;
					Unsafe.As<byte, short>(ref Unsafe.Add(ref b, 20)) = 0;
					return;
				}
			}
			nuint num3;
			if (byteLength < 512)
			{
				num3 = 0u;
				if (((nuint)Unsafe.AsPointer(ref b) & (nuint)3u) != 0)
				{
					if (((nuint)Unsafe.AsPointer(ref b) & (nuint)1u) != 0)
					{
						b = 0;
						num3++;
						if (((nuint)Unsafe.AsPointer(ref b) & (nuint)2u) != 0)
						{
							goto IL_046b;
						}
					}
					Unsafe.As<byte, short>(ref Unsafe.AddByteOffset(ref b, num3)) = 0;
					num3 += 2;
				}
				goto IL_046b;
			}
			Buffer._ZeroMemory(ref b, byteLength);
			return;
			IL_046b:
			if (((nuint)((byte*)Unsafe.AsPointer(ref b) - 1) & (nuint)4u) == 0)
			{
				Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref b, num3)) = 0;
				num3 += 4;
			}
			nuint num4 = byteLength - 16;
			byteLength -= num3;
			nuint num5;
			do
			{
				num5 = num3 + 16;
				Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref b, num3)) = 0;
				Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref b, num3 + 4)) = 0;
				Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref b, num3 + 8)) = 0;
				Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref b, num3 + 12)) = 0;
				num3 = num5;
			}
			while (num5 <= num4);
			if ((byteLength & 8) != 0)
			{
				Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref b, num3)) = 0;
				Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref b, num3 + 4)) = 0;
				num3 += 8;
			}
			if ((byteLength & 4) != 0)
			{
				Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref b, num3)) = 0;
				num3 += 4;
			}
			if ((byteLength & 2) != 0)
			{
				Unsafe.As<byte, short>(ref Unsafe.AddByteOffset(ref b, num3)) = 0;
				num3 += 2;
			}
			if ((byteLength & 1) != 0)
			{
				Unsafe.AddByteOffset(ref b, num3) = 0;
			}
		}

		public static void ClearWithReferences(ref IntPtr ip, nuint pointerSizeLength)
		{
			while (pointerSizeLength >= 8)
			{
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -1) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -2) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -3) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -4) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -5) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -6) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -7) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -8) = default(IntPtr);
				pointerSizeLength -= 8;
			}
			if (pointerSizeLength < 4)
			{
				if (pointerSizeLength < 2)
				{
					if (pointerSizeLength == 0)
					{
						return;
					}
					goto IL_012f;
				}
			}
			else
			{
				Unsafe.Add(ref ip, 2) = default(IntPtr);
				Unsafe.Add(ref ip, 3) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -3) = default(IntPtr);
				Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -2) = default(IntPtr);
			}
			Unsafe.Add(ref ip, 1) = default(IntPtr);
			Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -1) = default(IntPtr);
			goto IL_012f;
			IL_012f:
			ip = default(IntPtr);
		}

		public static void Fill<T>(ref T refData, nuint numElements, T value)
		{
			if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>() && Vector.IsHardwareAccelerated && Unsafe.SizeOf<T>() <= Vector<byte>.Count && BitOperations.IsPow2(Unsafe.SizeOf<T>()) && numElements >= (uint)(Vector<byte>.Count / Unsafe.SizeOf<T>()))
			{
				T source = value;
				Vector<byte> value2;
				if (Unsafe.SizeOf<T>() == 1)
				{
					value2 = new Vector<byte>(Unsafe.As<T, byte>(ref source));
				}
				else if (Unsafe.SizeOf<T>() == 2)
				{
					value2 = (Vector<byte>)new Vector<ushort>(Unsafe.As<T, ushort>(ref source));
				}
				else if (Unsafe.SizeOf<T>() == 4)
				{
					value2 = ((typeof(T) == typeof(float)) ? ((Vector<byte>)new Vector<float>((float)(object)source)) : ((Vector<byte>)new Vector<uint>(Unsafe.As<T, uint>(ref source))));
				}
				else if (Unsafe.SizeOf<T>() == 8)
				{
					value2 = ((typeof(T) == typeof(double)) ? ((Vector<byte>)new Vector<double>((double)(object)source)) : ((Vector<byte>)new Vector<ulong>(Unsafe.As<T, ulong>(ref source))));
				}
				else if (Unsafe.SizeOf<T>() == 16)
				{
					Vector128<byte> vector = Unsafe.As<T, Vector128<byte>>(ref source);
					if (Vector<byte>.Count == 16)
					{
						value2 = vector.AsVector();
					}
					else
					{
						if (Vector<byte>.Count != 32)
						{
							goto IL_022e;
						}
						value2 = Vector256.Create(vector, vector).AsVector();
					}
				}
				else
				{
					if (Unsafe.SizeOf<T>() != 32 || Vector<byte>.Count != 32)
					{
						goto IL_022e;
					}
					value2 = Unsafe.As<T, Vector256<byte>>(ref source).AsVector();
				}
				ref byte source2 = ref Unsafe.As<T, byte>(ref refData);
				nuint num = numElements * (nuint)Unsafe.SizeOf<T>();
				nuint num2 = num & (nuint)(2 * -Vector<byte>.Count);
				nuint num3 = 0u;
				if (numElements >= (uint)(2 * Vector<byte>.Count / Unsafe.SizeOf<T>()))
				{
					do
					{
						Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref source2, num3), value2);
						Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref source2, num3 + (nuint)Vector<byte>.Count), value2);
						num3 += (uint)(2 * Vector<byte>.Count);
					}
					while (num3 < num2);
				}
				if ((num & (nuint)Vector<byte>.Count) != 0)
				{
					Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref source2, num3), value2);
				}
				Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref source2, num - (nuint)Vector<byte>.Count), value2);
				return;
			}
			goto IL_022e;
			IL_022e:
			nuint num4 = 0u;
			if (numElements >= 8)
			{
				nuint num5 = numElements & ~(nuint)7u;
				do
				{
					Unsafe.Add(ref refData, (nint)(num4 + 0)) = value;
					Unsafe.Add(ref refData, (nint)(num4 + 1)) = value;
					Unsafe.Add(ref refData, (nint)(num4 + 2)) = value;
					Unsafe.Add(ref refData, (nint)(num4 + 3)) = value;
					Unsafe.Add(ref refData, (nint)(num4 + 4)) = value;
					Unsafe.Add(ref refData, (nint)(num4 + 5)) = value;
					Unsafe.Add(ref refData, (nint)(num4 + 6)) = value;
					Unsafe.Add(ref refData, (nint)(num4 + 7)) = value;
				}
				while ((num4 += 8) < num5);
			}
			if ((numElements & 4) != 0)
			{
				Unsafe.Add(ref refData, (nint)(num4 + 0)) = value;
				Unsafe.Add(ref refData, (nint)(num4 + 1)) = value;
				Unsafe.Add(ref refData, (nint)(num4 + 2)) = value;
				Unsafe.Add(ref refData, (nint)(num4 + 3)) = value;
				num4 += 4;
			}
			if ((numElements & 2) != 0)
			{
				Unsafe.Add(ref refData, (nint)(num4 + 0)) = value;
				Unsafe.Add(ref refData, (nint)(num4 + 1)) = value;
				num4 += 2;
			}
			if ((numElements & 1) != 0)
			{
				Unsafe.Add(ref refData, (nint)num4) = value;
			}
		}

		public static int IndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
		{
			if (valueLength == 0)
			{
				return 0;
			}
			T value2 = value;
			ref T second = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = 0;
			while (true)
			{
				int num3 = searchSpaceLength - num2 - num;
				if (num3 <= 0)
				{
					break;
				}
				int num4 = IndexOf(ref Unsafe.Add(ref searchSpace, num2), value2, num3);
				if (num4 == -1)
				{
					break;
				}
				num2 += num4;
				if (SequenceEqual(ref Unsafe.Add(ref searchSpace, num2 + 1), ref second, num))
				{
					return num2;
				}
				num2++;
			}
			return -1;
		}

		public static bool Contains<T>(ref T searchSpace, T value, int length) where T : IEquatable<T>
		{
			nint num = 0;
			if (default(T) != null || value != null)
			{
				while (length >= 8)
				{
					length -= 8;
					if (!value.Equals(Unsafe.Add(ref searchSpace, num + 0)) && !value.Equals(Unsafe.Add(ref searchSpace, num + 1)) && !value.Equals(Unsafe.Add(ref searchSpace, num + 2)) && !value.Equals(Unsafe.Add(ref searchSpace, num + 3)) && !value.Equals(Unsafe.Add(ref searchSpace, num + 4)) && !value.Equals(Unsafe.Add(ref searchSpace, num + 5)) && !value.Equals(Unsafe.Add(ref searchSpace, num + 6)) && !value.Equals(Unsafe.Add(ref searchSpace, num + 7)))
					{
						num += 8;
						continue;
					}
					goto IL_0220;
				}
				if (length >= 4)
				{
					length -= 4;
					if (value.Equals(Unsafe.Add(ref searchSpace, num + 0)) || value.Equals(Unsafe.Add(ref searchSpace, num + 1)) || value.Equals(Unsafe.Add(ref searchSpace, num + 2)) || value.Equals(Unsafe.Add(ref searchSpace, num + 3)))
					{
						goto IL_0220;
					}
					num += 4;
				}
				while (length > 0)
				{
					length--;
					if (!value.Equals(Unsafe.Add(ref searchSpace, num)))
					{
						num++;
						continue;
					}
					goto IL_0220;
				}
			}
			else
			{
				nint num2 = length;
				num = 0;
				while (num < num2)
				{
					if (Unsafe.Add(ref searchSpace, num) != null)
					{
						num++;
						continue;
					}
					goto IL_0220;
				}
			}
			return false;
			IL_0220:
			return true;
		}

		public static int IndexOf<T>(ref T searchSpace, T value, int length) where T : IEquatable<T>
		{
			nint num = 0;
			if (default(T) != null || value != null)
			{
				while (length >= 8)
				{
					length -= 8;
					if (value.Equals(Unsafe.Add(ref searchSpace, num)))
					{
						goto IL_021a;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, num + 1)))
					{
						goto IL_021d;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, num + 2)))
					{
						goto IL_0223;
					}
					if (!value.Equals(Unsafe.Add(ref searchSpace, num + 3)))
					{
						if (!value.Equals(Unsafe.Add(ref searchSpace, num + 4)))
						{
							if (!value.Equals(Unsafe.Add(ref searchSpace, num + 5)))
							{
								if (!value.Equals(Unsafe.Add(ref searchSpace, num + 6)))
								{
									if (!value.Equals(Unsafe.Add(ref searchSpace, num + 7)))
									{
										num += 8;
										continue;
									}
									return (int)(num + 7);
								}
								return (int)(num + 6);
							}
							return (int)(num + 5);
						}
						return (int)(num + 4);
					}
					goto IL_0229;
				}
				if (length >= 4)
				{
					length -= 4;
					if (value.Equals(Unsafe.Add(ref searchSpace, num)))
					{
						goto IL_021a;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, num + 1)))
					{
						goto IL_021d;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, num + 2)))
					{
						goto IL_0223;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, num + 3)))
					{
						goto IL_0229;
					}
					num += 4;
				}
				while (length > 0)
				{
					if (!value.Equals(Unsafe.Add(ref searchSpace, num)))
					{
						num++;
						length--;
						continue;
					}
					goto IL_021a;
				}
			}
			else
			{
				nint num2 = length;
				num = 0;
				while (num < num2)
				{
					if (Unsafe.Add(ref searchSpace, num) != null)
					{
						num++;
						continue;
					}
					goto IL_021a;
				}
			}
			return -1;
			IL_0223:
			return (int)(num + 2);
			IL_021d:
			return (int)(num + 1);
			IL_021a:
			return (int)num;
			IL_0229:
			return (int)(num + 3);
		}

		public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, int length) where T : IEquatable<T>
		{
			int i = 0;
			if (default(T) != null || (value0 != null && value1 != null))
			{
				while (length - i >= 8)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0350;
					}
					other = Unsafe.Add(ref searchSpace, i + 1);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0352;
					}
					other = Unsafe.Add(ref searchSpace, i + 2);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0356;
					}
					other = Unsafe.Add(ref searchSpace, i + 3);
					if (!value0.Equals(other) && !value1.Equals(other))
					{
						other = Unsafe.Add(ref searchSpace, i + 4);
						if (!value0.Equals(other) && !value1.Equals(other))
						{
							other = Unsafe.Add(ref searchSpace, i + 5);
							if (!value0.Equals(other) && !value1.Equals(other))
							{
								other = Unsafe.Add(ref searchSpace, i + 6);
								if (!value0.Equals(other) && !value1.Equals(other))
								{
									other = Unsafe.Add(ref searchSpace, i + 7);
									if (!value0.Equals(other) && !value1.Equals(other))
									{
										i += 8;
										continue;
									}
									return i + 7;
								}
								return i + 6;
							}
							return i + 5;
						}
						return i + 4;
					}
					goto IL_035a;
				}
				if (length - i >= 4)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0350;
					}
					other = Unsafe.Add(ref searchSpace, i + 1);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0352;
					}
					other = Unsafe.Add(ref searchSpace, i + 2);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0356;
					}
					other = Unsafe.Add(ref searchSpace, i + 3);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_035a;
					}
					i += 4;
				}
				while (i < length)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					if (!value0.Equals(other) && !value1.Equals(other))
					{
						i++;
						continue;
					}
					goto IL_0350;
				}
			}
			else
			{
				for (i = 0; i < length; i++)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					if (other == null)
					{
						if (value0 != null && value1 != null)
						{
							continue;
						}
					}
					else if (!other.Equals(value0) && !other.Equals(value1))
					{
						continue;
					}
					goto IL_0350;
				}
			}
			return -1;
			IL_0352:
			return i + 1;
			IL_035a:
			return i + 3;
			IL_0350:
			return i;
			IL_0356:
			return i + 2;
		}

		public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2, int length) where T : IEquatable<T>
		{
			int i = 0;
			if (default(T) != null || (value0 != null && value1 != null && value2 != null))
			{
				while (length - i >= 8)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_0471;
					}
					other = Unsafe.Add(ref searchSpace, i + 1);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_0473;
					}
					other = Unsafe.Add(ref searchSpace, i + 2);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_0477;
					}
					other = Unsafe.Add(ref searchSpace, i + 3);
					if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
					{
						other = Unsafe.Add(ref searchSpace, i + 4);
						if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
						{
							other = Unsafe.Add(ref searchSpace, i + 5);
							if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
							{
								other = Unsafe.Add(ref searchSpace, i + 6);
								if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
								{
									other = Unsafe.Add(ref searchSpace, i + 7);
									if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
									{
										i += 8;
										continue;
									}
									return i + 7;
								}
								return i + 6;
							}
							return i + 5;
						}
						return i + 4;
					}
					goto IL_047b;
				}
				if (length - i >= 4)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_0471;
					}
					other = Unsafe.Add(ref searchSpace, i + 1);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_0473;
					}
					other = Unsafe.Add(ref searchSpace, i + 2);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_0477;
					}
					other = Unsafe.Add(ref searchSpace, i + 3);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_047b;
					}
					i += 4;
				}
				while (i < length)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
					{
						i++;
						continue;
					}
					goto IL_0471;
				}
			}
			else
			{
				for (i = 0; i < length; i++)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					if (other == null)
					{
						if (value0 != null && value1 != null && value2 != null)
						{
							continue;
						}
					}
					else if (!other.Equals(value0) && !other.Equals(value1) && !other.Equals(value2))
					{
						continue;
					}
					goto IL_0471;
				}
			}
			return -1;
			IL_0477:
			return i + 2;
			IL_0471:
			return i;
			IL_047b:
			return i + 3;
			IL_0473:
			return i + 1;
		}

		public static int IndexOfAny<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
		{
			if (valueLength == 0)
			{
				return -1;
			}
			if (typeof(T).IsValueType)
			{
				for (int i = 0; i < searchSpaceLength; i++)
				{
					T other = Unsafe.Add(ref searchSpace, i);
					for (int j = 0; j < valueLength; j++)
					{
						if (Unsafe.Add(ref value, j).Equals(other))
						{
							return i;
						}
					}
				}
			}
			else
			{
				for (int k = 0; k < searchSpaceLength; k++)
				{
					T val = Unsafe.Add(ref searchSpace, k);
					if (val != null)
					{
						for (int l = 0; l < valueLength; l++)
						{
							if (val.Equals(Unsafe.Add(ref value, l)))
							{
								return k;
							}
						}
						continue;
					}
					for (int m = 0; m < valueLength; m++)
					{
						if (Unsafe.Add(ref value, m) == null)
						{
							return k;
						}
					}
				}
			}
			return -1;
		}

		public static int LastIndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
		{
			if (valueLength == 0)
			{
				return searchSpaceLength;
			}
			T value2 = value;
			ref T second = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = 0;
			while (true)
			{
				int num3 = searchSpaceLength - num2 - num;
				if (num3 <= 0)
				{
					break;
				}
				int num4 = LastIndexOf(ref searchSpace, value2, num3);
				if (num4 == -1)
				{
					break;
				}
				if (SequenceEqual(ref Unsafe.Add(ref searchSpace, num4 + 1), ref second, num))
				{
					return num4;
				}
				num2 += num3 - num4;
			}
			return -1;
		}

		public static int LastIndexOf<T>(ref T searchSpace, T value, int length) where T : IEquatable<T>
		{
			if (default(T) != null || value != null)
			{
				while (length >= 8)
				{
					length -= 8;
					if (!value.Equals(Unsafe.Add(ref searchSpace, length + 7)))
					{
						if (!value.Equals(Unsafe.Add(ref searchSpace, length + 6)))
						{
							if (!value.Equals(Unsafe.Add(ref searchSpace, length + 5)))
							{
								if (!value.Equals(Unsafe.Add(ref searchSpace, length + 4)))
								{
									if (!value.Equals(Unsafe.Add(ref searchSpace, length + 3)))
									{
										if (!value.Equals(Unsafe.Add(ref searchSpace, length + 2)))
										{
											if (!value.Equals(Unsafe.Add(ref searchSpace, length + 1)))
											{
												if (!value.Equals(Unsafe.Add(ref searchSpace, length)))
												{
													continue;
												}
												goto IL_01fe;
											}
											goto IL_0200;
										}
										goto IL_0204;
									}
									goto IL_0208;
								}
								return length + 4;
							}
							return length + 5;
						}
						return length + 6;
					}
					return length + 7;
				}
				if (length >= 4)
				{
					length -= 4;
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 3)))
					{
						goto IL_0208;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 2)))
					{
						goto IL_0204;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 1)))
					{
						goto IL_0200;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length)))
					{
						goto IL_01fe;
					}
				}
				while (length > 0)
				{
					length--;
					if (!value.Equals(Unsafe.Add(ref searchSpace, length)))
					{
						continue;
					}
					goto IL_01fe;
				}
			}
			else
			{
				length--;
				while (length >= 0)
				{
					if (Unsafe.Add(ref searchSpace, length) != null)
					{
						length--;
						continue;
					}
					goto IL_01fe;
				}
			}
			return -1;
			IL_0208:
			return length + 3;
			IL_0204:
			return length + 2;
			IL_0200:
			return length + 1;
			IL_01fe:
			return length;
		}

		public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, int length) where T : IEquatable<T>
		{
			if (default(T) != null || (value0 != null && value1 != null))
			{
				while (length >= 8)
				{
					length -= 8;
					T other = Unsafe.Add(ref searchSpace, length + 7);
					if (!value0.Equals(other) && !value1.Equals(other))
					{
						other = Unsafe.Add(ref searchSpace, length + 6);
						if (!value0.Equals(other) && !value1.Equals(other))
						{
							other = Unsafe.Add(ref searchSpace, length + 5);
							if (!value0.Equals(other) && !value1.Equals(other))
							{
								other = Unsafe.Add(ref searchSpace, length + 4);
								if (!value0.Equals(other) && !value1.Equals(other))
								{
									other = Unsafe.Add(ref searchSpace, length + 3);
									if (!value0.Equals(other) && !value1.Equals(other))
									{
										other = Unsafe.Add(ref searchSpace, length + 2);
										if (!value0.Equals(other) && !value1.Equals(other))
										{
											other = Unsafe.Add(ref searchSpace, length + 1);
											if (!value0.Equals(other) && !value1.Equals(other))
											{
												other = Unsafe.Add(ref searchSpace, length);
												if (!value0.Equals(other) && !value1.Equals(other))
												{
													continue;
												}
												goto IL_0351;
											}
											goto IL_0353;
										}
										goto IL_0357;
									}
									goto IL_035b;
								}
								return length + 4;
							}
							return length + 5;
						}
						return length + 6;
					}
					return length + 7;
				}
				if (length >= 4)
				{
					length -= 4;
					T other = Unsafe.Add(ref searchSpace, length + 3);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_035b;
					}
					other = Unsafe.Add(ref searchSpace, length + 2);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0357;
					}
					other = Unsafe.Add(ref searchSpace, length + 1);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0353;
					}
					other = Unsafe.Add(ref searchSpace, length);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_0351;
					}
				}
				while (length > 0)
				{
					length--;
					T other = Unsafe.Add(ref searchSpace, length);
					if (!value0.Equals(other) && !value1.Equals(other))
					{
						continue;
					}
					goto IL_0351;
				}
			}
			else
			{
				for (length--; length >= 0; length--)
				{
					T other = Unsafe.Add(ref searchSpace, length);
					if (other == null)
					{
						if (value0 != null && value1 != null)
						{
							continue;
						}
					}
					else if (!other.Equals(value0) && !other.Equals(value1))
					{
						continue;
					}
					goto IL_0351;
				}
			}
			return -1;
			IL_0357:
			return length + 2;
			IL_0351:
			return length;
			IL_035b:
			return length + 3;
			IL_0353:
			return length + 1;
		}

		public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2, int length) where T : IEquatable<T>
		{
			if (default(T) != null || (value0 != null && value1 != null))
			{
				while (length >= 8)
				{
					length -= 8;
					T other = Unsafe.Add(ref searchSpace, length + 7);
					if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
					{
						other = Unsafe.Add(ref searchSpace, length + 6);
						if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
						{
							other = Unsafe.Add(ref searchSpace, length + 5);
							if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
							{
								other = Unsafe.Add(ref searchSpace, length + 4);
								if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
								{
									other = Unsafe.Add(ref searchSpace, length + 3);
									if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
									{
										other = Unsafe.Add(ref searchSpace, length + 2);
										if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
										{
											other = Unsafe.Add(ref searchSpace, length + 1);
											if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
											{
												other = Unsafe.Add(ref searchSpace, length);
												if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
												{
													continue;
												}
												goto IL_047a;
											}
											goto IL_047d;
										}
										goto IL_0482;
									}
									goto IL_0487;
								}
								return length + 4;
							}
							return length + 5;
						}
						return length + 6;
					}
					return length + 7;
				}
				if (length >= 4)
				{
					length -= 4;
					T other = Unsafe.Add(ref searchSpace, length + 3);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_0487;
					}
					other = Unsafe.Add(ref searchSpace, length + 2);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_0482;
					}
					other = Unsafe.Add(ref searchSpace, length + 1);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_047d;
					}
					other = Unsafe.Add(ref searchSpace, length);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_047a;
					}
				}
				while (length > 0)
				{
					length--;
					T other = Unsafe.Add(ref searchSpace, length);
					if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
					{
						continue;
					}
					goto IL_047a;
				}
			}
			else
			{
				for (length--; length >= 0; length--)
				{
					T other = Unsafe.Add(ref searchSpace, length);
					if (other == null)
					{
						if (value0 != null && value1 != null && value2 != null)
						{
							continue;
						}
					}
					else if (!other.Equals(value0) && !other.Equals(value1) && !other.Equals(value2))
					{
						continue;
					}
					goto IL_047a;
				}
			}
			return -1;
			IL_0482:
			return length + 2;
			IL_047a:
			return length;
			IL_0487:
			return length + 3;
			IL_047d:
			return length + 1;
		}

		public static int LastIndexOfAny<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
		{
			if (valueLength == 0)
			{
				return -1;
			}
			if (typeof(T).IsValueType)
			{
				for (int num = searchSpaceLength - 1; num >= 0; num--)
				{
					T other = Unsafe.Add(ref searchSpace, num);
					for (int i = 0; i < valueLength; i++)
					{
						if (Unsafe.Add(ref value, i).Equals(other))
						{
							return num;
						}
					}
				}
			}
			else
			{
				for (int num2 = searchSpaceLength - 1; num2 >= 0; num2--)
				{
					T val = Unsafe.Add(ref searchSpace, num2);
					if (val != null)
					{
						for (int j = 0; j < valueLength; j++)
						{
							if (val.Equals(Unsafe.Add(ref value, j)))
							{
								return num2;
							}
						}
					}
					else
					{
						for (int k = 0; k < valueLength; k++)
						{
							if (Unsafe.Add(ref value, k) == null)
							{
								return num2;
							}
						}
					}
				}
			}
			return -1;
		}

		public static bool SequenceEqual<T>(ref T first, ref T second, int length) where T : IEquatable<T>
		{
			if (!Unsafe.AreSame(ref first, ref second))
			{
				nint num = 0;
				while (true)
				{
					if (length >= 8)
					{
						length -= 8;
						T val = Unsafe.Add(ref first, num);
						T val2 = Unsafe.Add(ref second, num);
						if (val?.Equals(val2) ?? (val2 == null))
						{
							val = Unsafe.Add(ref first, num + 1);
							val2 = Unsafe.Add(ref second, num + 1);
							if (val?.Equals(val2) ?? (val2 == null))
							{
								val = Unsafe.Add(ref first, num + 2);
								val2 = Unsafe.Add(ref second, num + 2);
								if (val?.Equals(val2) ?? (val2 == null))
								{
									val = Unsafe.Add(ref first, num + 3);
									val2 = Unsafe.Add(ref second, num + 3);
									if (val?.Equals(val2) ?? (val2 == null))
									{
										val = Unsafe.Add(ref first, num + 4);
										val2 = Unsafe.Add(ref second, num + 4);
										if (val?.Equals(val2) ?? (val2 == null))
										{
											val = Unsafe.Add(ref first, num + 5);
											val2 = Unsafe.Add(ref second, num + 5);
											if (val?.Equals(val2) ?? (val2 == null))
											{
												val = Unsafe.Add(ref first, num + 6);
												val2 = Unsafe.Add(ref second, num + 6);
												if (val?.Equals(val2) ?? (val2 == null))
												{
													val = Unsafe.Add(ref first, num + 7);
													val2 = Unsafe.Add(ref second, num + 7);
													if (val?.Equals(val2) ?? (val2 == null))
													{
														num += 8;
														continue;
													}
												}
											}
										}
									}
								}
							}
						}
					}
					else
					{
						if (length < 4)
						{
							goto IL_03b8;
						}
						length -= 4;
						T val = Unsafe.Add(ref first, num);
						T val2 = Unsafe.Add(ref second, num);
						if (val?.Equals(val2) ?? (val2 == null))
						{
							val = Unsafe.Add(ref first, num + 1);
							val2 = Unsafe.Add(ref second, num + 1);
							if (val?.Equals(val2) ?? (val2 == null))
							{
								val = Unsafe.Add(ref first, num + 2);
								val2 = Unsafe.Add(ref second, num + 2);
								if (val?.Equals(val2) ?? (val2 == null))
								{
									val = Unsafe.Add(ref first, num + 3);
									val2 = Unsafe.Add(ref second, num + 3);
									if (val?.Equals(val2) ?? (val2 == null))
									{
										num += 4;
										goto IL_03b8;
									}
								}
							}
						}
					}
					goto IL_03be;
					IL_03b8:
					while (length > 0)
					{
						T val = Unsafe.Add(ref first, num);
						T val2 = Unsafe.Add(ref second, num);
						if (val?.Equals(val2) ?? (val2 == null))
						{
							num++;
							length--;
							continue;
						}
						goto IL_03be;
					}
					break;
					IL_03be:
					return false;
				}
			}
			return true;
		}

		public static int SequenceCompareTo<T>(ref T first, int firstLength, ref T second, int secondLength) where T : IComparable<T>
		{
			int num = firstLength;
			if (num > secondLength)
			{
				num = secondLength;
			}
			for (int i = 0; i < num; i++)
			{
				T val = Unsafe.Add(ref second, i);
				int num2 = Unsafe.Add(ref first, i)?.CompareTo(val) ?? ((val != null) ? (-1) : 0);
				if (num2 != 0)
				{
					return num2;
				}
			}
			return firstLength.CompareTo(secondLength);
		}
	}
	internal static class SR
	{
		private static readonly object _lock = new object();

		private static List<string> _currentlyLoading;

		private static int _infinitelyRecursingCount;

		private static bool _resourceManagerInited;

		private static readonly bool s_usingResourceKeys = AppContext.TryGetSwitch("System.Resources.UseSystemResourceKeys", out var isEnabled) && isEnabled;

		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(typeof(Strings)));

		internal static string Acc_CreateAbstEx => GetResourceString("Acc_CreateAbstEx");

		internal static string Acc_CreateArgIterator => GetResourceString("Acc_CreateArgIterator");

		internal static string Acc_CreateGenericEx => GetResourceString("Acc_CreateGenericEx");

		internal static string Acc_CreateInterfaceEx => GetResourceString("Acc_CreateInterfaceEx");

		internal static string Acc_CreateVoid => GetResourceString("Acc_CreateVoid");

		internal static string Acc_NotClassInit => GetResourceString("Acc_NotClassInit");

		internal static string Acc_ReadOnly => GetResourceString("Acc_ReadOnly");

		internal static string Access_Void => GetResourceString("Access_Void");

		internal static string AggregateException_ctor_DefaultMessage => GetResourceString("AggregateException_ctor_DefaultMessage");

		internal static string AggregateException_ctor_InnerExceptionNull => GetResourceString("AggregateException_ctor_InnerExceptionNull");

		internal static string AggregateException_DeserializationFailure => GetResourceString("AggregateException_DeserializationFailure");

		internal static string AggregateException_InnerException => GetResourceString("AggregateException_InnerException");

		internal static string AppDomain_Name => GetResourceString("AppDomain_Name");

		internal static string AppDomain_NoContextPolicies => GetResourceString("AppDomain_NoContextPolicies");

		internal static string AppDomain_Policy_PrincipalTwice => GetResourceString("AppDomain_Policy_PrincipalTwice");

		internal static string AmbiguousImplementationException_NullMessage => GetResourceString("AmbiguousImplementationException_NullMessage");

		internal static string Arg_AccessException => GetResourceString("Arg_AccessException");

		internal static string Arg_AccessViolationException => GetResourceString("Arg_AccessViolationException");

		internal static string Arg_AmbiguousMatchException => GetResourceString("Arg_AmbiguousMatchException");

		internal static string Arg_ApplicationException => GetResourceString("Arg_ApplicationException");

		internal static string Arg_ArgumentException => GetResourceString("Arg_ArgumentException");

		internal static string Arg_ArgumentOutOfRangeException => GetResourceString("Arg_ArgumentOutOfRangeException");

		internal static string Arg_ArithmeticException => GetResourceString("Arg_ArithmeticException");

		internal static string Arg_ArrayLengthsDiffer => GetResourceString("Arg_ArrayLengthsDiffer");

		internal static string Arg_ArrayPlusOffTooSmall => GetResourceString("Arg_ArrayPlusOffTooSmall");

		internal static string Arg_ArrayTypeMismatchException => GetResourceString("Arg_ArrayTypeMismatchException");

		internal static string Arg_ArrayZeroError => GetResourceString("Arg_ArrayZeroError");

		internal static string Arg_BadDecimal => GetResourceString("Arg_BadDecimal");

		internal static string Arg_BadImageFormatException => GetResourceString("Arg_BadImageFormatException");

		internal static string Arg_BadLiteralFormat => GetResourceString("Arg_BadLiteralFormat");

		internal static string Arg_BogusIComparer => GetResourceString("Arg_BogusIComparer");

		internal static string Arg_BufferTooSmall => GetResourceString("Arg_BufferTooSmall");

		internal static string Arg_CannotBeNaN => GetResourceString("Arg_CannotBeNaN");

		internal static string Arg_CannotHaveNegativeValue => GetResourceString("Arg_CannotHaveNegativeValue");

		internal static string Arg_CannotMixComparisonInfrastructure => GetResourceString("Arg_CannotMixComparisonInfrastructure");

		internal static string Arg_CannotUnloadAppDomainException => GetResourceString("Arg_CannotUnloadAppDomainException");

		internal static string Arg_CATypeResolutionFailed => GetResourceString("Arg_CATypeResolutionFailed");

		internal static string Arg_COMAccess => GetResourceString("Arg_COMAccess");

		internal static string Arg_COMException => GetResourceString("Arg_COMException");

		internal static string Arg_COMPropSetPut => GetResourceString("Arg_COMPropSetPut");

		internal static string Arg_CreatInstAccess => GetResourceString("Arg_CreatInstAccess");

		internal static string Arg_CryptographyException => GetResourceString("Arg_CryptographyException");

		internal static string Arg_CustomAttributeFormatException => GetResourceString("Arg_CustomAttributeFormatException");

		internal static string Arg_DataMisalignedException => GetResourceString("Arg_DataMisalignedException");

		internal static string Arg_DecBitCtor => GetResourceString("Arg_DecBitCtor");

		internal static string Arg_DirectoryNotFoundException => GetResourceString("Arg_DirectoryNotFoundException");

		internal static string Arg_DivideByZero => GetResourceString("Arg_DivideByZero");

		internal static string Arg_DlgtNullInst => GetResourceString("Arg_DlgtNullInst");

		internal static string Arg_DlgtTargMeth => GetResourceString("Arg_DlgtTargMeth");

		internal static string Arg_DlgtTypeMis => GetResourceString("Arg_DlgtTypeMis");

		internal static string Arg_DllNotFoundException => GetResourceString("Arg_DllNotFoundException");

		internal static string Arg_DuplicateWaitObjectException => GetResourceString("Arg_DuplicateWaitObjectException");

		internal static string Arg_EHClauseNotClause => GetResourceString("Arg_EHClauseNotClause");

		internal static string Arg_EHClauseNotFilter => GetResourceString("Arg_EHClauseNotFilter");

		internal static string Arg_EmptyArray => GetResourceString("Arg_EmptyArray");

		internal static string Arg_EndOfStreamException => GetResourceString("Arg_EndOfStreamException");

		internal static string Arg_EntryPointNotFoundException => GetResourceString("Arg_EntryPointNotFoundException");

		internal static string Arg_EnumAndObjectMustBeSameType => GetResourceString("Arg_EnumAndObjectMustBeSameType");

		internal static string Arg_EnumFormatUnderlyingTypeAndObjectMustBeSameType => GetResourceString("Arg_EnumFormatUnderlyingTypeAndObjectMustBeSameType");

		internal static string Arg_EnumIllegalVal => GetResourceString("Arg_EnumIllegalVal");

		internal static string Arg_EnumLitValueNotFound => GetResourceString("Arg_EnumLitValueNotFound");

		internal static string Arg_EnumUnderlyingTypeAndObjectMustBeSameType => GetResourceString("Arg_EnumUnderlyingTypeAndObjectMustBeSameType");

		internal static string Arg_EnumValueNotFound => GetResourceString("Arg_EnumValueNotFound");

		internal static string Arg_ExecutionEngineException => GetResourceString("Arg_ExecutionEngineException");

		internal static string Arg_ExternalException => GetResourceString("Arg_ExternalException");

		internal static string Arg_FieldAccessException => GetResourceString("Arg_FieldAccessException");

		internal static string Arg_FieldDeclTarget => GetResourceString("Arg_FieldDeclTarget");

		internal static string Arg_FldGetArgErr => GetResourceString("Arg_FldGetArgErr");

		internal static string Arg_FldGetPropSet => GetResourceString("Arg_FldGetPropSet");

		internal static string Arg_FldSetArgErr => GetResourceString("Arg_FldSetArgErr");

		internal static string Arg_FldSetGet => GetResourceString("Arg_FldSetGet");

		internal static string Arg_FldSetInvoke => GetResourceString("Arg_FldSetInvoke");

		internal static string Arg_FldSetPropGet => GetResourceString("Arg_FldSetPropGet");

		internal static string Arg_FormatException => GetResourceString("Arg_FormatException");

		internal static string Arg_GenericParameter => GetResourceString("Arg_GenericParameter");

		internal static string Arg_GetMethNotFnd => GetResourceString("Arg_GetMethNotFnd");

		internal static string Arg_GuidArrayCtor => GetResourceString("Arg_GuidArrayCtor");

		internal static string Arg_HandleNotAsync => GetResourceString("Arg_HandleNotAsync");

		internal static string Arg_HandleNotSync => GetResourceString("Arg_HandleNotSync");

		internal static string Arg_HexStyleNotSupported => GetResourceString("Arg_HexStyleNotSupported");

		internal static string Arg_HTCapacityOverflow => GetResourceString("Arg_HTCapacityOverflow");

		internal static string Arg_IndexMustBeInt => GetResourceString("Arg_IndexMustBeInt");

		internal static string Arg_IndexOutOfRangeException => GetResourceString("Arg_IndexOutOfRangeException");

		internal static string Arg_InsufficientExecutionStackException => GetResourceString("Arg_InsufficientExecutionStackException");

		internal static string Arg_InvalidANSIString => GetResourceString("Arg_InvalidANSIString");

		internal static string Arg_InvalidBase => GetResourceString("Arg_InvalidBase");

		internal static string Arg_InvalidCastException => GetResourceString("Arg_InvalidCastException");

		internal static string Arg_InvalidComObjectException => GetResourceString("Arg_InvalidComObjectException");

		internal static string Arg_InvalidFilterCriteriaException => GetResourceString("Arg_InvalidFilterCriteriaException");

		internal static string Arg_InvalidHandle => GetResourceString("Arg_InvalidHandle");

		internal static string Arg_InvalidHexStyle => GetResourceString("Arg_InvalidHexStyle");

		internal static string Arg_InvalidNeutralResourcesLanguage_Asm_Culture => GetResourceString("Arg_InvalidNeutralResourcesLanguage_Asm_Culture");

		internal static string Arg_InvalidNeutralResourcesLanguage_FallbackLoc => GetResourceString("Arg_InvalidNeutralResourcesLanguage_FallbackLoc");

		internal static string Arg_InvalidSatelliteContract_Asm_Ver => GetResourceString("Arg_InvalidSatelliteContract_Asm_Ver");

		internal static string Arg_InvalidOleVariantTypeException => GetResourceString("Arg_InvalidOleVariantTypeException");

		internal static string Arg_InvalidOperationException => GetResourceString("Arg_InvalidOperationException");

		internal static string Arg_InvalidTypeInRetType => GetResourceString("Arg_InvalidTypeInRetType");

		internal static string Arg_InvalidTypeInSignature => GetResourceString("Arg_InvalidTypeInSignature");

		internal static string Arg_IOException => GetResourceString("Arg_IOException");

		internal static string Arg_KeyNotFound => GetResourceString("Arg_KeyNotFound");

		internal static string Arg_KeyNotFoundWithKey => GetResourceString("Arg_KeyNotFoundWithKey");

		internal static string Arg_LongerThanDestArray => GetResourceString("Arg_LongerThanDestArray");

		internal static string Arg_LongerThanSrcArray => GetResourceString("Arg_LongerThanSrcArray");

		internal static string Arg_LongerThanSrcString => GetResourceString("Arg_LongerThanSrcString");

		internal static string Arg_LowerBoundsMustMatch => GetResourceString("Arg_LowerBoundsMustMatch");

		internal static string Arg_MarshalAsAnyRestriction => GetResourceString("Arg_MarshalAsAnyRestriction");

		internal static string Arg_MarshalDirectiveException => GetResourceString("Arg_MarshalDirectiveException");

		internal static string Arg_MethodAccessException => GetResourceString("Arg_MethodAccessException");

		internal static string Arg_MissingFieldException => GetResourceString("Arg_MissingFieldException");

		internal static string Arg_MissingManifestResourceException => GetResourceString("Arg_MissingManifestResourceException");

		internal static string Arg_MissingMemberException => GetResourceString("Arg_MissingMemberException");

		internal static string Arg_MissingMethodException => GetResourceString("Arg_MissingMethodException");

		internal static string Arg_MulticastNotSupportedException => GetResourceString("Arg_MulticastNotSupportedException");

		internal static string Arg_MustBeBoolean => GetResourceString("Arg_MustBeBoolean");

		internal static string Arg_MustBeByte => GetResourceString("Arg_MustBeByte");

		internal static string Arg_MustBeChar => GetResourceString("Arg_MustBeChar");

		internal static string Arg_MustBeDateOnly => GetResourceString("Arg_MustBeDateOnly");

		internal static string Arg_MustBeTimeOnly => GetResourceString("Arg_MustBeTimeOnly");

		internal static string Arg_MustBeDateTime => GetResourceString("Arg_MustBeDateTime");

		internal static string Arg_MustBeDateTimeOffset => GetResourceString("Arg_MustBeDateTimeOffset");

		internal static string Arg_MustBeDecimal => GetResourceString("Arg_MustBeDecimal");

		internal static string Arg_MustBeDelegate => GetResourceString("Arg_MustBeDelegate");

		internal static string Arg_MustBeDouble => GetResourceString("Arg_MustBeDouble");

		internal static string Arg_MustBeDriveLetterOrRootDir => GetResourceString("Arg_MustBeDriveLetterOrRootDir");

		internal static string Arg_MustBeEnum => GetResourceString("Arg_MustBeEnum");

		internal static string Arg_MustBeEnumBaseTypeOrEnum => GetResourceString("Arg_MustBeEnumBaseTypeOrEnum");

		internal static string Arg_MustBeGuid => GetResourceString("Arg_MustBeGuid");

		internal static string Arg_MustBeInt16 => GetResourceString("Arg_MustBeInt16");

		internal static string Arg_MustBeInt32 => GetResourceString("Arg_MustBeInt32");

		internal static string Arg_MustBeInt64 => GetResourceString("Arg_MustBeInt64");

		internal static string Arg_MustBeIntPtr => GetResourceString("Arg_MustBeIntPtr");

		internal static string Arg_MustBeNFloat => GetResourceString("Arg_MustBeNFloat");

		internal static string Arg_MustBePointer => GetResourceString("Arg_MustBePointer");

		internal static string Arg_MustBePrimArray => GetResourceString("Arg_MustBePrimArray");

		internal static string Arg_MustBeRuntimeAssembly => GetResourceString("Arg_MustBeRuntimeAssembly");

		internal static string Arg_MustBeSByte => GetResourceString("Arg_MustBeSByte");

		internal static string Arg_MustBeSingle => GetResourceString("Arg_MustBeSingle");

		internal static string Arg_MustBeString => GetResourceString("Arg_MustBeString");

		internal static string Arg_MustBeTimeSpan => GetResourceString("Arg_MustBeTimeSpan");

		internal static string Arg_MustBeType => GetResourceString("Arg_MustBeType");

		internal static string Arg_MustBeTrue => GetResourceString("Arg_MustBeTrue");

		internal static string Arg_MustBeUInt16 => GetResourceString("Arg_MustBeUInt16");

		internal static string Arg_MustBeUInt32 => GetResourceString("Arg_MustBeUInt32");

		internal static string Arg_MustBeUInt64 => GetResourceString("Arg_MustBeUInt64");

		internal static string Arg_MustBeUIntPtr => GetResourceString("Arg_MustBeUIntPtr");

		internal static string Arg_MustBeVersion => GetResourceString("Arg_MustBeVersion");

		internal static string Arg_MustContainEnumInfo => GetResourceString("Arg_MustContainEnumInfo");

		internal static string Arg_NamedParamNull => GetResourceString("Arg_NamedParamNull");

		internal static string Arg_NamedParamTooBig => GetResourceString("Arg_NamedParamTooBig");

		internal static string Arg_NDirectBadObject => GetResourceString("Arg_NDirectBadObject");

		internal static string Arg_Need1DArray => GetResourceString("Arg_Need1DArray");

		internal static string Arg_Need2DArray => GetResourceString("Arg_Need2DArray");

		internal static string Arg_Need3DArray => GetResourceString("Arg_Need3DArray");

		internal static string Arg_NeedAtLeast1Rank => GetResourceString("Arg_NeedAtLeast1Rank");

		internal static string Arg_NegativeArgCount => GetResourceString("Arg_NegativeArgCount");

		internal static string Arg_NoAccessSpec => GetResourceString("Arg_NoAccessSpec");

		internal static string Arg_NoDefCTor => GetResourceString("Arg_NoDefCTor");

		internal static string Arg_NonZeroLowerBound => GetResourceString("Arg_NonZeroLowerBound");

		internal static string Arg_NoStaticVirtual => GetResourceString("Arg_NoStaticVirtual");

		internal static string Arg_NotFiniteNumberException => GetResourceString("Arg_NotFiniteNumberException");

		internal static string Arg_NotGenericMethodDefinition => GetResourceString("Arg_NotGenericMethodDefinition");

		internal static string Arg_NotGenericParameter => GetResourceString("Arg_NotGenericParameter");

		internal static string Arg_NotGenericTypeDefinition => GetResourceString("Arg_NotGenericTypeDefinition");

		internal static string Arg_NotImplementedException => GetResourceString("Arg_NotImplementedException");

		internal static string Arg_NotSupportedException => GetResourceString("Arg_NotSupportedException");

		internal static string Arg_NullReferenceException => GetResourceString("Arg_NullReferenceException");

		internal static string Arg_ObjObjEx => GetResourceString("Arg_ObjObjEx");

		internal static string Arg_OleAutDateInvalid => GetResourceString("Arg_OleAutDateInvalid");

		internal static string Arg_OleAutDateScale => GetResourceString("Arg_OleAutDateScale");

		internal static string Arg_OverflowException => GetResourceString("Arg_OverflowException");

		internal static string Arg_ParamName_Name => GetResourceString("Arg_ParamName_Name");

		internal static string Arg_ParmArraySize => GetResourceString("Arg_ParmArraySize");

		internal static string Arg_ParmCnt => GetResourceString("Arg_ParmCnt");

		internal static string Arg_PathEmpty => GetResourceString("Arg_PathEmpty");

		internal static string Arg_PlatformNotSupported => GetResourceString("Arg_PlatformNotSupported");

		internal static string Arg_PropSetGet => GetResourceString("Arg_PropSetGet");

		internal static string Arg_PropSetInvoke => GetResourceString("Arg_PropSetInvoke");

		internal static string Arg_RankException => GetResourceString("Arg_RankException");

		internal static string Arg_RankIndices => GetResourceString("Arg_RankIndices");

		internal static string Arg_RankMultiDimNotSupported => GetResourceString("Arg_RankMultiDimNotSupported");

		internal static string Arg_RanksAndBounds => GetResourceString("Arg_RanksAndBounds");

		internal static string Arg_RegGetOverflowBug => GetResourceString("Arg_RegGetOverflowBug");

		internal static string Arg_RegKeyNotFound => GetResourceString("Arg_RegKeyNotFound");

		internal static string Arg_RegSubKeyValueAbsent => GetResourceString("Arg_RegSubKeyValueAbsent");

		internal static string Arg_RegValStrLenBug => GetResourceString("Arg_RegValStrLenBug");

		internal static string Arg_ResMgrNotResSet => GetResourceString("Arg_ResMgrNotResSet");

		internal static string Arg_ResourceFileUnsupportedVersion => GetResourceString("Arg_ResourceFileUnsupportedVersion");

		internal static string Arg_ResourceNameNotExist => GetResourceString("Arg_ResourceNameNotExist");

		internal static string Arg_SafeArrayRankMismatchException => GetResourceString("Arg_SafeArrayRankMismatchException");

		internal static string Arg_SafeArrayTypeMismatchException => GetResourceString("Arg_SafeArrayTypeMismatchException");

		internal static string Arg_SecurityException => GetResourceString("Arg_SecurityException");

		internal static string SerializationException => GetResourceString("SerializationException");

		internal static string Arg_SetMethNotFnd => GetResourceString("Arg_SetMethNotFnd");

		internal static string Arg_StackOverflowException => GetResourceString("Arg_StackOverflowException");

		internal static string Arg_SurrogatesNotAllowedAsSingleChar => GetResourceString("Arg_SurrogatesNotAllowedAsSingleChar");

		internal static string Arg_SynchronizationLockException => GetResourceString("Arg_SynchronizationLockException");

		internal static string Arg_SystemException => GetResourceString("Arg_SystemException");

		internal static string Arg_TargetInvocationException => GetResourceString("Arg_TargetInvocationException");

		internal static string Arg_TargetParameterCountException => GetResourceString("Arg_TargetParameterCountException");

		internal static string Arg_ThreadStartException => GetResourceString("Arg_ThreadStartException");

		internal static string Arg_ThreadStateException => GetResourceString("Arg_ThreadStateException");

		internal static string Arg_TimeoutException => GetResourceString("Arg_TimeoutException");

		internal static string Arg_TypeAccessException => GetResourceString("Arg_TypeAccessException");

		internal static string Arg_TypedReference_Null => GetResourceString("Arg_TypedReference_Null");

		internal static string Arg_TypeLoadException => GetResourceString("Arg_TypeLoadException");

		internal static string Arg_TypeLoadNullStr => GetResourceString("Arg_TypeLoadNullStr");

		internal static string Arg_TypeRefPrimitve => GetResourceString("Arg_TypeRefPrimitve");

		internal static string Arg_TypeUnloadedException => GetResourceString("Arg_TypeUnloadedException");

		internal static string Arg_UnauthorizedAccessException => GetResourceString("Arg_UnauthorizedAccessException");

		internal static string Arg_UnboundGenField => GetResourceString("Arg_UnboundGenField");

		internal static string Arg_UnboundGenParam => GetResourceString("Arg_UnboundGenParam");

		internal static string Arg_UnknownTypeCode => GetResourceString("Arg_UnknownTypeCode");

		internal static string Arg_VarMissNull => GetResourceString("Arg_VarMissNull");

		internal static string Arg_VersionString => GetResourceString("Arg_VersionString");

		internal static string Arg_WrongType => GetResourceString("Arg_WrongType");

		internal static string Argument_AbsolutePathRequired => GetResourceString("Argument_AbsolutePathRequired");

		internal static string Argument_AddingDuplicate => GetResourceString("Argument_AddingDuplicate");

		internal static string Argument_AddingDuplicate__ => GetResourceString("Argument_AddingDuplicate__");

		internal static string Argument_AddingDuplicateWithKey => GetResourceString("Argument_AddingDuplicateWithKey");

		internal static string Argument_AdjustmentRulesNoNulls => GetResourceString("Argument_AdjustmentRulesNoNulls");

		internal static string Argument_AdjustmentRulesOutOfOrder => GetResourceString("Argument_AdjustmentRulesOutOfOrder");

		internal static string Argument_AlignmentMustBePow2 => GetResourceString("Argument_AlignmentMustBePow2");

		internal static string Argument_AlreadyBoundOrSyncHandle => GetResourceString("Argument_AlreadyBoundOrSyncHandle");

		internal static string Argument_ArrayGetInterfaceMap => GetResourceString("Argument_ArrayGetInterfaceMap");

		internal static string Argument_ArraysInvalid => GetResourceString("Argument_ArraysInvalid");

		internal static string Argument_AttributeNamesMustBeUnique => GetResourceString("Argument_AttributeNamesMustBeUnique");

		internal static string Argument_BadConstructor => GetResourceString("Argument_BadConstructor");

		internal static string Argument_BadConstructorCallConv => GetResourceString("Argument_BadConstructorCallConv");

		internal static string Argument_BadExceptionCodeGen => GetResourceString("Argument_BadExceptionCodeGen");

		internal static string Argument_BadFieldForConstructorBuilder => GetResourceString("Argument_BadFieldForConstructorBuilder");

		internal static string Argument_BadFieldSig => GetResourceString("Argument_BadFieldSig");

		internal static string Argument_BadFieldType => GetResourceString("Argument_BadFieldType");

		internal static string Argument_BadFormatSpecifier => GetResourceString("Argument_BadFormatSpecifier");

		internal static string Argument_BadImageFormatExceptionResolve => GetResourceString("Argument_BadImageFormatExceptionResolve");

		internal static string Argument_BadLabel => GetResourceString("Argument_BadLabel");

		internal static string Argument_BadLabelContent => GetResourceString("Argument_BadLabelContent");

		internal static string Argument_BadNestedTypeFlags => GetResourceString("Argument_BadNestedTypeFlags");

		internal static string Argument_BadParameterCountsForConstructor => GetResourceString("Argument_BadParameterCountsForConstructor");

		internal static string Argument_BadParameterTypeForCAB => GetResourceString("Argument_BadParameterTypeForCAB");

		internal static string Argument_BadPropertyForConstructorBuilder => GetResourceString("Argument_BadPropertyForConstructorBuilder");

		internal static string Argument_BadSigFormat => GetResourceString("Argument_BadSigFormat");

		internal static string Argument_BadSizeForData => GetResourceString("Argument_BadSizeForData");

		internal static string Argument_BadTypeAttrInvalidLayout => GetResourceString("Argument_BadTypeAttrInvalidLayout");

		internal static string Argument_BadTypeAttrNestedVisibilityOnNonNestedType => GetResourceString("Argument_BadTypeAttrNestedVisibilityOnNonNestedType");

		internal static string Argument_BadTypeAttrNonNestedVisibilityNestedType => GetResourceString("Argument_BadTypeAttrNonNestedVisibilityNestedType");

		internal static string Argument_BadTypeAttrReservedBitsSet => GetResourceString("Argument_BadTypeAttrReservedBitsSet");

		internal static string Argument_BadTypeInCustomAttribute => GetResourceString("Argument_BadTypeInCustomAttribute");

		internal static string Argument_CannotGetTypeTokenForByRef => GetResourceString("Argument_CannotGetTypeTokenForByRef");

		internal static string Argument_CannotSetParentToInterface => GetResourceString("Argument_CannotSetParentToInterface");

		internal static string Argument_CodepageNotSupported => GetResourceString("Argument_CodepageNotSupported");

		internal static string Argument_CompareOptionOrdinal => GetResourceString("Argument_CompareOptionOrdinal");

		internal static string Argument_ConflictingDateTimeRoundtripStyles => GetResourceString("Argument_ConflictingDateTimeRoundtripStyles");

		internal static string Argument_ConflictingDateTimeStyles => GetResourceString("Argument_ConflictingDateTimeStyles");

		internal static string Argument_ConstantDoesntMatch => GetResourceString("Argument_ConstantDoesntMatch");

		internal static string Argument_ConstantNotSupported => GetResourceString("Argument_ConstantNotSupported");

		internal static string Argument_ConstantNull => GetResourceString("Argument_ConstantNull");

		internal static string Argument_ConstructorNeedGenericDeclaringType => GetResourceString("Argument_ConstructorNeedGenericDeclaringType");

		internal static string Argument_ConversionOverflow => GetResourceString("Argument_ConversionOverflow");

		internal static string Argument_ConvertMismatch => GetResourceString("Argument_ConvertMismatch");

		internal static string Argument_CultureIetfNotSupported => GetResourceString("Argument_CultureIetfNotSupported");

		internal static string Argument_CultureInvalidIdentifier => GetResourceString("Argument_CultureInvalidIdentifier");

		internal static string Argument_CultureIsNeutral => GetResourceString("Argument_CultureIsNeutral");

		internal static string Argument_CultureNotSupported => GetResourceString("Argument_CultureNotSupported");

		internal static string Argument_CultureNotSupportedInInvariantMode => GetResourceString("Argument_CultureNotSupportedInInvariantMode");

		internal static string Argument_CustomAssemblyLoadContextRequestedNameMismatch => GetResourceString("Argument_CustomAssemblyLoadContextRequestedNameMismatch");

		internal static string Argument_CustomCultureCannotBePassedByNumber => GetResourceString("Argument_CustomCultureCannotBePassedByNumber");

		internal static string Argument_DateTimeBadBinaryData => GetResourceString("Argument_DateTimeBadBinaryData");

		internal static string Argument_DateTimeHasTicks => GetResourceString("Argument_DateTimeHasTicks");

		internal static string Argument_DateTimeHasTimeOfDay => GetResourceString("Argument_DateTimeHasTimeOfDay");

		internal static string Argument_DateTimeIsInvalid => GetResourceString("Argument_DateTimeIsInvalid");

		internal static string Argument_DateTimeIsNotAmbiguous => GetResourceString("Argument_DateTimeIsNotAmbiguous");

		internal static string Argument_DateTimeKindMustBeUnspecified => GetResourceString("Argument_DateTimeKindMustBeUnspecified");

		internal static string Argument_DateTimeKindMustBeUnspecifiedOrUtc => GetResourceString("Argument_DateTimeKindMustBeUnspecifiedOrUtc");

		internal static string Argument_DateTimeOffsetInvalidDateTimeStyles => GetResourceString("Argument_DateTimeOffsetInvalidDateTimeStyles");

		internal static string Argument_DateTimeOffsetIsNotAmbiguous => GetResourceString("Argument_DateTimeOffsetIsNotAmbiguous");

		internal static string Argument_DestinationTooShort => GetResourceString("Argument_DestinationTooShort");

		internal static string Argument_DuplicateTypeName => GetResourceString("Argument_DuplicateTypeName");

		internal static string Argument_EmitWriteLineType => GetResourceString("Argument_EmitWriteLineType");

		internal static string Argument_EmptyDecString => GetResourceString("Argument_EmptyDecString");

		internal static string Argument_EmptyFileName => GetResourceString("Argument_EmptyFileName");

		internal static string Argument_EmptyName => GetResourceString("Argument_EmptyName");

		internal static string Argument_EmptyPath => GetResourceString("Argument_EmptyPath");

		internal static string Argument_EmptyWaithandleArray => GetResourceString("Argument_EmptyWaithandleArray");

		internal static string Argument_EncoderFallbackNotEmpty => GetResourceString("Argument_EncoderFallbackNotEmpty");

		internal static string Argument_EncodingConversionOverflowBytes => GetResourceString("Argument_EncodingConversionOverflowBytes");

		internal static string Argument_EncodingConversionOverflowChars => GetResourceString("Argument_EncodingConversionOverflowChars");

		internal static string Argument_EncodingNotSupported => GetResourceString("Argument_EncodingNotSupported");

		internal static string Argument_EnumTypeDoesNotMatch => GetResourceString("Argument_EnumTypeDoesNotMatch");

		internal static string Argument_FallbackBufferNotEmpty => GetResourceString("Argument_FallbackBufferNotEmpty");

		internal static string Argument_FieldDeclaringTypeGeneric => GetResourceString("Argument_FieldDeclaringTypeGeneric");

		internal static string Argument_FieldNeedGenericDeclaringType => GetResourceString("Argument_FieldNeedGenericDeclaringType");

		internal static string Argument_GenConstraintViolation => GetResourceString("Argument_GenConstraintViolation");

		internal static string Argument_GenericArgsCount => GetResourceString("Argument_GenericArgsCount");

		internal static string Argument_GenericsInvalid => GetResourceString("Argument_GenericsInvalid");

		internal static string Argument_GlobalFunctionHasToBeStatic => GetResourceString("Argument_GlobalFunctionHasToBeStatic");

		internal static string Argument_HasToBeArrayClass => GetResourceString("Argument_HasToBeArrayClass");

		internal static string Argument_IdnBadBidi => GetResourceString("Argument_IdnBadBidi");

		internal static string Argument_IdnBadLabelSize => GetResourceString("Argument_IdnBadLabelSize");

		internal static string Argument_IdnBadNameSize => GetResourceString("Argument_IdnBadNameSize");

		internal static string Argument_IdnBadPunycode => GetResourceString("Argument_IdnBadPunycode");

		internal static string Argument_IdnBadStd3 => GetResourceString("Argument_IdnBadStd3");

		internal static string Argument_IdnIllegalName => GetResourceString("Argument_IdnIllegalName");

		internal static string Argument_IllegalEnvVarName => GetResourceString("Argument_IllegalEnvVarName");

		internal static string Argument_IllegalName => GetResourceString("Argument_IllegalName");

		internal static string Argument_ImplementIComparable => GetResourceString("Argument_ImplementIComparable");

		internal static string Argument_InvalidAppendMode => GetResourceString("Argument_InvalidAppendMode");

		internal static string Argument_InvalidPreallocateAccess => GetResourceString("Argument_InvalidPreallocateAccess");

		internal static string Argument_InvalidPreallocateMode => GetResourceString("Argument_InvalidPreallocateMode");

		internal static string Argument_InvalidArgumentForComparison => GetResourceString("Argument_InvalidArgumentForComparison");

		internal static string Argument_InvalidArrayLength => GetResourceString("Argument_InvalidArrayLength");

		internal static string Argument_InvalidArrayType => GetResourceString("Argument_InvalidArrayType");

		internal static string Argument_InvalidCalendar => GetResourceString("Argument_InvalidCalendar");

		internal static string Argument_InvalidCharSequence => GetResourceString("Argument_InvalidCharSequence");

		internal static string Argument_InvalidCharSequenceNoIndex => GetResourceString("Argument_InvalidCharSequenceNoIndex");

		internal static string Argument_InvalidCodePageBytesIndex => GetResourceString("Argument_InvalidCodePageBytesIndex");

		internal static string Argument_InvalidCodePageConversionIndex => GetResourceString("Argument_InvalidCodePageConversionIndex");

		internal static string Argument_InvalidConstructorDeclaringType => GetResourceString("Argument_InvalidConstructorDeclaringType");

		internal static string Argument_InvalidConstructorInfo => GetResourceString("Argument_InvalidConstructorInfo");

		internal static string Argument_InvalidCultureName => GetResourceString("Argument_InvalidCultureName");

		internal static string Argument_InvalidPredefinedCultureName => GetResourceString("Argument_InvalidPredefinedCultureName");

		internal static string Argument_InvalidDateTimeKind => GetResourceString("Argument_InvalidDateTimeKind");

		internal static string Argument_InvalidDateTimeStyles => GetResourceString("Argument_InvalidDateTimeStyles");

		internal static string Argument_InvalidDateStyles => GetResourceString("Argument_InvalidDateStyles");

		internal static string Argument_InvalidDigitSubstitution => GetResourceString("Argument_InvalidDigitSubstitution");

		internal static string Argument_InvalidElementName => GetResourceString("Argument_InvalidElementName");

		internal static string Argument_InvalidElementTag => GetResourceString("Argument_InvalidElementTag");

		internal static string Argument_InvalidElementText => GetResourceString("Argument_InvalidElementText");

		internal static string Argument_InvalidElementValue => GetResourceString("Argument_InvalidElementValue");

		internal static string Argument_InvalidEnum => GetResourceString("Argument_InvalidEnum");

		internal static string Argument_InvalidEnumValue => GetResourceString("Argument_InvalidEnumValue");

		internal static string Argument_InvalidFieldDeclaringType => GetResourceString("Argument_InvalidFieldDeclaringType");

		internal static string Argument_InvalidFileModeAndAccessCombo => GetResourceString("Argument_InvalidFileModeAndAccessCombo");

		internal static string Argument_InvalidFlag => GetResourceString("Argument_InvalidFlag");

		internal static string Argument_InvalidGenericInstArray => GetResourceString("Argument_InvalidGenericInstArray");

		internal static string Argument_InvalidGroupSize => GetResourceString("Argument_InvalidGroupSize");

		internal static string Argument_InvalidHandle => GetResourceString("Argument_InvalidHandle");

		internal static string Argument_InvalidHighSurrogate => GetResourceString("Argument_InvalidHighSurrogate");

		internal static string Argument_InvalidId => GetResourceString("Argument_InvalidId");

		internal static string Argument_InvalidKindOfTypeForCA => GetResourceString("Argument_InvalidKindOfTypeForCA");

		internal static string Argument_InvalidLabel => GetResourceString("Argument_InvalidLabel");

		internal static string Argument_InvalidLowSurrogate => GetResourceString("Argument_InvalidLowSurrogate");

		internal static string Argument_InvalidMemberForNamedArgument => GetResourceString("Argument_InvalidMemberForNamedArgument");

		internal static string Argument_InvalidMethodDeclaringType => GetResourceString("Argument_InvalidMethodDeclaringType");

		internal static string Argument_InvalidName => GetResourceString("Argument_InvalidName");

		internal static string Argument_InvalidNativeDigitCount => GetResourceString("Argument_InvalidNativeDigitCount");

		internal static string Argument_InvalidNativeDigitValue => GetResourceString("Argument_InvalidNativeDigitValue");

		internal static string Argument_InvalidNeutralRegionName => GetResourceString("Argument_InvalidNeutralRegionName");

		internal static string Argument_InvalidNormalizationForm => GetResourceString("Argument_InvalidNormalizationForm");

		internal static string Argument_InvalidNumberStyles => GetResourceString("Argument_InvalidNumberStyles");

		internal static string Argument_InvalidOffLen => GetResourceString("Argument_InvalidOffLen");

		internal static string Argument_InvalidOpCodeOnDynamicMethod => GetResourceString("Argument_InvalidOpCodeOnDynamicMethod");

		internal static string Argument_InvalidParameterInfo => GetResourceString("Argument_InvalidParameterInfo");

		internal static string Argument_InvalidParamInfo => GetResourceString("Argument_InvalidParamInfo");

		internal static string Argument_InvalidPathChars => GetResourceString("Argument_InvalidPathChars");

		internal static string Argument_InvalidResourceCultureName => GetResourceString("Argument_InvalidResourceCultureName");

		internal static string Argument_InvalidSafeBufferOffLen => GetResourceString("Argument_InvalidSafeBufferOffLen");

		internal static string Argument_InvalidSeekOrigin => GetResourceString("Argument_InvalidSeekOrigin");

		internal static string Argument_InvalidSerializedString => GetResourceString("Argument_InvalidSerializedString");

		internal static string Argument_InvalidStartupHookSignature => GetResourceString("Argument_InvalidStartupHookSignature");

		internal static string Argument_InvalidTimeSpanStyles => GetResourceString("Argument_InvalidTimeSpanStyles");

		internal static string Argument_InvalidToken => GetResourceString("Argument_InvalidToken");

		internal static string Argument_InvalidTypeForCA => GetResourceString("Argument_InvalidTypeForCA");

		internal static string Argument_InvalidTypeForDynamicMethod => GetResourceString("Argument_InvalidTypeForDynamicMethod");

		internal static string Argument_InvalidTypeName => GetResourceString("Argument_InvalidTypeName");

		internal static string Argument_InvalidTypeWithPointersNotSupported => GetResourceString("Argument_InvalidTypeWithPointersNotSupported");

		internal static string Argument_InvalidUnity => GetResourceString("Argument_InvalidUnity");

		internal static string Argument_LargeInteger => GetResourceString("Argument_LargeInteger");

		internal static string Argument_LongEnvVarValue => GetResourceString("Argument_LongEnvVarValue");

		internal static string Argument_MethodDeclaringTypeGeneric => GetResourceString("Argument_MethodDeclaringTypeGeneric");

		internal static string Argument_MethodDeclaringTypeGenericLcg => GetResourceString("Argument_MethodDeclaringTypeGenericLcg");

		internal static string Argument_MethodNeedGenericDeclaringType => GetResourceString("Argument_MethodNeedGenericDeclaringType");

		internal static string Argument_MinMaxValue => GetResourceString("Argument_MinMaxValue");

		internal static string Argument_MismatchedArrays => GetResourceString("Argument_MismatchedArrays");

		internal static string Argument_MissingDefaultConstructor => GetResourceString("Argument_MissingDefaultConstructor");

		internal static string Argument_MustBeFalse => GetResourceString("Argument_MustBeFalse");

		internal static string Argument_MustBeRuntimeAssembly => GetResourceString("Argument_MustBeRuntimeAssembly");

		internal static string Argument_MustBeRuntimeFieldInfo => GetResourceString("Argument_MustBeRuntimeFieldInfo");

		internal static string Argument_MustBeRuntimeMethodInfo => GetResourceString("Argument_MustBeRuntimeMethodInfo");

		internal static string Argument_MustBeRuntimeReflectionObject => GetResourceString("Argument_MustBeRuntimeReflectionObject");

		internal static string Argument_MustBeRuntimeType => GetResourceString("Argument_MustBeRuntimeType");

		internal static string Argument_MustBeTypeBuilder => GetResourceString("Argument_MustBeTypeBuilder");

		internal static string Argument_MustHaveAttributeBaseClass => GetResourceString("Argument_MustHaveAttributeBaseClass");

		internal static string Argument_NativeOverlappedAlreadyFree => GetResourceString("Argument_NativeOverlappedAlreadyFree");

		internal static string Argument_NativeOverlappedWrongBoundHandle => GetResourceString("Argument_NativeOverlappedWrongBoundHandle");

		internal static string Argument_NeedGenericMethodDefinition => GetResourceString("Argument_NeedGenericMethodDefinition");

		internal static string Argument_NeedNonGenericType => GetResourceString("Argument_NeedNonGenericType");

		internal static string Argument_NeedStructWithNoRefs => GetResourceString("Argument_NeedStructWithNoRefs");

		internal static string Argument_NeverValidGenericArgument => GetResourceString("Argument_NeverValidGenericArgument");

		internal static string Argument_NoEra => GetResourceString("Argument_NoEra");

		internal static string Argument_NoRegionInvariantCulture => GetResourceString("Argument_NoRegionInvariantCulture");

		internal static string Argument_NotAWritableProperty => GetResourceString("Argument_NotAWritableProperty");

		internal static string Argument_NotEnoughBytesToRead => GetResourceString("Argument_NotEnoughBytesToRead");

		internal static string Argument_NotEnoughBytesToWrite => GetResourceString("Argument_NotEnoughBytesToWrite");

		internal static string Argument_NotEnoughGenArguments => GetResourceString("Argument_NotEnoughGenArguments");

		internal static string Argument_NotExceptionType => GetResourceString("Argument_NotExceptionType");

		internal static string Argument_NotInExceptionBlock => GetResourceString("Argument_NotInExceptionBlock");

		internal static string Argument_NotMethodCallOpcode => GetResourceString("Argument_NotMethodCallOpcode");

		internal static string Argument_NotSerializable => GetResourceString("Argument_NotSerializable");

		internal static string Argument_ObjNotComObject => GetResourceString("Argument_ObjNotComObject");

		internal static string Argument_OffsetAndCapacityOutOfBounds => GetResourceString("Argument_OffsetAndCapacityOutOfBounds");

		internal static string Argument_OffsetLocalMismatch => GetResourceString("Argument_OffsetLocalMismatch");

		internal static string Argument_OffsetOfFieldNotFound => GetResourceString("Argument_OffsetOfFieldNotFound");

		internal static string Argument_OffsetOutOfRange => GetResourceString("Argument_OffsetOutOfRange");

		internal static string Argument_OffsetPrecision => GetResourceString("Argument_OffsetPrecision");

		internal static string Argument_OffsetUtcMismatch => GetResourceString("Argument_OffsetUtcMismatch");

		internal static string Argument_OneOfCulturesNotSupported => GetResourceString("Argument_OneOfCulturesNotSupported");

		internal static string Argument_OnlyMscorlib => GetResourceString("Argument_OnlyMscorlib");

		internal static string Argument_OutOfOrderDateTimes => GetResourceString("Argument_OutOfOrderDateTimes");

		internal static string Argument_PathEmpty => GetResourceString("Argument_PathEmpty");

		internal static string Argument_PreAllocatedAlreadyAllocated => GetResourceString("Argument_PreAllocatedAlreadyAllocated");

		internal static string Argument_RecursiveFallback => GetResourceString("Argument_RecursiveFallback");

		internal static string Argument_RecursiveFallbackBytes => GetResourceString("Argument_RecursiveFallbackBytes");

		internal static string Argument_RedefinedLabel => GetResourceString("Argument_RedefinedLabel");

		internal static string Argument_ResolveField => GetResourceString("Argument_ResolveField");

		internal static string Argument_ResolveFieldHandle => GetResourceString("Argument_ResolveFieldHandle");

		internal static string Argument_ResolveMember => GetResourceString("Argument_ResolveMember");

		internal static string Argument_ResolveMethod => GetResourceString("Argument_ResolveMethod");

		internal static string Argument_ResolveMethodHandle => GetResourceString("Argument_ResolveMethodHandle");

		internal static string Argument_ResolveModuleType => GetResourceString("Argument_ResolveModuleType");

		internal static string Argument_ResolveString => GetResourceString("Argument_ResolveString");

		internal static string Argument_ResolveType => GetResourceString("Argument_ResolveType");

		internal static string Argument_ResultCalendarRange => GetResourceString("Argument_ResultCalendarRange");

		internal static string Argument_SemaphoreInitialMaximum => GetResourceString("Argument_SemaphoreInitialMaximum");

		internal static string Argument_ShouldNotSpecifyExceptionType => GetResourceString("Argument_ShouldNotSpecifyExceptionType");

		internal static string Argument_ShouldOnlySetVisibilityFlags => GetResourceString("Argument_ShouldOnlySetVisibilityFlags");

		internal static string Argument_SigIsFinalized => GetResourceString("Argument_SigIsFinalized");

		internal static string Argument_StreamNotReadable => GetResourceString("Argument_StreamNotReadable");

		internal static string Argument_StreamNotWritable => GetResourceString("Argument_StreamNotWritable");

		internal static string Argument_StringFirstCharIsZero => GetResourceString("Argument_StringFirstCharIsZero");

		internal static string Argument_StringZeroLength => GetResourceString("Argument_StringZeroLength");

		internal static string Argument_TimeSpanHasSeconds => GetResourceString("Argument_TimeSpanHasSeconds");

		internal static string Argument_ToExclusiveLessThanFromExclusive => GetResourceString("Argument_ToExclusiveLessThanFromExclusive");

		internal static string Argument_TooManyFinallyClause => GetResourceString("Argument_TooManyFinallyClause");

		internal static string Argument_TransitionTimesAreIdentical => GetResourceString("Argument_TransitionTimesAreIdentical");

		internal static string Argument_TypedReferenceInvalidField => GetResourceString("Argument_TypedReferenceInvalidField");

		internal static string Argument_TypeMustNotBeComImport => GetResourceString("Argument_TypeMustNotBeComImport");

		internal static string Argument_TypeNameTooLong => GetResourceString("Argument_TypeNameTooLong");

		internal static string Argument_TypeNotComObject => GetResourceString("Argument_TypeNotComObject");

		internal static string Argument_TypeNotValid => GetResourceString("Argument_TypeNotValid");

		internal static string Argument_UnclosedExceptionBlock => GetResourceString("Argument_UnclosedExceptionBlock");

		internal static string Argument_UnknownUnmanagedCallConv => GetResourceString("Argument_UnknownUnmanagedCallConv");

		internal static string Argument_UnmanagedMemAccessorWrapAround => GetResourceString("Argument_UnmanagedMemAccessorWrapAround");

		internal static string Argument_UnmatchedMethodForLocal => GetResourceString("Argument_UnmatchedMethodForLocal");

		internal static string Argument_UnmatchingSymScope => GetResourceString("Argument_UnmatchingSymScope");

		internal static string Argument_UTCOutOfRange => GetResourceString("Argument_UTCOutOfRange");

		internal static string ArgumentException_BadMethodImplBody => GetResourceString("ArgumentException_BadMethodImplBody");

		internal static string ArgumentException_BufferNotFromPool => GetResourceString("ArgumentException_BufferNotFromPool");

		internal static string ArgumentException_OtherNotArrayOfCorrectLength => GetResourceString("ArgumentException_OtherNotArrayOfCorrectLength");

		internal static string ArgumentException_NotIsomorphic => GetResourceString("ArgumentException_NotIsomorphic");

		internal static string ArgumentException_TupleIncorrectType => GetResourceString("ArgumentException_TupleIncorrectType");

		internal static string ArgumentException_TupleLastArgumentNotATuple => GetResourceString("ArgumentException_TupleLastArgumentNotATuple");

		internal static string ArgumentException_ValueTupleIncorrectType => GetResourceString("ArgumentException_ValueTupleIncorrectType");

		internal static string ArgumentException_ValueTupleLastArgumentNotAValueTuple => GetResourceString("ArgumentException_ValueTupleLastArgumentNotAValueTuple");

		internal static string ArgumentNull_Array => GetResourceString("ArgumentNull_Array");

		internal static string ArgumentNull_ArrayElement => GetResourceString("ArgumentNull_ArrayElement");

		internal static string ArgumentNull_ArrayValue => GetResourceString("ArgumentNull_ArrayValue");

		internal static string ArgumentNull_Assembly => GetResourceString("ArgumentNull_Assembly");

		internal static string ArgumentNull_AssemblyNameName => GetResourceString("ArgumentNull_AssemblyNameName");

		internal static string ArgumentNull_Buffer => GetResourceString("ArgumentNull_Buffer");

		internal static string ArgumentNull_Child => GetResourceString("ArgumentNull_Child");

		internal static string ArgumentNull_Collection => GetResourceString("ArgumentNull_Collection");

		internal static string ArgumentNull_Dictionary => GetResourceString("ArgumentNull_Dictionary");

		internal static string ArgumentNull_FileName => GetResourceString("ArgumentNull_FileName");

		internal static string ArgumentNull_Generic => GetResourceString("ArgumentNull_Generic");

		internal static string ArgumentNull_Key => GetResourceString("ArgumentNull_Key");

		internal static string ArgumentNull_Path => GetResourceString("ArgumentNull_Path");

		internal static string ArgumentNull_SafeHandle => GetResourceString("ArgumentNull_SafeHandle");

		internal static string ArgumentNull_Stream => GetResourceString("ArgumentNull_Stream");

		internal static string ArgumentNull_String => GetResourceString("ArgumentNull_String");

		internal static string ArgumentNull_Type => GetResourceString("ArgumentNull_Type");

		internal static string ArgumentNull_Waithandles => GetResourceString("ArgumentNull_Waithandles");

		internal static string ArgumentOutOfRange_ActualValue => GetResourceString("ArgumentOutOfRange_ActualValue");

		internal static string ArgumentOutOfRange_AddressSpace => GetResourceString("ArgumentOutOfRange_AddressSpace");

		internal static string ArgumentOutOfRange_AddValue => GetResourceString("ArgumentOutOfRange_AddValue");

		internal static string ArgumentOutOfRange_ArrayLB => GetResourceString("ArgumentOutOfRange_ArrayLB");

		internal static string ArgumentOutOfRange_BadHourMinuteSecond => GetResourceString("ArgumentOutOfRange_BadHourMinuteSecond");

		internal static string ArgumentOutOfRange_BadYearMonthDay => GetResourceString("ArgumentOutOfRange_BadYearMonthDay");

		internal static string ArgumentOutOfRange_BiggerThanCollection => GetResourceString("ArgumentOutOfRange_BiggerThanCollection");

		internal static string ArgumentOutOfRange_BinaryReaderFillBuffer => GetResourceString("ArgumentOutOfRange_BinaryReaderFillBuffer");

		internal static string ArgumentOutOfRange_Bounds_Lower_Upper => GetResourceString("ArgumentOutOfRange_Bounds_Lower_Upper");

		internal static string ArgumentOutOfRange_CalendarRange => GetResourceString("ArgumentOutOfRange_CalendarRange");

		internal static string ArgumentOutOfRange_Capacity => GetResourceString("ArgumentOutOfRange_Capacity");

		internal static string ArgumentOutOfRange_Count => GetResourceString("ArgumentOutOfRange_Count");

		internal static string ArgumentOutOfRange_DateArithmetic => GetResourceString("ArgumentOutOfRange_DateArithmetic");

		internal static string ArgumentOutOfRange_DateTimeBadMonths => GetResourceString("ArgumentOutOfRange_DateTimeBadMonths");

		internal static string ArgumentOutOfRange_DateTimeBadTicks => GetResourceString("ArgumentOutOfRange_DateTimeBadTicks");

		internal static string ArgumentOutOfRange_TimeOnlyBadTicks => GetResourceString("ArgumentOutOfRange_TimeOnlyBadTicks");

		internal static string ArgumentOutOfRange_DateTimeBadYears => GetResourceString("ArgumentOutOfRange_DateTimeBadYears");

		internal static string ArgumentOutOfRange_Day => GetResourceString("ArgumentOutOfRange_Day");

		internal static string ArgumentOutOfRange_DayOfWeek => GetResourceString("ArgumentOutOfRange_DayOfWeek");

		internal static string ArgumentOutOfRange_DayParam => GetResourceString("ArgumentOutOfRange_DayParam");

		internal static string ArgumentOutOfRange_DecimalRound => GetResourceString("ArgumentOutOfRange_DecimalRound");

		internal static string ArgumentOutOfRange_DecimalScale => GetResourceString("ArgumentOutOfRange_DecimalScale");

		internal static string ArgumentOutOfRange_EndIndexStartIndex => GetResourceString("ArgumentOutOfRange_EndIndexStartIndex");

		internal static string ArgumentOutOfRange_Enum => GetResourceString("ArgumentOutOfRange_Enum");

		internal static string ArgumentOutOfRange_Era => GetResourceString("ArgumentOutOfRange_Era");

		internal static string ArgumentOutOfRange_FileLengthTooBig => GetResourceString("ArgumentOutOfRange_FileLengthTooBig");

		internal static string ArgumentOutOfRange_FileTimeInvalid => GetResourceString("ArgumentOutOfRange_FileTimeInvalid");

		internal static string ArgumentOutOfRange_GenericPositive => GetResourceString("ArgumentOutOfRange_GenericPositive");

		internal static string ArgumentOutOfRange_GetByteCountOverflow => GetResourceString("ArgumentOutOfRange_GetByteCountOverflow");

		internal static string ArgumentOutOfRange_GetCharCountOverflow => GetResourceString("ArgumentOutOfRange_GetCharCountOverflow");

		internal static string ArgumentOutOfRange_HashtableLoadFactor => GetResourceString("ArgumentOutOfRange_HashtableLoadFactor");

		internal static string ArgumentOutOfRange_HugeArrayNotSupported => GetResourceString("ArgumentOutOfRange_HugeArrayNotSupported");

		internal static string ArgumentOutOfRange_Index => GetResourceString("ArgumentOutOfRange_Index");

		internal static string ArgumentOutOfRange_IndexCount => GetResourceString("ArgumentOutOfRange_IndexCount");

		internal static string ArgumentOutOfRange_IndexCountBuffer => GetResourceString("ArgumentOutOfRange_IndexCountBuffer");

		internal static string ArgumentOutOfRange_IndexLength => GetResourceString("ArgumentOutOfRange_IndexLength");

		internal static string ArgumentOutOfRange_IndexString => GetResourceString("ArgumentOutOfRange_IndexString");

		internal static string ArgumentOutOfRange_InputTooLarge => GetResourceString("ArgumentOutOfRange_InputTooLarge");

		internal static string ArgumentOutOfRange_InvalidEraValue => GetResourceString("ArgumentOutOfRange_InvalidEraValue");

		internal static string ArgumentOutOfRange_InvalidHighSurrogate => GetResourceString("ArgumentOutOfRange_InvalidHighSurrogate");

		internal static string ArgumentOutOfRange_InvalidLowSurrogate => GetResourceString("ArgumentOutOfRange_InvalidLowSurrogate");

		internal static string ArgumentOutOfRange_InvalidUTF32 => GetResourceString("ArgumentOutOfRange_InvalidUTF32");

		internal static string ArgumentOutOfRange_Length => GetResourceString("ArgumentOutOfRange_Length");

		internal static string ArgumentOutOfRange_LengthGreaterThanCapacity => GetResourceString("ArgumentOutOfRange_LengthGreaterThanCapacity");

		internal static string ArgumentOutOfRange_LengthTooLarge => GetResourceString("ArgumentOutOfRange_LengthTooLarge");

		internal static string ArgumentOutOfRange_LessEqualToIntegerMaxVal => GetResourceString("ArgumentOutOfRange_LessEqualToIntegerMaxVal");

		internal static string ArgumentOutOfRange_ListInsert => GetResourceString("ArgumentOutOfRange_ListInsert");

		internal static string ArgumentOutOfRange_Month => GetResourceString("ArgumentOutOfRange_Month");

		internal static string ArgumentOutOfRange_DayNumber => GetResourceString("ArgumentOutOfRange_DayNumber");

		internal static string ArgumentOutOfRange_MonthParam => GetResourceString("ArgumentOutOfRange_MonthParam");

		internal static string ArgumentOutOfRange_MustBeNonNegInt32 => GetResourceString("ArgumentOutOfRange_MustBeNonNegInt32");

		internal static string ArgumentOutOfRange_MustBeNonNegNum => GetResourceString("ArgumentOutOfRange_MustBeNonNegNum");

		internal static string ArgumentOutOfRange_MustBePositive => GetResourceString("ArgumentOutOfRange_MustBePositive");

		internal static string ArgumentOutOfRange_NeedNonNegNum => GetResourceString("ArgumentOutOfRange_NeedNonNegNum");

		internal static string ArgumentOutOfRange_NeedNonNegOrNegative1 => GetResourceString("ArgumentOutOfRange_NeedNonNegOrNegative1");

		internal static string ArgumentOutOfRange_NeedPosNum => GetResourceString("ArgumentOutOfRange_NeedPosNum");

		internal static string ArgumentOutOfRange_NeedValidId => GetResourceString("ArgumentOutOfRange_NeedValidId");

		internal static string ArgumentOutOfRange_NegativeCapacity => GetResourceString("ArgumentOutOfRange_NegativeCapacity");

		internal static string ArgumentOutOfRange_NegativeCount => GetResourceString("ArgumentOutOfRange_NegativeCount");

		internal static string ArgumentOutOfRange_NegativeLength => GetResourceString("ArgumentOutOfRange_NegativeLength");

		internal static string ArgumentOutOfRange_OffsetLength => GetResourceString("ArgumentOutOfRange_OffsetLength");

		internal static string ArgumentOutOfRange_OffsetOut => GetResourceString("ArgumentOutOfRange_OffsetOut");

		internal static string ArgumentOutOfRange_ParamSequence => GetResourceString("ArgumentOutOfRange_ParamSequence");

		internal static string ArgumentOutOfRange_PartialWCHAR => GetResourceString("ArgumentOutOfRange_PartialWCHAR");

		internal static string ArgumentOutOfRange_PeriodTooLarge => GetResourceString("ArgumentOutOfRange_PeriodTooLarge");

		internal static string ArgumentOutOfRange_PositionLessThanCapacityRequired => GetResourceString("ArgumentOutOfRange_PositionLessThanCapacityRequired");

		internal static string ArgumentOutOfRange_Range => GetResourceString("ArgumentOutOfRange_Range");

		internal static string ArgumentOutOfRange_RoundingDigits => GetResourceString("ArgumentOutOfRange_RoundingDigits");

		internal static string ArgumentOutOfRange_RoundingDigits_MathF => GetResourceString("ArgumentOutOfRange_RoundingDigits_MathF");

		internal static string ArgumentOutOfRange_SmallCapacity => GetResourceString("ArgumentOutOfRange_SmallCapacity");

		internal static string ArgumentOutOfRange_SmallMaxCapacity => GetResourceString("ArgumentOutOfRange_SmallMaxCapacity");

		internal static string ArgumentOutOfRange_StartIndex => GetResourceString("ArgumentOutOfRange_StartIndex");

		internal static string ArgumentOutOfRange_StartIndexLargerThanLength => GetResourceString("ArgumentOutOfRange_StartIndexLargerThanLength");

		internal static string ArgumentOutOfRange_StreamLength => GetResourceString("ArgumentOutOfRange_StreamLength");

		internal static string ArgumentOutOfRange_TimeoutTooLarge => GetResourceString("ArgumentOutOfRange_TimeoutTooLarge");

		internal static string ArgumentOutOfRange_UIntPtrMax => GetResourceString("ArgumentOutOfRange_UIntPtrMax");

		internal static string ArgumentOutOfRange_UnmanagedMemStreamLength => GetResourceString("ArgumentOutOfRange_UnmanagedMemStreamLength");

		internal static string ArgumentOutOfRange_UnmanagedMemStreamWrapAround => GetResourceString("ArgumentOutOfRange_UnmanagedMemStreamWrapAround");

		internal static string ArgumentOutOfRange_UtcOffset => GetResourceString("ArgumentOutOfRange_UtcOffset");

		internal static string ArgumentOutOfRange_UtcOffsetAndDaylightDelta => GetResourceString("ArgumentOutOfRange_UtcOffsetAndDaylightDelta");

		internal static string ArgumentOutOfRange_Version => GetResourceString("ArgumentOutOfRange_Version");

		internal static string ArgumentOutOfRange_Week => GetResourceString("ArgumentOutOfRange_Week");

		internal static string ArgumentOutOfRange_Year => GetResourceString("ArgumentOutOfRange_Year");

		internal static string Arithmetic_NaN => GetResourceString("Arithmetic_NaN");

		internal static string ArrayTypeMismatch_ConstrainedCopy => GetResourceString("ArrayTypeMismatch_ConstrainedCopy");

		internal static string AssemblyLoadContext_Unload_CannotUnloadIfNotCollectible => GetResourceString("AssemblyLoadContext_Unload_CannotUnloadIfNotCollectible");

		internal static string AssemblyLoadContext_Verify_NotUnloading => GetResourceString("AssemblyLoadContext_Verify_NotUnloading");

		internal static string AssertionFailed => GetResourceString("AssertionFailed");

		internal static string AssertionFailed_Cnd => GetResourceString("AssertionFailed_Cnd");

		internal static string AssumptionFailed => GetResourceString("AssumptionFailed");

		internal static string AssumptionFailed_Cnd => GetResourceString("AssumptionFailed_Cnd");

		internal static string AsyncMethodBuilder_InstanceNotInitialized => GetResourceString("AsyncMethodBuilder_InstanceNotInitialized");

		internal static string BadImageFormat_BadILFormat => GetResourceString("BadImageFormat_BadILFormat");

		internal static string BadImageFormat_InvalidType => GetResourceString("BadImageFormat_InvalidType");

		internal static string BadImageFormat_NegativeStringLength => GetResourceString("BadImageFormat_NegativeStringLength");

		internal static string BadImageFormat_ParameterSignatureMismatch => GetResourceString("BadImageFormat_ParameterSignatureMismatch");

		internal static string BadImageFormat_ResType_SerBlobMismatch => GetResourceString("BadImageFormat_ResType_SerBlobMismatch");

		internal static string BadImageFormat_ResourceDataLengthInvalid => GetResourceString("BadImageFormat_ResourceDataLengthInvalid");

		internal static string BadImageFormat_ResourceNameCorrupted => GetResourceString("BadImageFormat_ResourceNameCorrupted");

		internal static string BadImageFormat_ResourceNameCorrupted_NameIndex => GetResourceString("BadImageFormat_ResourceNameCorrupted_NameIndex");

		internal static string BadImageFormat_ResourcesDataInvalidOffset => GetResourceString("BadImageFormat_ResourcesDataInvalidOffset");

		internal static string BadImageFormat_ResourcesHeaderCorrupted => GetResourceString("BadImageFormat_ResourcesHeaderCorrupted");

		internal static string BadImageFormat_ResourcesIndexTooLong => GetResourceString("BadImageFormat_ResourcesIndexTooLong");

		internal static string BadImageFormat_ResourcesNameInvalidOffset => GetResourceString("BadImageFormat_ResourcesNameInvalidOffset");

		internal static string BadImageFormat_ResourcesNameTooLong => GetResourceString("BadImageFormat_ResourcesNameTooLong");

		internal static string BadImageFormat_TypeMismatch => GetResourceString("BadImageFormat_TypeMismatch");

		internal static string CancellationToken_CreateLinkedToken_TokensIsEmpty => GetResourceString("CancellationToken_CreateLinkedToken_TokensIsEmpty");

		internal static string CancellationTokenSource_Disposed => GetResourceString("CancellationTokenSource_Disposed");

		internal static string ConcurrentCollection_SyncRoot_NotSupported => GetResourceString("ConcurrentCollection_SyncRoot_NotSupported");

		internal static string EventSource_AbstractMustNotDeclareEventMethods => GetResourceString("EventSource_AbstractMustNotDeclareEventMethods");

		internal static string EventSource_AbstractMustNotDeclareKTOC => GetResourceString("EventSource_AbstractMustNotDeclareKTOC");

		internal static string EventSource_AddScalarOutOfRange => GetResourceString("EventSource_AddScalarOutOfRange");

		internal static string EventSource_BadHexDigit => GetResourceString("EventSource_BadHexDigit");

		internal static string EventSource_ChannelTypeDoesNotMatchEventChannelValue => GetResourceString("EventSource_ChannelTypeDoesNotMatchEventChannelValue");

		internal static string EventSource_DataDescriptorsOutOfRange => GetResourceString("EventSource_DataDescriptorsOutOfRange");

		internal static string EventSource_DuplicateStringKey => GetResourceString("EventSource_DuplicateStringKey");

		internal static string EventSource_EnumKindMismatch => GetResourceString("EventSource_EnumKindMismatch");

		internal static string EventSource_EvenHexDigits => GetResourceString("EventSource_EvenHexDigits");

		internal static string EventSource_EventChannelOutOfRange => GetResourceString("EventSource_EventChannelOutOfRange");

		internal static string EventSource_EventIdReused => GetResourceString("EventSource_EventIdReused");

		internal static string EventSource_EventMustHaveTaskIfNonDefaultOpcode => GetResourceString("EventSource_EventMustHaveTaskIfNonDefaultOpcode");

		internal static string EventSource_EventMustNotBeExplicitImplementation => GetResourceString("EventSource_EventMustNotBeExplicitImplementation");

		internal static string EventSource_EventNameReused => GetResourceString("EventSource_EventNameReused");

		internal static string EventSource_EventParametersMismatch => GetResourceString("EventSource_EventParametersMismatch");

		internal static string EventSource_EventSourceGuidInUse => GetResourceString("EventSource_EventSourceGuidInUse");

		internal static string EventSource_EventTooBig => GetResourceString("EventSource_EventTooBig");

		internal static string EventSource_EventWithAdminChannelMustHaveMessage => GetResourceString("EventSource_EventWithAdminChannelMustHaveMessage");

		internal static string EventSource_IllegalKeywordsValue => GetResourceString("EventSource_IllegalKeywordsValue");

		internal static string EventSource_IllegalOpcodeValue => GetResourceString("EventSource_IllegalOpcodeValue");

		internal static string EventSource_IllegalTaskValue => GetResourceString("EventSource_IllegalTaskValue");

		internal static string EventSource_IllegalValue => GetResourceString("EventSource_IllegalValue");

		internal static string EventSource_IncorrentlyAuthoredTypeInfo => GetResourceString("EventSource_IncorrentlyAuthoredTypeInfo");

		internal static string EventSource_InvalidCommand => GetResourceString("EventSource_InvalidCommand");

		internal static string EventSource_InvalidEventFormat => GetResourceString("EventSource_InvalidEventFormat");

		internal static string EventSource_KeywordCollision => GetResourceString("EventSource_KeywordCollision");

		internal static string EventSource_KeywordNeedPowerOfTwo => GetResourceString("EventSource_KeywordNeedPowerOfTwo");

		internal static string EventSource_ListenerCreatedInsideCallback => GetResourceString("EventSource_ListenerCreatedInsideCallback");

		internal static string EventSource_ListenerNotFound => GetResourceString("EventSource_ListenerNotFound");

		internal static string EventSource_ListenerWriteFailure => GetResourceString("EventSource_ListenerWriteFailure");

		internal static string EventSource_MaxChannelExceeded => GetResourceString("EventSource_MaxChannelExceeded");

		internal static string EventSource_MismatchIdToWriteEvent => GetResourceString("EventSource_MismatchIdToWriteEvent");

		internal static string EventSource_NeedGuid => GetResourceString("EventSource_NeedGuid");

		internal static string EventSource_NeedName => GetResourceString("EventSource_NeedName");

		internal static string EventSource_NeedPositiveId => GetResourceString("EventSource_NeedPositiveId");

		internal static string EventSource_NoFreeBuffers => GetResourceString("EventSource_NoFreeBuffers");

		internal static string EventSource_NonCompliantTypeError => GetResourceString("EventSource_NonCompliantTypeError");

		internal static string EventSource_NoRelatedActivityId => GetResourceString("EventSource_NoRelatedActivityId");

		internal static string EventSource_NotSupportedArrayOfBinary => GetResourceString("EventSource_NotSupportedArrayOfBinary");

		internal static string EventSource_NotSupportedArrayOfNil => GetResourceString("EventSource_NotSupportedArrayOfNil");

		internal static string EventSource_NotSupportedArrayOfNullTerminatedString => GetResourceString("EventSource_NotSupportedArrayOfNullTerminatedString");

		internal static string EventSource_NotSupportedNestedArraysEnums => GetResourceString("EventSource_NotSupportedNestedArraysEnums");

		internal static string EventSource_NullInput => GetResourceString("EventSource_NullInput");

		internal static string EventSource_OpcodeCollision => GetResourceString("EventSource_OpcodeCollision");

		internal static string EventSource_PinArrayOutOfRange => GetResourceString("EventSource_PinArrayOutOfRange");

		internal static string EventSource_RecursiveTypeDefinition => GetResourceString("EventSource_RecursiveTypeDefinition");

		internal static string EventSource_StopsFollowStarts => GetResourceString("EventSource_StopsFollowStarts");

		internal static string EventSource_TaskCollision => GetResourceString("EventSource_TaskCollision");

		internal static string EventSource_TaskOpcodePairReused => GetResourceString("EventSource_TaskOpcodePairReused");

		internal static string EventSource_TooManyArgs => GetResourceString("EventSource_TooManyArgs");

		internal static string EventSource_TooManyFields => GetResourceString("EventSource_TooManyFields");

		internal static string EventSource_ToString => GetResourceString("EventSource_ToString");

		internal static string EventSource_TraitEven => GetResourceString("EventSource_TraitEven");

		internal static string EventSource_TypeMustBeSealedOrAbstract => GetResourceString("EventSource_TypeMustBeSealedOrAbstract");

		internal static string EventSource_TypeMustDeriveFromEventSource => GetResourceString("EventSource_TypeMustDeriveFromEventSource");

		internal static string EventSource_UndefinedChannel => GetResourceString("EventSource_UndefinedChannel");

		internal static string EventSource_UndefinedKeyword => GetResourceString("EventSource_UndefinedKeyword");

		internal static string EventSource_UndefinedOpcode => GetResourceString("EventSource_UndefinedOpcode");

		internal static string EventSource_UnknownEtwTrait => GetResourceString("EventSource_UnknownEtwTrait");

		internal static string EventSource_UnsupportedEventTypeInManifest => GetResourceString("EventSource_UnsupportedEventTypeInManifest");

		internal static string EventSource_UnsupportedMessageProperty => GetResourceString("EventSource_UnsupportedMessageProperty");

		internal static string EventSource_VarArgsParameterMismatch => GetResourceString("EventSource_VarArgsParameterMismatch");

		internal static string Exception_EndOfInnerExceptionStack => GetResourceString("Exception_EndOfInnerExceptionStack");

		internal static string Exception_EndStackTraceFromPreviousThrow => GetResourceString("Exception_EndStackTraceFromPreviousThrow");

		internal static string Exception_WasThrown => GetResourceString("Exception_WasThrown");

		internal static string ExecutionContext_ExceptionInAsyncLocalNotification => GetResourceString("ExecutionContext_ExceptionInAsyncLocalNotification");

		internal static string FileNotFound_ResolveAssembly => GetResourceString("FileNotFound_ResolveAssembly");

		internal static string Format_AttributeUsage => GetResourceString("Format_AttributeUsage");

		internal static string Format_Bad7BitInt => GetResourceString("Format_Bad7BitInt");

		internal static string Format_BadBase64Char => GetResourceString("Format_BadBase64Char");

		internal static string Format_BadBoolean => GetResourceString("Format_BadBoolean");

		internal static string Format_BadDateOnly => GetResourceString("Format_BadDateOnly");

		internal static string Format_BadTimeOnly => GetResourceString("Format_BadTimeOnly");

		internal static string Format_DateTimeOnlyContainsNoneDateParts => GetResourceString("Format_DateTimeOnlyContainsNoneDateParts");

		internal static string Format_BadFormatSpecifier => GetResourceString("Format_BadFormatSpecifier");

		internal static string Format_NoFormatSpecifier => GetResourceString("Format_NoFormatSpecifier");

		internal static string Format_BadHexChar => GetResourceString("Format_BadHexChar");

		internal static string Format_BadHexLength => GetResourceString("Format_BadHexLength");

		internal static string Format_BadQuote => GetResourceString("Format_BadQuote");

		internal static string Format_BadTimeSpan => GetResourceString("Format_BadTimeSpan");

		internal static string Format_EmptyInputString => GetResourceString("Format_EmptyInputString");

		internal static string Format_ExtraJunkAtEnd => GetResourceString("Format_ExtraJunkAtEnd");

		internal static string Format_GuidUnrecognized => GetResourceString("Format_GuidUnrecognized");

		internal static string Format_IndexOutOfRange => GetResourceString("Format_IndexOutOfRange");

		internal static string Format_InvalidEnumFormatSpecification => GetResourceString("Format_InvalidEnumFormatSpecification");

		internal static string Format_InvalidGuidFormatSpecification => GetResourceString("Format_InvalidGuidFormatSpecification");

		internal static string Format_InvalidString => GetResourceString("Format_InvalidString");

		internal static string Format_NeedSingleChar => GetResourceString("Format_NeedSingleChar");

		internal static string Format_NoParsibleDigits => GetResourceString("Format_NoParsibleDigits");

		internal static string Format_StringZeroLength => GetResourceString("Format_StringZeroLength");

		internal static string IndexOutOfRange_ArrayRankIndex => GetResourceString("IndexOutOfRange_ArrayRankIndex");

		internal static string IndexOutOfRange_UMSPosition => GetResourceString("IndexOutOfRange_UMSPosition");

		internal static string InsufficientMemory_MemFailPoint => GetResourceString("InsufficientMemory_MemFailPoint");

		internal static string InsufficientMemory_MemFailPoint_TooBig => GetResourceString("InsufficientMemory_MemFailPoint_TooBig");

		internal static string InsufficientMemory_MemFailPoint_VAFrag => GetResourceString("InsufficientMemory_MemFailPoint_VAFrag");

		internal static string Interop_COM_TypeMismatch => GetResourceString("Interop_COM_TypeMismatch");

		internal static string Interop_Marshal_Unmappable_Char => GetResourceString("Interop_Marshal_Unmappable_Char");

		internal static string Interop_Marshal_SafeHandle_InvalidOperation => GetResourceString("Interop_Marshal_SafeHandle_InvalidOperation");

		internal static string Interop_Marshal_CannotCreateSafeHandleField => GetResourceString("Interop_Marshal_CannotCreateSafeHandleField");

		internal static string Interop_Marshal_CannotCreateCriticalHandleField => GetResourceString("Interop_Marshal_CannotCreateCriticalHandleField");

		internal static string InvalidCast_CannotCastNullToValueType => GetResourceString("InvalidCast_CannotCastNullToValueType");

		internal static string InvalidCast_CannotCoerceByRefVariant => GetResourceString("InvalidCast_CannotCoerceByRefVariant");

		internal static string InvalidCast_DBNull => GetResourceString("InvalidCast_DBNull");

		internal static string InvalidCast_Empty => GetResourceString("InvalidCast_Empty");

		internal static string InvalidCast_FromDBNull => GetResourceString("InvalidCast_FromDBNull");

		internal static string InvalidCast_FromTo => GetResourceString("InvalidCast_FromTo");

		internal static string InvalidCast_IConvertible => GetResourceString("InvalidCast_IConvertible");

		internal static string InvalidOperation_AsyncFlowCtrlCtxMismatch => GetResourceString("InvalidOperation_AsyncFlowCtrlCtxMismatch");

		internal static string InvalidOperation_AsyncIOInProgress => GetResourceString("InvalidOperation_AsyncIOInProgress");

		internal static string InvalidOperation_BadEmptyMethodBody => GetResourceString("InvalidOperation_BadEmptyMethodBody");

		internal static string InvalidOperation_BadILGeneratorUsage => GetResourceString("InvalidOperation_BadILGeneratorUsage");

		internal static string InvalidOperation_BadInstructionOrIndexOutOfBound => GetResourceString("InvalidOperation_BadInstructionOrIndexOutOfBound");

		internal static string InvalidOperation_BadInterfaceNotAbstract => GetResourceString("InvalidOperation_BadInterfaceNotAbstract");

		internal static string InvalidOperation_BadMethodBody => GetResourceString("InvalidOperation_BadMethodBody");

		internal static string InvalidOperation_BadTypeAttributesNotAbstract => GetResourceString("InvalidOperation_BadTypeAttributesNotAbstract");

		internal static string InvalidOperation_CalledTwice => GetResourceString("InvalidOperation_CalledTwice");

		internal static string InvalidOperation_CannotImportGlobalFromDifferentModule => GetResourceString("InvalidOperation_CannotImportGlobalFromDifferentModule");

		internal static string InvalidOperation_CannotRegisterSecondResolver => GetResourceString("InvalidOperation_CannotRegisterSecondResolver");

		internal static string InvalidOperation_CannotRestoreUnsupressedFlow => GetResourceString("InvalidOperation_CannotRestoreUnsupressedFlow");

		internal static string InvalidOperation_CannotSupressFlowMultipleTimes => GetResourceString("InvalidOperation_CannotSupressFlowMultipleTimes");

		internal static string InvalidOperation_CannotUseAFCMultiple => GetResourceString("InvalidOperation_CannotUseAFCMultiple");

		internal static string InvalidOperation_CannotUseAFCOtherThread => GetResourceString("InvalidOperation_CannotUseAFCOtherThread");

		internal static string InvalidOperation_CollectionCorrupted => GetResourceString("InvalidOperation_CollectionCorrupted");

		internal static string InvalidOperation_ComputerName => GetResourceString("InvalidOperation_ComputerName");

		internal static string InvalidOperation_ConcurrentOperationsNotSupported => GetResourceString("InvalidOperation_ConcurrentOperationsNotSupported");

		internal static string InvalidOperation_ConstructorNotAllowedOnInterface => GetResourceString("InvalidOperation_ConstructorNotAllowedOnInterface");

		internal static string InvalidOperation_DateTimeParsing => GetResourceString("InvalidOperation_DateTimeParsing");

		internal static string InvalidOperation_DefaultConstructorILGen => GetResourceString("InvalidOperation_DefaultConstructorILGen");

		internal static string InvalidOperation_EnumEnded => GetResourceString("InvalidOperation_EnumEnded");

		internal static string InvalidOperation_EnumFailedVersion => GetResourceString("InvalidOperation_EnumFailedVersion");

		internal static string InvalidOperation_EnumNotStarted => GetResourceString("InvalidOperation_EnumNotStarted");

		internal static string InvalidOperation_EnumOpCantHappen => GetResourceString("InvalidOperation_EnumOpCantHappen");

		internal static string InvalidOperation_EventInfoNotAvailable => GetResourceString("InvalidOperation_EventInfoNotAvailable");

		internal static string InvalidOperation_GenericParametersAlreadySet => GetResourceString("InvalidOperation_GenericParametersAlreadySet");

		internal static string InvalidOperation_GetVersion => GetResourceString("InvalidOperation_GetVersion");

		internal static string InvalidOperation_GlobalsHaveBeenCreated => GetResourceString("InvalidOperation_GlobalsHaveBeenCreated");

		internal static string InvalidOperation_HandleIsNotInitialized => GetResourceString("InvalidOperation_HandleIsNotInitialized");

		internal static string InvalidOperation_HandleIsNotPinned => GetResourceString("InvalidOperation_HandleIsNotPinned");

		internal static string InvalidOperation_HashInsertFailed => GetResourceString("InvalidOperation_HashInsertFailed");

		internal static string InvalidOperation_IComparerFailed => GetResourceString("InvalidOperation_IComparerFailed");

		internal static string InvalidOperation_MethodBaked => GetResourceString("InvalidOperation_MethodBaked");

		internal static string InvalidOperation_MethodBuilderBaked => GetResourceString("InvalidOperation_MethodBuilderBaked");

		internal static string InvalidOperation_MethodHasBody => GetResourceString("InvalidOperation_MethodHasBody");

		internal static string InvalidOperation_MustCallInitialize => GetResourceString("InvalidOperation_MustCallInitialize");

		internal static string InvalidOperation_NativeOverlappedReused => GetResourceString("InvalidOperation_NativeOverlappedReused");

		internal static string InvalidOperation_NoMultiModuleAssembly => GetResourceString("InvalidOperation_NoMultiModuleAssembly");

		internal static string InvalidOperation_NoPublicAddMethod => GetResourceString("InvalidOperation_NoPublicAddMethod");

		internal static string InvalidOperation_NoPublicRemoveMethod => GetResourceString("InvalidOperation_NoPublicRemoveMethod");

		internal static string InvalidOperation_NotADebugModule => GetResourceString("InvalidOperation_NotADebugModule");

		internal static string InvalidOperation_NotAllowedInDynamicMethod => GetResourceString("InvalidOperation_NotAllowedInDynamicMethod");

		internal static string InvalidOperation_NotAVarArgCallingConvention => GetResourceString("InvalidOperation_NotAVarArgCallingConvention");

		internal static string InvalidOperation_NotGenericType => GetResourceString("InvalidOperation_NotGenericType");

		internal static string InvalidOperation_NotWithConcurrentGC => GetResourceString("InvalidOperation_NotWithConcurrentGC");

		internal static string InvalidOperation_NoUnderlyingTypeOnEnum => GetResourceString("InvalidOperation_NoUnderlyingTypeOnEnum");

		internal static string InvalidOperation_NoValue => GetResourceString("InvalidOperation_NoValue");

		internal static string InvalidOperation_NullArray => GetResourceString("InvalidOperation_NullArray");

		internal static string InvalidOperation_NullContext => GetResourceString("InvalidOperation_NullContext");

		internal static string InvalidOperation_NullModuleHandle => GetResourceString("InvalidOperation_NullModuleHandle");

		internal static string InvalidOperation_OpenLocalVariableScope => GetResourceString("InvalidOperation_OpenLocalVariableScope");

		internal static string InvalidOperation_Overlapped_Pack => GetResourceString("InvalidOperation_Overlapped_Pack");

		internal static string InvalidOperation_PropertyInfoNotAvailable => GetResourceString("InvalidOperation_PropertyInfoNotAvailable");

		internal static string InvalidOperation_ReadOnly => GetResourceString("InvalidOperation_ReadOnly");

		internal static string InvalidOperation_ResMgrBadResSet_Type => GetResourceString("InvalidOperation_ResMgrBadResSet_Type");

		internal static string InvalidOperation_ResourceNotStream_Name => GetResourceString("InvalidOperation_ResourceNotStream_Name");

		internal static string InvalidOperation_ResourceNotString_Name => GetResourceString("InvalidOperation_ResourceNotString_Name");

		internal static string InvalidOperation_ResourceNotString_Type => GetResourceString("InvalidOperation_ResourceNotString_Type");

		internal static string InvalidOperation_SetLatencyModeNoGC => GetResourceString("InvalidOperation_SetLatencyModeNoGC");

		internal static string InvalidOperation_ShouldNotHaveMethodBody => GetResourceString("InvalidOperation_ShouldNotHaveMethodBody");

		internal static string InvalidOperation_ThreadWrongThreadStart => GetResourceString("InvalidOperation_ThreadWrongThreadStart");

		internal static string InvalidOperation_TimeoutsNotSupported => GetResourceString("InvalidOperation_TimeoutsNotSupported");

		internal static string InvalidOperation_TimerAlreadyClosed => GetResourceString("InvalidOperation_TimerAlreadyClosed");

		internal static string InvalidOperation_TypeHasBeenCreated => GetResourceString("InvalidOperation_TypeHasBeenCreated");

		internal static string InvalidOperation_TypeNotCreated => GetResourceString("InvalidOperation_TypeNotCreated");

		internal static string InvalidOperation_UnderlyingArrayListChanged => GetResourceString("InvalidOperation_UnderlyingArrayListChanged");

		internal static string InvalidOperation_UnknownEnumType => GetResourceString("InvalidOperation_UnknownEnumType");

		internal static string InvalidOperation_WrongAsyncResultOrEndCalledMultiple => GetResourceString("InvalidOperation_WrongAsyncResultOrEndCalledMultiple");

		internal static string InvalidProgram_Default => GetResourceString("InvalidProgram_Default");

		internal static string InvalidTimeZone_InvalidRegistryData => GetResourceString("InvalidTimeZone_InvalidRegistryData");

		internal static string InvariantFailed => GetResourceString("InvariantFailed");

		internal static string InvariantFailed_Cnd => GetResourceString("InvariantFailed_Cnd");

		internal static string IO_NoFileTableInInMemoryAssemblies => GetResourceString("IO_NoFileTableInInMemoryAssemblies");

		internal static string IO_EOF_ReadBeyondEOF => GetResourceString("IO_EOF_ReadBeyondEOF");

		internal static string IO_FileLoad => GetResourceString("IO_FileLoad");

		internal static string IO_FileName_Name => GetResourceString("IO_FileName_Name");

		internal static string IO_FileNotFound => GetResourceString("IO_FileNotFound");

		internal static string IO_FileNotFound_FileName => GetResourceString("IO_FileNotFound_FileName");

		internal static string IO_AlreadyExists_Name => GetResourceString("IO_AlreadyExists_Name");

		internal static string IO_DiskFull_Path_AllocationSize => GetResourceString("IO_DiskFull_Path_AllocationSize");

		internal static string IO_FileTooLarge_Path_AllocationSize => GetResourceString("IO_FileTooLarge_Path_AllocationSize");

		internal static string IO_BindHandleFailed => GetResourceString("IO_BindHandleFailed");

		internal static string IO_FileExists_Name => GetResourceString("IO_FileExists_Name");

		internal static string IO_FileStreamHandlePosition => GetResourceString("IO_FileStreamHandlePosition");

		internal static string IO_FileTooLong2GB => GetResourceString("IO_FileTooLong2GB");

		internal static string IO_FileTooLong => GetResourceString("IO_FileTooLong");

		internal static string IO_FileTooLongOrHandleNotSync => GetResourceString("IO_FileTooLongOrHandleNotSync");

		internal static string IO_FixedCapacity => GetResourceString("IO_FixedCapacity");

		internal static string IO_InvalidStringLen_Len => GetResourceString("IO_InvalidStringLen_Len");

		internal static string IO_SeekAppendOverwrite => GetResourceString("IO_SeekAppendOverwrite");

		internal static string IO_SeekBeforeBegin => GetResourceString("IO_SeekBeforeBegin");

		internal static string IO_SetLengthAppendTruncate => GetResourceString("IO_SetLengthAppendTruncate");

		internal static string IO_SharingViolation_File => GetResourceString("IO_SharingViolation_File");

		internal static string IO_SharingViolation_NoFileName => GetResourceString("IO_SharingViolation_NoFileName");

		internal static string IO_StreamTooLong => GetResourceString("IO_StreamTooLong");

		internal static string IO_PathNotFound_NoPathName => GetResourceString("IO_PathNotFound_NoPathName");

		internal static string IO_PathNotFound_Path => GetResourceString("IO_PathNotFound_Path");

		internal static string IO_PathTooLong => GetResourceString("IO_PathTooLong");

		internal static string IO_PathTooLong_Path => GetResourceString("IO_PathTooLong_Path");

		internal static string IO_UnknownFileName => GetResourceString("IO_UnknownFileName");

		internal static string Lazy_CreateValue_NoParameterlessCtorForT => GetResourceString("Lazy_CreateValue_NoParameterlessCtorForT");

		internal static string Lazy_ctor_ModeInvalid => GetResourceString("Lazy_ctor_ModeInvalid");

		internal static string Lazy_StaticInit_InvalidOperation => GetResourceString("Lazy_StaticInit_InvalidOperation");

		internal static string Lazy_ToString_ValueNotCreated => GetResourceString("Lazy_ToString_ValueNotCreated");

		internal static string Lazy_Value_RecursiveCallsToValue => GetResourceString("Lazy_Value_RecursiveCallsToValue");

		internal static string ManualResetEventSlim_ctor_SpinCountOutOfRange => GetResourceString("ManualResetEventSlim_ctor_SpinCountOutOfRange");

		internal static string ManualResetEventSlim_ctor_TooManyWaiters => GetResourceString("ManualResetEventSlim_ctor_TooManyWaiters");

		internal static string ManualResetEventSlim_Disposed => GetResourceString("ManualResetEventSlim_Disposed");

		internal static string Marshaler_StringTooLong => GetResourceString("Marshaler_StringTooLong");

		internal static string MissingConstructor_Name => GetResourceString("MissingConstructor_Name");

		internal static string MissingField => GetResourceString("MissingField");

		internal static string MissingField_Name => GetResourceString("MissingField_Name");

		internal static string MissingManifestResource_MultipleBlobs => GetResourceString("MissingManifestResource_MultipleBlobs");

		internal static string MissingManifestResource_NoNeutralAsm => GetResourceString("MissingManifestResource_NoNeutralAsm");

		internal static string MissingManifestResource_NoNeutralDisk => GetResourceString("MissingManifestResource_NoNeutralDisk");

		internal static string MissingMember => GetResourceString("MissingMember");

		internal static string MissingMember_Name => GetResourceString("MissingMember_Name");

		internal static string MissingMemberNestErr => GetResourceString("MissingMemberNestErr");

		internal static string MissingMemberTypeRef => GetResourceString("MissingMemberTypeRef");

		internal static string MissingMethod_Name => GetResourceString("MissingMethod_Name");

		internal static string MissingSatelliteAssembly_Culture_Name => GetResourceString("MissingSatelliteAssembly_Culture_Name");

		internal static string MissingSatelliteAssembly_Default => GetResourceString("MissingSatelliteAssembly_Default");

		internal static string Multicast_Combine => GetResourceString("Multicast_Combine");

		internal static string MustUseCCRewrite => GetResourceString("MustUseCCRewrite");

		internal static string NotSupported_AbstractNonCLS => GetResourceString("NotSupported_AbstractNonCLS");

		internal static string NotSupported_ActivAttr => GetResourceString("NotSupported_ActivAttr");

		internal static string NotSupported_AssemblyLoadFromHash => GetResourceString("NotSupported_AssemblyLoadFromHash");

		internal static string NotSupported_ByRefToByRefLikeReturn => GetResourceString("NotSupported_ByRefToByRefLikeReturn");

		internal static string NotSupported_ByRefToVoidReturn => GetResourceString("NotSupported_ByRefToVoidReturn");

		internal static string NotSupported_CallToVarArg => GetResourceString("NotSupported_CallToVarArg");

		internal static string NotSupported_CannotCallEqualsOnSpan => GetResourceString("NotSupported_CannotCallEqualsOnSpan");

		internal static string NotSupported_CannotCallGetHashCodeOnSpan => GetResourceString("NotSupported_CannotCallGetHashCodeOnSpan");

		internal static string NotSupported_ChangeType => GetResourceString("NotSupported_ChangeType");

		internal static string NotSupported_CreateInstanceWithTypeBuilder => GetResourceString("NotSupported_CreateInstanceWithTypeBuilder");

		internal static string NotSupported_DBNullSerial => GetResourceString("NotSupported_DBNullSerial");

		internal static string NotSupported_DynamicAssembly => GetResourceString("NotSupported_DynamicAssembly");

		internal static string NotSupported_DynamicMethodFlags => GetResourceString("NotSupported_DynamicMethodFlags");

		internal static string NotSupported_DynamicModule => GetResourceString("NotSupported_DynamicModule");

		internal static string NotSupported_FixedSizeCollection => GetResourceString("NotSupported_FixedSizeCollection");

		internal static string InvalidOperation_SpanOverlappedOperation => GetResourceString("InvalidOperation_SpanOverlappedOperation");

		internal static string NotSupported_IllegalOneByteBranch => GetResourceString("NotSupported_IllegalOneByteBranch");

		internal static string NotSupported_KeyCollectionSet => GetResourceString("NotSupported_KeyCollectionSet");

		internal static string NotSupported_MaxWaitHandles => GetResourceString("NotSupported_MaxWaitHandles");

		internal static string NotSupported_MemStreamNotExpandable => GetResourceString("NotSupported_MemStreamNotExpandable");

		internal static string NotSupported_MustBeModuleBuilder => GetResourceString("NotSupported_MustBeModuleBuilder");

		internal static string NotSupported_NoCodepageData => GetResourceString("NotSupported_NoCodepageData");

		internal static string InvalidOperation_FunctionMissingUnmanagedCallersOnly => GetResourceString("InvalidOperation_FunctionMissingUnmanagedCallersOnly");

		internal static string NotSupported_NonReflectedType => GetResourceString("NotSupported_NonReflectedType");

		internal static string NotSupported_NoParentDefaultConstructor => GetResourceString("NotSupported_NoParentDefaultConstructor");

		internal static string NotSupported_NoTypeInfo => GetResourceString("NotSupported_NoTypeInfo");

		internal static string NotSupported_NYI => GetResourceString("NotSupported_NYI");

		internal static string NotSupported_ObsoleteResourcesFile => GetResourceString("NotSupported_ObsoleteResourcesFile");

		internal static string NotSupported_OutputStreamUsingTypeBuilder => GetResourceString("NotSupported_OutputStreamUsingTypeBuilder");

		internal static string NotSupported_RangeCollection => GetResourceString("NotSupported_RangeCollection");

		internal static string NotSupported_Reading => GetResourceString("NotSupported_Reading");

		internal static string NotSupported_ReadOnlyCollection => GetResourceString("NotSupported_ReadOnlyCollection");

		internal static string NotSupported_ResourceObjectSerialization => GetResourceString("NotSupported_ResourceObjectSerialization");

		internal static string NotSupported_StringComparison => GetResourceString("NotSupported_StringComparison");

		internal static string NotSupported_SubclassOverride => GetResourceString("NotSupported_SubclassOverride");

		internal static string NotSupported_SymbolMethod => GetResourceString("NotSupported_SymbolMethod");

		internal static string NotSupported_Type => GetResourceString("NotSupported_Type");

		internal static string NotSupported_TypeNotYetCreated => GetResourceString("NotSupported_TypeNotYetCreated");

		internal static string NotSupported_UmsSafeBuffer => GetResourceString("NotSupported_UmsSafeBuffer");

		internal static string NotSupported_UnitySerHolder => GetResourceString("NotSupported_UnitySerHolder");

		internal static string NotSupported_UnknownTypeCode => GetResourceString("NotSupported_UnknownTypeCode");

		internal static string NotSupported_UnreadableStream => GetResourceString("NotSupported_UnreadableStream");

		internal static string NotSupported_UnseekableStream => GetResourceString("NotSupported_UnseekableStream");

		internal static string NotSupported_UnwritableStream => GetResourceString("NotSupported_UnwritableStream");

		internal static string NotSupported_ValueCollectionSet => GetResourceString("NotSupported_ValueCollectionSet");

		internal static string NotSupported_Writing => GetResourceString("NotSupported_Writing");

		internal static string NotSupported_WrongResourceReader_Type => GetResourceString("NotSupported_WrongResourceReader_Type");

		internal static string ObjectDisposed_FileClosed => GetResourceString("ObjectDisposed_FileClosed");

		internal static string ObjectDisposed_Generic => GetResourceString("ObjectDisposed_Generic");

		internal static string ObjectDisposed_ObjectName_Name => GetResourceString("ObjectDisposed_ObjectName_Name");

		internal static string ObjectDisposed_WriterClosed => GetResourceString("ObjectDisposed_WriterClosed");

		internal static string ObjectDisposed_ReaderClosed => GetResourceString("ObjectDisposed_ReaderClosed");

		internal static string ObjectDisposed_ResourceSet => GetResourceString("ObjectDisposed_ResourceSet");

		internal static string ObjectDisposed_StreamClosed => GetResourceString("ObjectDisposed_StreamClosed");

		internal static string ObjectDisposed_ViewAccessorClosed => GetResourceString("ObjectDisposed_ViewAccessorClosed");

		internal static string ObjectDisposed_SafeHandleClosed => GetResourceString("ObjectDisposed_SafeHandleClosed");

		internal static string OperationCanceled => GetResourceString("OperationCanceled");

		internal static string Overflow_Byte => GetResourceString("Overflow_Byte");

		internal static string Overflow_Char => GetResourceString("Overflow_Char");

		internal static string Overflow_Currency => GetResourceString("Overflow_Currency");

		internal static string Overflow_Decimal => GetResourceString("Overflow_Decimal");

		internal static string Overflow_Duration => GetResourceString("Overflow_Duration");

		internal static string Overflow_Int16 => GetResourceString("Overflow_Int16");

		internal static string Overflow_Int32 => GetResourceString("Overflow_Int32");

		internal static string Overflow_Int64 => GetResourceString("Overflow_Int64");

		internal static string Overflow_NegateTwosCompNum => GetResourceString("Overflow_NegateTwosCompNum");

		internal static string Overflow_NegativeUnsigned => GetResourceString("Overflow_NegativeUnsigned");

		internal static string Overflow_SByte => GetResourceString("Overflow_SByte");

		internal static string Overflow_TimeSpanElementTooLarge => GetResourceString("Overflow_TimeSpanElementTooLarge");

		internal static string Overflow_TimeSpanTooLong => GetResourceString("Overflow_TimeSpanTooLong");

		internal static string Overflow_UInt16 => GetResourceString("Overflow_UInt16");

		internal static string Overflow_UInt32 => GetResourceString("Overflow_UInt32");

		internal static string Overflow_UInt64 => GetResourceString("Overflow_UInt64");

		internal static string PlatformNotSupported_ReflectionOnly => GetResourceString("PlatformNotSupported_ReflectionOnly");

		internal static string PlatformNotSupported_Remoting => GetResourceString("PlatformNotSupported_Remoting");

		internal static string PlatformNotSupported_SecureBinarySerialization => GetResourceString("PlatformNotSupported_SecureBinarySerialization");

		internal static string PlatformNotSupported_StrongNameSigning => GetResourceString("PlatformNotSupported_StrongNameSigning");

		internal static string PlatformNotSupported_ITypeInfo => GetResourceString("PlatformNotSupported_ITypeInfo");

		internal static string PlatformNotSupported_IExpando => GetResourceString("PlatformNotSupported_IExpando");

		internal static string PlatformNotSupported_AppDomains => GetResourceString("PlatformNotSupported_AppDomains");

		internal static string PlatformNotSupported_CAS => GetResourceString("PlatformNotSupported_CAS");

		internal static string PlatformNotSupported_Principal => GetResourceString("PlatformNotSupported_Principal");

		internal static string PlatformNotSupported_ThreadAbort => GetResourceString("PlatformNotSupported_ThreadAbort");

		internal static string PlatformNotSupported_ThreadSuspend => GetResourceString("PlatformNotSupported_ThreadSuspend");

		internal static string PostconditionFailed => GetResourceString("PostconditionFailed");

		internal static string PostconditionFailed_Cnd => GetResourceString("PostconditionFailed_Cnd");

		internal static string PostconditionOnExceptionFailed => GetResourceString("PostconditionOnExceptionFailed");

		internal static string PostconditionOnExceptionFailed_Cnd => GetResourceString("PostconditionOnExceptionFailed_Cnd");

		internal static string PreconditionFailed => GetResourceString("PreconditionFailed");

		internal static string PreconditionFailed_Cnd => GetResourceString("PreconditionFailed_Cnd");

		internal static string Rank_MultiDimNotSupported => GetResourceString("Rank_MultiDimNotSupported");

		internal static string Rank_MustMatch => GetResourceString("Rank_MustMatch");

		internal static string ResourceReaderIsClosed => GetResourceString("ResourceReaderIsClosed");

		internal static string Resources_StreamNotValid => GetResourceString("Resources_StreamNotValid");

		internal static string RFLCT_AmbigCust => GetResourceString("RFLCT_AmbigCust");

		internal static string RFLCT_Ambiguous => GetResourceString("RFLCT_Ambiguous");

		internal static string InvalidFilterCriteriaException_CritInt => GetResourceString("InvalidFilterCriteriaException_CritInt");

		internal static string InvalidFilterCriteriaException_CritString => GetResourceString("InvalidFilterCriteriaException_CritString");

		internal static string RFLCT_InvalidFieldFail => GetResourceString("RFLCT_InvalidFieldFail");

		internal static string RFLCT_InvalidPropFail => GetResourceString("RFLCT_InvalidPropFail");

		internal static string RFLCT_Targ_ITargMismatch => GetResourceString("RFLCT_Targ_ITargMismatch");

		internal static string RFLCT_Targ_StatFldReqTarg => GetResourceString("RFLCT_Targ_StatFldReqTarg");

		internal static string RFLCT_Targ_StatMethReqTarg => GetResourceString("RFLCT_Targ_StatMethReqTarg");

		internal static string RuntimeWrappedException => GetResourceString("RuntimeWrappedException");

		internal static string StandardOleMarshalObjectGetMarshalerFailed => GetResourceString("StandardOleMarshalObjectGetMarshalerFailed");

		internal static string Security_CannotReadRegistryData => GetResourceString("Security_CannotReadRegistryData");

		internal static string Security_RegistryPermission => GetResourceString("Security_RegistryPermission");

		internal static string SemaphoreSlim_ctor_InitialCountWrong => GetResourceString("SemaphoreSlim_ctor_InitialCountWrong");

		internal static string SemaphoreSlim_ctor_MaxCountWrong => GetResourceString("SemaphoreSlim_ctor_MaxCountWrong");

		internal static string SemaphoreSlim_Disposed => GetResourceString("SemaphoreSlim_Disposed");

		internal static string SemaphoreSlim_Release_CountWrong => GetResourceString("SemaphoreSlim_Release_CountWrong");

		internal static string SemaphoreSlim_Wait_TimeoutWrong => GetResourceString("SemaphoreSlim_Wait_TimeoutWrong");

		internal static string Serialization_BadParameterInfo => GetResourceString("Serialization_BadParameterInfo");

		internal static string Serialization_CorruptField => GetResourceString("Serialization_CorruptField");

		internal static string Serialization_DateTimeTicksOutOfRange => GetResourceString("Serialization_DateTimeTicksOutOfRange");

		internal static string Serialization_DelegatesNotSupported => GetResourceString("Serialization_DelegatesNotSupported");

		internal static string Serialization_InsufficientState => GetResourceString("Serialization_InsufficientState");

		internal static string Serialization_InvalidData => GetResourceString("Serialization_InvalidData");

		internal static string Serialization_InvalidEscapeSequence => GetResourceString("Serialization_InvalidEscapeSequence");

		internal static string Serialization_InvalidOnDeser => GetResourceString("Serialization_InvalidOnDeser");

		internal static string Serialization_InvalidPtrValue => GetResourceString("Serialization_InvalidPtrValue");

		internal static string Serialization_InvalidType => GetResourceString("Serialization_InvalidType");

		internal static string Serialization_KeyValueDifferentSizes => GetResourceString("Serialization_KeyValueDifferentSizes");

		internal static string Serialization_MissingDateTimeData => GetResourceString("Serialization_MissingDateTimeData");

		internal static string Serialization_MissingKeys => GetResourceString("Serialization_MissingKeys");

		internal static string Serialization_MissingValues => GetResourceString("Serialization_MissingValues");

		internal static string Serialization_NoParameterInfo => GetResourceString("Serialization_NoParameterInfo");

		internal static string Serialization_NotFound => GetResourceString("Serialization_NotFound");

		internal static string Serialization_NullKey => GetResourceString("Serialization_NullKey");

		internal static string Serialization_OptionalFieldVersionValue => GetResourceString("Serialization_OptionalFieldVersionValue");

		internal static string Serialization_SameNameTwice => GetResourceString("Serialization_SameNameTwice");

		internal static string Serialization_StringBuilderCapacity => GetResourceString("Serialization_StringBuilderCapacity");

		internal static string Serialization_StringBuilderMaxCapacity => GetResourceString("Serialization_StringBuilderMaxCapacity");

		internal static string SpinLock_Exit_SynchronizationLockException => GetResourceString("SpinLock_Exit_SynchronizationLockException");

		internal static string SpinLock_IsHeldByCurrentThread => GetResourceString("SpinLock_IsHeldByCurrentThread");

		internal static string SpinLock_TryEnter_ArgumentOutOfRange => GetResourceString("SpinLock_TryEnter_ArgumentOutOfRange");

		internal static string SpinLock_TryEnter_LockRecursionException => GetResourceString("SpinLock_TryEnter_LockRecursionException");

		internal static string SpinLock_TryReliableEnter_ArgumentException => GetResourceString("SpinLock_TryReliableEnter_ArgumentException");

		internal static string SpinWait_SpinUntil_ArgumentNull => GetResourceString("SpinWait_SpinUntil_ArgumentNull");

		internal static string SpinWait_SpinUntil_TimeoutWrong => GetResourceString("SpinWait_SpinUntil_TimeoutWrong");

		internal static string Task_ContinueWith_ESandLR => GetResourceString("Task_ContinueWith_ESandLR");

		internal static string Task_ContinueWith_NotOnAnything => GetResourceString("Task_ContinueWith_NotOnAnything");

		internal static string Task_InvalidTimerTimeSpan => GetResourceString("Task_InvalidTimerTimeSpan");

		internal static string Task_Delay_InvalidMillisecondsDelay => GetResourceString("Task_Delay_InvalidMillisecondsDelay");

		internal static string Task_Dispose_NotCompleted => GetResourceString("Task_Dispose_NotCompleted");

		internal static string Task_FromAsync_LongRunning => GetResourceString("Task_FromAsync_LongRunning");

		internal static string Task_FromAsync_PreferFairness => GetResourceString("Task_FromAsync_PreferFairness");

		internal static string Task_MultiTaskContinuation_EmptyTaskList => GetResourceString("Task_MultiTaskContinuation_EmptyTaskList");

		internal static string Task_MultiTaskContinuation_FireOptions => GetResourceString("Task_MultiTaskContinuation_FireOptions");

		internal static string Task_MultiTaskContinuation_NullTask => GetResourceString("Task_MultiTaskContinuation_NullTask");

		internal static string Task_RunSynchronously_AlreadyStarted => GetResourceString("Task_RunSynchronously_AlreadyStarted");

		internal static string Task_RunSynchronously_Continuation => GetResourceString("Task_RunSynchronously_Continuation");

		internal static string Task_RunSynchronously_Promise => GetResourceString("Task_RunSynchronously_Promise");

		internal static string Task_RunSynchronously_TaskCompleted => GetResourceString("Task_RunSynchronously_TaskCompleted");

		internal static string Task_Start_AlreadyStarted => GetResourceString("Task_Start_AlreadyStarted");

		internal static string Task_Start_ContinuationTask => GetResourceString("Task_Start_ContinuationTask");

		internal static string Task_Start_Promise => GetResourceString("Task_Start_Promise");

		internal static string Task_Start_TaskCompleted => GetResourceString("Task_Start_TaskCompleted");

		internal static string Task_ThrowIfDisposed => GetResourceString("Task_ThrowIfDisposed");

		internal static string Task_WaitMulti_NullTask => GetResourceString("Task_WaitMulti_NullTask");

		internal static string TaskCanceledException_ctor_DefaultMessage => GetResourceString("TaskCanceledException_ctor_DefaultMessage");

		internal static string TaskCompletionSourceT_TrySetException_NoExceptions => GetResourceString("TaskCompletionSourceT_TrySetException_NoExceptions");

		internal static string TaskCompletionSourceT_TrySetException_NullException => GetResourceString("TaskCompletionSourceT_TrySetException_NullException");

		internal static string TaskExceptionHolder_UnhandledException => GetResourceString("TaskExceptionHolder_UnhandledException");

		internal static string TaskExceptionHolder_UnknownExceptionType => GetResourceString("TaskExceptionHolder_UnknownExceptionType");

		internal static string TaskScheduler_ExecuteTask_WrongTaskScheduler => GetResourceString("TaskScheduler_ExecuteTask_WrongTaskScheduler");

		internal static string TaskScheduler_FromCurrentSynchronizationContext_NoCurrent => GetResourceString("TaskScheduler_FromCurrentSynchronizationContext_NoCurrent");

		internal static string TaskScheduler_InconsistentStateAfterTryExecuteTaskInline => GetResourceString("TaskScheduler_InconsistentStateAfterTryExecuteTaskInline");

		internal static string TaskSchedulerException_ctor_DefaultMessage => GetResourceString("TaskSchedulerException_ctor_DefaultMessage");

		internal static string TaskT_DebuggerNoResult => GetResourceString("TaskT_DebuggerNoResult");

		internal static string TaskT_TransitionToFinal_AlreadyCompleted => GetResourceString("TaskT_TransitionToFinal_AlreadyCompleted");

		internal static string Thread_ApartmentState_ChangeFailed => GetResourceString("Thread_ApartmentState_ChangeFailed");

		internal static string Thread_GetSetCompressedStack_NotSupported => GetResourceString("Thread_GetSetCompressedStack_NotSupported");

		internal static string Thread_Operation_RequiresCurrentThread => GetResourceString("Thread_Operation_RequiresCurrentThread");

		internal static string Threading_AbandonedMutexException => GetResourceString("Threading_AbandonedMutexException");

		internal static string Threading_WaitHandleCannotBeOpenedException => GetResourceString("Threading_WaitHandleCannotBeOpenedException");

		internal static string Threading_WaitHandleCannotBeOpenedException_InvalidHandle => GetResourceString("Threading_WaitHandleCannotBeOpenedException_InvalidHandle");

		internal static string Threading_WaitHandleTooManyPosts => GetResourceString("Threading_WaitHandleTooManyPosts");

		internal static string Threading_SemaphoreFullException => GetResourceString("Threading_SemaphoreFullException");

		internal static string ThreadLocal_Disposed => GetResourceString("ThreadLocal_Disposed");

		internal static string ThreadLocal_Value_RecursiveCallsToValue => GetResourceString("ThreadLocal_Value_RecursiveCallsToValue");

		internal static string ThreadLocal_ValuesNotAvailable => GetResourceString("ThreadLocal_ValuesNotAvailable");

		internal static string TimeZoneNotFound_MissingData => GetResourceString("TimeZoneNotFound_MissingData");

		internal static string TypeInitialization_Default => GetResourceString("TypeInitialization_Default");

		internal static string TypeInitialization_Type => GetResourceString("TypeInitialization_Type");

		internal static string TypeLoad_ResolveNestedType => GetResourceString("TypeLoad_ResolveNestedType");

		internal static string TypeLoad_ResolveType => GetResourceString("TypeLoad_ResolveType");

		internal static string TypeLoad_ResolveTypeFromAssembly => GetResourceString("TypeLoad_ResolveTypeFromAssembly");

		internal static string UnauthorizedAccess_IODenied_NoPathName => GetResourceString("UnauthorizedAccess_IODenied_NoPathName");

		internal static string UnauthorizedAccess_IODenied_Path => GetResourceString("UnauthorizedAccess_IODenied_Path");

		internal static string UnauthorizedAccess_MemStreamBuffer => GetResourceString("UnauthorizedAccess_MemStreamBuffer");

		internal static string UnauthorizedAccess_RegistryKeyGeneric_Key => GetResourceString("UnauthorizedAccess_RegistryKeyGeneric_Key");

		internal static string UnknownError_Num => GetResourceString("UnknownError_Num");

		internal static string Verification_Exception => GetResourceString("Verification_Exception");

		internal static string DebugAssertBanner => GetResourceString("DebugAssertBanner");

		internal static string DebugAssertLongMessage => GetResourceString("DebugAssertLongMessage");

		internal static string DebugAssertShortMessage => GetResourceString("DebugAssertShortMessage");

		internal static string LockRecursionException_ReadAfterWriteNotAllowed => GetResourceString("LockRecursionException_ReadAfterWriteNotAllowed");

		internal static string LockRecursionException_RecursiveReadNotAllowed => GetResourceString("LockRecursionException_RecursiveReadNotAllowed");

		internal static string LockRecursionException_RecursiveWriteNotAllowed => GetResourceString("LockRecursionException_RecursiveWriteNotAllowed");

		internal static string LockRecursionException_RecursiveUpgradeNotAllowed => GetResourceString("LockRecursionException_RecursiveUpgradeNotAllowed");

		internal static string LockRecursionException_WriteAfterReadNotAllowed => GetResourceString("LockRecursionException_WriteAfterReadNotAllowed");

		internal static string SynchronizationLockException_MisMatchedUpgrade => GetResourceString("SynchronizationLockException_MisMatchedUpgrade");

		internal static string SynchronizationLockException_MisMatchedRead => GetResourceString("SynchronizationLockException_MisMatchedRead");

		internal static string SynchronizationLockException_IncorrectDispose => GetResourceString("SynchronizationLockException_IncorrectDispose");

		internal static string LockRecursionException_UpgradeAfterReadNotAllowed => GetResourceString("LockRecursionException_UpgradeAfterReadNotAllowed");

		internal static string LockRecursionException_UpgradeAfterWriteNotAllowed => GetResourceString("LockRecursionException_UpgradeAfterWriteNotAllowed");

		internal static string SynchronizationLockException_MisMatchedWrite => GetResourceString("SynchronizationLockException_MisMatchedWrite");

		internal static string NotSupported_SignatureType => GetResourceString("NotSupported_SignatureType");

		internal static string HashCode_HashCodeNotSupported => GetResourceString("HashCode_HashCodeNotSupported");

		internal static string HashCode_EqualityNotSupported => GetResourceString("HashCode_EqualityNotSupported");

		internal static string Arg_TypeNotSupported => GetResourceString("Arg_TypeNotSupported");

		internal static string IO_InvalidReadLength => GetResourceString("IO_InvalidReadLength");

		internal static string Arg_BasePathNotFullyQualified => GetResourceString("Arg_BasePathNotFullyQualified");

		internal static string Arg_ElementsInSourceIsGreaterThanDestination => GetResourceString("Arg_ElementsInSourceIsGreaterThanDestination");

		internal static string Arg_NullArgumentNullRef => GetResourceString("Arg_NullArgumentNullRef");

		internal static string Argument_OverlapAlignmentMismatch => GetResourceString("Argument_OverlapAlignmentMismatch");

		internal static string Arg_InsufficientNumberOfElements => GetResourceString("Arg_InsufficientNumberOfElements");

		internal static string Arg_MustBeNullTerminatedString => GetResourceString("Arg_MustBeNullTerminatedString");

		internal static string ArgumentOutOfRange_Week_ISO => GetResourceString("ArgumentOutOfRange_Week_ISO");

		internal static string Argument_BadPInvokeMethod => GetResourceString("Argument_BadPInvokeMethod");

		internal static string Argument_BadPInvokeOnInterface => GetResourceString("Argument_BadPInvokeOnInterface");

		internal static string Argument_MethodRedefined => GetResourceString("Argument_MethodRedefined");

		internal static string Argument_CannotExtractScalar => GetResourceString("Argument_CannotExtractScalar");

		internal static string Argument_CannotParsePrecision => GetResourceString("Argument_CannotParsePrecision");

		internal static string Argument_GWithPrecisionNotSupported => GetResourceString("Argument_GWithPrecisionNotSupported");

		internal static string Argument_PrecisionTooLarge => GetResourceString("Argument_PrecisionTooLarge");

		internal static string AssemblyDependencyResolver_FailedToLoadHostpolicy => GetResourceString("AssemblyDependencyResolver_FailedToLoadHostpolicy");

		internal static string AssemblyDependencyResolver_FailedToResolveDependencies => GetResourceString("AssemblyDependencyResolver_FailedToResolveDependencies");

		internal static string Arg_EnumNotCloneable => GetResourceString("Arg_EnumNotCloneable");

		internal static string InvalidOp_InvalidNewEnumVariant => GetResourceString("InvalidOp_InvalidNewEnumVariant");

		internal static string Argument_StructArrayTooLarge => GetResourceString("Argument_StructArrayTooLarge");

		internal static string IndexOutOfRange_ArrayWithOffset => GetResourceString("IndexOutOfRange_ArrayWithOffset");

		internal static string Serialization_DangerousDeserialization => GetResourceString("Serialization_DangerousDeserialization");

		internal static string Serialization_DangerousDeserialization_Switch => GetResourceString("Serialization_DangerousDeserialization_Switch");

		internal static string Argument_InvalidStartupHookSimpleAssemblyName => GetResourceString("Argument_InvalidStartupHookSimpleAssemblyName");

		internal static string Argument_StartupHookAssemblyLoadFailed => GetResourceString("Argument_StartupHookAssemblyLoadFailed");

		internal static string InvalidOperation_NonStaticComRegFunction => GetResourceString("InvalidOperation_NonStaticComRegFunction");

		internal static string InvalidOperation_NonStaticComUnRegFunction => GetResourceString("InvalidOperation_NonStaticComUnRegFunction");

		internal static string InvalidOperation_InvalidComRegFunctionSig => GetResourceString("InvalidOperation_InvalidComRegFunctionSig");

		internal static string InvalidOperation_InvalidComUnRegFunctionSig => GetResourceString("InvalidOperation_InvalidComUnRegFunctionSig");

		internal static string InvalidOperation_MultipleComRegFunctions => GetResourceString("InvalidOperation_MultipleComRegFunctions");

		internal static string InvalidOperation_MultipleComUnRegFunctions => GetResourceString("InvalidOperation_MultipleComUnRegFunctions");

		internal static string InvalidOperation_ResetGlobalComWrappersInstance => GetResourceString("InvalidOperation_ResetGlobalComWrappersInstance");

		internal static string InvalidOperation_SuppliedInnerMustBeMarkedAggregation => GetResourceString("InvalidOperation_SuppliedInnerMustBeMarkedAggregation");

		internal static string Argument_SpansMustHaveSameLength => GetResourceString("Argument_SpansMustHaveSameLength");

		internal static string NotSupported_CannotWriteToBufferedStreamIfReadBufferCannotBeFlushed => GetResourceString("NotSupported_CannotWriteToBufferedStreamIfReadBufferCannotBeFlushed");

		internal static string GenericInvalidData => GetResourceString("GenericInvalidData");

		internal static string Argument_ResourceScopeWrongDirection => GetResourceString("Argument_ResourceScopeWrongDirection");

		internal static string ArgumentNull_TypeRequiredByResourceScope => GetResourceString("ArgumentNull_TypeRequiredByResourceScope");

		internal static string Argument_BadResourceScopeTypeBits => GetResourceString("Argument_BadResourceScopeTypeBits");

		internal static string Argument_BadResourceScopeVisibilityBits => GetResourceString("Argument_BadResourceScopeVisibilityBits");

		internal static string net_emptystringcall => GetResourceString("net_emptystringcall");

		internal static string Argument_EmptyApplicationName => GetResourceString("Argument_EmptyApplicationName");

		internal static string Argument_FrameworkNameInvalid => GetResourceString("Argument_FrameworkNameInvalid");

		internal static string Argument_FrameworkNameInvalidVersion => GetResourceString("Argument_FrameworkNameInvalidVersion");

		internal static string Argument_FrameworkNameMissingVersion => GetResourceString("Argument_FrameworkNameMissingVersion");

		internal static string Argument_FrameworkNameTooShort => GetResourceString("Argument_FrameworkNameTooShort");

		internal static string Arg_SwitchExpressionException => GetResourceString("Arg_SwitchExpressionException");

		internal static string Arg_ContextMarshalException => GetResourceString("Arg_ContextMarshalException");

		internal static string Arg_AppDomainUnloadedException => GetResourceString("Arg_AppDomainUnloadedException");

		internal static string SwitchExpressionException_UnmatchedValue => GetResourceString("SwitchExpressionException_UnmatchedValue");

		internal static string Encoding_UTF7_Disabled => GetResourceString("Encoding_UTF7_Disabled");

		internal static string IDynamicInterfaceCastable_DoesNotImplementRequested => GetResourceString("IDynamicInterfaceCastable_DoesNotImplementRequested");

		internal static string IDynamicInterfaceCastable_MissingImplementationAttribute => GetResourceString("IDynamicInterfaceCastable_MissingImplementationAttribute");

		internal static string IDynamicInterfaceCastable_NotInterface => GetResourceString("IDynamicInterfaceCastable_NotInterface");

		internal static string Arg_MustBeHalf => GetResourceString("Arg_MustBeHalf");

		internal static string Arg_MustBeRune => GetResourceString("Arg_MustBeRune");

		internal static string BinaryFormatter_SerializationDisallowed => GetResourceString("BinaryFormatter_SerializationDisallowed");

		internal static string NotSupported_CodeBase => GetResourceString("NotSupported_CodeBase");

		internal static string Activator_CannotCreateInstance => GetResourceString("Activator_CannotCreateInstance");

		internal static string Argv_IncludeDoubleQuote => GetResourceString("Argv_IncludeDoubleQuote");

		internal static string ResourceManager_ReflectionNotAllowed => GetResourceString("ResourceManager_ReflectionNotAllowed");

		internal static string NotSupported_COM => GetResourceString("NotSupported_COM");

		internal static string InvalidOperation_EmptyQueue => GetResourceString("InvalidOperation_EmptyQueue");

		internal static string Arg_FileIsDirectory_Name => GetResourceString("Arg_FileIsDirectory_Name");

		internal static string Arg_InvalidFileAttrs => GetResourceString("Arg_InvalidFileAttrs");

		internal static string Arg_Path2IsRooted => GetResourceString("Arg_Path2IsRooted");

		internal static string Arg_PathIsVolume => GetResourceString("Arg_PathIsVolume");

		internal static string Argument_InvalidSubPath => GetResourceString("Argument_InvalidSubPath");

		internal static string IO_SourceDestMustBeDifferent => GetResourceString("IO_SourceDestMustBeDifferent");

		internal static string IO_SourceDestMustHaveSameRoot => GetResourceString("IO_SourceDestMustHaveSameRoot");

		internal static string PlatformNotSupported_FileEncryption => GetResourceString("PlatformNotSupported_FileEncryption");

		internal static string Arg_MemberInfoNotFound => GetResourceString("Arg_MemberInfoNotFound");

		internal static string NullabilityInfoContext_NotSupported => GetResourceString("NullabilityInfoContext_NotSupported");

		private static string InternalGetResourceString(string key)
		{
			if (key.Length == 0)
			{
				return key;
			}
			bool lockTaken = false;
			try
			{
				Monitor.Enter(_lock, ref lockTaken);
				if (_currentlyLoading != null && _currentlyLoading.Count > 0 && _currentlyLoading.LastIndexOf(key) != -1)
				{
					if (_infinitelyRecursingCount > 0)
					{
						return key;
					}
					_infinitelyRecursingCount++;
					string message = $"Infinite recursion during resource lookup within {"System.Private.CoreLib"}.  This may be a bug in {"System.Private.CoreLib"}, or potentially in certain extensibility points such as assembly resolve events or CultureInfo names.  Resource name: {key}";
					Environment.FailFast(message);
				}
				if (_currentlyLoading == null)
				{
					_currentlyLoading = new List<string>();
				}
				if (!_resourceManagerInited)
				{
					RuntimeHelpers.RunClassConstructor(typeof(ResourceManager).TypeHandle);
					RuntimeHelpers.RunClassConstructor(typeof(ResourceReader).TypeHandle);
					RuntimeHelpers.RunClassConstructor(typeof(RuntimeResourceSet).TypeHandle);
					RuntimeHelpers.RunClassConstructor(typeof(BinaryReader).TypeHandle);
					_resourceManagerInited = true;
				}
				_currentlyLoading.Add(key);
				string @string = ResourceManager.GetString(key, null);
				_currentlyLoading.RemoveAt(_currentlyLoading.Count - 1);
				return @string ?? key;
			}
			catch
			{
				if (lockTaken)
				{
					s_resourceManager = null;
					_currentlyLoading = null;
				}
				throw;
			}
			finally
			{
				if (lockTaken)
				{
					Monitor.Exit(_lock);
				}
			}
		}

		private static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

		internal static string GetResourceString(string resourceKey)
		{
			if (UsingResourceKeys())
			{
				return resourceKey;
			}
			string result = null;
			try
			{
				result = InternalGetResourceString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			return result;
		}

		internal static string GetResourceString(string resourceKey, string defaultString)
		{
			string resourceString = GetResourceString(resourceKey);
			if (!(resourceKey == resourceString) && resourceString != null)
			{
				return resourceString;
			}
			return defaultString;
		}

		internal static string Format(string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}

		internal static string Format(string resourceFormat, params object[] args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(provider, resourceFormat, p1);
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(provider, resourceFormat, p1, p2);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class StackOverflowException : SystemException
	{
		public StackOverflowException()
			: base(SR.Arg_StackOverflowException)
		{
			base.HResult = -2147023895;
		}

		public StackOverflowException(string? message)
			: base(message)
		{
			base.HResult = -2147023895;
		}

		public StackOverflowException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147023895;
		}

		private StackOverflowException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public abstract class StringComparer : IComparer, IEqualityComparer, IComparer<string?>, IEqualityComparer<string?>
	{
		public static StringComparer InvariantCulture => CultureAwareComparer.InvariantCaseSensitiveInstance;

		public static StringComparer InvariantCultureIgnoreCase => CultureAwareComparer.InvariantIgnoreCaseInstance;

		public static StringComparer CurrentCulture => new CultureAwareComparer(CultureInfo.CurrentCulture, CompareOptions.None);

		public static StringComparer CurrentCultureIgnoreCase => new CultureAwareComparer(CultureInfo.CurrentCulture, CompareOptions.IgnoreCase);

		public static StringComparer Ordinal => OrdinalCaseSensitiveComparer.Instance;

		public static StringComparer OrdinalIgnoreCase => OrdinalIgnoreCaseComparer.Instance;

		public static StringComparer FromComparison(StringComparison comparisonType)
		{
			return comparisonType switch
			{
				StringComparison.CurrentCulture => CurrentCulture, 
				StringComparison.CurrentCultureIgnoreCase => CurrentCultureIgnoreCase, 
				StringComparison.InvariantCulture => InvariantCulture, 
				StringComparison.InvariantCultureIgnoreCase => InvariantCultureIgnoreCase, 
				StringComparison.Ordinal => Ordinal, 
				StringComparison.OrdinalIgnoreCase => OrdinalIgnoreCase, 
				_ => throw new ArgumentException(SR.NotSupported_StringComparison, "comparisonType"), 
			};
		}

		public static StringComparer Create(CultureInfo culture, bool ignoreCase)
		{
			if (culture == null)
			{
				throw new ArgumentNullException("culture");
			}
			return new CultureAwareComparer(culture, ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
		}

		public static StringComparer Create(CultureInfo culture, CompareOptions options)
		{
			if (culture == null)
			{
				throw new ArgumentNullException("culture");
			}
			return new CultureAwareComparer(culture, options);
		}

		public static bool IsWellKnownOrdinalComparer(IEqualityComparer<string?>? comparer, out bool ignoreCase)
		{
			if (comparer is IInternalStringEqualityComparer internalStringEqualityComparer)
			{
				comparer = internalStringEqualityComparer.GetUnderlyingEqualityComparer();
			}
			if (!(comparer is StringComparer stringComparer))
			{
				if (comparer is GenericEqualityComparer<string>)
				{
					ignoreCase = false;
					return true;
				}
				ignoreCase = false;
				return false;
			}
			return stringComparer.IsWellKnownOrdinalComparerCore(out ignoreCase);
		}

		private protected virtual bool IsWellKnownOrdinalComparerCore(out bool ignoreCase)
		{
			ignoreCase = false;
			return false;
		}

		public static bool IsWellKnownCultureAwareComparer(IEqualityComparer<string?>? comparer, [NotNullWhen(true)] out CompareInfo? compareInfo, out CompareOptions compareOptions)
		{
			if (comparer is IInternalStringEqualityComparer internalStringEqualityComparer)
			{
				comparer = internalStringEqualityComparer.GetUnderlyingEqualityComparer();
			}
			if (comparer is StringComparer stringComparer)
			{
				return stringComparer.IsWellKnownCultureAwareComparerCore(out compareInfo, out compareOptions);
			}
			compareInfo = null;
			compareOptions = CompareOptions.None;
			return false;
		}

		private protected virtual bool IsWellKnownCultureAwareComparerCore([NotNullWhen(true)] out CompareInfo compareInfo, out CompareOptions compareOptions)
		{
			compareInfo = null;
			compareOptions = CompareOptions.None;
			return false;
		}

		public int Compare(object? x, object? y)
		{
			if (x == y)
			{
				return 0;
			}
			if (x == null)
			{
				return -1;
			}
			if (y == null)
			{
				return 1;
			}
			if (x is string x2 && y is string y2)
			{
				return Compare(x2, y2);
			}
			if (x is IComparable comparable)
			{
				return comparable.CompareTo(y);
			}
			throw new ArgumentException(SR.Argument_ImplementIComparable);
		}

		public new bool Equals(object? x, object? y)
		{
			if (x == y)
			{
				return true;
			}
			if (x == null || y == null)
			{
				return false;
			}
			if (x is string x2 && y is string y2)
			{
				return Equals(x2, y2);
			}
			return x.Equals(y);
		}

		public int GetHashCode(object obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			if (obj is string obj2)
			{
				return GetHashCode(obj2);
			}
			return obj.GetHashCode();
		}

		public abstract int Compare(string? x, string? y);

		public abstract bool Equals(string? x, string? y);

		public abstract int GetHashCode(string obj);
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class CultureAwareComparer : StringComparer, ISerializable
	{
		internal static readonly CultureAwareComparer InvariantCaseSensitiveInstance = new CultureAwareComparer(CompareInfo.Invariant, CompareOptions.None);

		internal static readonly CultureAwareComparer InvariantIgnoreCaseInstance = new CultureAwareComparer(CompareInfo.Invariant, CompareOptions.IgnoreCase);

		private readonly CompareInfo _compareInfo;

		private readonly CompareOptions _options;

		internal CultureAwareComparer(CultureInfo culture, CompareOptions options)
			: this(culture.CompareInfo, options)
		{
		}

		internal CultureAwareComparer(CompareInfo compareInfo, CompareOptions options)
		{
			_compareInfo = compareInfo;
			if (((uint)options & 0xDFFFFFE0u) != 0)
			{
				throw new ArgumentException(SR.Argument_InvalidFlag, "options");
			}
			_options = options;
		}

		private CultureAwareComparer(SerializationInfo info, StreamingContext context)
		{
			_compareInfo = (CompareInfo)info.GetValue("_compareInfo", typeof(CompareInfo));
			bool boolean = info.GetBoolean("_ignoreCase");
			object valueNoThrow = info.GetValueNoThrow("_options", typeof(CompareOptions));
			if (valueNoThrow != null)
			{
				_options = (CompareOptions)valueNoThrow;
			}
			_options |= (CompareOptions)(boolean ? 1 : 0);
		}

		public override int Compare(string? x, string? y)
		{
			if ((object)x == y)
			{
				return 0;
			}
			if (x == null)
			{
				return -1;
			}
			if (y == null)
			{
				return 1;
			}
			return _compareInfo.Compare(x, y, _options);
		}

		public override bool Equals(string? x, string? y)
		{
			if ((object)x == y)
			{
				return true;
			}
			if (x == null || y == null)
			{
				return false;
			}
			return _compareInfo.Compare(x, y, _options) == 0;
		}

		public override int GetHashCode(string obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			return _compareInfo.GetHashCode(obj, _options);
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is CultureAwareComparer cultureAwareComparer && _options == cultureAwareComparer._options)
			{
				return _compareInfo.Equals(cultureAwareComparer._compareInfo);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _compareInfo.GetHashCode() ^ (int)(_options & (CompareOptions)2147483647);
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.AddValue("_compareInfo", _compareInfo);
			info.AddValue("_options", _options);
			info.AddValue("_ignoreCase", (_options & CompareOptions.IgnoreCase) != 0);
		}

		private protected override bool IsWellKnownCultureAwareComparerCore([NotNullWhen(true)] out CompareInfo compareInfo, out CompareOptions compareOptions)
		{
			compareInfo = _compareInfo;
			compareOptions = _options;
			return true;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class OrdinalComparer : StringComparer
	{
		private readonly bool _ignoreCase;

		internal OrdinalComparer(bool ignoreCase)
		{
			_ignoreCase = ignoreCase;
		}

		public override int Compare(string? x, string? y)
		{
			if ((object)x == y)
			{
				return 0;
			}
			if (x == null)
			{
				return -1;
			}
			if (y == null)
			{
				return 1;
			}
			if (_ignoreCase)
			{
				return string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
			}
			return string.CompareOrdinal(x, y);
		}

		public override bool Equals(string? x, string? y)
		{
			if ((object)x == y)
			{
				return true;
			}
			if (x == null || y == null)
			{
				return false;
			}
			if (_ignoreCase)
			{
				if (x.Length != y.Length)
				{
					return false;
				}
				return System.Globalization.Ordinal.EqualsIgnoreCase(ref x.GetRawStringData(), ref y.GetRawStringData(), x.Length);
			}
			return x.Equals(y);
		}

		public override int GetHashCode(string obj)
		{
			if (obj == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.obj);
			}
			if (_ignoreCase)
			{
				return obj.GetHashCodeOrdinalIgnoreCase();
			}
			return obj.GetHashCode();
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is OrdinalComparer ordinalComparer))
			{
				return false;
			}
			return _ignoreCase == ordinalComparer._ignoreCase;
		}

		public override int GetHashCode()
		{
			int hashCode = "OrdinalComparer".GetHashCode();
			if (!_ignoreCase)
			{
				return hashCode;
			}
			return ~hashCode;
		}

		private protected override bool IsWellKnownOrdinalComparerCore(out bool ignoreCase)
		{
			ignoreCase = _ignoreCase;
			return true;
		}
	}
	[Serializable]
	internal sealed class OrdinalCaseSensitiveComparer : OrdinalComparer, ISerializable
	{
		internal static readonly OrdinalCaseSensitiveComparer Instance = new OrdinalCaseSensitiveComparer();

		private OrdinalCaseSensitiveComparer()
			: base(ignoreCase: false)
		{
		}

		public override int Compare(string x, string y)
		{
			return string.CompareOrdinal(x, y);
		}

		public override bool Equals(string x, string y)
		{
			return string.Equals(x, y);
		}

		public override int GetHashCode(string obj)
		{
			if (obj == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.obj);
			}
			return obj.GetHashCode();
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.SetType(typeof(OrdinalComparer));
			info.AddValue("_ignoreCase", value: false);
		}
	}
	[Serializable]
	internal sealed class OrdinalIgnoreCaseComparer : OrdinalComparer, ISerializable
	{
		internal static readonly OrdinalIgnoreCaseComparer Instance = new OrdinalIgnoreCaseComparer();

		private OrdinalIgnoreCaseComparer()
			: base(ignoreCase: true)
		{
		}

		public override int Compare(string x, string y)
		{
			return string.Compare(x, y, StringComparison.OrdinalIgnoreCase);
		}

		public override bool Equals(string x, string y)
		{
			if ((object)x == y)
			{
				return true;
			}
			if (x == null || y == null)
			{
				return false;
			}
			if (x.Length != y.Length)
			{
				return false;
			}
			return System.Globalization.Ordinal.EqualsIgnoreCase(ref x.GetRawStringData(), ref y.GetRawStringData(), x.Length);
		}

		public override int GetHashCode(string obj)
		{
			if (obj == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.obj);
			}
			return obj.GetHashCodeOrdinalIgnoreCase();
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.SetType(typeof(OrdinalComparer));
			info.AddValue("_ignoreCase", value: true);
		}
	}
	public enum StringComparison
	{
		CurrentCulture,
		CurrentCultureIgnoreCase,
		InvariantCulture,
		InvariantCultureIgnoreCase,
		Ordinal,
		OrdinalIgnoreCase
	}
	public static class StringNormalizationExtensions
	{
		public static bool IsNormalized(this string strInput)
		{
			return IsNormalized(strInput, NormalizationForm.FormC);
		}

		public static bool IsNormalized(this string strInput, NormalizationForm normalizationForm)
		{
			if (strInput == null)
			{
				throw new ArgumentNullException("strInput");
			}
			return strInput.IsNormalized(normalizationForm);
		}

		public static string Normalize(this string strInput)
		{
			return Normalize(strInput, NormalizationForm.FormC);
		}

		public static string Normalize(this string strInput, NormalizationForm normalizationForm)
		{
			if (strInput == null)
			{
				throw new ArgumentNullException("strInput");
			}
			return strInput.Normalize(normalizationForm);
		}
	}
	[Flags]
	public enum StringSplitOptions
	{
		None = 0,
		RemoveEmptyEntries = 1,
		TrimEntries = 2
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class SystemException : Exception
	{
		public SystemException()
			: base(SR.Arg_SystemException)
		{
			base.HResult = -2146233087;
		}

		public SystemException(string? message)
			: base(message)
		{
			base.HResult = -2146233087;
		}

		public SystemException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233087;
		}

		protected SystemException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class STAThreadAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class MTAThreadAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field, Inherited = false)]
	public class ThreadStaticAttribute : Attribute
	{
	}
	[StackTraceHidden]
	internal static class ThrowHelper
	{
		[DoesNotReturn]
		internal static void ThrowArrayTypeMismatchException()
		{
			throw new ArrayTypeMismatchException();
		}

		[DoesNotReturn]
		internal static void ThrowInvalidTypeWithPointersNotSupported(Type targetType)
		{
			throw new ArgumentException(SR.Format(SR.Argument_InvalidTypeWithPointersNotSupported, targetType));
		}

		[DoesNotReturn]
		internal static void ThrowIndexOutOfRangeException()
		{
			throw new IndexOutOfRangeException();
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException()
		{
			throw new ArgumentOutOfRangeException();
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_DestinationTooShort()
		{
			throw new ArgumentException(SR.Argument_DestinationTooShort, "destination");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_OverlapAlignmentMismatch()
		{
			throw new ArgumentException(SR.Argument_OverlapAlignmentMismatch);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_CannotExtractScalar(ExceptionArgument argument)
		{
			throw GetArgumentException(ExceptionResource.Argument_CannotExtractScalar, argument);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_TupleIncorrectType(object obj)
		{
			throw new ArgumentException(SR.Format(SR.ArgumentException_ValueTupleIncorrectType, obj.GetType()), "other");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRange_IndexException()
		{
			throw GetArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_BadComparer(object comparer)
		{
			throw new ArgumentException(SR.Format(SR.Arg_BogusIComparer, comparer));
		}

		[DoesNotReturn]
		internal static void ThrowIndexArgumentOutOfRange_NeedNonNegNumException()
		{
			throw GetArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
		}

		[DoesNotReturn]
		internal static void ThrowValueArgumentOutOfRange_NeedNonNegNumException()
		{
			throw GetArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
		}

		[DoesNotReturn]
		internal static void ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum()
		{
			throw GetArgumentOutOfRangeException(ExceptionArgument.length, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
		}

		[DoesNotReturn]
		internal static void ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index()
		{
			throw GetArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
		}

		[DoesNotReturn]
		internal static void ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count()
		{
			throw GetArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_Count);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRange_Year()
		{
			throw GetArgumentOutOfRangeException(ExceptionArgument.year, ExceptionResource.ArgumentOutOfRange_Year);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRange_Month(int month)
		{
			throw new ArgumentOutOfRangeException("month", month, SR.ArgumentOutOfRange_Month);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRange_DayNumber(int dayNumber)
		{
			throw new ArgumentOutOfRangeException("dayNumber", dayNumber, SR.ArgumentOutOfRange_DayNumber);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRange_BadYearMonthDay()
		{
			throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRange_BadHourMinuteSecond()
		{
			throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadHourMinuteSecond);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRange_TimeSpanTooLong()
		{
			throw new ArgumentOutOfRangeException(null, SR.Overflow_TimeSpanTooLong);
		}

		[DoesNotReturn]
		internal static void ThrowWrongKeyTypeArgumentException<T>(T key, Type targetType)
		{
			throw GetWrongKeyTypeArgumentException(key, targetType);
		}

		[DoesNotReturn]
		internal static void ThrowWrongValueTypeArgumentException<T>(T value, Type targetType)
		{
			throw GetWrongValueTypeArgumentException(value, targetType);
		}

		private static ArgumentException GetAddingDuplicateWithKeyArgumentException(object key)
		{
			return new ArgumentException(SR.Format(SR.Argument_AddingDuplicateWithKey, key));
		}

		[DoesNotReturn]
		internal static void ThrowAddingDuplicateWithKeyArgumentException<T>(T key)
		{
			throw GetAddingDuplicateWithKeyArgumentException(key);
		}

		[DoesNotReturn]
		internal static void ThrowKeyNotFoundException<T>(T key)
		{
			throw GetKeyNotFoundException(key);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException(ExceptionResource resource)
		{
			throw GetArgumentException(resource);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException(ExceptionResource resource, ExceptionArgument argument)
		{
			throw GetArgumentException(resource, argument);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_HandleNotSync(string paramName)
		{
			throw new ArgumentException(SR.Arg_HandleNotSync, paramName);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_HandleNotAsync(string paramName)
		{
			throw new ArgumentException(SR.Arg_HandleNotAsync, paramName);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException(ExceptionArgument argument)
		{
			throw new ArgumentNullException(GetArgumentName(argument));
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException(ExceptionArgument argument, ExceptionResource resource)
		{
			throw new ArgumentNullException(GetArgumentName(argument), GetResourceString(resource));
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument)
		{
			throw new ArgumentOutOfRangeException(GetArgumentName(argument));
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
		{
			throw GetArgumentOutOfRangeException(argument, resource);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, int paramNumber, ExceptionResource resource)
		{
			throw GetArgumentOutOfRangeException(argument, paramNumber, resource);
		}

		[DoesNotReturn]
		internal static void ThrowEndOfFileException()
		{
			throw CreateEndOfFileException();
		}

		internal static Exception CreateEndOfFileException()
		{
			return new EndOfStreamException(SR.IO_EOF_ReadBeyondEOF);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException()
		{
			throw new InvalidOperationException();
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException(ExceptionResource resource)
		{
			throw GetInvalidOperationException(resource);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException(ExceptionResource resource, Exception e)
		{
			throw new InvalidOperationException(GetResourceString(resource), e);
		}

		[DoesNotReturn]
		internal static void ThrowSerializationException(ExceptionResource resource)
		{
			throw new SerializationException(GetResourceString(resource));
		}

		[DoesNotReturn]
		internal static void ThrowRankException(ExceptionResource resource)
		{
			throw new RankException(GetResourceString(resource));
		}

		[DoesNotReturn]
		internal static void ThrowNotSupportedException(ExceptionResource resource)
		{
			throw new NotSupportedException(GetResourceString(resource));
		}

		[DoesNotReturn]
		internal static void ThrowNotSupportedException_UnseekableStream()
		{
			throw new NotSupportedException(SR.NotSupported_UnseekableStream);
		}

		[DoesNotReturn]
		internal static void ThrowNotSupportedException_UnreadableStream()
		{
			throw new NotSupportedException(SR.NotSupported_UnreadableStream);
		}

		[DoesNotReturn]
		internal static void ThrowNotSupportedException_UnwritableStream()
		{
			throw new NotSupportedException(SR.NotSupported_UnwritableStream);
		}

		[DoesNotReturn]
		internal static void ThrowObjectDisposedException_StreamClosed(string objectName)
		{
			throw new ObjectDisposedException(objectName, SR.ObjectDisposed_StreamClosed);
		}

		[DoesNotReturn]
		internal static void ThrowObjectDisposedException_FileClosed()
		{
			throw new ObjectDisposedException(null, SR.ObjectDisposed_FileClosed);
		}

		[DoesNotReturn]
		internal static void ThrowObjectDisposedException(ExceptionResource resource)
		{
			throw new ObjectDisposedException(null, GetResourceString(resource));
		}

		[DoesNotReturn]
		internal static void ThrowNotSupportedException()
		{
			throw new NotSupportedException();
		}

		[DoesNotReturn]
		internal static void ThrowAggregateException(List<Exception> exceptions)
		{
			throw new AggregateException(exceptions);
		}

		[DoesNotReturn]
		internal static void ThrowOutOfMemoryException()
		{
			throw new OutOfMemoryException();
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_Argument_InvalidArrayType()
		{
			throw new ArgumentException(SR.Argument_InvalidArrayType);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentException_InvalidHandle(string paramName)
		{
			throw new ArgumentException(SR.Arg_InvalidHandle, paramName);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_InvalidOperation_EnumNotStarted()
		{
			throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_InvalidOperation_EnumEnded()
		{
			throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_EnumCurrent(int index)
		{
			throw GetInvalidOperationException_EnumCurrent(index);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion()
		{
			throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen()
		{
			throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_InvalidOperation_NoValue()
		{
			throw new InvalidOperationException(SR.InvalidOperation_NoValue);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_ConcurrentOperationsNotSupported()
		{
			throw new InvalidOperationException(SR.InvalidOperation_ConcurrentOperationsNotSupported);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_HandleIsNotInitialized()
		{
			throw new InvalidOperationException(SR.InvalidOperation_HandleIsNotInitialized);
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException_HandleIsNotPinned()
		{
			throw new InvalidOperationException(SR.InvalidOperation_HandleIsNotPinned);
		}

		[DoesNotReturn]
		internal static void ThrowArraySegmentCtorValidationFailedExceptions(Array array, int offset, int count)
		{
			throw GetArraySegmentCtorValidationFailedException(array, offset, count);
		}

		[DoesNotReturn]
		internal static void ThrowFormatException_BadFormatSpecifier()
		{
			throw new FormatException(SR.Argument_BadFormatSpecifier);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_PrecisionTooLarge()
		{
			throw new ArgumentOutOfRangeException("precision", SR.Format(SR.Argument_PrecisionTooLarge, (byte)99));
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_SymbolDoesNotFit()
		{
			throw new ArgumentOutOfRangeException("symbol", SR.Argument_BadFormatSpecifier);
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_NeedNonNegNum(string paramName)
		{
			throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_NeedNonNegNum);
		}

		[DoesNotReturn]
		internal static void ArgumentOutOfRangeException_Enum_Value()
		{
			throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_Enum);
		}

		private static Exception GetArraySegmentCtorValidationFailedException(Array array, int offset, int count)
		{
			if (array == null)
			{
				return new ArgumentNullException("array");
			}
			if (offset < 0)
			{
				return new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				return new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return new ArgumentException(SR.Argument_InvalidOffLen);
		}

		private static ArgumentException GetArgumentException(ExceptionResource resource)
		{
			return new ArgumentException(GetResourceString(resource));
		}

		private static InvalidOperationException GetInvalidOperationException(ExceptionResource resource)
		{
			return new InvalidOperationException(GetResourceString(resource));
		}

		private static ArgumentException GetWrongKeyTypeArgumentException(object key, Type targetType)
		{
			return new ArgumentException(SR.Format(SR.Arg_WrongType, key, targetType), "key");
		}

		private static ArgumentException GetWrongValueTypeArgumentException(object value, Type targetType)
		{
			return new ArgumentException(SR.Format(SR.Arg_WrongType, value, targetType), "value");
		}

		private static KeyNotFoundException GetKeyNotFoundException(object key)
		{
			return new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key));
		}

		private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
		{
			return new ArgumentOutOfRangeException(GetArgumentName(argument), GetResourceString(resource));
		}

		private static ArgumentException GetArgumentException(ExceptionResource resource, ExceptionArgument argument)
		{
			return new ArgumentException(GetResourceString(resource), GetArgumentName(argument));
		}

		private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument, int paramNumber, ExceptionResource resource)
		{
			return new ArgumentOutOfRangeException(GetArgumentName(argument) + "[" + paramNumber + "]", GetResourceString(resource));
		}

		private static InvalidOperationException GetInvalidOperationException_EnumCurrent(int index)
		{
			return new InvalidOperationException((index < 0) ? SR.InvalidOperation_EnumNotStarted : SR.InvalidOperation_EnumEnded);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void IfNullAndNullsAreIllegalThenThrow<T>(object value, ExceptionArgument argName)
		{
			if (default(T) != null && value == null)
			{
				ThrowArgumentNullException(argName);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ThrowForUnsupportedNumericsVectorBaseType<T>() where T : struct
		{
			if (typeof(T) != typeof(byte) && typeof(T) != typeof(sbyte) && typeof(T) != typeof(short) && typeof(T) != typeof(ushort) && typeof(T) != typeof(int) && typeof(T) != typeof(uint) && typeof(T) != typeof(long) && typeof(T) != typeof(ulong) && typeof(T) != typeof(float) && typeof(T) != typeof(double) && typeof(T) != typeof(IntPtr) && typeof(T) != typeof(UIntPtr))
			{
				ThrowNotSupportedException(ExceptionResource.Arg_TypeNotSupported);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ThrowForUnsupportedIntrinsicsVectorBaseType<T>() where T : struct
		{
			if (typeof(T) != typeof(byte) && typeof(T) != typeof(sbyte) && typeof(T) != typeof(short) && typeof(T) != typeof(ushort) && typeof(T) != typeof(int) && typeof(T) != typeof(uint) && typeof(T) != typeof(long) && typeof(T) != typeof(ulong) && typeof(T) != typeof(float) && typeof(T) != typeof(double))
			{
				ThrowNotSupportedException(ExceptionResource.Arg_TypeNotSupported);
			}
		}

		private static string GetArgumentName(ExceptionArgument argument)
		{
			return argument switch
			{
				ExceptionArgument.obj => "obj", 
				ExceptionArgument.dictionary => "dictionary", 
				ExceptionArgument.array => "array", 
				ExceptionArgument.info => "info", 
				ExceptionArgument.key => "key", 
				ExceptionArgument.text => "text", 
				ExceptionArgument.values => "values", 
				ExceptionArgument.value => "value", 
				ExceptionArgument.startIndex => "startIndex", 
				ExceptionArgument.task => "task", 
				ExceptionArgument.bytes => "bytes", 
				ExceptionArgument.byteIndex => "byteIndex", 
				ExceptionArgument.byteCount => "byteCount", 
				ExceptionArgument.ch => "ch", 
				ExceptionArgument.chars => "chars", 
				ExceptionArgument.charIndex => "charIndex", 
				ExceptionArgument.charCount => "charCount", 
				ExceptionArgument.s => "s", 
				ExceptionArgument.input => "input", 
				ExceptionArgument.ownedMemory => "ownedMemory", 
				ExceptionArgument.list => "list", 
				ExceptionArgument.index => "index", 
				ExceptionArgument.capacity => "capacity", 
				ExceptionArgument.collection => "collection", 
				ExceptionArgument.item => "item", 
				ExceptionArgument.converter => "converter", 
				ExceptionArgument.match => "match", 
				ExceptionArgument.count => "count", 
				ExceptionArgument.action => "action", 
				ExceptionArgument.comparison => "comparison", 
				ExceptionArgument.exceptions => "exceptions", 
				ExceptionArgument.exception => "exception", 
				ExceptionArgument.pointer => "pointer", 
				ExceptionArgument.start => "start", 
				ExceptionArgument.format => "format", 
				ExceptionArgument.formats => "formats", 
				ExceptionArgument.culture => "culture", 
				ExceptionArgument.comparer => "comparer", 
				ExceptionArgument.comparable => "comparable", 
				ExceptionArgument.source => "source", 
				ExceptionArgument.state => "state", 
				ExceptionArgument.length => "length", 
				ExceptionArgument.comparisonType => "comparisonType", 
				ExceptionArgument.manager => "manager", 
				ExceptionArgument.sourceBytesToCopy => "sourceBytesToCopy", 
				ExceptionArgument.callBack => "callBack", 
				ExceptionArgument.creationOptions => "creationOptions", 
				ExceptionArgument.function => "function", 
				ExceptionArgument.scheduler => "scheduler", 
				ExceptionArgument.continuationAction => "continuationAction", 
				ExceptionArgument.continuationFunction => "continuationFunction", 
				ExceptionArgument.tasks => "tasks", 
				ExceptionArgument.asyncResult => "asyncResult", 
				ExceptionArgument.beginMethod => "beginMethod", 
				ExceptionArgument.endMethod => "endMethod", 
				ExceptionArgument.endFunction => "endFunction", 
				ExceptionArgument.cancellationToken => "cancellationToken", 
				ExceptionArgument.continuationOptions => "continuationOptions", 
				ExceptionArgument.delay => "delay", 
				ExceptionArgument.millisecondsDelay => "millisecondsDelay", 
				ExceptionArgument.millisecondsTimeout => "millisecondsTimeout", 
				ExceptionArgument.stateMachine => "stateMachine", 
				ExceptionArgument.timeout => "timeout", 
				ExceptionArgument.type => "type", 
				ExceptionArgument.sourceIndex => "sourceIndex", 
				ExceptionArgument.sourceArray => "sourceArray", 
				ExceptionArgument.destinationIndex => "destinationIndex", 
				ExceptionArgument.destinationArray => "destinationArray", 
				ExceptionArgument.pHandle => "pHandle", 
				ExceptionArgument.handle => "handle", 
				ExceptionArgument.other => "other", 
				ExceptionArgument.newSize => "newSize", 
				ExceptionArgument.lowerBounds => "lowerBounds", 
				ExceptionArgument.lengths => "lengths", 
				ExceptionArgument.len => "len", 
				ExceptionArgument.keys => "keys", 
				ExceptionArgument.indices => "indices", 
				ExceptionArgument.index1 => "index1", 
				ExceptionArgument.index2 => "index2", 
				ExceptionArgument.index3 => "index3", 
				ExceptionArgument.length1 => "length1", 
				ExceptionArgument.length2 => "length2", 
				ExceptionArgument.length3 => "length3", 
				ExceptionArgument.endIndex => "endIndex", 
				ExceptionArgument.elementType => "elementType", 
				ExceptionArgument.arrayIndex => "arrayIndex", 
				ExceptionArgument.year => "year", 
				ExceptionArgument.codePoint => "codePoint", 
				ExceptionArgument.str => "str", 
				ExceptionArgument.options => "options", 
				ExceptionArgument.prefix => "prefix", 
				ExceptionArgument.suffix => "suffix", 
				ExceptionArgument.buffer => "buffer", 
				ExceptionArgument.buffers => "buffers", 
				ExceptionArgument.offset => "offset", 
				ExceptionArgument.stream => "stream", 
				_ => "", 
			};
		}

		private static string GetResourceString(ExceptionResource resource)
		{
			return resource switch
			{
				ExceptionResource.ArgumentOutOfRange_Index => SR.ArgumentOutOfRange_Index, 
				ExceptionResource.ArgumentOutOfRange_IndexCount => SR.ArgumentOutOfRange_IndexCount, 
				ExceptionResource.ArgumentOutOfRange_IndexCountBuffer => SR.ArgumentOutOfRange_IndexCountBuffer, 
				ExceptionResource.ArgumentOutOfRange_Count => SR.ArgumentOutOfRange_Count, 
				ExceptionResource.ArgumentOutOfRange_Year => SR.ArgumentOutOfRange_Year, 
				ExceptionResource.Arg_ArrayPlusOffTooSmall => SR.Arg_ArrayPlusOffTooSmall, 
				ExceptionResource.NotSupported_ReadOnlyCollection => SR.NotSupported_ReadOnlyCollection, 
				ExceptionResource.Arg_RankMultiDimNotSupported => SR.Arg_RankMultiDimNotSupported, 
				ExceptionResource.Arg_NonZeroLowerBound => SR.Arg_NonZeroLowerBound, 
				ExceptionResource.ArgumentOutOfRange_GetCharCountOverflow => SR.ArgumentOutOfRange_GetCharCountOverflow, 
				ExceptionResource.ArgumentOutOfRange_ListInsert => SR.ArgumentOutOfRange_ListInsert, 
				ExceptionResource.ArgumentOutOfRange_NeedNonNegNum => SR.ArgumentOutOfRange_NeedNonNegNum, 
				ExceptionResource.ArgumentOutOfRange_SmallCapacity => SR.ArgumentOutOfRange_SmallCapacity, 
				ExceptionResource.Argument_InvalidOffLen => SR.Argument_InvalidOffLen, 
				ExceptionResource.Argument_CannotExtractScalar => SR.Argument_CannotExtractScalar, 
				ExceptionResource.ArgumentOutOfRange_BiggerThanCollection => SR.ArgumentOutOfRange_BiggerThanCollection, 
				ExceptionResource.Serialization_MissingKeys => SR.Serialization_MissingKeys, 
				ExceptionResource.Serialization_NullKey => SR.Serialization_NullKey, 
				ExceptionResource.NotSupported_KeyCollectionSet => SR.NotSupported_KeyCollectionSet, 
				ExceptionResource.NotSupported_ValueCollectionSet => SR.NotSupported_ValueCollectionSet, 
				ExceptionResource.InvalidOperation_NullArray => SR.InvalidOperation_NullArray, 
				ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted => SR.TaskT_TransitionToFinal_AlreadyCompleted, 
				ExceptionResource.TaskCompletionSourceT_TrySetException_NullException => SR.TaskCompletionSourceT_TrySetException_NullException, 
				ExceptionResource.TaskCompletionSourceT_TrySetException_NoExceptions => SR.TaskCompletionSourceT_TrySetException_NoExceptions, 
				ExceptionResource.NotSupported_StringComparison => SR.NotSupported_StringComparison, 
				ExceptionResource.ConcurrentCollection_SyncRoot_NotSupported => SR.ConcurrentCollection_SyncRoot_NotSupported, 
				ExceptionResource.Task_MultiTaskContinuation_NullTask => SR.Task_MultiTaskContinuation_NullTask, 
				ExceptionResource.InvalidOperation_WrongAsyncResultOrEndCalledMultiple => SR.InvalidOperation_WrongAsyncResultOrEndCalledMultiple, 
				ExceptionResource.Task_MultiTaskContinuation_EmptyTaskList => SR.Task_MultiTaskContinuation_EmptyTaskList, 
				ExceptionResource.Task_Start_TaskCompleted => SR.Task_Start_TaskCompleted, 
				ExceptionResource.Task_Start_Promise => SR.Task_Start_Promise, 
				ExceptionResource.Task_Start_ContinuationTask => SR.Task_Start_ContinuationTask, 
				ExceptionResource.Task_Start_AlreadyStarted => SR.Task_Start_AlreadyStarted, 
				ExceptionResource.Task_RunSynchronously_Continuation => SR.Task_RunSynchronously_Continuation, 
				ExceptionResource.Task_RunSynchronously_Promise => SR.Task_RunSynchronously_Promise, 
				ExceptionResource.Task_RunSynchronously_TaskCompleted => SR.Task_RunSynchronously_TaskCompleted, 
				ExceptionResource.Task_RunSynchronously_AlreadyStarted => SR.Task_RunSynchronously_AlreadyStarted, 
				ExceptionResource.AsyncMethodBuilder_InstanceNotInitialized => SR.AsyncMethodBuilder_InstanceNotInitialized, 
				ExceptionResource.Task_ContinueWith_ESandLR => SR.Task_ContinueWith_ESandLR, 
				ExceptionResource.Task_ContinueWith_NotOnAnything => SR.Task_ContinueWith_NotOnAnything, 
				ExceptionResource.Task_InvalidTimerTimeSpan => SR.Task_InvalidTimerTimeSpan, 
				ExceptionResource.Task_Delay_InvalidMillisecondsDelay => SR.Task_Delay_InvalidMillisecondsDelay, 
				ExceptionResource.Task_Dispose_NotCompleted => SR.Task_Dispose_NotCompleted, 
				ExceptionResource.Task_ThrowIfDisposed => SR.Task_ThrowIfDisposed, 
				ExceptionResource.Task_WaitMulti_NullTask => SR.Task_WaitMulti_NullTask, 
				ExceptionResource.ArgumentException_OtherNotArrayOfCorrectLength => SR.ArgumentException_OtherNotArrayOfCorrectLength, 
				ExceptionResource.ArgumentNull_Array => SR.ArgumentNull_Array, 
				ExceptionResource.ArgumentNull_SafeHandle => SR.ArgumentNull_SafeHandle, 
				ExceptionResource.ArgumentOutOfRange_EndIndexStartIndex => SR.ArgumentOutOfRange_EndIndexStartIndex, 
				ExceptionResource.ArgumentOutOfRange_Enum => SR.ArgumentOutOfRange_Enum, 
				ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported => SR.ArgumentOutOfRange_HugeArrayNotSupported, 
				ExceptionResource.Argument_AddingDuplicate => SR.Argument_AddingDuplicate, 
				ExceptionResource.Argument_InvalidArgumentForComparison => SR.Argument_InvalidArgumentForComparison, 
				ExceptionResource.Arg_LowerBoundsMustMatch => SR.Arg_LowerBoundsMustMatch, 
				ExceptionResource.Arg_MustBeType => SR.Arg_MustBeType, 
				ExceptionResource.Arg_Need1DArray => SR.Arg_Need1DArray, 
				ExceptionResource.Arg_Need2DArray => SR.Arg_Need2DArray, 
				ExceptionResource.Arg_Need3DArray => SR.Arg_Need3DArray, 
				ExceptionResource.Arg_NeedAtLeast1Rank => SR.Arg_NeedAtLeast1Rank, 
				ExceptionResource.Arg_RankIndices => SR.Arg_RankIndices, 
				ExceptionResource.Arg_RanksAndBounds => SR.Arg_RanksAndBounds, 
				ExceptionResource.InvalidOperation_IComparerFailed => SR.InvalidOperation_IComparerFailed, 
				ExceptionResource.NotSupported_FixedSizeCollection => SR.NotSupported_FixedSizeCollection, 
				ExceptionResource.Rank_MultiDimNotSupported => SR.Rank_MultiDimNotSupported, 
				ExceptionResource.Arg_TypeNotSupported => SR.Arg_TypeNotSupported, 
				ExceptionResource.Argument_SpansMustHaveSameLength => SR.Argument_SpansMustHaveSameLength, 
				ExceptionResource.Argument_InvalidFlag => SR.Argument_InvalidFlag, 
				ExceptionResource.CancellationTokenSource_Disposed => SR.CancellationTokenSource_Disposed, 
				ExceptionResource.Argument_AlignmentMustBePow2 => SR.Argument_AlignmentMustBePow2, 
				_ => "", 
			};
		}
	}
	internal enum ExceptionArgument
	{
		obj,
		dictionary,
		array,
		info,
		key,
		text,
		values,
		value,
		startIndex,
		task,
		bytes,
		byteIndex,
		byteCount,
		ch,
		chars,
		charIndex,
		charCount,
		s,
		input,
		ownedMemory,
		list,
		index,
		capacity,
		collection,
		item,
		converter,
		match,
		count,
		action,
		comparison,
		exceptions,
		exception,
		pointer,
		start,
		format,
		formats,
		culture,
		comparer,
		comparable,
		source,
		state,
		length,
		comparisonType,
		manager,
		sourceBytesToCopy,
		callBack,
		creationOptions,
		function,
		scheduler,
		continuationAction,
		continuationFunction,
		tasks,
		asyncResult,
		beginMethod,
		endMethod,
		endFunction,
		cancellationToken,
		continuationOptions,
		delay,
		millisecondsDelay,
		millisecondsTimeout,
		stateMachine,
		timeout,
		type,
		sourceIndex,
		sourceArray,
		destinationIndex,
		destinationArray,
		pHandle,
		handle,
		other,
		newSize,
		lowerBounds,
		lengths,
		len,
		keys,
		indices,
		index1,
		index2,
		index3,
		length1,
		length2,
		length3,
		endIndex,
		elementType,
		arrayIndex,
		year,
		codePoint,
		str,
		options,
		prefix,
		suffix,
		buffer,
		buffers,
		offset,
		stream
	}
	internal enum ExceptionResource
	{
		ArgumentOutOfRange_Index,
		ArgumentOutOfRange_IndexCount,
		ArgumentOutOfRange_IndexCountBuffer,
		ArgumentOutOfRange_Count,
		ArgumentOutOfRange_Year,
		Arg_ArrayPlusOffTooSmall,
		NotSupported_ReadOnlyCollection,
		Arg_RankMultiDimNotSupported,
		Arg_NonZeroLowerBound,
		ArgumentOutOfRange_GetCharCountOverflow,
		ArgumentOutOfRange_ListInsert,
		ArgumentOutOfRange_NeedNonNegNum,
		ArgumentOutOfRange_SmallCapacity,
		Argument_InvalidOffLen,
		Argument_CannotExtractScalar,
		ArgumentOutOfRange_BiggerThanCollection,
		Serialization_MissingKeys,
		Serialization_NullKey,
		NotSupported_KeyCollectionSet,
		NotSupported_ValueCollectionSet,
		InvalidOperation_NullArray,
		TaskT_TransitionToFinal_AlreadyCompleted,
		TaskCompletionSourceT_TrySetException_NullException,
		TaskCompletionSourceT_TrySetException_NoExceptions,
		NotSupported_StringComparison,
		ConcurrentCollection_SyncRoot_NotSupported,
		Task_MultiTaskContinuation_NullTask,
		InvalidOperation_WrongAsyncResultOrEndCalledMultiple,
		Task_MultiTaskContinuation_EmptyTaskList,
		Task_Start_TaskCompleted,
		Task_Start_Promise,
		Task_Start_ContinuationTask,
		Task_Start_AlreadyStarted,
		Task_RunSynchronously_Continuation,
		Task_RunSynchronously_Promise,
		Task_RunSynchronously_TaskCompleted,
		Task_RunSynchronously_AlreadyStarted,
		AsyncMethodBuilder_InstanceNotInitialized,
		Task_ContinueWith_ESandLR,
		Task_ContinueWith_NotOnAnything,
		Task_InvalidTimerTimeSpan,
		Task_Delay_InvalidMillisecondsDelay,
		Task_Dispose_NotCompleted,
		Task_ThrowIfDisposed,
		Task_WaitMulti_NullTask,
		ArgumentException_OtherNotArrayOfCorrectLength,
		ArgumentNull_Array,
		ArgumentNull_SafeHandle,
		ArgumentOutOfRange_EndIndexStartIndex,
		ArgumentOutOfRange_Enum,
		ArgumentOutOfRange_HugeArrayNotSupported,
		Argument_AddingDuplicate,
		Argument_InvalidArgumentForComparison,
		Arg_LowerBoundsMustMatch,
		Arg_MustBeType,
		Arg_Need1DArray,
		Arg_Need2DArray,
		Arg_Need3DArray,
		Arg_NeedAtLeast1Rank,
		Arg_RankIndices,
		Arg_RanksAndBounds,
		InvalidOperation_IComparerFailed,
		NotSupported_FixedSizeCollection,
		Rank_MultiDimNotSupported,
		Arg_TypeNotSupported,
		Argument_SpansMustHaveSameLength,
		Argument_InvalidFlag,
		CancellationTokenSource_Disposed,
		Argument_AlignmentMustBePow2
	}
	public readonly struct TimeOnly : IComparable, IComparable<TimeOnly>, IEquatable<TimeOnly>, ISpanFormattable, IFormattable, IComparisonOperators<TimeOnly, TimeOnly>, IEqualityOperators<TimeOnly, TimeOnly>, IMinMaxValue<TimeOnly>, ISpanParseable<TimeOnly>, IParseable<TimeOnly>, ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan>
	{
		private readonly long _ticks;

		public static TimeOnly MinValue => new TimeOnly(0uL);

		public static TimeOnly MaxValue => new TimeOnly(863999999999uL);

		public int Hour => new TimeSpan(_ticks).Hours;

		public int Minute => new TimeSpan(_ticks).Minutes;

		public int Second => new TimeSpan(_ticks).Seconds;

		public int Millisecond => new TimeSpan(_ticks).Milliseconds;

		public long Ticks => _ticks;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeOnly IMinMaxValue<TimeOnly>.MinValue => MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeOnly IMinMaxValue<TimeOnly>.MaxValue => MaxValue;

		public TimeOnly(int hour, int minute)
			: this(DateTime.TimeToTicks(hour, minute, 0, 0))
		{
		}

		public TimeOnly(int hour, int minute, int second)
			: this(DateTime.TimeToTicks(hour, minute, second, 0))
		{
		}

		public TimeOnly(int hour, int minute, int second, int millisecond)
			: this(DateTime.TimeToTicks(hour, minute, second, millisecond))
		{
		}

		public TimeOnly(long ticks)
		{
			if ((ulong)ticks > 863999999999uL)
			{
				throw new ArgumentOutOfRangeException("ticks", SR.ArgumentOutOfRange_TimeOnlyBadTicks);
			}
			_ticks = ticks;
		}

		internal TimeOnly(ulong ticks)
		{
			_ticks = (long)ticks;
		}

		private TimeOnly AddTicks(long ticks)
		{
			return new TimeOnly((_ticks + 864000000000L + ticks % 864000000000L) % 864000000000L);
		}

		private TimeOnly AddTicks(long ticks, out int wrappedDays)
		{
			wrappedDays = (int)(ticks / 864000000000L);
			long num = _ticks + ticks % 864000000000L;
			if (num < 0)
			{
				wrappedDays--;
				num += 864000000000L;
			}
			else if (num >= 864000000000L)
			{
				wrappedDays++;
				num -= 864000000000L;
			}
			return new TimeOnly(num);
		}

		public TimeOnly Add(TimeSpan value)
		{
			return AddTicks(value.Ticks);
		}

		public TimeOnly Add(TimeSpan value, out int wrappedDays)
		{
			return AddTicks(value.Ticks, out wrappedDays);
		}

		public TimeOnly AddHours(double value)
		{
			return AddTicks((long)(value * 36000000000.0));
		}

		public TimeOnly AddHours(double value, out int wrappedDays)
		{
			return AddTicks((long)(value * 36000000000.0), out wrappedDays);
		}

		public TimeOnly AddMinutes(double value)
		{
			return AddTicks((long)(value * 600000000.0));
		}

		public TimeOnly AddMinutes(double value, out int wrappedDays)
		{
			return AddTicks((long)(value * 600000000.0), out wrappedDays);
		}

		public bool IsBetween(TimeOnly start, TimeOnly end)
		{
			long ticks = start._ticks;
			long ticks2 = end._ticks;
			if (ticks > ticks2)
			{
				if (ticks > _ticks)
				{
					return ticks2 > _ticks;
				}
				return true;
			}
			if (ticks <= _ticks)
			{
				return ticks2 > _ticks;
			}
			return false;
		}

		public static bool operator ==(TimeOnly left, TimeOnly right)
		{
			return left._ticks == right._ticks;
		}

		public static bool operator !=(TimeOnly left, TimeOnly right)
		{
			return left._ticks != right._ticks;
		}

		public static bool operator >(TimeOnly left, TimeOnly right)
		{
			return left._ticks > right._ticks;
		}

		public static bool operator >=(TimeOnly left, TimeOnly right)
		{
			return left._ticks >= right._ticks;
		}

		public static bool operator <(TimeOnly left, TimeOnly right)
		{
			return left._ticks < right._ticks;
		}

		public static bool operator <=(TimeOnly left, TimeOnly right)
		{
			return left._ticks <= right._ticks;
		}

		public static TimeSpan operator -(TimeOnly t1, TimeOnly t2)
		{
			return new TimeSpan((t1._ticks - t2._ticks + 864000000000L) % 864000000000L);
		}

		public static TimeOnly FromTimeSpan(TimeSpan timeSpan)
		{
			return new TimeOnly(timeSpan._ticks);
		}

		public static TimeOnly FromDateTime(DateTime dateTime)
		{
			return new TimeOnly(dateTime.TimeOfDay.Ticks);
		}

		public TimeSpan ToTimeSpan()
		{
			return new TimeSpan(_ticks);
		}

		internal DateTime ToDateTime()
		{
			return new DateTime(_ticks);
		}

		public int CompareTo(TimeOnly value)
		{
			return _ticks.CompareTo(value._ticks);
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is TimeOnly value2))
			{
				throw new ArgumentException(SR.Arg_MustBeTimeOnly);
			}
			return CompareTo(value2);
		}

		public bool Equals(TimeOnly value)
		{
			return _ticks == value._ticks;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is TimeOnly timeOnly)
			{
				return _ticks == timeOnly._ticks;
			}
			return false;
		}

		public override int GetHashCode()
		{
			long ticks = _ticks;
			return (int)ticks ^ (int)(ticks >> 32);
		}

		public static TimeOnly Parse(ReadOnlySpan<char> s, IFormatProvider? provider = null, DateTimeStyles style = DateTimeStyles.None)
		{
			TimeOnly result;
			ParseFailureKind parseFailureKind = TryParseInternal(s, provider, style, out result);
			if (parseFailureKind != 0)
			{
				ThrowOnError(parseFailureKind, s);
			}
			return result;
		}

		public static TimeOnly ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider = null, DateTimeStyles style = DateTimeStyles.None)
		{
			TimeOnly result;
			ParseFailureKind parseFailureKind = TryParseExactInternal(s, format, provider, style, out result);
			if (parseFailureKind != 0)
			{
				ThrowOnError(parseFailureKind, s);
			}
			return result;
		}

		public static TimeOnly ParseExact(ReadOnlySpan<char> s, string[] formats)
		{
			return ParseExact(s, formats, null);
		}

		public static TimeOnly ParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			TimeOnly result;
			ParseFailureKind parseFailureKind = TryParseExactInternal(s, formats, provider, style, out result);
			if (parseFailureKind != 0)
			{
				ThrowOnError(parseFailureKind, s);
			}
			return result;
		}

		public static TimeOnly Parse(string s)
		{
			return Parse(s, null);
		}

		public static TimeOnly Parse(string s, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse(s.AsSpan(), provider, style);
		}

		public static TimeOnly ParseExact(string s, string format)
		{
			return ParseExact(s, format, null);
		}

		public static TimeOnly ParseExact(string s, string format, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if (format == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
			}
			return ParseExact(s.AsSpan(), format.AsSpan(), provider, style);
		}

		public static TimeOnly ParseExact(string s, string[] formats)
		{
			return ParseExact(s, formats, null);
		}

		public static TimeOnly ParseExact(string s, string[] formats, IFormatProvider? provider, DateTimeStyles style = DateTimeStyles.None)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return ParseExact(s.AsSpan(), formats, provider, style);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out TimeOnly result)
		{
			return TryParse(s, null, DateTimeStyles.None, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
		{
			return TryParseInternal(s, provider, style, out result) == ParseFailureKind.None;
		}

		private static ParseFailureKind TryParseInternal(ReadOnlySpan<char> s, IFormatProvider provider, DateTimeStyles style, out TimeOnly result)
		{
			if (((uint)style & 0xFFFFFFF8u) != 0)
			{
				result = default(TimeOnly);
				return ParseFailureKind.FormatWithParameter;
			}
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			if (!DateTimeParse.TryParse(s, DateTimeFormatInfo.GetInstance(provider), style, ref result2))
			{
				result = default(TimeOnly);
				return ParseFailureKind.FormatWithOriginalDateTime;
			}
			if ((result2.flags & (ParseFlags.HaveYear | ParseFlags.HaveMonth | ParseFlags.HaveDay | ParseFlags.HaveDate | ParseFlags.TimeZoneUsed | ParseFlags.TimeZoneUtc | ParseFlags.ParsedMonthName | ParseFlags.CaptureOffset | ParseFlags.UtcSortPattern)) != 0)
			{
				result = default(TimeOnly);
				return ParseFailureKind.WrongParts;
			}
			result = new TimeOnly(result2.parsedDate.TimeOfDay.Ticks);
			return ParseFailureKind.None;
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, out TimeOnly result)
		{
			return TryParseExact(s, format, null, DateTimeStyles.None, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
		{
			return TryParseExactInternal(s, format, provider, style, out result) == ParseFailureKind.None;
		}

		private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, DateTimeStyles style, out TimeOnly result)
		{
			if (((uint)style & 0xFFFFFFF8u) != 0)
			{
				result = default(TimeOnly);
				return ParseFailureKind.FormatWithParameter;
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'O':
				case 'o':
					format = "HH':'mm':'ss'.'fffffff";
					provider = CultureInfo.InvariantCulture.DateTimeFormat;
					break;
				case 'R':
				case 'r':
					format = "HH':'mm':'ss";
					provider = CultureInfo.InvariantCulture.DateTimeFormat;
					break;
				}
			}
			DateTimeResult result2 = default(DateTimeResult);
			result2.Init(s);
			if (!DateTimeParse.TryParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style, ref result2))
			{
				result = default(TimeOnly);
				return ParseFailureKind.FormatWithOriginalDateTime;
			}
			if ((result2.flags & (ParseFlags.HaveYear | ParseFlags.HaveMonth | ParseFlags.HaveDay | ParseFlags.HaveDate | ParseFlags.TimeZoneUsed | ParseFlags.TimeZoneUtc | ParseFlags.ParsedMonthName | ParseFlags.CaptureOffset | ParseFlags.UtcSortPattern)) != 0)
			{
				result = default(TimeOnly);
				return ParseFailureKind.WrongParts;
			}
			result = new TimeOnly(result2.parsedDate.TimeOfDay.Ticks);
			return ParseFailureKind.None;
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true)] string?[]? formats, out TimeOnly result)
		{
			return TryParseExact(s, formats, null, DateTimeStyles.None, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> s, [NotNullWhen(true)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
		{
			return TryParseExactInternal(s, formats, provider, style, out result) == ParseFailureKind.None;
		}

		private static ParseFailureKind TryParseExactInternal(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, DateTimeStyles style, out TimeOnly result)
		{
			if (((uint)style & 0xFFFFFFF8u) != 0 || formats == null)
			{
				result = default(TimeOnly);
				return ParseFailureKind.FormatWithParameter;
			}
			DateTimeFormatInfo instance = DateTimeFormatInfo.GetInstance(provider);
			for (int i = 0; i < formats.Length; i++)
			{
				DateTimeFormatInfo dtfi = instance;
				string text = formats[i];
				if (string.IsNullOrEmpty(text))
				{
					result = default(TimeOnly);
					return ParseFailureKind.FormatWithFormatSpecifier;
				}
				if (text.Length == 1)
				{
					switch (text[0])
					{
					case 'O':
					case 'o':
						text = "HH':'mm':'ss'.'fffffff";
						dtfi = CultureInfo.InvariantCulture.DateTimeFormat;
						break;
					case 'R':
					case 'r':
						text = "HH':'mm':'ss";
						dtfi = CultureInfo.InvariantCulture.DateTimeFormat;
						break;
					}
				}
				DateTimeResult result2 = default(DateTimeResult);
				result2.Init(s);
				if (DateTimeParse.TryParseExact(s, text, dtfi, style, ref result2) && (result2.flags & (ParseFlags.HaveYear | ParseFlags.HaveMonth | ParseFlags.HaveDay | ParseFlags.HaveDate | ParseFlags.TimeZoneUsed | ParseFlags.TimeZoneUtc | ParseFlags.ParsedMonthName | ParseFlags.CaptureOffset | ParseFlags.UtcSortPattern)) == 0)
				{
					result = new TimeOnly(result2.parsedDate.TimeOfDay.Ticks);
					return ParseFailureKind.None;
				}
			}
			result = default(TimeOnly);
			return ParseFailureKind.FormatWithOriginalDateTime;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out TimeOnly result)
		{
			return TryParse(s, null, DateTimeStyles.None, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
		{
			if (s == null)
			{
				result = default(TimeOnly);
				return false;
			}
			return TryParse(s.AsSpan(), provider, style, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string? format, out TimeOnly result)
		{
			return TryParseExact(s, format, null, DateTimeStyles.None, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string? format, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
		{
			if (s == null || format == null)
			{
				result = default(TimeOnly);
				return false;
			}
			return TryParseExact(s.AsSpan(), format.AsSpan(), provider, style, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string?[]? formats, out TimeOnly result)
		{
			return TryParseExact(s, formats, null, DateTimeStyles.None, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? s, [NotNullWhen(true)] string?[]? formats, IFormatProvider? provider, DateTimeStyles style, out TimeOnly result)
		{
			if (s == null)
			{
				result = default(TimeOnly);
				return false;
			}
			return TryParseExact(s.AsSpan(), formats, provider, style, out result);
		}

		private static void ThrowOnError(ParseFailureKind result, ReadOnlySpan<char> s)
		{
			switch (result)
			{
			case ParseFailureKind.FormatWithParameter:
				throw new ArgumentException(SR.Argument_InvalidDateStyles, "style");
			case ParseFailureKind.FormatWithOriginalDateTime:
				throw new FormatException(SR.Format(SR.Format_BadTimeOnly, s.ToString()));
			case ParseFailureKind.FormatWithFormatSpecifier:
				throw new FormatException(SR.Argument_BadFormatSpecifier);
			default:
				throw new FormatException(SR.Format(SR.Format_DateTimeOnlyContainsNoneDateParts, s.ToString(), "TimeOnly"));
			}
		}

		public string ToLongTimeString()
		{
			return ToString("T");
		}

		public string ToShortTimeString()
		{
			return ToString();
		}

		public override string ToString()
		{
			return ToString("t");
		}

		public string ToString(string? format)
		{
			return ToString(format, null);
		}

		public string ToString(IFormatProvider? provider)
		{
			return ToString("t", provider);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			if (format == null || format.Length == 0)
			{
				format = "t";
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'O':
				case 'o':
					return string.Create(16, this, delegate(Span<char> destination, TimeOnly value)
					{
						bool flag = DateTimeFormat.TryFormatTimeOnlyO(value.Hour, value.Minute, value.Second, value._ticks % 10000000, destination);
					});
				case 'R':
				case 'r':
					return string.Create(8, this, delegate(Span<char> destination, TimeOnly value)
					{
						bool flag2 = DateTimeFormat.TryFormatTimeOnlyR(value.Hour, value.Minute, value.Second, destination);
					});
				case 'T':
				case 't':
					return DateTimeFormat.Format(ToDateTime(), format, provider);
				default:
					throw new FormatException(SR.Format_InvalidString);
				}
			}
			DateTimeFormat.IsValidCustomTimeFormat(format.AsSpan(), throwOnError: true);
			return DateTimeFormat.Format(ToDateTime(), format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			if (format.Length == 0)
			{
				format = "t";
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'O':
				case 'o':
					if (!DateTimeFormat.TryFormatTimeOnlyO(Hour, Minute, Second, _ticks % 10000000, destination))
					{
						charsWritten = 0;
						return false;
					}
					charsWritten = 16;
					return true;
				case 'R':
				case 'r':
					if (!DateTimeFormat.TryFormatTimeOnlyR(Hour, Minute, Second, destination))
					{
						charsWritten = 0;
						return false;
					}
					charsWritten = 8;
					return true;
				case 'T':
				case 't':
					return DateTimeFormat.TryFormat(ToDateTime(), destination, out charsWritten, format, provider);
				default:
					throw new FormatException(SR.Argument_BadFormatSpecifier);
				}
			}
			if (!DateTimeFormat.IsValidCustomTimeFormat(format, throwOnError: false))
			{
				throw new FormatException(SR.Format(SR.Format_DateTimeOnlyContainsNoneDateParts, format.ToString(), "TimeOnly"));
			}
			return DateTimeFormat.TryFormat(ToDateTime(), destination, out charsWritten, format, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<TimeOnly, TimeOnly>.op_LessThan(TimeOnly left, TimeOnly right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<TimeOnly, TimeOnly>.op_LessThanOrEqual(TimeOnly left, TimeOnly right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<TimeOnly, TimeOnly>.op_GreaterThan(TimeOnly left, TimeOnly right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<TimeOnly, TimeOnly>.op_GreaterThanOrEqual(TimeOnly left, TimeOnly right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<TimeOnly, TimeOnly>.op_Equality(TimeOnly left, TimeOnly right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<TimeOnly, TimeOnly>.op_Inequality(TimeOnly left, TimeOnly right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeOnly IParseable<TimeOnly>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<TimeOnly>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out TimeOnly result)
		{
			return TryParse(s, provider, DateTimeStyles.None, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeOnly ISpanParseable<TimeOnly>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<TimeOnly>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out TimeOnly result)
		{
			return TryParse(s, provider, DateTimeStyles.None, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan>.op_Subtraction(TimeOnly left, TimeOnly right)
		{
			return left - right;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class TimeoutException : SystemException
	{
		public TimeoutException()
			: base(SR.Arg_TimeoutException)
		{
			base.HResult = -2146233083;
		}

		public TimeoutException(string? message)
			: base(message)
		{
			base.HResult = -2146233083;
		}

		public TimeoutException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233083;
		}

		protected TimeoutException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	public readonly struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, ISpanFormattable, IFormattable, IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>, IAdditiveIdentity<TimeSpan, TimeSpan>, IComparisonOperators<TimeSpan, TimeSpan>, IEqualityOperators<TimeSpan, TimeSpan>, IDivisionOperators<TimeSpan, double, TimeSpan>, IDivisionOperators<TimeSpan, TimeSpan, double>, IMinMaxValue<TimeSpan>, IMultiplyOperators<TimeSpan, double, TimeSpan>, IMultiplicativeIdentity<TimeSpan, double>, ISpanParseable<TimeSpan>, IParseable<TimeSpan>, ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>, IUnaryNegationOperators<TimeSpan, TimeSpan>, IUnaryPlusOperators<TimeSpan, TimeSpan>
	{
		public const long TicksPerMillisecond = 10000L;

		public const long TicksPerSecond = 10000000L;

		public const long TicksPerMinute = 600000000L;

		public const long TicksPerHour = 36000000000L;

		public const long TicksPerDay = 864000000000L;

		public static readonly TimeSpan Zero = new TimeSpan(0L);

		public static readonly TimeSpan MaxValue = new TimeSpan(long.MaxValue);

		public static readonly TimeSpan MinValue = new TimeSpan(long.MinValue);

		internal readonly long _ticks;

		public long Ticks => _ticks;

		public int Days => (int)(_ticks / 864000000000L);

		public int Hours => (int)(_ticks / 36000000000L % 24);

		public int Milliseconds => (int)(_ticks / 10000 % 1000);

		public int Minutes => (int)(_ticks / 600000000 % 60);

		public int Seconds => (int)(_ticks / 10000000 % 60);

		public double TotalDays => (double)_ticks / 864000000000.0;

		public double TotalHours => (double)_ticks / 36000000000.0;

		public double TotalMilliseconds
		{
			get
			{
				double num = (double)_ticks / 10000.0;
				if (num > 922337203685477.0)
				{
					return 922337203685477.0;
				}
				if (num < -922337203685477.0)
				{
					return -922337203685477.0;
				}
				return num;
			}
		}

		public double TotalMinutes => (double)_ticks / 600000000.0;

		public double TotalSeconds => (double)_ticks / 10000000.0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IAdditiveIdentity<TimeSpan, TimeSpan>.AdditiveIdentity => default(TimeSpan);

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IMinMaxValue<TimeSpan>.MinValue => MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IMinMaxValue<TimeSpan>.MaxValue => MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IMultiplicativeIdentity<TimeSpan, double>.MultiplicativeIdentity => 1.0;

		public TimeSpan(long ticks)
		{
			_ticks = ticks;
		}

		public TimeSpan(int hours, int minutes, int seconds)
		{
			_ticks = TimeToTicks(hours, minutes, seconds);
		}

		public TimeSpan(int days, int hours, int minutes, int seconds)
			: this(days, hours, minutes, seconds, 0)
		{
		}

		public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds)
		{
			long num = ((long)days * 3600L * 24 + (long)hours * 3600L + (long)minutes * 60L + seconds) * 1000 + milliseconds;
			if (num > 922337203685477L || num < -922337203685477L)
			{
				throw new ArgumentOutOfRangeException(null, SR.Overflow_TimeSpanTooLong);
			}
			_ticks = num * 10000;
		}

		public TimeSpan Add(TimeSpan ts)
		{
			long num = _ticks + ts._ticks;
			if (_ticks >> 63 == ts._ticks >> 63 && _ticks >> 63 != num >> 63)
			{
				throw new OverflowException(SR.Overflow_TimeSpanTooLong);
			}
			return new TimeSpan(num);
		}

		public static int Compare(TimeSpan t1, TimeSpan t2)
		{
			if (t1._ticks > t2._ticks)
			{
				return 1;
			}
			if (t1._ticks < t2._ticks)
			{
				return -1;
			}
			return 0;
		}

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (!(value is TimeSpan))
			{
				throw new ArgumentException(SR.Arg_MustBeTimeSpan);
			}
			long ticks = ((TimeSpan)value)._ticks;
			if (_ticks > ticks)
			{
				return 1;
			}
			if (_ticks < ticks)
			{
				return -1;
			}
			return 0;
		}

		public int CompareTo(TimeSpan value)
		{
			long ticks = value._ticks;
			if (_ticks > ticks)
			{
				return 1;
			}
			if (_ticks < ticks)
			{
				return -1;
			}
			return 0;
		}

		public static TimeSpan FromDays(double value)
		{
			return Interval(value, 864000000000.0);
		}

		public TimeSpan Duration()
		{
			if (Ticks == MinValue.Ticks)
			{
				throw new OverflowException(SR.Overflow_Duration);
			}
			return new TimeSpan((_ticks >= 0) ? _ticks : (-_ticks));
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is TimeSpan)
			{
				return _ticks == ((TimeSpan)value)._ticks;
			}
			return false;
		}

		public bool Equals(TimeSpan obj)
		{
			return _ticks == obj._ticks;
		}

		public static bool Equals(TimeSpan t1, TimeSpan t2)
		{
			return t1._ticks == t2._ticks;
		}

		public override int GetHashCode()
		{
			return (int)_ticks ^ (int)(_ticks >> 32);
		}

		public static TimeSpan FromHours(double value)
		{
			return Interval(value, 36000000000.0);
		}

		private static TimeSpan Interval(double value, double scale)
		{
			if (double.IsNaN(value))
			{
				throw new ArgumentException(SR.Arg_CannotBeNaN);
			}
			double ticks = value * scale;
			return IntervalFromDoubleTicks(ticks);
		}

		private static TimeSpan IntervalFromDoubleTicks(double ticks)
		{
			if (ticks > 9.223372036854776E+18 || ticks < -9.223372036854776E+18 || double.IsNaN(ticks))
			{
				throw new OverflowException(SR.Overflow_TimeSpanTooLong);
			}
			if (ticks == 9.223372036854776E+18)
			{
				return MaxValue;
			}
			return new TimeSpan((long)ticks);
		}

		public static TimeSpan FromMilliseconds(double value)
		{
			return Interval(value, 10000.0);
		}

		public static TimeSpan FromMinutes(double value)
		{
			return Interval(value, 600000000.0);
		}

		public TimeSpan Negate()
		{
			if (Ticks == MinValue.Ticks)
			{
				throw new OverflowException(SR.Overflow_NegateTwosCompNum);
			}
			return new TimeSpan(-_ticks);
		}

		public static TimeSpan FromSeconds(double value)
		{
			return Interval(value, 10000000.0);
		}

		public TimeSpan Subtract(TimeSpan ts)
		{
			long num = _ticks - ts._ticks;
			if (_ticks >> 63 != ts._ticks >> 63 && _ticks >> 63 != num >> 63)
			{
				throw new OverflowException(SR.Overflow_TimeSpanTooLong);
			}
			return new TimeSpan(num);
		}

		public TimeSpan Multiply(double factor)
		{
			return this * factor;
		}

		public TimeSpan Divide(double divisor)
		{
			return this / divisor;
		}

		public double Divide(TimeSpan ts)
		{
			return this / ts;
		}

		public static TimeSpan FromTicks(long value)
		{
			return new TimeSpan(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static long TimeToTicks(int hour, int minute, int second)
		{
			long num = (long)hour * 3600L + (long)minute * 60L + second;
			if (num > 922337203685L || num < -922337203685L)
			{
				ThrowHelper.ThrowArgumentOutOfRange_TimeSpanTooLong();
			}
			return num * 10000000;
		}

		private static void ValidateStyles(TimeSpanStyles style, string parameterName)
		{
			if (style != 0 && style != TimeSpanStyles.AssumeNegative)
			{
				throw new ArgumentException(SR.Argument_InvalidTimeSpanStyles, parameterName);
			}
		}

		public static TimeSpan Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			return TimeSpanParse.Parse(s, null);
		}

		public static TimeSpan Parse(string input, IFormatProvider? formatProvider)
		{
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			return TimeSpanParse.Parse(input, formatProvider);
		}

		public static TimeSpan Parse(ReadOnlySpan<char> input, IFormatProvider? formatProvider = null)
		{
			return TimeSpanParse.Parse(input, formatProvider);
		}

		public static TimeSpan ParseExact(string input, string format, IFormatProvider? formatProvider)
		{
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			if (format == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
			}
			return TimeSpanParse.ParseExact(input, format, formatProvider, TimeSpanStyles.None);
		}

		public static TimeSpan ParseExact(string input, string[] formats, IFormatProvider? formatProvider)
		{
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			return TimeSpanParse.ParseExactMultiple(input, formats, formatProvider, TimeSpanStyles.None);
		}

		public static TimeSpan ParseExact(string input, string format, IFormatProvider? formatProvider, TimeSpanStyles styles)
		{
			ValidateStyles(styles, "styles");
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			if (format == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
			}
			return TimeSpanParse.ParseExact(input, format, formatProvider, styles);
		}

		public static TimeSpan ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, TimeSpanStyles styles = TimeSpanStyles.None)
		{
			ValidateStyles(styles, "styles");
			return TimeSpanParse.ParseExact(input, format, formatProvider, styles);
		}

		public static TimeSpan ParseExact(string input, string[] formats, IFormatProvider? formatProvider, TimeSpanStyles styles)
		{
			ValidateStyles(styles, "styles");
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			return TimeSpanParse.ParseExactMultiple(input, formats, formatProvider, styles);
		}

		public static TimeSpan ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider? formatProvider, TimeSpanStyles styles = TimeSpanStyles.None)
		{
			ValidateStyles(styles, "styles");
			return TimeSpanParse.ParseExactMultiple(input, formats, formatProvider, styles);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out TimeSpan result)
		{
			if (s == null)
			{
				result = default(TimeSpan);
				return false;
			}
			return TimeSpanParse.TryParse(s, null, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out TimeSpan result)
		{
			return TimeSpanParse.TryParse(s, null, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? input, IFormatProvider? formatProvider, out TimeSpan result)
		{
			if (input == null)
			{
				result = default(TimeSpan);
				return false;
			}
			return TimeSpanParse.TryParse(input, formatProvider, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> input, IFormatProvider? formatProvider, out TimeSpan result)
		{
			return TimeSpanParse.TryParse(input, formatProvider, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? input, [NotNullWhen(true)] string? format, IFormatProvider? formatProvider, out TimeSpan result)
		{
			if (input == null || format == null)
			{
				result = default(TimeSpan);
				return false;
			}
			return TimeSpanParse.TryParseExact(input, format, formatProvider, TimeSpanStyles.None, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, out TimeSpan result)
		{
			return TimeSpanParse.TryParseExact(input, format, formatProvider, TimeSpanStyles.None, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? input, [NotNullWhen(true)] string?[]? formats, IFormatProvider? formatProvider, out TimeSpan result)
		{
			if (input == null)
			{
				result = default(TimeSpan);
				return false;
			}
			return TimeSpanParse.TryParseExactMultiple(input, formats, formatProvider, TimeSpanStyles.None, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> input, [NotNullWhen(true)] string?[]? formats, IFormatProvider? formatProvider, out TimeSpan result)
		{
			return TimeSpanParse.TryParseExactMultiple(input, formats, formatProvider, TimeSpanStyles.None, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? input, [NotNullWhen(true)] string? format, IFormatProvider? formatProvider, TimeSpanStyles styles, out TimeSpan result)
		{
			ValidateStyles(styles, "styles");
			if (input == null || format == null)
			{
				result = default(TimeSpan);
				return false;
			}
			return TimeSpanParse.TryParseExact(input, format, formatProvider, styles, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider? formatProvider, TimeSpanStyles styles, out TimeSpan result)
		{
			ValidateStyles(styles, "styles");
			return TimeSpanParse.TryParseExact(input, format, formatProvider, styles, out result);
		}

		public static bool TryParseExact([NotNullWhen(true)] string? input, [NotNullWhen(true)] string?[]? formats, IFormatProvider? formatProvider, TimeSpanStyles styles, out TimeSpan result)
		{
			ValidateStyles(styles, "styles");
			if (input == null)
			{
				result = default(TimeSpan);
				return false;
			}
			return TimeSpanParse.TryParseExactMultiple(input, formats, formatProvider, styles, out result);
		}

		public static bool TryParseExact(ReadOnlySpan<char> input, [NotNullWhen(true)] string?[]? formats, IFormatProvider? formatProvider, TimeSpanStyles styles, out TimeSpan result)
		{
			ValidateStyles(styles, "styles");
			return TimeSpanParse.TryParseExactMultiple(input, formats, formatProvider, styles, out result);
		}

		public override string ToString()
		{
			return TimeSpanFormat.FormatC(this);
		}

		public string ToString(string? format)
		{
			return TimeSpanFormat.Format(this, format, null);
		}

		public string ToString(string? format, IFormatProvider? formatProvider)
		{
			return TimeSpanFormat.Format(this, format, formatProvider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? formatProvider = null)
		{
			return TimeSpanFormat.TryFormat(this, destination, out charsWritten, format, formatProvider);
		}

		public static TimeSpan operator -(TimeSpan t)
		{
			if (t._ticks == MinValue._ticks)
			{
				throw new OverflowException(SR.Overflow_NegateTwosCompNum);
			}
			return new TimeSpan(-t._ticks);
		}

		public static TimeSpan operator -(TimeSpan t1, TimeSpan t2)
		{
			return t1.Subtract(t2);
		}

		public static TimeSpan operator +(TimeSpan t)
		{
			return t;
		}

		public static TimeSpan operator +(TimeSpan t1, TimeSpan t2)
		{
			return t1.Add(t2);
		}

		public static TimeSpan operator *(TimeSpan timeSpan, double factor)
		{
			if (double.IsNaN(factor))
			{
				throw new ArgumentException(SR.Arg_CannotBeNaN, "factor");
			}
			double ticks = Math.Round((double)timeSpan.Ticks * factor);
			return IntervalFromDoubleTicks(ticks);
		}

		public static TimeSpan operator *(double factor, TimeSpan timeSpan)
		{
			return timeSpan * factor;
		}

		public static TimeSpan operator /(TimeSpan timeSpan, double divisor)
		{
			if (double.IsNaN(divisor))
			{
				throw new ArgumentException(SR.Arg_CannotBeNaN, "divisor");
			}
			double ticks = Math.Round((double)timeSpan.Ticks / divisor);
			return IntervalFromDoubleTicks(ticks);
		}

		public static double operator /(TimeSpan t1, TimeSpan t2)
		{
			return (double)t1.Ticks / (double)t2.Ticks;
		}

		public static bool operator ==(TimeSpan t1, TimeSpan t2)
		{
			return t1._ticks == t2._ticks;
		}

		public static bool operator !=(TimeSpan t1, TimeSpan t2)
		{
			return t1._ticks != t2._ticks;
		}

		public static bool operator <(TimeSpan t1, TimeSpan t2)
		{
			return t1._ticks < t2._ticks;
		}

		public static bool operator <=(TimeSpan t1, TimeSpan t2)
		{
			return t1._ticks <= t2._ticks;
		}

		public static bool operator >(TimeSpan t1, TimeSpan t2)
		{
			return t1._ticks > t2._ticks;
		}

		public static bool operator >=(TimeSpan t1, TimeSpan t2)
		{
			return t1._ticks >= t2._ticks;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IAdditionOperators<TimeSpan, TimeSpan, TimeSpan>.op_Addition(TimeSpan left, TimeSpan right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<TimeSpan, TimeSpan>.op_LessThan(TimeSpan left, TimeSpan right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<TimeSpan, TimeSpan>.op_LessThanOrEqual(TimeSpan left, TimeSpan right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<TimeSpan, TimeSpan>.op_GreaterThan(TimeSpan left, TimeSpan right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<TimeSpan, TimeSpan>.op_GreaterThanOrEqual(TimeSpan left, TimeSpan right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IDivisionOperators<TimeSpan, double, TimeSpan>.op_Division(TimeSpan left, double right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static double IDivisionOperators<TimeSpan, TimeSpan, double>.op_Division(TimeSpan left, TimeSpan right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<TimeSpan, TimeSpan>.op_Equality(TimeSpan left, TimeSpan right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<TimeSpan, TimeSpan>.op_Inequality(TimeSpan left, TimeSpan right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IMultiplyOperators<TimeSpan, double, TimeSpan>.op_Multiply(TimeSpan left, double right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IParseable<TimeSpan>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<TimeSpan>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out TimeSpan result)
		{
			return TryParse(s, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan ISpanParseable<TimeSpan>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<TimeSpan>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out TimeSpan result)
		{
			return TryParse(s, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>.op_Subtraction(TimeSpan left, TimeSpan right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IUnaryNegationOperators<TimeSpan, TimeSpan>.op_UnaryNegation(TimeSpan value)
		{
			return -value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static TimeSpan IUnaryPlusOperators<TimeSpan, TimeSpan>.op_UnaryPlus(TimeSpan value)
		{
			return +value;
		}
	}
	[Obsolete("System.TimeZone has been deprecated. Investigate the use of System.TimeZoneInfo instead.")]
	public abstract class TimeZone
	{
		private static volatile TimeZone currentTimeZone;

		private static object s_InternalSyncObject;

		private static object InternalSyncObject
		{
			get
			{
				if (s_InternalSyncObject == null)
				{
					object value = new object();
					Interlocked.CompareExchange<object>(ref s_InternalSyncObject, value, (object)null);
				}
				return s_InternalSyncObject;
			}
		}

		public static TimeZone CurrentTimeZone
		{
			get
			{
				TimeZone timeZone = currentTimeZone;
				if (timeZone == null)
				{
					lock (InternalSyncObject)
					{
						if (currentTimeZone == null)
						{
							currentTimeZone = new CurrentSystemTimeZone();
						}
						timeZone = currentTimeZone;
					}
				}
				return timeZone;
			}
		}

		public abstract string StandardName { get; }

		public abstract string DaylightName { get; }

		internal static void ResetTimeZone()
		{
			if (currentTimeZone != null)
			{
				lock (InternalSyncObject)
				{
					currentTimeZone = null;
				}
			}
		}

		public abstract TimeSpan GetUtcOffset(DateTime time);

		public virtual DateTime ToUniversalTime(DateTime time)
		{
			if (time.Kind == DateTimeKind.Utc)
			{
				return time;
			}
			long num = time.Ticks - GetUtcOffset(time).Ticks;
			if (num > 3155378975999999999L)
			{
				return new DateTime(3155378975999999999L, DateTimeKind.Utc);
			}
			if (num < 0)
			{
				return new DateTime(0L, DateTimeKind.Utc);
			}
			return new DateTime(num, DateTimeKind.Utc);
		}

		public virtual DateTime ToLocalTime(DateTime time)
		{
			if (time.Kind == DateTimeKind.Local)
			{
				return time;
			}
			bool isAmbiguousLocalDst = false;
			long utcOffsetFromUniversalTime = ((CurrentSystemTimeZone)CurrentTimeZone).GetUtcOffsetFromUniversalTime(time, ref isAmbiguousLocalDst);
			return new DateTime(time.Ticks + utcOffsetFromUniversalTime, DateTimeKind.Local, isAmbiguousLocalDst);
		}

		public abstract DaylightTime GetDaylightChanges(int year);

		public virtual bool IsDaylightSavingTime(DateTime time)
		{
			return IsDaylightSavingTime(time, GetDaylightChanges(time.Year));
		}

		public static bool IsDaylightSavingTime(DateTime time, DaylightTime daylightTimes)
		{
			return CalculateUtcOffset(time, daylightTimes) != TimeSpan.Zero;
		}

		internal static TimeSpan CalculateUtcOffset(DateTime time, DaylightTime daylightTimes)
		{
			if (daylightTimes == null)
			{
				return TimeSpan.Zero;
			}
			DateTimeKind kind = time.Kind;
			if (kind == DateTimeKind.Utc)
			{
				return TimeSpan.Zero;
			}
			DateTime dateTime = daylightTimes.Start + daylightTimes.Delta;
			DateTime end = daylightTimes.End;
			DateTime dateTime2;
			DateTime dateTime3;
			if (daylightTimes.Delta.Ticks > 0)
			{
				dateTime2 = end - daylightTimes.Delta;
				dateTime3 = end;
			}
			else
			{
				dateTime2 = dateTime;
				dateTime3 = dateTime - daylightTimes.Delta;
			}
			bool flag = false;
			if (dateTime > end)
			{
				if (time >= dateTime || time < end)
				{
					flag = true;
				}
			}
			else if (time >= dateTime && time < end)
			{
				flag = true;
			}
			if (flag && time >= dateTime2 && time < dateTime3)
			{
				flag = time.IsAmbiguousDaylightSavingTime();
			}
			if (flag)
			{
				return daylightTimes.Delta;
			}
			return TimeSpan.Zero;
		}
	}
	[Serializable]
	[TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class TimeZoneInfo : IEquatable<TimeZoneInfo?>, ISerializable, IDeserializationCallback
	{
		[Serializable]
		public sealed class AdjustmentRule : IEquatable<AdjustmentRule?>, ISerializable, IDeserializationCallback
		{
			private static readonly TimeSpan DaylightDeltaAdjustment = TimeSpan.FromHours(24.0);

			private static readonly TimeSpan MaxDaylightDelta = TimeSpan.FromHours(12.0);

			private readonly DateTime _dateStart;

			private readonly DateTime _dateEnd;

			private readonly TimeSpan _daylightDelta;

			private readonly TransitionTime _daylightTransitionStart;

			private readonly TransitionTime _daylightTransitionEnd;

			private readonly TimeSpan _baseUtcOffsetDelta;

			private readonly bool _noDaylightTransitions;

			public DateTime DateStart => _dateStart;

			public DateTime DateEnd => _dateEnd;

			public TimeSpan DaylightDelta => _daylightDelta;

			public TransitionTime DaylightTransitionStart => _daylightTransitionStart;

			public TransitionTime DaylightTransitionEnd => _daylightTransitionEnd;

			public TimeSpan BaseUtcOffsetDelta => _baseUtcOffsetDelta;

			internal bool NoDaylightTransitions => _noDaylightTransitions;

			internal bool HasDaylightSaving
			{
				get
				{
					if (!(DaylightDelta != TimeSpan.Zero) && (!(DaylightTransitionStart != default(TransitionTime)) || !(DaylightTransitionStart.TimeOfDay != DateTime.MinValue)))
					{
						if (DaylightTransitionEnd != default(TransitionTime))
						{
							return DaylightTransitionEnd.TimeOfDay != DateTime.MinValue.AddMilliseconds(1.0);
						}
						return false;
					}
					return true;
				}
			}

			public bool Equals([NotNullWhen(true)] AdjustmentRule? other)
			{
				if (other != null && _dateStart == other._dateStart && _dateEnd == other._dateEnd && _daylightDelta == other._daylightDelta && _baseUtcOffsetDelta == other._baseUtcOffsetDelta && _daylightTransitionEnd.Equals(other._daylightTransitionEnd))
				{
					return _daylightTransitionStart.Equals(other._daylightTransitionStart);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return _dateStart.GetHashCode();
			}

			private AdjustmentRule(DateTime dateStart, DateTime dateEnd, TimeSpan daylightDelta, TransitionTime daylightTransitionStart, TransitionTime daylightTransitionEnd, TimeSpan baseUtcOffsetDelta, bool noDaylightTransitions)
			{
				ValidateAdjustmentRule(dateStart, dateEnd, daylightDelta, daylightTransitionStart, daylightTransitionEnd, noDaylightTransitions);
				_dateStart = dateStart;
				_dateEnd = dateEnd;
				_daylightDelta = daylightDelta;
				_daylightTransitionStart = daylightTransitionStart;
				_daylightTransitionEnd = daylightTransitionEnd;
				_baseUtcOffsetDelta = baseUtcOffsetDelta;
				_noDaylightTransitions = noDaylightTransitions;
			}

			public static AdjustmentRule CreateAdjustmentRule(DateTime dateStart, DateTime dateEnd, TimeSpan daylightDelta, TransitionTime daylightTransitionStart, TransitionTime daylightTransitionEnd, TimeSpan baseUtcOffsetDelta)
			{
				return new AdjustmentRule(dateStart, dateEnd, daylightDelta, daylightTransitionStart, daylightTransitionEnd, baseUtcOffsetDelta, noDaylightTransitions: false);
			}

			public static AdjustmentRule CreateAdjustmentRule(DateTime dateStart, DateTime dateEnd, TimeSpan daylightDelta, TransitionTime daylightTransitionStart, TransitionTime daylightTransitionEnd)
			{
				return new AdjustmentRule(dateStart, dateEnd, daylightDelta, daylightTransitionStart, daylightTransitionEnd, TimeSpan.Zero, noDaylightTransitions: false);
			}

			internal static AdjustmentRule CreateAdjustmentRule(DateTime dateStart, DateTime dateEnd, TimeSpan daylightDelta, TransitionTime daylightTransitionStart, TransitionTime daylightTransitionEnd, TimeSpan baseUtcOffsetDelta, bool noDaylightTransitions)
			{
				AdjustDaylightDeltaToExpectedRange(ref daylightDelta, ref baseUtcOffsetDelta);
				return new AdjustmentRule(dateStart, dateEnd, daylightDelta, daylightTransitionStart, daylightTransitionEnd, baseUtcOffsetDelta, noDaylightTransitions);
			}

			internal bool IsStartDateMarkerForBeginningOfYear()
			{
				if (!NoDaylightTransitions && DaylightTransitionStart.Month == 1 && DaylightTransitionStart.Day == 1)
				{
					return DaylightTransitionStart.TimeOfDay.TimeOfDay.Ticks < 10000000;
				}
				return false;
			}

			internal bool IsEndDateMarkerForEndOfYear()
			{
				if (!NoDaylightTransitions && DaylightTransitionEnd.Month == 1 && DaylightTransitionEnd.Day == 1)
				{
					return DaylightTransitionEnd.TimeOfDay.TimeOfDay.Ticks < 10000000;
				}
				return false;
			}

			private static void ValidateAdjustmentRule(DateTime dateStart, DateTime dateEnd, TimeSpan daylightDelta, TransitionTime daylightTransitionStart, TransitionTime daylightTransitionEnd, bool noDaylightTransitions)
			{
				if (dateStart.Kind != 0 && dateStart.Kind != DateTimeKind.Utc)
				{
					throw new ArgumentException(SR.Argument_DateTimeKindMustBeUnspecifiedOrUtc, "dateStart");
				}
				if (dateEnd.Kind != 0 && dateEnd.Kind != DateTimeKind.Utc)
				{
					throw new ArgumentException(SR.Argument_DateTimeKindMustBeUnspecifiedOrUtc, "dateEnd");
				}
				if (daylightTransitionStart.Equals(daylightTransitionEnd) && !noDaylightTransitions)
				{
					throw new ArgumentException(SR.Argument_TransitionTimesAreIdentical, "daylightTransitionEnd");
				}
				if (dateStart > dateEnd)
				{
					throw new ArgumentException(SR.Argument_OutOfOrderDateTimes, "dateStart");
				}
				if (daylightDelta.TotalHours < -23.0 || daylightDelta.TotalHours > 14.0)
				{
					throw new ArgumentOutOfRangeException("daylightDelta", daylightDelta, SR.ArgumentOutOfRange_UtcOffset);
				}
				if (daylightDelta.Ticks % 600000000 != 0L)
				{
					throw new ArgumentException(SR.Argument_TimeSpanHasSeconds, "daylightDelta");
				}
				if (dateStart != DateTime.MinValue && dateStart.Kind == DateTimeKind.Unspecified && dateStart.TimeOfDay != TimeSpan.Zero)
				{
					throw new ArgumentException(SR.Argument_DateTimeHasTimeOfDay, "dateStart");
				}
				if (dateEnd != DateTime.MaxValue && dateEnd.Kind == DateTimeKind.Unspecified && dateEnd.TimeOfDay != TimeSpan.Zero)
				{
					throw new ArgumentException(SR.Argument_DateTimeHasTimeOfDay, "dateEnd");
				}
			}

			private static void AdjustDaylightDeltaToExpectedRange(ref TimeSpan daylightDelta, ref TimeSpan baseUtcOffsetDelta)
			{
				if (daylightDelta > MaxDaylightDelta)
				{
					daylightDelta -= DaylightDeltaAdjustment;
					baseUtcOffsetDelta += DaylightDeltaAdjustment;
				}
				else if (daylightDelta < -MaxDaylightDelta)
				{
					daylightDelta += DaylightDeltaAdjustment;
					baseUtcOffsetDelta -= DaylightDeltaAdjustment;
				}
			}

			void IDeserializationCallback.OnDeserialization(object sender)
			{
				try
				{
					ValidateAdjustmentRule(_dateStart, _dateEnd, _daylightDelta, _daylightTransitionStart, _daylightTransitionEnd, _noDaylightTransitions);
				}
				catch (ArgumentException innerException)
				{
					throw new SerializationException(SR.Serialization_InvalidData, innerException);
				}
			}

			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
				if (info == null)
				{
					throw new ArgumentNullException("info");
				}
				info.AddValue("DateStart", _dateStart);
				info.AddValue("DateEnd", _dateEnd);
				info.AddValue("DaylightDelta", _daylightDelta);
				info.AddValue("DaylightTransitionStart", _daylightTransitionStart);
				info.AddValue("DaylightTransitionEnd", _daylightTransitionEnd);
				info.AddValue("BaseUtcOffsetDelta", _baseUtcOffsetDelta);
				info.AddValue("NoDaylightTransitions", _noDaylightTransitions);
			}

			private AdjustmentRule(SerializationInfo info, StreamingContext context)
			{
				if (info == null)
				{
					throw new ArgumentNullException("info");
				}
				_dateStart = (DateTime)info.GetValue("DateStart", typeof(DateTime));
				_dateEnd = (DateTime)info.GetValue("DateEnd", typeof(DateTime));
				_daylightDelta = (TimeSpan)info.GetValue("DaylightDelta", typeof(TimeSpan));
				_daylightTransitionStart = (TransitionTime)info.GetValue("DaylightTransitionStart", typeof(TransitionTime));
				_daylightTransitionEnd = (TransitionTime)info.GetValue("DaylightTransitionEnd", typeof(TransitionTime));
				object valueNoThrow = info.GetValueNoThrow("BaseUtcOffsetDelta", typeof(TimeSpan));
				if (valueNoThrow != null)
				{
					_baseUtcOffsetDelta = (TimeSpan)valueNoThrow;
				}
				valueNoThrow = info.GetValueNoThrow("NoDaylightTransitions", typeof(bool));
				if (valueNoThrow != null)
				{
					_noDaylightTransitions = (bool)valueNoThrow;
				}
			}
		}

		private enum TimeZoneInfoResult
		{
			Success,
			TimeZoneNotFoundException,
			InvalidTimeZoneException,
			SecurityException
		}

		private sealed class CachedData
		{
			private volatile TimeZoneInfo _localTimeZone;

			public Dictionary<string, TimeZoneInfo> _systemTimeZones;

			public ReadOnlyCollection<TimeZoneInfo> _readOnlySystemTimeZones;

			public bool _allSystemTimeZonesRead;

			private volatile OffsetAndRule _oneYearLocalFromUtc;

			public TimeZoneInfo Local => _localTimeZone ?? CreateLocal();

			private TimeZoneInfo CreateLocal()
			{
				lock (this)
				{
					TimeZoneInfo timeZoneInfo = _localTimeZone;
					if (timeZoneInfo == null)
					{
						timeZoneInfo = GetLocalTimeZone(this);
						timeZoneInfo = (_localTimeZone = new TimeZoneInfo(timeZoneInfo._id, timeZoneInfo._baseUtcOffset, timeZoneInfo._displayName, timeZoneInfo._standardDisplayName, timeZoneInfo._daylightDisplayName, timeZoneInfo._adjustmentRules, disableDaylightSavingTime: false, timeZoneInfo.HasIanaId));
					}
					return timeZoneInfo;
				}
			}

			public DateTimeKind GetCorrespondingKind(TimeZoneInfo timeZone)
			{
				if (timeZone != s_utcTimeZone)
				{
					if (timeZone != _localTimeZone)
					{
						return DateTimeKind.Unspecified;
					}
					return DateTimeKind.Local;
				}
				return DateTimeKind.Utc;
			}

			private static TimeZoneInfo GetCurrentOneYearLocal()
			{
				Interop.Kernel32.TIME_ZONE_INFORMATION lpTimeZoneInformation;
				uint timeZoneInformation = Interop.Kernel32.GetTimeZoneInformation(out lpTimeZoneInformation);
				if (timeZoneInformation != uint.MaxValue)
				{
					return GetLocalTimeZoneFromWin32Data(in lpTimeZoneInformation, dstDisabled: false);
				}
				return CreateCustomTimeZone("Local", TimeSpan.Zero, "Local", "Local");
			}

			public OffsetAndRule GetOneYearLocalFromUtc(int year)
			{
				OffsetAndRule offsetAndRule = _oneYearLocalFromUtc;
				if (offsetAndRule == null || offsetAndRule.Year != year)
				{
					TimeZoneInfo currentOneYearLocal = GetCurrentOneYearLocal();
					AdjustmentRule[] adjustmentRules = currentOneYearLocal._adjustmentRules;
					AdjustmentRule rule = ((adjustmentRules != null) ? adjustmentRules[0] : null);
					offsetAndRule = (_oneYearLocalFromUtc = new OffsetAndRule(year, currentOneYearLocal.BaseUtcOffset, rule));
				}
				return offsetAndRule;
			}
		}

		private struct StringSerializer
		{
			private enum State
			{
				Escaped,
				NotEscaped,
				StartOfToken,
				EndOfLine
			}

			private readonly string _serializedText;

			private int _currentTokenStartIndex;

			private State _state;

			public static string GetSerializedString(TimeZoneInfo zone)
			{
				Span<char> initialBuffer = stackalloc char[64];
				ValueStringBuilder serializedText = new ValueStringBuilder(initialBuffer);
				SerializeSubstitute(zone.Id, ref serializedText);
				serializedText.Append(';');
				serializedText.AppendSpanFormattable(zone.BaseUtcOffset.TotalMinutes, null, CultureInfo.InvariantCulture);
				serializedText.Append(';');
				SerializeSubstitute(zone.DisplayName, ref serializedText);
				serializedText.Append(';');
				SerializeSubstitute(zone.StandardName, ref serializedText);
				serializedText.Append(';');
				SerializeSubstitute(zone.DaylightName, ref serializedText);
				serializedText.Append(';');
				AdjustmentRule[] adjustmentRules = zone.GetAdjustmentRules();
				AdjustmentRule[] array = adjustmentRules;
				foreach (AdjustmentRule adjustmentRule in array)
				{
					serializedText.Append('[');
					serializedText.AppendSpanFormattable(adjustmentRule.DateStart, "MM:dd:yyyy", DateTimeFormatInfo.InvariantInfo);
					serializedText.Append(';');
					serializedText.AppendSpanFormattable(adjustmentRule.DateEnd, "MM:dd:yyyy", DateTimeFormatInfo.InvariantInfo);
					serializedText.Append(';');
					serializedText.AppendSpanFormattable(adjustmentRule.DaylightDelta.TotalMinutes, null, CultureInfo.InvariantCulture);
					serializedText.Append(';');
					SerializeTransitionTime(adjustmentRule.DaylightTransitionStart, ref serializedText);
					serializedText.Append(';');
					SerializeTransitionTime(adjustmentRule.DaylightTransitionEnd, ref serializedText);
					serializedText.Append(';');
					if (adjustmentRule.BaseUtcOffsetDelta != TimeSpan.Zero)
					{
						serializedText.AppendSpanFormattable(adjustmentRule.BaseUtcOffsetDelta.TotalMinutes, null, CultureInfo.InvariantCulture);
						serializedText.Append(';');
					}
					if (adjustmentRule.NoDaylightTransitions)
					{
						serializedText.Append('1');
						serializedText.Append(';');
					}
					serializedText.Append(']');
				}
				serializedText.Append(';');
				return serializedText.ToString();
			}

			public static TimeZoneInfo GetDeserializedTimeZoneInfo(string source)
			{
				StringSerializer stringSerializer = new StringSerializer(source);
				string nextStringValue = stringSerializer.GetNextStringValue();
				TimeSpan nextTimeSpanValue = stringSerializer.GetNextTimeSpanValue();
				string nextStringValue2 = stringSerializer.GetNextStringValue();
				string nextStringValue3 = stringSerializer.GetNextStringValue();
				string nextStringValue4 = stringSerializer.GetNextStringValue();
				AdjustmentRule[] nextAdjustmentRuleArrayValue = stringSerializer.GetNextAdjustmentRuleArrayValue();
				try
				{
					return new TimeZoneInfo(nextStringValue, nextTimeSpanValue, nextStringValue2, nextStringValue3, nextStringValue4, nextAdjustmentRuleArrayValue, disableDaylightSavingTime: false);
				}
				catch (ArgumentException innerException)
				{
					throw new SerializationException(SR.Serialization_InvalidData, innerException);
				}
				catch (InvalidTimeZoneException innerException2)
				{
					throw new SerializationException(SR.Serialization_InvalidData, innerException2);
				}
			}

			private StringSerializer(string str)
			{
				_serializedText = str;
				_currentTokenStartIndex = 0;
				_state = State.StartOfToken;
			}

			private static void SerializeSubstitute(string text, ref ValueStringBuilder serializedText)
			{
				foreach (char c in text)
				{
					if (c == '\\' || c == '[' || c == ']' || c == ';')
					{
						serializedText.Append('\\');
					}
					serializedText.Append(c);
				}
			}

			private static void SerializeTransitionTime(TransitionTime time, ref ValueStringBuilder serializedText)
			{
				serializedText.Append('[');
				serializedText.Append(time.IsFixedDateRule ? '1' : '0');
				serializedText.Append(';');
				serializedText.AppendSpanFormattable(time.TimeOfDay, "HH:mm:ss.FFF", DateTimeFormatInfo.InvariantInfo);
				serializedText.Append(';');
				serializedText.AppendSpanFormattable(time.Month, null, CultureInfo.InvariantCulture);
				serializedText.Append(';');
				if (time.IsFixedDateRule)
				{
					serializedText.AppendSpanFormattable(time.Day, null, CultureInfo.InvariantCulture);
					serializedText.Append(';');
				}
				else
				{
					serializedText.AppendSpanFormattable(time.Week, null, CultureInfo.InvariantCulture);
					serializedText.Append(';');
					serializedText.AppendSpanFormattable((int)time.DayOfWeek, null, CultureInfo.InvariantCulture);
					serializedText.Append(';');
				}
				serializedText.Append(']');
			}

			private static void VerifyIsEscapableCharacter(char c)
			{
				if (c != '\\' && c != ';' && c != '[' && c != ']')
				{
					throw new SerializationException(SR.Format(SR.Serialization_InvalidEscapeSequence, c));
				}
			}

			private void SkipVersionNextDataFields(int depth)
			{
				if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				State state = State.NotEscaped;
				for (int i = _currentTokenStartIndex; i < _serializedText.Length; i++)
				{
					switch (state)
					{
					case State.Escaped:
						VerifyIsEscapableCharacter(_serializedText[i]);
						state = State.NotEscaped;
						break;
					case State.NotEscaped:
						switch (_serializedText[i])
						{
						case '\\':
							state = State.Escaped;
							break;
						case '[':
							depth++;
							break;
						case ']':
							depth--;
							if (depth == 0)
							{
								_currentTokenStartIndex = i + 1;
								if (_currentTokenStartIndex >= _serializedText.Length)
								{
									_state = State.EndOfLine;
								}
								else
								{
									_state = State.StartOfToken;
								}
								return;
							}
							break;
						case '\0':
							throw new SerializationException(SR.Serialization_InvalidData);
						}
						break;
					}
				}
				throw new SerializationException(SR.Serialization_InvalidData);
			}

			private string GetNextStringValue()
			{
				if (_state == State.EndOfLine)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				State state = State.NotEscaped;
				Span<char> initialBuffer = stackalloc char[64];
				ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
				for (int i = _currentTokenStartIndex; i < _serializedText.Length; i++)
				{
					switch (state)
					{
					case State.Escaped:
						VerifyIsEscapableCharacter(_serializedText[i]);
						valueStringBuilder.Append(_serializedText[i]);
						state = State.NotEscaped;
						break;
					case State.NotEscaped:
						switch (_serializedText[i])
						{
						case '\\':
							state = State.Escaped;
							break;
						case '[':
							throw new SerializationException(SR.Serialization_InvalidData);
						case ']':
							throw new SerializationException(SR.Serialization_InvalidData);
						case ';':
							_currentTokenStartIndex = i + 1;
							if (_currentTokenStartIndex >= _serializedText.Length)
							{
								_state = State.EndOfLine;
							}
							else
							{
								_state = State.StartOfToken;
							}
							return valueStringBuilder.ToString();
						case '\0':
							throw new SerializationException(SR.Serialization_InvalidData);
						default:
							valueStringBuilder.Append(_serializedText[i]);
							break;
						}
						break;
					}
				}
				if (state == State.Escaped)
				{
					throw new SerializationException(SR.Format(SR.Serialization_InvalidEscapeSequence, string.Empty));
				}
				throw new SerializationException(SR.Serialization_InvalidData);
			}

			private DateTime GetNextDateTimeValue(string format)
			{
				string nextStringValue = GetNextStringValue();
				if (!DateTime.TryParseExact(nextStringValue, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.None, out var result))
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				return result;
			}

			private TimeSpan GetNextTimeSpanValue()
			{
				int nextInt32Value = GetNextInt32Value();
				try
				{
					return new TimeSpan(0, nextInt32Value, 0);
				}
				catch (ArgumentOutOfRangeException innerException)
				{
					throw new SerializationException(SR.Serialization_InvalidData, innerException);
				}
			}

			private int GetNextInt32Value()
			{
				string nextStringValue = GetNextStringValue();
				if (!int.TryParse(nextStringValue, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result))
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				return result;
			}

			private AdjustmentRule[] GetNextAdjustmentRuleArrayValue()
			{
				List<AdjustmentRule> list = new List<AdjustmentRule>(1);
				int num = 0;
				for (AdjustmentRule nextAdjustmentRuleValue = GetNextAdjustmentRuleValue(); nextAdjustmentRuleValue != null; nextAdjustmentRuleValue = GetNextAdjustmentRuleValue())
				{
					list.Add(nextAdjustmentRuleValue);
					num++;
				}
				if (_state == State.EndOfLine)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (num == 0)
				{
					return null;
				}
				return list.ToArray();
			}

			private AdjustmentRule GetNextAdjustmentRuleValue()
			{
				if (_state == State.EndOfLine)
				{
					return null;
				}
				if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (_serializedText[_currentTokenStartIndex] == ';')
				{
					return null;
				}
				if (_serializedText[_currentTokenStartIndex] != '[')
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				_currentTokenStartIndex++;
				DateTime nextDateTimeValue = GetNextDateTimeValue("MM:dd:yyyy");
				DateTime nextDateTimeValue2 = GetNextDateTimeValue("MM:dd:yyyy");
				TimeSpan nextTimeSpanValue = GetNextTimeSpanValue();
				TransitionTime nextTransitionTimeValue = GetNextTransitionTimeValue();
				TransitionTime nextTransitionTimeValue2 = GetNextTransitionTimeValue();
				TimeSpan baseUtcOffsetDelta = TimeSpan.Zero;
				int num = 0;
				if (_state == State.EndOfLine || _currentTokenStartIndex >= _serializedText.Length)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if ((_serializedText[_currentTokenStartIndex] >= '0' && _serializedText[_currentTokenStartIndex] <= '9') || _serializedText[_currentTokenStartIndex] == '-' || _serializedText[_currentTokenStartIndex] == '+')
				{
					baseUtcOffsetDelta = GetNextTimeSpanValue();
				}
				if (_serializedText[_currentTokenStartIndex] >= '0' && _serializedText[_currentTokenStartIndex] <= '1')
				{
					num = GetNextInt32Value();
				}
				if (_state == State.EndOfLine || _currentTokenStartIndex >= _serializedText.Length)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (_serializedText[_currentTokenStartIndex] != ']')
				{
					SkipVersionNextDataFields(1);
				}
				else
				{
					_currentTokenStartIndex++;
				}
				AdjustmentRule result;
				try
				{
					result = AdjustmentRule.CreateAdjustmentRule(nextDateTimeValue, nextDateTimeValue2, nextTimeSpanValue, nextTransitionTimeValue, nextTransitionTimeValue2, baseUtcOffsetDelta, num > 0);
				}
				catch (ArgumentException innerException)
				{
					throw new SerializationException(SR.Serialization_InvalidData, innerException);
				}
				if (_currentTokenStartIndex >= _serializedText.Length)
				{
					_state = State.EndOfLine;
				}
				else
				{
					_state = State.StartOfToken;
				}
				return result;
			}

			private TransitionTime GetNextTransitionTimeValue()
			{
				if (_state == State.EndOfLine || (_currentTokenStartIndex < _serializedText.Length && _serializedText[_currentTokenStartIndex] == ']'))
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (_serializedText[_currentTokenStartIndex] != '[')
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				_currentTokenStartIndex++;
				int nextInt32Value = GetNextInt32Value();
				if (nextInt32Value != 0 && nextInt32Value != 1)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				DateTime nextDateTimeValue = GetNextDateTimeValue("HH:mm:ss.FFF");
				nextDateTimeValue = new DateTime(1, 1, 1, nextDateTimeValue.Hour, nextDateTimeValue.Minute, nextDateTimeValue.Second, nextDateTimeValue.Millisecond);
				int nextInt32Value2 = GetNextInt32Value();
				TransitionTime result;
				if (nextInt32Value == 1)
				{
					int nextInt32Value3 = GetNextInt32Value();
					try
					{
						result = TransitionTime.CreateFixedDateRule(nextDateTimeValue, nextInt32Value2, nextInt32Value3);
					}
					catch (ArgumentException innerException)
					{
						throw new SerializationException(SR.Serialization_InvalidData, innerException);
					}
				}
				else
				{
					int nextInt32Value4 = GetNextInt32Value();
					int nextInt32Value5 = GetNextInt32Value();
					try
					{
						result = TransitionTime.CreateFloatingDateRule(nextDateTimeValue, nextInt32Value2, nextInt32Value4, (DayOfWeek)nextInt32Value5);
					}
					catch (ArgumentException innerException2)
					{
						throw new SerializationException(SR.Serialization_InvalidData, innerException2);
					}
				}
				if (_state == State.EndOfLine || _currentTokenStartIndex >= _serializedText.Length)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (_serializedText[_currentTokenStartIndex] != ']')
				{
					SkipVersionNextDataFields(1);
				}
				else
				{
					_currentTokenStartIndex++;
				}
				bool flag = false;
				if (_currentTokenStartIndex < _serializedText.Length && _serializedText[_currentTokenStartIndex] == ';')
				{
					_currentTokenStartIndex++;
					flag = true;
				}
				if (!flag)
				{
					throw new SerializationException(SR.Serialization_InvalidData);
				}
				if (_currentTokenStartIndex >= _serializedText.Length)
				{
					_state = State.EndOfLine;
				}
				else
				{
					_state = State.StartOfToken;
				}
				return result;
			}
		}

		[Serializable]
		public readonly struct TransitionTime : IEquatable<TransitionTime>, ISerializable, IDeserializationCallback
		{
			private readonly DateTime _timeOfDay;

			private readonly byte _month;

			private readonly byte _week;

			private readonly byte _day;

			private readonly DayOfWeek _dayOfWeek;

			private readonly bool _isFixedDateRule;

			public DateTime TimeOfDay => _timeOfDay;

			public int Month => _month;

			public int Week => _week;

			public int Day => _day;

			public DayOfWeek DayOfWeek => _dayOfWeek;

			public bool IsFixedDateRule => _isFixedDateRule;

			public override bool Equals([NotNullWhen(true)] object? obj)
			{
				if (obj is TransitionTime)
				{
					return Equals((TransitionTime)obj);
				}
				return false;
			}

			public static bool operator ==(TransitionTime t1, TransitionTime t2)
			{
				return t1.Equals(t2);
			}

			public static bool operator !=(TransitionTime t1, TransitionTime t2)
			{
				return !t1.Equals(t2);
			}

			public bool Equals(TransitionTime other)
			{
				if (_isFixedDateRule == other._isFixedDateRule && _timeOfDay == other._timeOfDay && _month == other._month)
				{
					if (!other._isFixedDateRule)
					{
						if (_week == other._week)
						{
							return _dayOfWeek == other._dayOfWeek;
						}
						return false;
					}
					return _day == other._day;
				}
				return false;
			}

			public override int GetHashCode()
			{
				return _month ^ (_week << 8);
			}

			private TransitionTime(DateTime timeOfDay, int month, int week, int day, DayOfWeek dayOfWeek, bool isFixedDateRule)
			{
				ValidateTransitionTime(timeOfDay, month, week, day, dayOfWeek);
				_timeOfDay = timeOfDay;
				_month = (byte)month;
				_week = (byte)week;
				_day = (byte)day;
				_dayOfWeek = dayOfWeek;
				_isFixedDateRule = isFixedDateRule;
			}

			public static TransitionTime CreateFixedDateRule(DateTime timeOfDay, int month, int day)
			{
				return new TransitionTime(timeOfDay, month, 1, day, DayOfWeek.Sunday, isFixedDateRule: true);
			}

			public static TransitionTime CreateFloatingDateRule(DateTime timeOfDay, int month, int week, DayOfWeek dayOfWeek)
			{
				return new TransitionTime(timeOfDay, month, week, 1, dayOfWeek, isFixedDateRule: false);
			}

			private static void ValidateTransitionTime(DateTime timeOfDay, int month, int week, int day, DayOfWeek dayOfWeek)
			{
				if (timeOfDay.Kind != 0)
				{
					throw new ArgumentException(SR.Argument_DateTimeKindMustBeUnspecified, "timeOfDay");
				}
				if (month < 1 || month > 12)
				{
					throw new ArgumentOutOfRangeException("month", SR.ArgumentOutOfRange_MonthParam);
				}
				if (day < 1 || day > 31)
				{
					throw new ArgumentOutOfRangeException("day", SR.ArgumentOutOfRange_DayParam);
				}
				if (week < 1 || week > 5)
				{
					throw new ArgumentOutOfRangeException("week", SR.ArgumentOutOfRange_Week);
				}
				if (dayOfWeek < DayOfWeek.Sunday || dayOfWeek > DayOfWeek.Saturday)
				{
					throw new ArgumentOutOfRangeException("dayOfWeek", SR.ArgumentOutOfRange_DayOfWeek);
				}
				timeOfDay.GetDate(out var year, out var month2, out var day2);
				if (year != 1 || month2 != 1 || day2 != 1 || timeOfDay.Ticks % 10000 != 0L)
				{
					throw new ArgumentException(SR.Argument_DateTimeHasTicks, "timeOfDay");
				}
			}

			void IDeserializationCallback.OnDeserialization(object sender)
			{
				if (this != default(TransitionTime))
				{
					try
					{
						ValidateTransitionTime(_timeOfDay, _month, _week, _day, _dayOfWeek);
					}
					catch (ArgumentException innerException)
					{
						throw new SerializationException(SR.Serialization_InvalidData, innerException);
					}
				}
			}

			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
				if (info == null)
				{
					throw new ArgumentNullException("info");
				}
				info.AddValue("TimeOfDay", _timeOfDay);
				info.AddValue("Month", _month);
				info.AddValue("Week", _week);
				info.AddValue("Day", _day);
				info.AddValue("DayOfWeek", _dayOfWeek);
				info.AddValue("IsFixedDateRule", _isFixedDateRule);
			}

			private TransitionTime(SerializationInfo info, StreamingContext context)
			{
				if (info == null)
				{
					throw new ArgumentNullException("info");
				}
				_timeOfDay = (DateTime)info.GetValue("TimeOfDay", typeof(DateTime));
				_month = (byte)info.GetValue("Month", typeof(byte));
				_week = (byte)info.GetValue("Week", typeof(byte));
				_day = (byte)info.GetValue("Day", typeof(byte));
				_dayOfWeek = (DayOfWeek)info.GetValue("DayOfWeek", typeof(DayOfWeek));
				_isFixedDateRule = (bool)info.GetValue("IsFixedDateRule", typeof(bool));
			}
		}

		private sealed class OffsetAndRule
		{
			public readonly int Year;

			public readonly TimeSpan Offset;

			public readonly AdjustmentRule Rule;

			public OffsetAndRule(int year, TimeSpan offset, AdjustmentRule rule)
			{
				Year = year;
				Offset = offset;
				Rule = rule;
			}
		}

		private readonly string _id;

		private readonly string _displayName;

		private readonly string _standardDisplayName;

		private readonly string _daylightDisplayName;

		private readonly TimeSpan _baseUtcOffset;

		private readonly bool _supportsDaylightSavingTime;

		private readonly AdjustmentRule[] _adjustmentRules;

		private List<TimeZoneInfo> _equivalentZones;

		private static readonly TimeZoneInfo s_utcTimeZone = CreateUtcTimeZone();

		private static CachedData s_cachedData = new CachedData();

		private static readonly DateTime s_maxDateOnly = new DateTime(9999, 12, 31);

		private static readonly DateTime s_minDateOnly = new DateTime(1, 1, 2);

		private static readonly TimeSpan MaxOffset = TimeSpan.FromHours(14.0);

		private static readonly TimeSpan MinOffset = -MaxOffset;

		public string Id => _id;

		public bool HasIanaId { get; }

		public string DisplayName => _displayName ?? string.Empty;

		public string StandardName => _standardDisplayName ?? string.Empty;

		public string DaylightName => _daylightDisplayName ?? string.Empty;

		public TimeSpan BaseUtcOffset => _baseUtcOffset;

		public bool SupportsDaylightSavingTime => _supportsDaylightSavingTime;

		public static TimeZoneInfo Local => s_cachedData.Local;

		public static TimeZoneInfo Utc => s_utcTimeZone;

		public TimeSpan[] GetAmbiguousTimeOffsets(DateTimeOffset dateTimeOffset)
		{
			if (!SupportsDaylightSavingTime)
			{
				throw new ArgumentException(SR.Argument_DateTimeOffsetIsNotAmbiguous, "dateTimeOffset");
			}
			DateTime dateTime = ConvertTime(dateTimeOffset, this).DateTime;
			bool flag = false;
			int? ruleIndex;
			AdjustmentRule adjustmentRuleForAmbiguousOffsets = GetAdjustmentRuleForAmbiguousOffsets(dateTime, out ruleIndex);
			if (adjustmentRuleForAmbiguousOffsets != null && adjustmentRuleForAmbiguousOffsets.HasDaylightSaving)
			{
				DaylightTimeStruct daylightTime = GetDaylightTime(dateTime.Year, adjustmentRuleForAmbiguousOffsets, ruleIndex);
				flag = GetIsAmbiguousTime(dateTime, adjustmentRuleForAmbiguousOffsets, daylightTime);
			}
			if (!flag)
			{
				throw new ArgumentException(SR.Argument_DateTimeOffsetIsNotAmbiguous, "dateTimeOffset");
			}
			TimeSpan[] array = new TimeSpan[2];
			TimeSpan timeSpan = _baseUtcOffset + adjustmentRuleForAmbiguousOffsets.BaseUtcOffsetDelta;
			if (adjustmentRuleForAmbiguousOffsets.DaylightDelta > TimeSpan.Zero)
			{
				array[0] = timeSpan;
				array[1] = timeSpan + adjustmentRuleForAmbiguousOffsets.DaylightDelta;
			}
			else
			{
				array[0] = timeSpan + adjustmentRuleForAmbiguousOffsets.DaylightDelta;
				array[1] = timeSpan;
			}
			return array;
		}

		public TimeSpan[] GetAmbiguousTimeOffsets(DateTime dateTime)
		{
			if (!SupportsDaylightSavingTime)
			{
				throw new ArgumentException(SR.Argument_DateTimeIsNotAmbiguous, "dateTime");
			}
			DateTime dateTime2;
			if (dateTime.Kind == DateTimeKind.Local)
			{
				CachedData cachedData = s_cachedData;
				dateTime2 = ConvertTime(dateTime, cachedData.Local, this, TimeZoneInfoOptions.None, cachedData);
			}
			else if (dateTime.Kind == DateTimeKind.Utc)
			{
				CachedData cachedData2 = s_cachedData;
				dateTime2 = ConvertTime(dateTime, s_utcTimeZone, this, TimeZoneInfoOptions.None, cachedData2);
			}
			else
			{
				dateTime2 = dateTime;
			}
			bool flag = false;
			int? ruleIndex;
			AdjustmentRule adjustmentRuleForAmbiguousOffsets = GetAdjustmentRuleForAmbiguousOffsets(dateTime2, out ruleIndex);
			if (adjustmentRuleForAmbiguousOffsets != null && adjustmentRuleForAmbiguousOffsets.HasDaylightSaving)
			{
				DaylightTimeStruct daylightTime = GetDaylightTime(dateTime2.Year, adjustmentRuleForAmbiguousOffsets, ruleIndex);
				flag = GetIsAmbiguousTime(dateTime2, adjustmentRuleForAmbiguousOffsets, daylightTime);
			}
			if (!flag)
			{
				throw new ArgumentException(SR.Argument_DateTimeIsNotAmbiguous, "dateTime");
			}
			TimeSpan[] array = new TimeSpan[2];
			TimeSpan timeSpan = _baseUtcOffset + adjustmentRuleForAmbiguousOffsets.BaseUtcOffsetDelta;
			if (adjustmentRuleForAmbiguousOffsets.DaylightDelta > TimeSpan.Zero)
			{
				array[0] = timeSpan;
				array[1] = timeSpan + adjustmentRuleForAmbiguousOffsets.DaylightDelta;
			}
			else
			{
				array[0] = timeSpan + adjustmentRuleForAmbiguousOffsets.DaylightDelta;
				array[1] = timeSpan;
			}
			return array;
		}

		private AdjustmentRule GetAdjustmentRuleForAmbiguousOffsets(DateTime adjustedTime, out int? ruleIndex)
		{
			AdjustmentRule adjustmentRuleForTime = GetAdjustmentRuleForTime(adjustedTime, out ruleIndex);
			if (adjustmentRuleForTime != null && adjustmentRuleForTime.NoDaylightTransitions && !adjustmentRuleForTime.HasDaylightSaving)
			{
				return GetPreviousAdjustmentRule(adjustmentRuleForTime, ruleIndex);
			}
			return adjustmentRuleForTime;
		}

		private AdjustmentRule GetPreviousAdjustmentRule(AdjustmentRule rule, int? ruleIndex)
		{
			if (ruleIndex.HasValue && 0 < ruleIndex.GetValueOrDefault() && ruleIndex.GetValueOrDefault() < _adjustmentRules.Length)
			{
				return _adjustmentRules[ruleIndex.GetValueOrDefault() - 1];
			}
			AdjustmentRule result = rule;
			for (int i = 1; i < _adjustmentRules.Length; i++)
			{
				if (rule == _adjustmentRules[i])
				{
					result = _adjustmentRules[i - 1];
					break;
				}
			}
			return result;
		}

		public TimeSpan GetUtcOffset(DateTimeOffset dateTimeOffset)
		{
			return GetUtcOffsetFromUtc(dateTimeOffset.UtcDateTime, this);
		}

		public TimeSpan GetUtcOffset(DateTime dateTime)
		{
			return GetUtcOffset(dateTime, TimeZoneInfoOptions.NoThrowOnInvalidTime, s_cachedData);
		}

		internal static TimeSpan GetLocalUtcOffset(DateTime dateTime, TimeZoneInfoOptions flags)
		{
			CachedData cachedData = s_cachedData;
			return cachedData.Local.GetUtcOffset(dateTime, flags, cachedData);
		}

		internal TimeSpan GetUtcOffset(DateTime dateTime, TimeZoneInfoOptions flags)
		{
			return GetUtcOffset(dateTime, flags, s_cachedData);
		}

		private TimeSpan GetUtcOffset(DateTime dateTime, TimeZoneInfoOptions flags, CachedData cachedData)
		{
			if (dateTime.Kind == DateTimeKind.Local)
			{
				if (cachedData.GetCorrespondingKind(this) != DateTimeKind.Local)
				{
					DateTime time = ConvertTime(dateTime, cachedData.Local, s_utcTimeZone, flags);
					return GetUtcOffsetFromUtc(time, this);
				}
			}
			else if (dateTime.Kind == DateTimeKind.Utc)
			{
				if (cachedData.GetCorrespondingKind(this) == DateTimeKind.Utc)
				{
					return _baseUtcOffset;
				}
				return GetUtcOffsetFromUtc(dateTime, this);
			}
			return GetUtcOffset(dateTime, this);
		}

		public bool IsAmbiguousTime(DateTimeOffset dateTimeOffset)
		{
			if (!_supportsDaylightSavingTime)
			{
				return false;
			}
			return IsAmbiguousTime(ConvertTime(dateTimeOffset, this).DateTime);
		}

		public bool IsAmbiguousTime(DateTime dateTime)
		{
			return IsAmbiguousTime(dateTime, TimeZoneInfoOptions.NoThrowOnInvalidTime);
		}

		internal bool IsAmbiguousTime(DateTime dateTime, TimeZoneInfoOptions flags)
		{
			if (!_supportsDaylightSavingTime)
			{
				return false;
			}
			CachedData cachedData = s_cachedData;
			DateTime dateTime2 = ((dateTime.Kind == DateTimeKind.Local) ? ConvertTime(dateTime, cachedData.Local, this, flags, cachedData) : ((dateTime.Kind == DateTimeKind.Utc) ? ConvertTime(dateTime, s_utcTimeZone, this, flags, cachedData) : dateTime));
			int? ruleIndex;
			AdjustmentRule adjustmentRuleForTime = GetAdjustmentRuleForTime(dateTime2, out ruleIndex);
			if (adjustmentRuleForTime != null && adjustmentRuleForTime.HasDaylightSaving)
			{
				DaylightTimeStruct daylightTime = GetDaylightTime(dateTime2.Year, adjustmentRuleForTime, ruleIndex);
				return GetIsAmbiguousTime(dateTime2, adjustmentRuleForTime, daylightTime);
			}
			return false;
		}

		public bool IsDaylightSavingTime(DateTimeOffset dateTimeOffset)
		{
			GetUtcOffsetFromUtc(dateTimeOffset.UtcDateTime, this, out var isDaylightSavings);
			return isDaylightSavings;
		}

		public bool IsDaylightSavingTime(DateTime dateTime)
		{
			return IsDaylightSavingTime(dateTime, TimeZoneInfoOptions.NoThrowOnInvalidTime, s_cachedData);
		}

		internal bool IsDaylightSavingTime(DateTime dateTime, TimeZoneInfoOptions flags)
		{
			return IsDaylightSavingTime(dateTime, flags, s_cachedData);
		}

		private bool IsDaylightSavingTime(DateTime dateTime, TimeZoneInfoOptions flags, CachedData cachedData)
		{
			if (!_supportsDaylightSavingTime || _adjustmentRules == null)
			{
				return false;
			}
			DateTime dateTime2;
			if (dateTime.Kind == DateTimeKind.Local)
			{
				dateTime2 = ConvertTime(dateTime, cachedData.Local, this, flags, cachedData);
			}
			else
			{
				if (dateTime.Kind == DateTimeKind.Utc)
				{
					if (cachedData.GetCorrespondingKind(this) == DateTimeKind.Utc)
					{
						return false;
					}
					GetUtcOffsetFromUtc(dateTime, this, out var isDaylightSavings);
					return isDaylightSavings;
				}
				dateTime2 = dateTime;
			}
			int? ruleIndex;
			AdjustmentRule adjustmentRuleForTime = GetAdjustmentRuleForTime(dateTime2, out ruleIndex);
			if (adjustmentRuleForTime != null && adjustmentRuleForTime.HasDaylightSaving)
			{
				DaylightTimeStruct daylightTime = GetDaylightTime(dateTime2.Year, adjustmentRuleForTime, ruleIndex);
				return GetIsDaylightSavings(dateTime2, adjustmentRuleForTime, daylightTime);
			}
			return false;
		}

		public bool IsInvalidTime(DateTime dateTime)
		{
			bool result = false;
			if (dateTime.Kind == DateTimeKind.Unspecified || (dateTime.Kind == DateTimeKind.Local && s_cachedData.GetCorrespondingKind(this) == DateTimeKind.Local))
			{
				int? ruleIndex;
				AdjustmentRule adjustmentRuleForTime = GetAdjustmentRuleForTime(dateTime, out ruleIndex);
				if (adjustmentRuleForTime != null && adjustmentRuleForTime.HasDaylightSaving)
				{
					DaylightTimeStruct daylightTime = GetDaylightTime(dateTime.Year, adjustmentRuleForTime, ruleIndex);
					result = GetIsInvalidTime(dateTime, adjustmentRuleForTime, daylightTime);
				}
				else
				{
					result = false;
				}
			}
			return result;
		}

		public static void ClearCachedData()
		{
			s_cachedData = new CachedData();
		}

		public static DateTimeOffset ConvertTimeBySystemTimeZoneId(DateTimeOffset dateTimeOffset, string destinationTimeZoneId)
		{
			return ConvertTime(dateTimeOffset, FindSystemTimeZoneById(destinationTimeZoneId));
		}

		public static DateTime ConvertTimeBySystemTimeZoneId(DateTime dateTime, string destinationTimeZoneId)
		{
			return ConvertTime(dateTime, FindSystemTimeZoneById(destinationTimeZoneId));
		}

		public static DateTime ConvertTimeBySystemTimeZoneId(DateTime dateTime, string sourceTimeZoneId, string destinationTimeZoneId)
		{
			if (dateTime.Kind == DateTimeKind.Local && string.Equals(sourceTimeZoneId, Local.Id, StringComparison.OrdinalIgnoreCase))
			{
				CachedData cachedData = s_cachedData;
				return ConvertTime(dateTime, cachedData.Local, FindSystemTimeZoneById(destinationTimeZoneId), TimeZoneInfoOptions.None, cachedData);
			}
			if (dateTime.Kind == DateTimeKind.Utc && string.Equals(sourceTimeZoneId, Utc.Id, StringComparison.OrdinalIgnoreCase))
			{
				return ConvertTime(dateTime, s_utcTimeZone, FindSystemTimeZoneById(destinationTimeZoneId), TimeZoneInfoOptions.None, s_cachedData);
			}
			return ConvertTime(dateTime, FindSystemTimeZoneById(sourceTimeZoneId), FindSystemTimeZoneById(destinationTimeZoneId));
		}

		public static DateTimeOffset ConvertTime(DateTimeOffset dateTimeOffset, TimeZoneInfo destinationTimeZone)
		{
			if (destinationTimeZone == null)
			{
				throw new ArgumentNullException("destinationTimeZone");
			}
			DateTime utcDateTime = dateTimeOffset.UtcDateTime;
			TimeSpan utcOffsetFromUtc = GetUtcOffsetFromUtc(utcDateTime, destinationTimeZone);
			long num = utcDateTime.Ticks + utcOffsetFromUtc.Ticks;
			if (num <= DateTimeOffset.MaxValue.Ticks)
			{
				if (num >= DateTimeOffset.MinValue.Ticks)
				{
					return new DateTimeOffset(num, utcOffsetFromUtc);
				}
				return DateTimeOffset.MinValue;
			}
			return DateTimeOffset.MaxValue;
		}

		public static DateTime ConvertTime(DateTime dateTime, TimeZoneInfo destinationTimeZone)
		{
			if (destinationTimeZone == null)
			{
				throw new ArgumentNullException("destinationTimeZone");
			}
			if (dateTime.Ticks == 0L)
			{
				ClearCachedData();
			}
			CachedData cachedData = s_cachedData;
			TimeZoneInfo sourceTimeZone = ((dateTime.Kind == DateTimeKind.Utc) ? s_utcTimeZone : cachedData.Local);
			return ConvertTime(dateTime, sourceTimeZone, destinationTimeZone, TimeZoneInfoOptions.None, cachedData);
		}

		public static DateTime ConvertTime(DateTime dateTime, TimeZoneInfo sourceTimeZone, TimeZoneInfo destinationTimeZone)
		{
			return ConvertTime(dateTime, sourceTimeZone, destinationTimeZone, TimeZoneInfoOptions.None, s_cachedData);
		}

		internal static DateTime ConvertTime(DateTime dateTime, TimeZoneInfo sourceTimeZone, TimeZoneInfo destinationTimeZone, TimeZoneInfoOptions flags)
		{
			return ConvertTime(dateTime, sourceTimeZone, destinationTimeZone, flags, s_cachedData);
		}

		private static DateTime ConvertTime(DateTime dateTime, TimeZoneInfo sourceTimeZone, TimeZoneInfo destinationTimeZone, TimeZoneInfoOptions flags, CachedData cachedData)
		{
			if (sourceTimeZone == null)
			{
				throw new ArgumentNullException("sourceTimeZone");
			}
			if (destinationTimeZone == null)
			{
				throw new ArgumentNullException("destinationTimeZone");
			}
			DateTimeKind correspondingKind = cachedData.GetCorrespondingKind(sourceTimeZone);
			if ((flags & TimeZoneInfoOptions.NoThrowOnInvalidTime) == 0 && dateTime.Kind != 0 && dateTime.Kind != correspondingKind)
			{
				throw new ArgumentException(SR.Argument_ConvertMismatch, "sourceTimeZone");
			}
			int? ruleIndex;
			AdjustmentRule adjustmentRuleForTime = sourceTimeZone.GetAdjustmentRuleForTime(dateTime, out ruleIndex);
			TimeSpan baseUtcOffset = sourceTimeZone.BaseUtcOffset;
			if (adjustmentRuleForTime != null)
			{
				baseUtcOffset += adjustmentRuleForTime.BaseUtcOffsetDelta;
				if (adjustmentRuleForTime.HasDaylightSaving)
				{
					bool flag = false;
					DaylightTimeStruct daylightTime = sourceTimeZone.GetDaylightTime(dateTime.Year, adjustmentRuleForTime, ruleIndex);
					if ((flags & TimeZoneInfoOptions.NoThrowOnInvalidTime) == 0 && GetIsInvalidTime(dateTime, adjustmentRuleForTime, daylightTime))
					{
						throw new ArgumentException(SR.Argument_DateTimeIsInvalid, "dateTime");
					}
					flag = GetIsDaylightSavings(dateTime, adjustmentRuleForTime, daylightTime);
					baseUtcOffset += (flag ? adjustmentRuleForTime.DaylightDelta : TimeSpan.Zero);
				}
			}
			DateTimeKind correspondingKind2 = cachedData.GetCorrespondingKind(destinationTimeZone);
			if (dateTime.Kind != 0 && correspondingKind != 0 && correspondingKind == correspondingKind2)
			{
				return dateTime;
			}
			long ticks = dateTime.Ticks - baseUtcOffset.Ticks;
			bool isAmbiguousLocalDst;
			DateTime dateTime2 = ConvertUtcToTimeZone(ticks, destinationTimeZone, out isAmbiguousLocalDst);
			if (correspondingKind2 == DateTimeKind.Local)
			{
				return new DateTime(dateTime2.Ticks, DateTimeKind.Local, isAmbiguousLocalDst);
			}
			return new DateTime(dateTime2.Ticks, correspondingKind2);
		}

		public static DateTime ConvertTimeFromUtc(DateTime dateTime, TimeZoneInfo destinationTimeZone)
		{
			return ConvertTime(dateTime, s_utcTimeZone, destinationTimeZone, TimeZoneInfoOptions.None, s_cachedData);
		}

		public static DateTime ConvertTimeToUtc(DateTime dateTime)
		{
			if (dateTime.Kind == DateTimeKind.Utc)
			{
				return dateTime;
			}
			CachedData cachedData = s_cachedData;
			return ConvertTime(dateTime, cachedData.Local, s_utcTimeZone, TimeZoneInfoOptions.None, cachedData);
		}

		internal static DateTime ConvertTimeToUtc(DateTime dateTime, TimeZoneInfoOptions flags)
		{
			if (dateTime.Kind == DateTimeKind.Utc)
			{
				return dateTime;
			}
			CachedData cachedData = s_cachedData;
			return ConvertTime(dateTime, cachedData.Local, s_utcTimeZone, flags, cachedData);
		}

		public static DateTime ConvertTimeToUtc(DateTime dateTime, TimeZoneInfo sourceTimeZone)
		{
			return ConvertTime(dateTime, sourceTimeZone, s_utcTimeZone, TimeZoneInfoOptions.None, s_cachedData);
		}

		public bool Equals([NotNullWhen(true)] TimeZoneInfo? other)
		{
			if (other != null && string.Equals(_id, other._id, StringComparison.OrdinalIgnoreCase))
			{
				return HasSameRules(other);
			}
			return false;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj as TimeZoneInfo);
		}

		public static TimeZoneInfo FromSerializedString(string source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (source.Length == 0)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidSerializedString, source), "source");
			}
			return StringSerializer.GetDeserializedTimeZoneInfo(source);
		}

		public override int GetHashCode()
		{
			return StringComparer.OrdinalIgnoreCase.GetHashCode(_id);
		}

		public static ReadOnlyCollection<TimeZoneInfo> GetSystemTimeZones()
		{
			CachedData cachedData = s_cachedData;
			lock (cachedData)
			{
				if (cachedData._readOnlySystemTimeZones == null)
				{
					PopulateAllSystemTimeZones(cachedData);
					cachedData._allSystemTimeZonesRead = true;
					List<TimeZoneInfo> list = ((cachedData._systemTimeZones == null) ? new List<TimeZoneInfo>() : new List<TimeZoneInfo>(cachedData._systemTimeZones.Values));
					list.Sort(delegate(TimeZoneInfo x, TimeZoneInfo y)
					{
						int num = x.BaseUtcOffset.CompareTo(y.BaseUtcOffset);
						return (num != 0) ? num : string.CompareOrdinal(x.DisplayName, y.DisplayName);
					});
					cachedData._readOnlySystemTimeZones = new ReadOnlyCollection<TimeZoneInfo>(list);
				}
			}
			return cachedData._readOnlySystemTimeZones;
		}

		public bool HasSameRules(TimeZoneInfo other)
		{
			if (other == null)
			{
				throw new ArgumentNullException("other");
			}
			if (_baseUtcOffset != other._baseUtcOffset || _supportsDaylightSavingTime != other._supportsDaylightSavingTime)
			{
				return false;
			}
			AdjustmentRule[] adjustmentRules = _adjustmentRules;
			AdjustmentRule[] adjustmentRules2 = other._adjustmentRules;
			if (adjustmentRules == null || adjustmentRules2 == null)
			{
				return adjustmentRules == adjustmentRules2;
			}
			return adjustmentRules.AsSpan().SequenceEqual(adjustmentRules2);
		}

		public string ToSerializedString()
		{
			return StringSerializer.GetSerializedString(this);
		}

		public override string ToString()
		{
			return DisplayName;
		}

		private TimeZoneInfo(string id, TimeSpan baseUtcOffset, string displayName, string standardDisplayName, string daylightDisplayName, AdjustmentRule[] adjustmentRules, bool disableDaylightSavingTime, bool hasIanaId = false)
		{
			ValidateTimeZoneInfo(id, baseUtcOffset, adjustmentRules, out var adjustmentRulesSupportDst);
			_id = id;
			_baseUtcOffset = baseUtcOffset;
			_displayName = displayName;
			_standardDisplayName = standardDisplayName;
			_daylightDisplayName = (disableDaylightSavingTime ? null : daylightDisplayName);
			_supportsDaylightSavingTime = adjustmentRulesSupportDst && !disableDaylightSavingTime;
			_adjustmentRules = adjustmentRules;
			HasIanaId = _id.Equals("UTC", StringComparison.OrdinalIgnoreCase) || hasIanaId;
		}

		public static TimeZoneInfo CreateCustomTimeZone(string id, TimeSpan baseUtcOffset, string? displayName, string? standardDisplayName)
		{
			string windowsId;
			bool hasIanaId = TryConvertIanaIdToWindowsId(id, allocate: false, out windowsId);
			return new TimeZoneInfo(id, baseUtcOffset, displayName, standardDisplayName, standardDisplayName, null, disableDaylightSavingTime: false, hasIanaId);
		}

		public static TimeZoneInfo CreateCustomTimeZone(string id, TimeSpan baseUtcOffset, string? displayName, string? standardDisplayName, string? daylightDisplayName, AdjustmentRule[]? adjustmentRules)
		{
			return CreateCustomTimeZone(id, baseUtcOffset, displayName, standardDisplayName, daylightDisplayName, adjustmentRules, disableDaylightSavingTime: false);
		}

		public static TimeZoneInfo CreateCustomTimeZone(string id, TimeSpan baseUtcOffset, string? displayName, string? standardDisplayName, string? daylightDisplayName, AdjustmentRule[]? adjustmentRules, bool disableDaylightSavingTime)
		{
			if (!disableDaylightSavingTime && adjustmentRules != null && adjustmentRules.Length != 0)
			{
				adjustmentRules = (AdjustmentRule[])adjustmentRules.Clone();
			}
			string windowsId;
			bool hasIanaId = TryConvertIanaIdToWindowsId(id, allocate: false, out windowsId);
			return new TimeZoneInfo(id, baseUtcOffset, displayName, standardDisplayName, daylightDisplayName, adjustmentRules, disableDaylightSavingTime, hasIanaId);
		}

		public static bool TryConvertIanaIdToWindowsId(string ianaId, [NotNullWhen(true)] out string? windowsId)
		{
			return TryConvertIanaIdToWindowsId(ianaId, allocate: true, out windowsId);
		}

		public static bool TryConvertWindowsIdToIanaId(string windowsId, [NotNullWhen(true)] out string? ianaId)
		{
			return TryConvertWindowsIdToIanaId(windowsId, null, allocate: true, out ianaId);
		}

		public static bool TryConvertWindowsIdToIanaId(string windowsId, string? region, [NotNullWhen(true)] out string? ianaId)
		{
			return TryConvertWindowsIdToIanaId(windowsId, region, allocate: true, out ianaId);
		}

		void IDeserializationCallback.OnDeserialization(object sender)
		{
			try
			{
				ValidateTimeZoneInfo(_id, _baseUtcOffset, _adjustmentRules, out var adjustmentRulesSupportDst);
				if (adjustmentRulesSupportDst != _supportsDaylightSavingTime)
				{
					throw new SerializationException(SR.Format(SR.Serialization_CorruptField, "SupportsDaylightSavingTime"));
				}
			}
			catch (ArgumentException innerException)
			{
				throw new SerializationException(SR.Serialization_InvalidData, innerException);
			}
			catch (InvalidTimeZoneException innerException2)
			{
				throw new SerializationException(SR.Serialization_InvalidData, innerException2);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("Id", _id);
			info.AddValue("DisplayName", _displayName);
			info.AddValue("StandardName", _standardDisplayName);
			info.AddValue("DaylightName", _daylightDisplayName);
			info.AddValue("BaseUtcOffset", _baseUtcOffset);
			info.AddValue("AdjustmentRules", _adjustmentRules);
			info.AddValue("SupportsDaylightSavingTime", _supportsDaylightSavingTime);
		}

		private TimeZoneInfo(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_id = (string)info.GetValue("Id", typeof(string));
			_displayName = (string)info.GetValue("DisplayName", typeof(string));
			_standardDisplayName = (string)info.GetValue("StandardName", typeof(string));
			_daylightDisplayName = (string)info.GetValue("DaylightName", typeof(string));
			_baseUtcOffset = (TimeSpan)info.GetValue("BaseUtcOffset", typeof(TimeSpan));
			_adjustmentRules = (AdjustmentRule[])info.GetValue("AdjustmentRules", typeof(AdjustmentRule[]));
			_supportsDaylightSavingTime = (bool)info.GetValue("SupportsDaylightSavingTime", typeof(bool));
		}

		private AdjustmentRule GetAdjustmentRuleForTime(DateTime dateTime, out int? ruleIndex)
		{
			return GetAdjustmentRuleForTime(dateTime, dateTimeisUtc: false, out ruleIndex);
		}

		private AdjustmentRule GetAdjustmentRuleForTime(DateTime dateTime, bool dateTimeisUtc, out int? ruleIndex)
		{
			if (_adjustmentRules == null || _adjustmentRules.Length == 0)
			{
				ruleIndex = null;
				return null;
			}
			DateTime dateOnly = (dateTimeisUtc ? (dateTime + BaseUtcOffset).Date : dateTime.Date);
			int num = 0;
			int num2 = _adjustmentRules.Length - 1;
			while (num <= num2)
			{
				int num3 = num + (num2 - num >> 1);
				AdjustmentRule adjustmentRule = _adjustmentRules[num3];
				AdjustmentRule previousRule = ((num3 > 0) ? _adjustmentRules[num3 - 1] : adjustmentRule);
				int num4 = CompareAdjustmentRuleToDateTime(adjustmentRule, previousRule, dateTime, dateOnly, dateTimeisUtc);
				if (num4 == 0)
				{
					ruleIndex = num3;
					return adjustmentRule;
				}
				if (num4 < 0)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			ruleIndex = null;
			return null;
		}

		private int CompareAdjustmentRuleToDateTime(AdjustmentRule rule, AdjustmentRule previousRule, DateTime dateTime, DateTime dateOnly, bool dateTimeisUtc)
		{
			bool flag;
			if (rule.DateStart.Kind == DateTimeKind.Utc)
			{
				DateTime dateTime2 = (dateTimeisUtc ? dateTime : ConvertToUtc(dateTime, previousRule.DaylightDelta, previousRule.BaseUtcOffsetDelta));
				flag = dateTime2 >= rule.DateStart;
			}
			else
			{
				flag = dateOnly >= rule.DateStart;
			}
			if (!flag)
			{
				return 1;
			}
			bool flag2;
			if (rule.DateEnd.Kind == DateTimeKind.Utc)
			{
				DateTime dateTime3 = (dateTimeisUtc ? dateTime : ConvertToUtc(dateTime, rule.DaylightDelta, rule.BaseUtcOffsetDelta));
				flag2 = dateTime3 <= rule.DateEnd;
			}
			else
			{
				flag2 = dateOnly <= rule.DateEnd;
			}
			if (!flag2)
			{
				return -1;
			}
			return 0;
		}

		private DateTime ConvertToUtc(DateTime dateTime, TimeSpan daylightDelta, TimeSpan baseUtcOffsetDelta)
		{
			return ConvertToFromUtc(dateTime, daylightDelta, baseUtcOffsetDelta, convertToUtc: true);
		}

		private DateTime ConvertFromUtc(DateTime dateTime, TimeSpan daylightDelta, TimeSpan baseUtcOffsetDelta)
		{
			return ConvertToFromUtc(dateTime, daylightDelta, baseUtcOffsetDelta, convertToUtc: false);
		}

		private DateTime ConvertToFromUtc(DateTime dateTime, TimeSpan daylightDelta, TimeSpan baseUtcOffsetDelta, bool convertToUtc)
		{
			TimeSpan timeSpan = BaseUtcOffset + daylightDelta + baseUtcOffsetDelta;
			if (convertToUtc)
			{
				timeSpan = timeSpan.Negate();
			}
			long num = dateTime.Ticks + timeSpan.Ticks;
			if (num <= DateTime.MaxValue.Ticks)
			{
				if (num >= DateTime.MinValue.Ticks)
				{
					return new DateTime(num);
				}
				return DateTime.MinValue;
			}
			return DateTime.MaxValue;
		}

		private static DateTime ConvertUtcToTimeZone(long ticks, TimeZoneInfo destinationTimeZone, out bool isAmbiguousLocalDst)
		{
			DateTime time = ((ticks > DateTime.MaxValue.Ticks) ? DateTime.MaxValue : ((ticks < DateTime.MinValue.Ticks) ? DateTime.MinValue : new DateTime(ticks)));
			ticks += GetUtcOffsetFromUtc(time, destinationTimeZone, out isAmbiguousLocalDst).Ticks;
			if (ticks <= DateTime.MaxValue.Ticks)
			{
				if (ticks >= DateTime.MinValue.Ticks)
				{
					return new DateTime(ticks);
				}
				return DateTime.MinValue;
			}
			return DateTime.MaxValue;
		}

		private DaylightTimeStruct GetDaylightTime(int year, AdjustmentRule rule, int? ruleIndex)
		{
			TimeSpan daylightDelta = rule.DaylightDelta;
			DateTime start;
			DateTime end;
			if (rule.NoDaylightTransitions)
			{
				AdjustmentRule previousAdjustmentRule = GetPreviousAdjustmentRule(rule, ruleIndex);
				start = ConvertFromUtc(rule.DateStart, previousAdjustmentRule.DaylightDelta, previousAdjustmentRule.BaseUtcOffsetDelta);
				end = ConvertFromUtc(rule.DateEnd, rule.DaylightDelta, rule.BaseUtcOffsetDelta);
			}
			else
			{
				start = TransitionTimeToDateTime(year, rule.DaylightTransitionStart);
				end = TransitionTimeToDateTime(year, rule.DaylightTransitionEnd);
			}
			return new DaylightTimeStruct(start, end, daylightDelta);
		}

		private static bool GetIsDaylightSavings(DateTime time, AdjustmentRule rule, DaylightTimeStruct daylightTime)
		{
			if (rule == null)
			{
				return false;
			}
			DateTime startTime;
			DateTime endTime;
			if (time.Kind == DateTimeKind.Local)
			{
				startTime = (rule.IsStartDateMarkerForBeginningOfYear() ? new DateTime(daylightTime.Start.Year, 1, 1, 0, 0, 0) : (daylightTime.Start + daylightTime.Delta));
				endTime = (rule.IsEndDateMarkerForEndOfYear() ? new DateTime(daylightTime.End.Year + 1, 1, 1, 0, 0, 0).AddTicks(-1L) : daylightTime.End);
			}
			else
			{
				bool flag = rule.DaylightDelta > TimeSpan.Zero;
				startTime = (rule.IsStartDateMarkerForBeginningOfYear() ? new DateTime(daylightTime.Start.Year, 1, 1, 0, 0, 0) : (daylightTime.Start + (flag ? rule.DaylightDelta : TimeSpan.Zero)));
				endTime = (rule.IsEndDateMarkerForEndOfYear() ? new DateTime(daylightTime.End.Year + 1, 1, 1, 0, 0, 0).AddTicks(-1L) : (daylightTime.End + (flag ? (-rule.DaylightDelta) : TimeSpan.Zero)));
			}
			bool flag2 = CheckIsDst(startTime, time, endTime, ignoreYearAdjustment: false, rule);
			if (flag2 && time.Kind == DateTimeKind.Local && GetIsAmbiguousTime(time, rule, daylightTime))
			{
				flag2 = time.IsAmbiguousDaylightSavingTime();
			}
			return flag2;
		}

		private TimeSpan GetDaylightSavingsStartOffsetFromUtc(TimeSpan baseUtcOffset, AdjustmentRule rule, int? ruleIndex)
		{
			if (rule.NoDaylightTransitions)
			{
				AdjustmentRule previousAdjustmentRule = GetPreviousAdjustmentRule(rule, ruleIndex);
				return baseUtcOffset + previousAdjustmentRule.BaseUtcOffsetDelta + previousAdjustmentRule.DaylightDelta;
			}
			return baseUtcOffset + rule.BaseUtcOffsetDelta;
		}

		private static TimeSpan GetDaylightSavingsEndOffsetFromUtc(TimeSpan baseUtcOffset, AdjustmentRule rule)
		{
			return baseUtcOffset + rule.BaseUtcOffsetDelta + rule.DaylightDelta;
		}

		private static bool GetIsDaylightSavingsFromUtc(DateTime time, int year, TimeSpan utc, AdjustmentRule rule, int? ruleIndex, out bool isAmbiguousLocalDst, TimeZoneInfo zone)
		{
			isAmbiguousLocalDst = false;
			if (rule == null)
			{
				return false;
			}
			DaylightTimeStruct daylightTime = zone.GetDaylightTime(year, rule, ruleIndex);
			bool ignoreYearAdjustment = false;
			TimeSpan daylightSavingsStartOffsetFromUtc = zone.GetDaylightSavingsStartOffsetFromUtc(utc, rule, ruleIndex);
			DateTime dateTime;
			if (rule.IsStartDateMarkerForBeginningOfYear() && daylightTime.Start.Year > DateTime.MinValue.Year)
			{
				int? ruleIndex2;
				AdjustmentRule adjustmentRuleForTime = zone.GetAdjustmentRuleForTime(new DateTime(daylightTime.Start.Year - 1, 12, 31), out ruleIndex2);
				if (adjustmentRuleForTime != null && adjustmentRuleForTime.IsEndDateMarkerForEndOfYear())
				{
					dateTime = zone.GetDaylightTime(daylightTime.Start.Year - 1, adjustmentRuleForTime, ruleIndex2).Start - utc - adjustmentRuleForTime.BaseUtcOffsetDelta;
					ignoreYearAdjustment = true;
				}
				else
				{
					dateTime = new DateTime(daylightTime.Start.Year, 1, 1, 0, 0, 0) - daylightSavingsStartOffsetFromUtc;
				}
			}
			else
			{
				dateTime = daylightTime.Start - daylightSavingsStartOffsetFromUtc;
			}
			TimeSpan daylightSavingsEndOffsetFromUtc = GetDaylightSavingsEndOffsetFromUtc(utc, rule);
			DateTime dateTime2;
			if (rule.IsEndDateMarkerForEndOfYear() && daylightTime.End.Year < DateTime.MaxValue.Year)
			{
				int? ruleIndex3;
				AdjustmentRule adjustmentRuleForTime2 = zone.GetAdjustmentRuleForTime(new DateTime(daylightTime.End.Year + 1, 1, 1), out ruleIndex3);
				if (adjustmentRuleForTime2 != null && adjustmentRuleForTime2.IsStartDateMarkerForBeginningOfYear())
				{
					dateTime2 = ((!adjustmentRuleForTime2.IsEndDateMarkerForEndOfYear()) ? (zone.GetDaylightTime(daylightTime.End.Year + 1, adjustmentRuleForTime2, ruleIndex3).End - utc - adjustmentRuleForTime2.BaseUtcOffsetDelta - adjustmentRuleForTime2.DaylightDelta) : (new DateTime(daylightTime.End.Year + 1, 12, 31) - utc - adjustmentRuleForTime2.BaseUtcOffsetDelta - adjustmentRuleForTime2.DaylightDelta));
					ignoreYearAdjustment = true;
				}
				else
				{
					dateTime2 = new DateTime(daylightTime.End.Year + 1, 1, 1, 0, 0, 0).AddTicks(-1L) - daylightSavingsEndOffsetFromUtc;
				}
			}
			else
			{
				dateTime2 = daylightTime.End - daylightSavingsEndOffsetFromUtc;
			}
			DateTime dateTime3;
			DateTime dateTime4;
			if (daylightTime.Delta.Ticks > 0)
			{
				dateTime3 = dateTime2 - daylightTime.Delta;
				dateTime4 = dateTime2;
			}
			else
			{
				dateTime3 = dateTime;
				dateTime4 = dateTime - daylightTime.Delta;
			}
			bool flag = CheckIsDst(dateTime, time, dateTime2, ignoreYearAdjustment, rule);
			if (flag)
			{
				isAmbiguousLocalDst = time >= dateTime3 && time < dateTime4;
				if (!isAmbiguousLocalDst && dateTime3.Year != dateTime4.Year)
				{
					try
					{
						DateTime dateTime5 = dateTime3.AddYears(1);
						DateTime dateTime6 = dateTime4.AddYears(1);
						isAmbiguousLocalDst = time >= dateTime5 && time < dateTime6;
					}
					catch (ArgumentOutOfRangeException)
					{
					}
					if (!isAmbiguousLocalDst)
					{
						try
						{
							DateTime dateTime5 = dateTime3.AddYears(-1);
							DateTime dateTime6 = dateTime4.AddYears(-1);
							isAmbiguousLocalDst = time >= dateTime5 && time < dateTime6;
						}
						catch (ArgumentOutOfRangeException)
						{
						}
					}
				}
			}
			return flag;
		}

		private static bool CheckIsDst(DateTime startTime, DateTime time, DateTime endTime, bool ignoreYearAdjustment, AdjustmentRule rule)
		{
			if (!ignoreYearAdjustment && !rule.NoDaylightTransitions)
			{
				int year = startTime.Year;
				int year2 = endTime.Year;
				if (year != year2)
				{
					endTime = endTime.AddYears(year - year2);
				}
				int year3 = time.Year;
				if (year != year3)
				{
					time = time.AddYears(year - year3);
				}
			}
			if (startTime > endTime)
			{
				if (!(time < endTime))
				{
					return time >= startTime;
				}
				return true;
			}
			if (rule.NoDaylightTransitions)
			{
				if (time >= startTime)
				{
					return time <= endTime;
				}
				return false;
			}
			if (time >= startTime)
			{
				return time < endTime;
			}
			return false;
		}

		private static bool GetIsAmbiguousTime(DateTime time, AdjustmentRule rule, DaylightTimeStruct daylightTime)
		{
			bool result = false;
			if (rule == null || rule.DaylightDelta == TimeSpan.Zero)
			{
				return result;
			}
			DateTime dateTime;
			DateTime dateTime2;
			if (rule.DaylightDelta > TimeSpan.Zero)
			{
				if (rule.IsEndDateMarkerForEndOfYear())
				{
					return false;
				}
				dateTime = daylightTime.End;
				dateTime2 = daylightTime.End - rule.DaylightDelta;
			}
			else
			{
				if (rule.IsStartDateMarkerForBeginningOfYear())
				{
					return false;
				}
				dateTime = daylightTime.Start;
				dateTime2 = daylightTime.Start + rule.DaylightDelta;
			}
			result = time >= dateTime2 && time < dateTime;
			if (!result && dateTime.Year != dateTime2.Year)
			{
				try
				{
					DateTime dateTime3 = dateTime.AddYears(1);
					DateTime dateTime4 = dateTime2.AddYears(1);
					result = time >= dateTime4 && time < dateTime3;
				}
				catch (ArgumentOutOfRangeException)
				{
				}
				if (!result)
				{
					try
					{
						DateTime dateTime3 = dateTime.AddYears(-1);
						DateTime dateTime4 = dateTime2.AddYears(-1);
						result = time >= dateTime4 && time < dateTime3;
					}
					catch (ArgumentOutOfRangeException)
					{
					}
				}
			}
			return result;
		}

		private static bool GetIsInvalidTime(DateTime time, AdjustmentRule rule, DaylightTimeStruct daylightTime)
		{
			bool result = false;
			if (rule == null || rule.DaylightDelta == TimeSpan.Zero)
			{
				return result;
			}
			DateTime dateTime;
			DateTime dateTime2;
			if (rule.DaylightDelta < TimeSpan.Zero)
			{
				if (rule.IsEndDateMarkerForEndOfYear())
				{
					return false;
				}
				dateTime = daylightTime.End;
				dateTime2 = daylightTime.End - rule.DaylightDelta;
			}
			else
			{
				if (rule.IsStartDateMarkerForBeginningOfYear())
				{
					return false;
				}
				dateTime = daylightTime.Start;
				dateTime2 = daylightTime.Start + rule.DaylightDelta;
			}
			result = time >= dateTime && time < dateTime2;
			if (!result && dateTime.Year != dateTime2.Year)
			{
				try
				{
					DateTime dateTime3 = dateTime.AddYears(1);
					DateTime dateTime4 = dateTime2.AddYears(1);
					result = time >= dateTime3 && time < dateTime4;
				}
				catch (ArgumentOutOfRangeException)
				{
				}
				if (!result)
				{
					try
					{
						DateTime dateTime3 = dateTime.AddYears(-1);
						DateTime dateTime4 = dateTime2.AddYears(-1);
						result = time >= dateTime3 && time < dateTime4;
					}
					catch (ArgumentOutOfRangeException)
					{
					}
				}
			}
			return result;
		}

		private static TimeSpan GetUtcOffset(DateTime time, TimeZoneInfo zone)
		{
			TimeSpan baseUtcOffset = zone.BaseUtcOffset;
			int? ruleIndex;
			AdjustmentRule adjustmentRuleForTime = zone.GetAdjustmentRuleForTime(time, out ruleIndex);
			if (adjustmentRuleForTime != null)
			{
				baseUtcOffset += adjustmentRuleForTime.BaseUtcOffsetDelta;
				if (adjustmentRuleForTime.HasDaylightSaving)
				{
					DaylightTimeStruct daylightTime = zone.GetDaylightTime(time.Year, adjustmentRuleForTime, ruleIndex);
					bool isDaylightSavings = GetIsDaylightSavings(time, adjustmentRuleForTime, daylightTime);
					baseUtcOffset += (isDaylightSavings ? adjustmentRuleForTime.DaylightDelta : TimeSpan.Zero);
				}
			}
			return baseUtcOffset;
		}

		private static TimeSpan GetUtcOffsetFromUtc(DateTime time, TimeZoneInfo zone)
		{
			bool isDaylightSavings;
			return GetUtcOffsetFromUtc(time, zone, out isDaylightSavings);
		}

		private static TimeSpan GetUtcOffsetFromUtc(DateTime time, TimeZoneInfo zone, out bool isDaylightSavings)
		{
			bool isAmbiguousLocalDst;
			return GetUtcOffsetFromUtc(time, zone, out isDaylightSavings, out isAmbiguousLocalDst);
		}

		internal static TimeSpan GetUtcOffsetFromUtc(DateTime time, TimeZoneInfo zone, out bool isDaylightSavings, out bool isAmbiguousLocalDst)
		{
			isDaylightSavings = false;
			isAmbiguousLocalDst = false;
			TimeSpan baseUtcOffset = zone.BaseUtcOffset;
			AdjustmentRule adjustmentRuleForTime;
			int? ruleIndex;
			int year;
			if (time > s_maxDateOnly)
			{
				adjustmentRuleForTime = zone.GetAdjustmentRuleForTime(DateTime.MaxValue, out ruleIndex);
				year = 9999;
			}
			else if (time < s_minDateOnly)
			{
				adjustmentRuleForTime = zone.GetAdjustmentRuleForTime(DateTime.MinValue, out ruleIndex);
				year = 1;
			}
			else
			{
				adjustmentRuleForTime = zone.GetAdjustmentRuleForTime(time, dateTimeisUtc: true, out ruleIndex);
				year = (time + baseUtcOffset).Year;
			}
			if (adjustmentRuleForTime != null)
			{
				baseUtcOffset += adjustmentRuleForTime.BaseUtcOffsetDelta;
				if (adjustmentRuleForTime.HasDaylightSaving)
				{
					isDaylightSavings = GetIsDaylightSavingsFromUtc(time, year, zone._baseUtcOffset, adjustmentRuleForTime, ruleIndex, out isAmbiguousLocalDst, zone);
					baseUtcOffset += (isDaylightSavings ? adjustmentRuleForTime.DaylightDelta : TimeSpan.Zero);
				}
			}
			return baseUtcOffset;
		}

		internal static DateTime TransitionTimeToDateTime(int year, TransitionTime transitionTime)
		{
			TimeSpan timeOfDay = transitionTime.TimeOfDay.TimeOfDay;
			DateTime result;
			if (transitionTime.IsFixedDateRule)
			{
				int num = transitionTime.Day;
				if (num > 28)
				{
					int num2 = DateTime.DaysInMonth(year, transitionTime.Month);
					if (num > num2)
					{
						num = num2;
					}
				}
				result = new DateTime(year, transitionTime.Month, num) + timeOfDay;
			}
			else if (transitionTime.Week <= 4)
			{
				result = new DateTime(year, transitionTime.Month, 1) + timeOfDay;
				int dayOfWeek = (int)result.DayOfWeek;
				int num3 = (int)(transitionTime.DayOfWeek - dayOfWeek);
				if (num3 < 0)
				{
					num3 += 7;
				}
				num3 += 7 * (transitionTime.Week - 1);
				if (num3 > 0)
				{
					result = result.AddDays(num3);
				}
			}
			else
			{
				int day = DateTime.DaysInMonth(year, transitionTime.Month);
				result = new DateTime(year, transitionTime.Month, day) + timeOfDay;
				int dayOfWeek2 = (int)result.DayOfWeek;
				int num4 = (int)(dayOfWeek2 - transitionTime.DayOfWeek);
				if (num4 < 0)
				{
					num4 += 7;
				}
				if (num4 > 0)
				{
					result = result.AddDays(-num4);
				}
			}
			return result;
		}

		private static TimeZoneInfoResult TryGetTimeZone(string id, bool dstDisabled, out TimeZoneInfo value, out Exception e, CachedData cachedData, bool alwaysFallbackToLocalMachine = false)
		{
			TimeZoneInfoResult timeZoneInfoResult = TryGetTimeZoneUsingId(id, dstDisabled, out value, out e, cachedData, alwaysFallbackToLocalMachine);
			if (timeZoneInfoResult != 0)
			{
				bool idIsIana;
				string alternativeId = GetAlternativeId(id, out idIsIana);
				if (alternativeId != null)
				{
					timeZoneInfoResult = TryGetTimeZoneUsingId(alternativeId, dstDisabled, out value, out e, cachedData, alwaysFallbackToLocalMachine);
					if (timeZoneInfoResult == TimeZoneInfoResult.Success)
					{
						TimeZoneInfo timeZoneInfo = null;
						if (value._equivalentZones == null)
						{
							timeZoneInfo = new TimeZoneInfo(id, value._baseUtcOffset, value._displayName, value._standardDisplayName, value._daylightDisplayName, value._adjustmentRules, dstDisabled && value._supportsDaylightSavingTime, idIsIana);
							value._equivalentZones = new List<TimeZoneInfo>();
							lock (value._equivalentZones)
							{
								value._equivalentZones.Add(timeZoneInfo);
							}
						}
						else
						{
							foreach (TimeZoneInfo equivalentZone in value._equivalentZones)
							{
								if (equivalentZone.Id == id)
								{
									timeZoneInfo = equivalentZone;
									break;
								}
							}
							if (timeZoneInfo == null)
							{
								timeZoneInfo = new TimeZoneInfo(id, value._baseUtcOffset, value._displayName, value._standardDisplayName, value._daylightDisplayName, value._adjustmentRules, dstDisabled && value._supportsDaylightSavingTime, idIsIana);
								lock (value._equivalentZones)
								{
									value._equivalentZones.Add(timeZoneInfo);
								}
							}
						}
						value = timeZoneInfo;
					}
				}
			}
			return timeZoneInfoResult;
		}

		private static TimeZoneInfoResult TryGetTimeZoneUsingId(string id, bool dstDisabled, out TimeZoneInfo value, out Exception e, CachedData cachedData, bool alwaysFallbackToLocalMachine)
		{
			TimeZoneInfoResult result = TimeZoneInfoResult.Success;
			e = null;
			if (cachedData._systemTimeZones != null && cachedData._systemTimeZones.TryGetValue(id, out var value2))
			{
				if (dstDisabled && value2._supportsDaylightSavingTime)
				{
					value = CreateCustomTimeZone(value2._id, value2._baseUtcOffset, value2._displayName, value2._standardDisplayName);
				}
				else
				{
					value = new TimeZoneInfo(value2._id, value2._baseUtcOffset, value2._displayName, value2._standardDisplayName, value2._daylightDisplayName, value2._adjustmentRules, disableDaylightSavingTime: false, value2.HasIanaId);
				}
				return result;
			}
			if (!cachedData._allSystemTimeZonesRead || alwaysFallbackToLocalMachine)
			{
				result = TryGetTimeZoneFromLocalMachine(id, dstDisabled, out value, out e, cachedData);
			}
			else
			{
				result = TimeZoneInfoResult.TimeZoneNotFoundException;
				value = null;
			}
			return result;
		}

		private static TimeZoneInfoResult TryGetTimeZoneFromLocalMachine(string id, bool dstDisabled, out TimeZoneInfo value, out Exception e, CachedData cachedData)
		{
			TimeZoneInfo value2;
			TimeZoneInfoResult timeZoneInfoResult = TryGetTimeZoneFromLocalMachine(id, out value2, out e);
			if (timeZoneInfoResult == TimeZoneInfoResult.Success)
			{
				if (cachedData._systemTimeZones == null)
				{
					cachedData._systemTimeZones = new Dictionary<string, TimeZoneInfo>(StringComparer.OrdinalIgnoreCase) { { "UTC", s_utcTimeZone } };
				}
				if (!id.Equals("UTC", StringComparison.OrdinalIgnoreCase))
				{
					cachedData._systemTimeZones.Add(id, value2);
				}
				if (dstDisabled && value2._supportsDaylightSavingTime)
				{
					value = CreateCustomTimeZone(value2._id, value2._baseUtcOffset, value2._displayName, value2._standardDisplayName);
				}
				else
				{
					value = new TimeZoneInfo(value2._id, value2._baseUtcOffset, value2._displayName, value2._standardDisplayName, value2._daylightDisplayName, value2._adjustmentRules, disableDaylightSavingTime: false, value2.HasIanaId);
				}
			}
			else
			{
				value = null;
			}
			return timeZoneInfoResult;
		}

		private static void ValidateTimeZoneInfo(string id, TimeSpan baseUtcOffset, AdjustmentRule[] adjustmentRules, out bool adjustmentRulesSupportDst)
		{
			if (id == null)
			{
				throw new ArgumentNullException("id");
			}
			if (id.Length == 0)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidId, id), "id");
			}
			if (UtcOffsetOutOfRange(baseUtcOffset))
			{
				throw new ArgumentOutOfRangeException("baseUtcOffset", SR.ArgumentOutOfRange_UtcOffset);
			}
			if (baseUtcOffset.Ticks % 600000000 != 0L)
			{
				throw new ArgumentException(SR.Argument_TimeSpanHasSeconds, "baseUtcOffset");
			}
			adjustmentRulesSupportDst = false;
			if (adjustmentRules == null || adjustmentRules.Length == 0)
			{
				return;
			}
			adjustmentRulesSupportDst = true;
			AdjustmentRule adjustmentRule = null;
			AdjustmentRule adjustmentRule2 = null;
			for (int i = 0; i < adjustmentRules.Length; i++)
			{
				adjustmentRule = adjustmentRule2;
				adjustmentRule2 = adjustmentRules[i];
				if (adjustmentRule2 == null)
				{
					throw new InvalidTimeZoneException(SR.Argument_AdjustmentRulesNoNulls);
				}
				if (!IsValidAdjustmentRuleOffset(baseUtcOffset, adjustmentRule2))
				{
					throw new InvalidTimeZoneException(SR.ArgumentOutOfRange_UtcOffsetAndDaylightDelta);
				}
				if (adjustmentRule != null && adjustmentRule2.DateStart <= adjustmentRule.DateEnd)
				{
					throw new InvalidTimeZoneException(SR.Argument_AdjustmentRulesOutOfOrder);
				}
			}
		}

		internal static bool UtcOffsetOutOfRange(TimeSpan offset)
		{
			if (!(offset < MinOffset))
			{
				return offset > MaxOffset;
			}
			return true;
		}

		private static TimeSpan GetUtcOffset(TimeSpan baseUtcOffset, AdjustmentRule adjustmentRule)
		{
			return baseUtcOffset + adjustmentRule.BaseUtcOffsetDelta + (adjustmentRule.HasDaylightSaving ? adjustmentRule.DaylightDelta : TimeSpan.Zero);
		}

		private static bool IsValidAdjustmentRuleOffset(TimeSpan baseUtcOffset, AdjustmentRule adjustmentRule)
		{
			TimeSpan utcOffset = GetUtcOffset(baseUtcOffset, adjustmentRule);
			return !UtcOffsetOutOfRange(utcOffset);
		}

		private static TimeZoneInfo CreateUtcTimeZone()
		{
			string utcStandardDisplayName = GetUtcStandardDisplayName();
			string utcFullDisplayName = GetUtcFullDisplayName("UTC", utcStandardDisplayName);
			return CreateCustomTimeZone("UTC", TimeSpan.Zero, utcFullDisplayName, utcStandardDisplayName);
		}

		private unsafe static bool TryConvertIanaIdToWindowsId(string ianaId, bool allocate, out string windowsId)
		{
			if (GlobalizationMode.Invariant || GlobalizationMode.UseNls || ianaId == null)
			{
				windowsId = null;
				return false;
			}
			foreach (char c in ianaId)
			{
				if (c == '\\' || c == '\n' || c == '\r')
				{
					windowsId = null;
					return false;
				}
			}
			char* ptr = stackalloc char[100];
			int num = Interop.Globalization.IanaIdToWindowsId(ianaId, ptr, 100);
			if (num > 0)
			{
				windowsId = (allocate ? new string(ptr, 0, num) : null);
				return true;
			}
			windowsId = null;
			return false;
		}

		private unsafe static bool TryConvertWindowsIdToIanaId(string windowsId, string region, bool allocate, out string ianaId)
		{
			if (GlobalizationMode.Invariant || GlobalizationMode.UseNls || windowsId == null)
			{
				ianaId = null;
				return false;
			}
			if (windowsId.Equals("utc", StringComparison.OrdinalIgnoreCase))
			{
				ianaId = "Etc/UTC";
				return true;
			}
			foreach (char c in windowsId)
			{
				if (c == '\\' || c == '\n' || c == '\r')
				{
					ianaId = null;
					return false;
				}
			}
			IntPtr region2 = IntPtr.Zero;
			if (region != null && region.Length < 11)
			{
				byte* ptr = stackalloc byte[(int)(uint)(region.Length + 1)];
				int j;
				for (j = 0; j < region.Length && region[j] <= '\u007f'; j++)
				{
					ptr[j] = (((uint)(region[j] - 97) <= 25u) ? ((byte)(region[j] - 97 + 65)) : ((byte)region[j]));
				}
				if (j >= region.Length)
				{
					ptr[region.Length] = 0;
					region2 = new IntPtr(ptr);
				}
			}
			char* ptr2 = stackalloc char[100];
			int num = Interop.Globalization.WindowsIdToIanaId(windowsId, region2, ptr2, 100);
			if (num > 0)
			{
				ianaId = (allocate ? new string(ptr2, 0, num) : null);
				return true;
			}
			ianaId = null;
			return false;
		}

		public AdjustmentRule[] GetAdjustmentRules()
		{
			if (_adjustmentRules == null)
			{
				return Array.Empty<AdjustmentRule>();
			}
			return (AdjustmentRule[])_adjustmentRules.Clone();
		}

		private static void PopulateAllSystemTimeZones(CachedData cachedData)
		{
			using RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones", writable: false);
			if (registryKey != null)
			{
				string[] subKeyNames = registryKey.GetSubKeyNames();
				foreach (string id in subKeyNames)
				{
					TryGetTimeZone(id, dstDisabled: false, out var _, out var _, cachedData);
				}
			}
		}

		private static string GetAlternativeId(string id, out bool idIsIana)
		{
			idIsIana = true;
			if (!TryConvertIanaIdToWindowsId(id, out string windowsId))
			{
				return null;
			}
			return windowsId;
		}

		private TimeZoneInfo(in Interop.Kernel32.TIME_ZONE_INFORMATION zone, bool dstDisabled)
		{
			string standardName = zone.GetStandardName();
			if (standardName.Length == 0)
			{
				_id = "Local";
			}
			else
			{
				_id = standardName;
			}
			_baseUtcOffset = new TimeSpan(0, -zone.Bias, 0);
			if (!dstDisabled)
			{
				Interop.Kernel32.REG_TZI_FORMAT timeZoneInformation = new Interop.Kernel32.REG_TZI_FORMAT(in zone);
				AdjustmentRule adjustmentRule = CreateAdjustmentRuleFromTimeZoneInformation(in timeZoneInformation, DateTime.MinValue.Date, DateTime.MaxValue.Date, zone.Bias);
				if (adjustmentRule != null)
				{
					_adjustmentRules = new AdjustmentRule[1] { adjustmentRule };
				}
			}
			ValidateTimeZoneInfo(_id, _baseUtcOffset, _adjustmentRules, out _supportsDaylightSavingTime);
			_displayName = standardName;
			_standardDisplayName = standardName;
			_daylightDisplayName = zone.GetDaylightName();
		}

		private static bool CheckDaylightSavingTimeNotSupported(in Interop.Kernel32.TIME_ZONE_INFORMATION timeZone)
		{
			return timeZone.DaylightDate.Equals(in timeZone.StandardDate);
		}

		private static AdjustmentRule CreateAdjustmentRuleFromTimeZoneInformation(in Interop.Kernel32.REG_TZI_FORMAT timeZoneInformation, DateTime startDate, DateTime endDate, int defaultBaseUtcOffset)
		{
			if (timeZoneInformation.StandardDate.Month == 0)
			{
				if (timeZoneInformation.Bias == defaultBaseUtcOffset)
				{
					return null;
				}
				return AdjustmentRule.CreateAdjustmentRule(startDate, endDate, TimeSpan.Zero, TransitionTime.CreateFixedDateRule(DateTime.MinValue, 1, 1), TransitionTime.CreateFixedDateRule(DateTime.MinValue.AddMilliseconds(1.0), 1, 1), new TimeSpan(0, defaultBaseUtcOffset - timeZoneInformation.Bias, 0), noDaylightTransitions: false);
			}
			if (!TransitionTimeFromTimeZoneInformation(in timeZoneInformation, out var transitionTime, readStartDate: true))
			{
				return null;
			}
			if (!TransitionTimeFromTimeZoneInformation(in timeZoneInformation, out var transitionTime2, readStartDate: false))
			{
				return null;
			}
			if (transitionTime.Equals(transitionTime2))
			{
				return null;
			}
			return AdjustmentRule.CreateAdjustmentRule(startDate, endDate, new TimeSpan(0, -timeZoneInformation.DaylightBias, 0), transitionTime, transitionTime2, new TimeSpan(0, defaultBaseUtcOffset - timeZoneInformation.Bias, 0), noDaylightTransitions: false);
		}

		private static string FindIdFromTimeZoneInformation(in Interop.Kernel32.TIME_ZONE_INFORMATION timeZone, out bool dstDisabled)
		{
			dstDisabled = false;
			using (RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones", writable: false))
			{
				if (registryKey == null)
				{
					return null;
				}
				string[] subKeyNames = registryKey.GetSubKeyNames();
				foreach (string text in subKeyNames)
				{
					if (TryCompareTimeZoneInformationToRegistry(in timeZone, text, out dstDisabled))
					{
						return text;
					}
				}
			}
			return null;
		}

		private static TimeZoneInfo GetLocalTimeZone(CachedData cachedData)
		{
			Interop.Kernel32.TIME_DYNAMIC_ZONE_INFORMATION pTimeZoneInformation;
			uint dynamicTimeZoneInformation = Interop.Kernel32.GetDynamicTimeZoneInformation(out pTimeZoneInformation);
			if (dynamicTimeZoneInformation == uint.MaxValue)
			{
				return CreateCustomTimeZone("Local", TimeSpan.Zero, "Local", "Local");
			}
			string timeZoneKeyName = pTimeZoneInformation.GetTimeZoneKeyName();
			if (timeZoneKeyName.Length != 0 && TryGetTimeZone(timeZoneKeyName, pTimeZoneInformation.DynamicDaylightTimeDisabled != 0, out var value, out var e, cachedData) == TimeZoneInfoResult.Success)
			{
				return value;
			}
			Interop.Kernel32.TIME_ZONE_INFORMATION timeZone = new Interop.Kernel32.TIME_ZONE_INFORMATION(in pTimeZoneInformation);
			bool dstDisabled;
			string text = FindIdFromTimeZoneInformation(in timeZone, out dstDisabled);
			if (text != null && TryGetTimeZone(text, dstDisabled, out var value2, out e, cachedData) == TimeZoneInfoResult.Success)
			{
				return value2;
			}
			return GetLocalTimeZoneFromWin32Data(in timeZone, dstDisabled);
		}

		private static TimeZoneInfo GetLocalTimeZoneFromWin32Data(in Interop.Kernel32.TIME_ZONE_INFORMATION timeZoneInformation, bool dstDisabled)
		{
			try
			{
				return new TimeZoneInfo(in timeZoneInformation, dstDisabled);
			}
			catch (ArgumentException)
			{
			}
			catch (InvalidTimeZoneException)
			{
			}
			if (!dstDisabled)
			{
				try
				{
					return new TimeZoneInfo(in timeZoneInformation, dstDisabled: true);
				}
				catch (ArgumentException)
				{
				}
				catch (InvalidTimeZoneException)
				{
				}
			}
			return CreateCustomTimeZone("Local", TimeSpan.Zero, "Local", "Local");
		}

		public static TimeZoneInfo FindSystemTimeZoneById(string id)
		{
			if (string.Equals(id, "UTC", StringComparison.OrdinalIgnoreCase))
			{
				return Utc;
			}
			if (id == null)
			{
				throw new ArgumentNullException("id");
			}
			if (id.Length == 0 || id.Length > 255 || id.Contains('\0'))
			{
				throw new TimeZoneNotFoundException(SR.Format(SR.TimeZoneNotFound_MissingData, id));
			}
			CachedData cachedData = s_cachedData;
			TimeZoneInfoResult timeZoneInfoResult;
			TimeZoneInfo value;
			Exception e;
			lock (cachedData)
			{
				timeZoneInfoResult = TryGetTimeZone(id, dstDisabled: false, out value, out e, cachedData);
			}
			return timeZoneInfoResult switch
			{
				TimeZoneInfoResult.Success => value, 
				TimeZoneInfoResult.InvalidTimeZoneException => throw new InvalidTimeZoneException(SR.Format(SR.InvalidTimeZone_InvalidRegistryData, id), e), 
				TimeZoneInfoResult.SecurityException => throw new SecurityException(SR.Format(SR.Security_CannotReadRegistryData, id), e), 
				_ => throw new TimeZoneNotFoundException(SR.Format(SR.TimeZoneNotFound_MissingData, id), e), 
			};
		}

		internal static TimeSpan GetDateTimeNowUtcOffsetFromUtc(DateTime time, out bool isAmbiguousLocalDst)
		{
			isAmbiguousLocalDst = false;
			int year = time.Year;
			OffsetAndRule oneYearLocalFromUtc = s_cachedData.GetOneYearLocalFromUtc(year);
			TimeSpan offset = oneYearLocalFromUtc.Offset;
			if (oneYearLocalFromUtc.Rule != null)
			{
				offset += oneYearLocalFromUtc.Rule.BaseUtcOffsetDelta;
				if (oneYearLocalFromUtc.Rule.HasDaylightSaving)
				{
					bool isDaylightSavingsFromUtc = GetIsDaylightSavingsFromUtc(time, year, oneYearLocalFromUtc.Offset, oneYearLocalFromUtc.Rule, null, out isAmbiguousLocalDst, Local);
					offset += (isDaylightSavingsFromUtc ? oneYearLocalFromUtc.Rule.DaylightDelta : TimeSpan.Zero);
				}
			}
			return offset;
		}

		private static bool TransitionTimeFromTimeZoneInformation(in Interop.Kernel32.REG_TZI_FORMAT timeZoneInformation, out TransitionTime transitionTime, bool readStartDate)
		{
			if (timeZoneInformation.StandardDate.Month == 0)
			{
				transitionTime = default(TransitionTime);
				return false;
			}
			if (readStartDate)
			{
				if (timeZoneInformation.DaylightDate.Year == 0)
				{
					transitionTime = TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, timeZoneInformation.DaylightDate.Hour, timeZoneInformation.DaylightDate.Minute, timeZoneInformation.DaylightDate.Second, timeZoneInformation.DaylightDate.Milliseconds), timeZoneInformation.DaylightDate.Month, timeZoneInformation.DaylightDate.Day, (DayOfWeek)timeZoneInformation.DaylightDate.DayOfWeek);
				}
				else
				{
					transitionTime = TransitionTime.CreateFixedDateRule(new DateTime(1, 1, 1, timeZoneInformation.DaylightDate.Hour, timeZoneInformation.DaylightDate.Minute, timeZoneInformation.DaylightDate.Second, timeZoneInformation.DaylightDate.Milliseconds), timeZoneInformation.DaylightDate.Month, timeZoneInformation.DaylightDate.Day);
				}
			}
			else if (timeZoneInformation.StandardDate.Year == 0)
			{
				transitionTime = TransitionTime.CreateFloatingDateRule(new DateTime(1, 1, 1, timeZoneInformation.StandardDate.Hour, timeZoneInformation.StandardDate.Minute, timeZoneInformation.StandardDate.Second, timeZoneInformation.StandardDate.Milliseconds), timeZoneInformation.StandardDate.Month, timeZoneInformation.StandardDate.Day, (DayOfWeek)timeZoneInformation.StandardDate.DayOfWeek);
			}
			else
			{
				transitionTime = TransitionTime.CreateFixedDateRule(new DateTime(1, 1, 1, timeZoneInformation.StandardDate.Hour, timeZoneInformation.StandardDate.Minute, timeZoneInformation.StandardDate.Second, timeZoneInformation.StandardDate.Milliseconds), timeZoneInformation.StandardDate.Month, timeZoneInformation.StandardDate.Day);
			}
			return true;
		}

		private static bool TryCreateAdjustmentRules(string id, in Interop.Kernel32.REG_TZI_FORMAT defaultTimeZoneInformation, out AdjustmentRule[] rules, out Exception e, int defaultBaseUtcOffset)
		{
			rules = null;
			e = null;
			try
			{
				using RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\" + id + "\\Dynamic DST", writable: false);
				if (registryKey == null)
				{
					AdjustmentRule adjustmentRule = CreateAdjustmentRuleFromTimeZoneInformation(in defaultTimeZoneInformation, DateTime.MinValue.Date, DateTime.MaxValue.Date, defaultBaseUtcOffset);
					if (adjustmentRule != null)
					{
						rules = new AdjustmentRule[1] { adjustmentRule };
					}
					return true;
				}
				int num = (int)registryKey.GetValue("FirstEntry", -1);
				int num2 = (int)registryKey.GetValue("LastEntry", -1);
				if (num == -1 || num2 == -1 || num > num2)
				{
					return false;
				}
				if (!TryGetTimeZoneEntryFromRegistry(registryKey, num.ToString(CultureInfo.InvariantCulture), out var dtzi))
				{
					return false;
				}
				if (num == num2)
				{
					AdjustmentRule adjustmentRule2 = CreateAdjustmentRuleFromTimeZoneInformation(in dtzi, DateTime.MinValue.Date, DateTime.MaxValue.Date, defaultBaseUtcOffset);
					if (adjustmentRule2 != null)
					{
						rules = new AdjustmentRule[1] { adjustmentRule2 };
					}
					return true;
				}
				List<AdjustmentRule> list = new List<AdjustmentRule>(1);
				AdjustmentRule adjustmentRule3 = CreateAdjustmentRuleFromTimeZoneInformation(in dtzi, DateTime.MinValue.Date, new DateTime(num, 12, 31), defaultBaseUtcOffset);
				if (adjustmentRule3 != null)
				{
					list.Add(adjustmentRule3);
				}
				for (int i = num + 1; i < num2; i++)
				{
					if (!TryGetTimeZoneEntryFromRegistry(registryKey, i.ToString(CultureInfo.InvariantCulture), out dtzi))
					{
						return false;
					}
					AdjustmentRule adjustmentRule4 = CreateAdjustmentRuleFromTimeZoneInformation(in dtzi, new DateTime(i, 1, 1), new DateTime(i, 12, 31), defaultBaseUtcOffset);
					if (adjustmentRule4 != null)
					{
						list.Add(adjustmentRule4);
					}
				}
				if (!TryGetTimeZoneEntryFromRegistry(registryKey, num2.ToString(CultureInfo.InvariantCulture), out dtzi))
				{
					return false;
				}
				AdjustmentRule adjustmentRule5 = CreateAdjustmentRuleFromTimeZoneInformation(in dtzi, new DateTime(num2, 1, 1), DateTime.MaxValue.Date, defaultBaseUtcOffset);
				if (adjustmentRule5 != null)
				{
					list.Add(adjustmentRule5);
				}
				if (list.Count != 0)
				{
					rules = list.ToArray();
				}
			}
			catch (InvalidCastException ex)
			{
				e = ex;
				return false;
			}
			catch (ArgumentOutOfRangeException ex2)
			{
				e = ex2;
				return false;
			}
			catch (ArgumentException ex3)
			{
				e = ex3;
				return false;
			}
			return true;
		}

		private unsafe static bool TryGetTimeZoneEntryFromRegistry(RegistryKey key, string name, out Interop.Kernel32.REG_TZI_FORMAT dtzi)
		{
			if (!(key.GetValue(name, null) is byte[] array) || array.Length != sizeof(Interop.Kernel32.REG_TZI_FORMAT))
			{
				dtzi = default(Interop.Kernel32.REG_TZI_FORMAT);
				return false;
			}
			fixed (byte* ptr = &array[0])
			{
				dtzi = *(Interop.Kernel32.REG_TZI_FORMAT*)ptr;
			}
			return true;
		}

		private static bool TryCompareStandardDate(in Interop.Kernel32.TIME_ZONE_INFORMATION timeZone, in Interop.Kernel32.REG_TZI_FORMAT registryTimeZoneInfo)
		{
			if (timeZone.Bias == registryTimeZoneInfo.Bias && timeZone.StandardBias == registryTimeZoneInfo.StandardBias)
			{
				return timeZone.StandardDate.Equals(in registryTimeZoneInfo.StandardDate);
			}
			return false;
		}

		private static bool TryCompareTimeZoneInformationToRegistry(in Interop.Kernel32.TIME_ZONE_INFORMATION timeZone, string id, out bool dstDisabled)
		{
			dstDisabled = false;
			using RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\" + id, writable: false);
			if (registryKey == null)
			{
				return false;
			}
			if (!TryGetTimeZoneEntryFromRegistry(registryKey, "TZI", out var dtzi))
			{
				return false;
			}
			if (!TryCompareStandardDate(in timeZone, in dtzi))
			{
				return false;
			}
			bool flag = dstDisabled || CheckDaylightSavingTimeNotSupported(in timeZone) || (timeZone.DaylightBias == dtzi.DaylightBias && timeZone.DaylightDate.Equals(in dtzi.DaylightDate));
			if (flag)
			{
				string a = registryKey.GetValue("Std", string.Empty) as string;
				flag = string.Equals(a, timeZone.GetStandardName(), StringComparison.Ordinal);
			}
			return flag;
		}

		private static string GetLocalizedNameByMuiNativeResource(string resource)
		{
			if (string.IsNullOrEmpty(resource) || (GlobalizationMode.Invariant && GlobalizationMode.PredefinedCulturesOnly))
			{
				return string.Empty;
			}
			string[] array = resource.Split(',');
			if (array.Length != 2)
			{
				return string.Empty;
			}
			if (!int.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return string.Empty;
			}
			result = -result;
			CultureInfo cultureInfo = CultureInfo.CurrentUICulture;
			string systemDirectory = Environment.SystemDirectory;
			string path = $"{array[0].AsSpan().TrimStart('@')}.mui";
			try
			{
				while (cultureInfo.Name.Length != 0)
				{
					string text = Path.Join(systemDirectory, cultureInfo.Name, path);
					if (File.Exists(text))
					{
						return GetLocalizedNameByNativeResource(text, result);
					}
					cultureInfo = cultureInfo.Parent;
				}
			}
			catch (ArgumentException)
			{
			}
			return string.Empty;
		}

		private unsafe static string GetLocalizedNameByNativeResource(string filePath, int resource)
		{
			IntPtr intPtr = IntPtr.Zero;
			try
			{
				intPtr = Interop.Kernel32.LoadLibraryEx(filePath, IntPtr.Zero, 2);
				if (intPtr != IntPtr.Zero)
				{
					char* ptr = stackalloc char[500];
					int num = Interop.User32.LoadString(intPtr, (uint)resource, ptr, 500);
					if (num != 0)
					{
						return new string(ptr, 0, num);
					}
				}
			}
			finally
			{
				if (intPtr != IntPtr.Zero)
				{
					Interop.Kernel32.FreeLibrary(intPtr);
				}
			}
			return string.Empty;
		}

		private static void GetLocalizedNamesByRegistryKey(RegistryKey key, out string displayName, out string standardName, out string daylightName)
		{
			displayName = string.Empty;
			standardName = string.Empty;
			daylightName = string.Empty;
			string text = key.GetValue("MUI_Display", string.Empty) as string;
			string text2 = key.GetValue("MUI_Std", string.Empty) as string;
			string text3 = key.GetValue("MUI_Dlt", string.Empty) as string;
			if (!string.IsNullOrEmpty(text))
			{
				displayName = GetLocalizedNameByMuiNativeResource(text);
			}
			if (!string.IsNullOrEmpty(text2))
			{
				standardName = GetLocalizedNameByMuiNativeResource(text2);
			}
			if (!string.IsNullOrEmpty(text3))
			{
				daylightName = GetLocalizedNameByMuiNativeResource(text3);
			}
			if (string.IsNullOrEmpty(displayName))
			{
				displayName = key.GetValue("Display", string.Empty) as string;
			}
			if (string.IsNullOrEmpty(standardName))
			{
				standardName = key.GetValue("Std", string.Empty) as string;
			}
			if (string.IsNullOrEmpty(daylightName))
			{
				daylightName = key.GetValue("Dlt", string.Empty) as string;
			}
		}

		private static TimeZoneInfoResult TryGetTimeZoneFromLocalMachine(string id, out TimeZoneInfo value, out Exception e)
		{
			e = null;
			using RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\" + id, writable: false);
			if (registryKey == null)
			{
				value = null;
				return TimeZoneInfoResult.TimeZoneNotFoundException;
			}
			if (!TryGetTimeZoneEntryFromRegistry(registryKey, "TZI", out var dtzi))
			{
				value = null;
				return TimeZoneInfoResult.InvalidTimeZoneException;
			}
			if (!TryCreateAdjustmentRules(id, in dtzi, out var rules, out e, dtzi.Bias))
			{
				value = null;
				return TimeZoneInfoResult.InvalidTimeZoneException;
			}
			GetLocalizedNamesByRegistryKey(registryKey, out var displayName, out var standardName, out var daylightName);
			try
			{
				value = new TimeZoneInfo(id, new TimeSpan(0, -dtzi.Bias, 0), displayName, standardName, daylightName, rules, disableDaylightSavingTime: false);
				return TimeZoneInfoResult.Success;
			}
			catch (ArgumentException ex)
			{
				value = null;
				e = ex;
				return TimeZoneInfoResult.InvalidTimeZoneException;
			}
			catch (InvalidTimeZoneException ex2)
			{
				value = null;
				e = ex2;
				return TimeZoneInfoResult.InvalidTimeZoneException;
			}
		}

		private static string GetUtcStandardDisplayName()
		{
			CultureInfo currentUICulture = CultureInfo.CurrentUICulture;
			if (currentUICulture.Name.Length == 0 || currentUICulture.TwoLetterISOLanguageName == "en")
			{
				return "Coordinated Universal Time";
			}
			string text = null;
			using (RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\UTC", writable: false))
			{
				if (registryKey != null)
				{
					string text2 = registryKey.GetValue("MUI_Std", string.Empty) as string;
					if (!string.IsNullOrEmpty(text2))
					{
						text = GetLocalizedNameByMuiNativeResource(text2);
					}
					if (string.IsNullOrEmpty(text))
					{
						text = registryKey.GetValue("Std", string.Empty) as string;
					}
				}
			}
			switch (text)
			{
			case null:
			case "GMT":
			case "UTC":
				text = "Coordinated Universal Time";
				break;
			}
			return text;
		}

		private static string GetUtcFullDisplayName(string timeZoneId, string standardDisplayName)
		{
			return "(UTC) " + standardDisplayName;
		}
	}
	[Flags]
	internal enum TimeZoneInfoOptions
	{
		None = 1,
		NoThrowOnInvalidTime = 2
	}
	[Serializable]
	[TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class TimeZoneNotFoundException : Exception
	{
		public TimeZoneNotFoundException()
		{
		}

		public TimeZoneNotFoundException(string? message)
			: base(message)
		{
		}

		public TimeZoneNotFoundException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		protected TimeZoneNotFoundException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal interface ITupleInternal : ITuple
	{
		string ToString(StringBuilder sb);

		int GetHashCode(IEqualityComparer comparer);
	}
	public static class Tuple
	{
		public static Tuple<T1> Create<T1>(T1 item1)
		{
			return new Tuple<T1>(item1);
		}

		public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
		{
			return new Tuple<T1, T2>(item1, item2);
		}

		public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
		{
			return new Tuple<T1, T2, T3>(item1, item2, item3);
		}

		public static Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4)
		{
			return new Tuple<T1, T2, T3, T4>(item1, item2, item3, item4);
		}

		public static Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
		{
			return new Tuple<T1, T2, T3, T4, T5>(item1, item2, item3, item4, item5);
		}

		public static Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
		{
			return new Tuple<T1, T2, T3, T4, T5, T6>(item1, item2, item3, item4, item5, item6);
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
		{
			return new Tuple<T1, T2, T3, T4, T5, T6, T7>(item1, item2, item3, item4, item5, item6, item7);
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8)
		{
			return new Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>>(item1, item2, item3, item4, item5, item6, item7, new Tuple<T8>(item8));
		}

		internal static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		internal static int CombineHashCodes(int h1, int h2, int h3)
		{
			return CombineHashCodes(CombineHashCodes(h1, h2), h3);
		}

		internal static int CombineHashCodes(int h1, int h2, int h3, int h4)
		{
			return CombineHashCodes(CombineHashCodes(h1, h2), CombineHashCodes(h3, h4));
		}

		internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5)
		{
			return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), h5);
		}

		internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6)
		{
			return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6));
		}

		internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6, int h7)
		{
			return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6, h7));
		}

		internal static int CombineHashCodes(int h1, int h2, int h3, int h4, int h5, int h6, int h7, int h8)
		{
			return CombineHashCodes(CombineHashCodes(h1, h2, h3, h4), CombineHashCodes(h5, h6, h7, h8));
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Tuple<T1> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
	{
		private readonly T1 m_Item1;

		public T1 Item1 => m_Item1;

		int ITuple.Length => 1;

		object? ITuple.this[int index]
		{
			get
			{
				if (index != 0)
				{
					throw new IndexOutOfRangeException();
				}
				return Item1;
			}
		}

		public Tuple(T1 item1)
		{
			m_Item1 = item1;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj, EqualityComparer<object>.Default);
		}

		bool IStructuralEquatable.Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			return Equals(other, comparer);
		}

		private bool Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (!(other is Tuple<T1> tuple))
			{
				return false;
			}
			return comparer.Equals(m_Item1, tuple.m_Item1);
		}

		int IComparable.CompareTo(object obj)
		{
			return CompareTo(obj, Comparer<object>.Default);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return CompareTo(other, comparer);
		}

		private int CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is Tuple<T1> tuple))
			{
				throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), "other");
			}
			return comparer.Compare(m_Item1, tuple.m_Item1);
		}

		public override int GetHashCode()
		{
			return GetHashCode(EqualityComparer<object>.Default);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		int ITupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		private int GetHashCode(IEqualityComparer comparer)
		{
			return comparer.GetHashCode(m_Item1);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('(');
			return ToString(stringBuilder);
		}

		string ITupleInternal.ToString(StringBuilder sb)
		{
			return ToString(sb);
		}

		private string ToString(StringBuilder sb)
		{
			sb.Append(m_Item1);
			sb.Append(')');
			return sb.ToString();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Tuple<T1, T2> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
	{
		private readonly T1 m_Item1;

		private readonly T2 m_Item2;

		public T1 Item1 => m_Item1;

		public T2 Item2 => m_Item2;

		int ITuple.Length => 2;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public Tuple(T1 item1, T2 item2)
		{
			m_Item1 = item1;
			m_Item2 = item2;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj, EqualityComparer<object>.Default);
		}

		bool IStructuralEquatable.Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			return Equals(other, comparer);
		}

		private bool Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (!(other is Tuple<T1, T2> tuple))
			{
				return false;
			}
			if (comparer.Equals(m_Item1, tuple.m_Item1))
			{
				return comparer.Equals(m_Item2, tuple.m_Item2);
			}
			return false;
		}

		int IComparable.CompareTo(object obj)
		{
			return CompareTo(obj, Comparer<object>.Default);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return CompareTo(other, comparer);
		}

		private int CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is Tuple<T1, T2> tuple))
			{
				throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), "other");
			}
			int num = comparer.Compare(m_Item1, tuple.m_Item1);
			if (num != 0)
			{
				return num;
			}
			return comparer.Compare(m_Item2, tuple.m_Item2);
		}

		public override int GetHashCode()
		{
			return GetHashCode(EqualityComparer<object>.Default);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		int ITupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		private int GetHashCode(IEqualityComparer comparer)
		{
			return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2));
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('(');
			return ToString(stringBuilder);
		}

		string ITupleInternal.ToString(StringBuilder sb)
		{
			return ToString(sb);
		}

		private string ToString(StringBuilder sb)
		{
			sb.Append(m_Item1);
			sb.Append(", ");
			sb.Append(m_Item2);
			sb.Append(')');
			return sb.ToString();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Tuple<T1, T2, T3> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
	{
		private readonly T1 m_Item1;

		private readonly T2 m_Item2;

		private readonly T3 m_Item3;

		public T1 Item1 => m_Item1;

		public T2 Item2 => m_Item2;

		public T3 Item3 => m_Item3;

		int ITuple.Length => 3;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public Tuple(T1 item1, T2 item2, T3 item3)
		{
			m_Item1 = item1;
			m_Item2 = item2;
			m_Item3 = item3;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj, EqualityComparer<object>.Default);
		}

		bool IStructuralEquatable.Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			return Equals(other, comparer);
		}

		private bool Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (!(other is Tuple<T1, T2, T3> tuple))
			{
				return false;
			}
			if (comparer.Equals(m_Item1, tuple.m_Item1) && comparer.Equals(m_Item2, tuple.m_Item2))
			{
				return comparer.Equals(m_Item3, tuple.m_Item3);
			}
			return false;
		}

		int IComparable.CompareTo(object obj)
		{
			return CompareTo(obj, Comparer<object>.Default);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return CompareTo(other, comparer);
		}

		private int CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is Tuple<T1, T2, T3> tuple))
			{
				throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), "other");
			}
			int num = comparer.Compare(m_Item1, tuple.m_Item1);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item2, tuple.m_Item2);
			if (num != 0)
			{
				return num;
			}
			return comparer.Compare(m_Item3, tuple.m_Item3);
		}

		public override int GetHashCode()
		{
			return GetHashCode(EqualityComparer<object>.Default);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		int ITupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		private int GetHashCode(IEqualityComparer comparer)
		{
			return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3));
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('(');
			return ToString(stringBuilder);
		}

		string ITupleInternal.ToString(StringBuilder sb)
		{
			return ToString(sb);
		}

		private string ToString(StringBuilder sb)
		{
			sb.Append(m_Item1);
			sb.Append(", ");
			sb.Append(m_Item2);
			sb.Append(", ");
			sb.Append(m_Item3);
			sb.Append(')');
			return sb.ToString();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Tuple<T1, T2, T3, T4> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
	{
		private readonly T1 m_Item1;

		private readonly T2 m_Item2;

		private readonly T3 m_Item3;

		private readonly T4 m_Item4;

		public T1 Item1 => m_Item1;

		public T2 Item2 => m_Item2;

		public T3 Item3 => m_Item3;

		public T4 Item4 => m_Item4;

		int ITuple.Length => 4;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public Tuple(T1 item1, T2 item2, T3 item3, T4 item4)
		{
			m_Item1 = item1;
			m_Item2 = item2;
			m_Item3 = item3;
			m_Item4 = item4;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj, EqualityComparer<object>.Default);
		}

		bool IStructuralEquatable.Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			return Equals(other, comparer);
		}

		private bool Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (!(other is Tuple<T1, T2, T3, T4> tuple))
			{
				return false;
			}
			if (comparer.Equals(m_Item1, tuple.m_Item1) && comparer.Equals(m_Item2, tuple.m_Item2) && comparer.Equals(m_Item3, tuple.m_Item3))
			{
				return comparer.Equals(m_Item4, tuple.m_Item4);
			}
			return false;
		}

		int IComparable.CompareTo(object obj)
		{
			return CompareTo(obj, Comparer<object>.Default);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return CompareTo(other, comparer);
		}

		private int CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is Tuple<T1, T2, T3, T4> tuple))
			{
				throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), "other");
			}
			int num = comparer.Compare(m_Item1, tuple.m_Item1);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item2, tuple.m_Item2);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item3, tuple.m_Item3);
			if (num != 0)
			{
				return num;
			}
			return comparer.Compare(m_Item4, tuple.m_Item4);
		}

		public override int GetHashCode()
		{
			return GetHashCode(EqualityComparer<object>.Default);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		int ITupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		private int GetHashCode(IEqualityComparer comparer)
		{
			return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4));
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('(');
			return ToString(stringBuilder);
		}

		string ITupleInternal.ToString(StringBuilder sb)
		{
			return ToString(sb);
		}

		private string ToString(StringBuilder sb)
		{
			sb.Append(m_Item1);
			sb.Append(", ");
			sb.Append(m_Item2);
			sb.Append(", ");
			sb.Append(m_Item3);
			sb.Append(", ");
			sb.Append(m_Item4);
			sb.Append(')');
			return sb.ToString();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Tuple<T1, T2, T3, T4, T5> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
	{
		private readonly T1 m_Item1;

		private readonly T2 m_Item2;

		private readonly T3 m_Item3;

		private readonly T4 m_Item4;

		private readonly T5 m_Item5;

		public T1 Item1 => m_Item1;

		public T2 Item2 => m_Item2;

		public T3 Item3 => m_Item3;

		public T4 Item4 => m_Item4;

		public T5 Item5 => m_Item5;

		int ITuple.Length => 5;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			4 => Item5, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
		{
			m_Item1 = item1;
			m_Item2 = item2;
			m_Item3 = item3;
			m_Item4 = item4;
			m_Item5 = item5;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj, EqualityComparer<object>.Default);
		}

		bool IStructuralEquatable.Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			return Equals(other, comparer);
		}

		private bool Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (!(other is Tuple<T1, T2, T3, T4, T5> tuple))
			{
				return false;
			}
			if (comparer.Equals(m_Item1, tuple.m_Item1) && comparer.Equals(m_Item2, tuple.m_Item2) && comparer.Equals(m_Item3, tuple.m_Item3) && comparer.Equals(m_Item4, tuple.m_Item4))
			{
				return comparer.Equals(m_Item5, tuple.m_Item5);
			}
			return false;
		}

		int IComparable.CompareTo(object obj)
		{
			return CompareTo(obj, Comparer<object>.Default);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return CompareTo(other, comparer);
		}

		private int CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is Tuple<T1, T2, T3, T4, T5> tuple))
			{
				throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), "other");
			}
			int num = comparer.Compare(m_Item1, tuple.m_Item1);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item2, tuple.m_Item2);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item3, tuple.m_Item3);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item4, tuple.m_Item4);
			if (num != 0)
			{
				return num;
			}
			return comparer.Compare(m_Item5, tuple.m_Item5);
		}

		public override int GetHashCode()
		{
			return GetHashCode(EqualityComparer<object>.Default);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		int ITupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		private int GetHashCode(IEqualityComparer comparer)
		{
			return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5));
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('(');
			return ToString(stringBuilder);
		}

		string ITupleInternal.ToString(StringBuilder sb)
		{
			return ToString(sb);
		}

		private string ToString(StringBuilder sb)
		{
			sb.Append(m_Item1);
			sb.Append(", ");
			sb.Append(m_Item2);
			sb.Append(", ");
			sb.Append(m_Item3);
			sb.Append(", ");
			sb.Append(m_Item4);
			sb.Append(", ");
			sb.Append(m_Item5);
			sb.Append(')');
			return sb.ToString();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Tuple<T1, T2, T3, T4, T5, T6> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
	{
		private readonly T1 m_Item1;

		private readonly T2 m_Item2;

		private readonly T3 m_Item3;

		private readonly T4 m_Item4;

		private readonly T5 m_Item5;

		private readonly T6 m_Item6;

		public T1 Item1 => m_Item1;

		public T2 Item2 => m_Item2;

		public T3 Item3 => m_Item3;

		public T4 Item4 => m_Item4;

		public T5 Item5 => m_Item5;

		public T6 Item6 => m_Item6;

		int ITuple.Length => 6;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			4 => Item5, 
			5 => Item6, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
		{
			m_Item1 = item1;
			m_Item2 = item2;
			m_Item3 = item3;
			m_Item4 = item4;
			m_Item5 = item5;
			m_Item6 = item6;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj, EqualityComparer<object>.Default);
		}

		bool IStructuralEquatable.Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			return Equals(other, comparer);
		}

		private bool Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (!(other is Tuple<T1, T2, T3, T4, T5, T6> tuple))
			{
				return false;
			}
			if (comparer.Equals(m_Item1, tuple.m_Item1) && comparer.Equals(m_Item2, tuple.m_Item2) && comparer.Equals(m_Item3, tuple.m_Item3) && comparer.Equals(m_Item4, tuple.m_Item4) && comparer.Equals(m_Item5, tuple.m_Item5))
			{
				return comparer.Equals(m_Item6, tuple.m_Item6);
			}
			return false;
		}

		int IComparable.CompareTo(object obj)
		{
			return CompareTo(obj, Comparer<object>.Default);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return CompareTo(other, comparer);
		}

		private int CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is Tuple<T1, T2, T3, T4, T5, T6> tuple))
			{
				throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), "other");
			}
			int num = comparer.Compare(m_Item1, tuple.m_Item1);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item2, tuple.m_Item2);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item3, tuple.m_Item3);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item4, tuple.m_Item4);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item5, tuple.m_Item5);
			if (num != 0)
			{
				return num;
			}
			return comparer.Compare(m_Item6, tuple.m_Item6);
		}

		public override int GetHashCode()
		{
			return GetHashCode(EqualityComparer<object>.Default);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		int ITupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		private int GetHashCode(IEqualityComparer comparer)
		{
			return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6));
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('(');
			return ToString(stringBuilder);
		}

		string ITupleInternal.ToString(StringBuilder sb)
		{
			return ToString(sb);
		}

		private string ToString(StringBuilder sb)
		{
			sb.Append(m_Item1);
			sb.Append(", ");
			sb.Append(m_Item2);
			sb.Append(", ");
			sb.Append(m_Item3);
			sb.Append(", ");
			sb.Append(m_Item4);
			sb.Append(", ");
			sb.Append(m_Item5);
			sb.Append(", ");
			sb.Append(m_Item6);
			sb.Append(')');
			return sb.ToString();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple
	{
		private readonly T1 m_Item1;

		private readonly T2 m_Item2;

		private readonly T3 m_Item3;

		private readonly T4 m_Item4;

		private readonly T5 m_Item5;

		private readonly T6 m_Item6;

		private readonly T7 m_Item7;

		public T1 Item1 => m_Item1;

		public T2 Item2 => m_Item2;

		public T3 Item3 => m_Item3;

		public T4 Item4 => m_Item4;

		public T5 Item5 => m_Item5;

		public T6 Item6 => m_Item6;

		public T7 Item7 => m_Item7;

		int ITuple.Length => 7;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			4 => Item5, 
			5 => Item6, 
			6 => Item7, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
		{
			m_Item1 = item1;
			m_Item2 = item2;
			m_Item3 = item3;
			m_Item4 = item4;
			m_Item5 = item5;
			m_Item6 = item6;
			m_Item7 = item7;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj, EqualityComparer<object>.Default);
		}

		bool IStructuralEquatable.Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			return Equals(other, comparer);
		}

		private bool Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7> tuple))
			{
				return false;
			}
			if (comparer.Equals(m_Item1, tuple.m_Item1) && comparer.Equals(m_Item2, tuple.m_Item2) && comparer.Equals(m_Item3, tuple.m_Item3) && comparer.Equals(m_Item4, tuple.m_Item4) && comparer.Equals(m_Item5, tuple.m_Item5) && comparer.Equals(m_Item6, tuple.m_Item6))
			{
				return comparer.Equals(m_Item7, tuple.m_Item7);
			}
			return false;
		}

		int IComparable.CompareTo(object obj)
		{
			return ((IStructuralComparable)this).CompareTo(obj, (IComparer)Comparer<object>.Default);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return CompareTo(other, comparer);
		}

		private int CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7> tuple))
			{
				throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), "other");
			}
			int num = comparer.Compare(m_Item1, tuple.m_Item1);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item2, tuple.m_Item2);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item3, tuple.m_Item3);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item4, tuple.m_Item4);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item5, tuple.m_Item5);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item6, tuple.m_Item6);
			if (num != 0)
			{
				return num;
			}
			return comparer.Compare(m_Item7, tuple.m_Item7);
		}

		public override int GetHashCode()
		{
			return GetHashCode(EqualityComparer<object>.Default);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		int ITupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		private int GetHashCode(IEqualityComparer comparer)
		{
			return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7));
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('(');
			return ToString(stringBuilder);
		}

		string ITupleInternal.ToString(StringBuilder sb)
		{
			return ToString(sb);
		}

		private string ToString(StringBuilder sb)
		{
			sb.Append(m_Item1);
			sb.Append(", ");
			sb.Append(m_Item2);
			sb.Append(", ");
			sb.Append(m_Item3);
			sb.Append(", ");
			sb.Append(m_Item4);
			sb.Append(", ");
			sb.Append(m_Item5);
			sb.Append(", ");
			sb.Append(m_Item6);
			sb.Append(", ");
			sb.Append(m_Item7);
			sb.Append(')');
			return sb.ToString();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IStructuralEquatable, IStructuralComparable, IComparable, ITupleInternal, ITuple where TRest : notnull
	{
		private readonly T1 m_Item1;

		private readonly T2 m_Item2;

		private readonly T3 m_Item3;

		private readonly T4 m_Item4;

		private readonly T5 m_Item5;

		private readonly T6 m_Item6;

		private readonly T7 m_Item7;

		private readonly TRest m_Rest;

		public T1 Item1 => m_Item1;

		public T2 Item2 => m_Item2;

		public T3 Item3 => m_Item3;

		public T4 Item4 => m_Item4;

		public T5 Item5 => m_Item5;

		public T6 Item6 => m_Item6;

		public T7 Item7 => m_Item7;

		public TRest Rest => m_Rest;

		int ITuple.Length => 7 + ((ITupleInternal)(object)Rest).Length;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			4 => Item5, 
			5 => Item6, 
			6 => Item7, 
			_ => ((ITupleInternal)(object)Rest)[index - 7], 
		};

		public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
		{
			if (!(rest is ITupleInternal))
			{
				throw new ArgumentException(SR.ArgumentException_TupleLastArgumentNotATuple);
			}
			m_Item1 = item1;
			m_Item2 = item2;
			m_Item3 = item3;
			m_Item4 = item4;
			m_Item5 = item5;
			m_Item6 = item6;
			m_Item7 = item7;
			m_Rest = rest;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj, EqualityComparer<object>.Default);
		}

		bool IStructuralEquatable.Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			return Equals(other, comparer);
		}

		private bool Equals([NotNullWhen(true)] object other, IEqualityComparer comparer)
		{
			if (other == null)
			{
				return false;
			}
			if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> tuple))
			{
				return false;
			}
			if (comparer.Equals(m_Item1, tuple.m_Item1) && comparer.Equals(m_Item2, tuple.m_Item2) && comparer.Equals(m_Item3, tuple.m_Item3) && comparer.Equals(m_Item4, tuple.m_Item4) && comparer.Equals(m_Item5, tuple.m_Item5) && comparer.Equals(m_Item6, tuple.m_Item6) && comparer.Equals(m_Item7, tuple.m_Item7))
			{
				return comparer.Equals(m_Rest, tuple.m_Rest);
			}
			return false;
		}

		int IComparable.CompareTo(object obj)
		{
			return CompareTo(obj, Comparer<object>.Default);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			return CompareTo(other, comparer);
		}

		private int CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> tuple))
			{
				throw new ArgumentException(SR.Format(SR.ArgumentException_TupleIncorrectType, GetType()), "other");
			}
			int num = comparer.Compare(m_Item1, tuple.m_Item1);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item2, tuple.m_Item2);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item3, tuple.m_Item3);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item4, tuple.m_Item4);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item5, tuple.m_Item5);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item6, tuple.m_Item6);
			if (num != 0)
			{
				return num;
			}
			num = comparer.Compare(m_Item7, tuple.m_Item7);
			if (num != 0)
			{
				return num;
			}
			return comparer.Compare(m_Rest, tuple.m_Rest);
		}

		public override int GetHashCode()
		{
			return GetHashCode(EqualityComparer<object>.Default);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		private int GetHashCode(IEqualityComparer comparer)
		{
			ITupleInternal tupleInternal = (ITupleInternal)(object)m_Rest;
			if (tupleInternal.Length >= 8)
			{
				return tupleInternal.GetHashCode(comparer);
			}
			return (8 - tupleInternal.Length) switch
			{
				1 => Tuple.CombineHashCodes(comparer.GetHashCode(m_Item7), tupleInternal.GetHashCode(comparer)), 
				2 => Tuple.CombineHashCodes(comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), tupleInternal.GetHashCode(comparer)), 
				3 => Tuple.CombineHashCodes(comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), tupleInternal.GetHashCode(comparer)), 
				4 => Tuple.CombineHashCodes(comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), tupleInternal.GetHashCode(comparer)), 
				5 => Tuple.CombineHashCodes(comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), tupleInternal.GetHashCode(comparer)), 
				6 => Tuple.CombineHashCodes(comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), tupleInternal.GetHashCode(comparer)), 
				7 => Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7), tupleInternal.GetHashCode(comparer)), 
				_ => -1, 
			};
		}

		int ITupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCode(comparer);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('(');
			return ToString(stringBuilder);
		}

		string ITupleInternal.ToString(StringBuilder sb)
		{
			return ToString(sb);
		}

		private string ToString(StringBuilder sb)
		{
			sb.Append(m_Item1);
			sb.Append(", ");
			sb.Append(m_Item2);
			sb.Append(", ");
			sb.Append(m_Item3);
			sb.Append(", ");
			sb.Append(m_Item4);
			sb.Append(", ");
			sb.Append(m_Item5);
			sb.Append(", ");
			sb.Append(m_Item6);
			sb.Append(", ");
			sb.Append(m_Item7);
			sb.Append(", ");
			return ((ITupleInternal)(object)m_Rest).ToString(sb);
		}
	}
	internal sealed class TupleSlim<T1, T2>
	{
		public readonly T1 Item1;

		public readonly T2 Item2;

		public TupleSlim(T1 item1, T2 item2)
		{
			Item1 = item1;
			Item2 = item2;
		}
	}
	internal sealed class TupleSlim<T1, T2, T3>
	{
		public readonly T1 Item1;

		public readonly T2 Item2;

		public readonly T3 Item3;

		public TupleSlim(T1 item1, T2 item2, T3 item3)
		{
			Item1 = item1;
			Item2 = item2;
			Item3 = item3;
		}
	}
	internal sealed class TupleSlim<T1, T2, T3, T4>
	{
		public readonly T1 Item1;

		public readonly T2 Item2;

		public readonly T3 Item3;

		public readonly T4 Item4;

		public TupleSlim(T1 item1, T2 item2, T3 item3, T4 item4)
		{
			Item1 = item1;
			Item2 = item2;
			Item3 = item3;
			Item4 = item4;
		}
	}
	public static class TupleExtensions
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1>(this Tuple<T1> value, out T1 item1)
		{
			item1 = value.Item1;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2>(this Tuple<T1, T2> value, out T1 item1, out T2 item2)
		{
			item1 = value.Item1;
			item2 = value.Item2;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3>(this Tuple<T1, T2, T3> value, out T1 item1, out T2 item2, out T3 item3)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4>(this Tuple<T1, T2, T3, T4> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5>(this Tuple<T1, T2, T3, T4, T5> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6>(this Tuple<T1, T2, T3, T4, T5, T6> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7>(this Tuple<T1, T2, T3, T4, T5, T6, T7> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
			item14 = value.Rest.Item7;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
			item14 = value.Rest.Item7;
			item15 = value.Rest.Rest.Item1;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
			item14 = value.Rest.Item7;
			item15 = value.Rest.Rest.Item1;
			item16 = value.Rest.Rest.Item2;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
			item14 = value.Rest.Item7;
			item15 = value.Rest.Rest.Item1;
			item16 = value.Rest.Rest.Item2;
			item17 = value.Rest.Rest.Item3;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
			item14 = value.Rest.Item7;
			item15 = value.Rest.Rest.Item1;
			item16 = value.Rest.Rest.Item2;
			item17 = value.Rest.Rest.Item3;
			item18 = value.Rest.Rest.Item4;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
			item14 = value.Rest.Item7;
			item15 = value.Rest.Rest.Item1;
			item16 = value.Rest.Rest.Item2;
			item17 = value.Rest.Rest.Item3;
			item18 = value.Rest.Rest.Item4;
			item19 = value.Rest.Rest.Item5;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19, out T20 item20)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
			item14 = value.Rest.Item7;
			item15 = value.Rest.Rest.Item1;
			item16 = value.Rest.Rest.Item2;
			item17 = value.Rest.Rest.Item3;
			item18 = value.Rest.Rest.Item4;
			item19 = value.Rest.Rest.Item5;
			item20 = value.Rest.Rest.Item6;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void Deconstruct<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20, T21>>> value, out T1 item1, out T2 item2, out T3 item3, out T4 item4, out T5 item5, out T6 item6, out T7 item7, out T8 item8, out T9 item9, out T10 item10, out T11 item11, out T12 item12, out T13 item13, out T14 item14, out T15 item15, out T16 item16, out T17 item17, out T18 item18, out T19 item19, out T20 item20, out T21 item21)
		{
			item1 = value.Item1;
			item2 = value.Item2;
			item3 = value.Item3;
			item4 = value.Item4;
			item5 = value.Item5;
			item6 = value.Item6;
			item7 = value.Item7;
			item8 = value.Rest.Item1;
			item9 = value.Rest.Item2;
			item10 = value.Rest.Item3;
			item11 = value.Rest.Item4;
			item12 = value.Rest.Item5;
			item13 = value.Rest.Item6;
			item14 = value.Rest.Item7;
			item15 = value.Rest.Rest.Item1;
			item16 = value.Rest.Rest.Item2;
			item17 = value.Rest.Rest.Item3;
			item18 = value.Rest.Rest.Item4;
			item19 = value.Rest.Rest.Item5;
			item20 = value.Rest.Rest.Item6;
			item21 = value.Rest.Rest.Item7;
		}

		public static ValueTuple<T1> ToValueTuple<T1>(this Tuple<T1> value)
		{
			return ValueTuple.Create(value.Item1);
		}

		public static (T1, T2) ToValueTuple<T1, T2>(this Tuple<T1, T2> value)
		{
			return ValueTuple.Create(value.Item1, value.Item2);
		}

		public static (T1, T2, T3) ToValueTuple<T1, T2, T3>(this Tuple<T1, T2, T3> value)
		{
			return ValueTuple.Create(value.Item1, value.Item2, value.Item3);
		}

		public static (T1, T2, T3, T4) ToValueTuple<T1, T2, T3, T4>(this Tuple<T1, T2, T3, T4> value)
		{
			return ValueTuple.Create(value.Item1, value.Item2, value.Item3, value.Item4);
		}

		public static (T1, T2, T3, T4, T5) ToValueTuple<T1, T2, T3, T4, T5>(this Tuple<T1, T2, T3, T4, T5> value)
		{
			return ValueTuple.Create(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5);
		}

		public static (T1, T2, T3, T4, T5, T6) ToValueTuple<T1, T2, T3, T4, T5, T6>(this Tuple<T1, T2, T3, T4, T5, T6> value)
		{
			return ValueTuple.Create(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6);
		}

		public static (T1, T2, T3, T4, T5, T6, T7) ToValueTuple<T1, T2, T3, T4, T5, T6, T7>(this Tuple<T1, T2, T3, T4, T5, T6, T7> value)
		{
			return ValueTuple.Create(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7);
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> value)
		{
			return CreateLong(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, ValueTuple.Create(value.Rest.Item1));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9>> value)
		{
			return CreateLong<T1, T2, T3, T4, T5, T6, T7, (T8, T9)>(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, ValueTuple.Create(value.Rest.Item1, value.Rest.Item2));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10>> value)
		{
			return CreateLong<T1, T2, T3, T4, T5, T6, T7, (T8, T9, T10)>(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, ValueTuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11>> value)
		{
			return CreateLong<T1, T2, T3, T4, T5, T6, T7, (T8, T9, T10, T11)>(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, ValueTuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12>> value)
		{
			return CreateLong<T1, T2, T3, T4, T5, T6, T7, (T8, T9, T10, T11, T12)>(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, ValueTuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13>> value)
		{
			return CreateLong<T1, T2, T3, T4, T5, T6, T7, (T8, T9, T10, T11, T12, T13)>(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, ValueTuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14>> value)
		{
			return CreateLong<T1, T2, T3, T4, T5, T6, T7, (T8, T9, T10, T11, T12, T13, T14)>(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, ValueTuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15>>> value)
		{
			return CreateLong(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLong(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, ValueTuple.Create(value.Rest.Rest.Item1)));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16>>> value)
		{
			return CreateLong(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLong<T8, T9, T10, T11, T12, T13, T14, (T15, T16)>(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, ValueTuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2)));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17>>> value)
		{
			return CreateLong(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLong<T8, T9, T10, T11, T12, T13, T14, (T15, T16, T17)>(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, ValueTuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3)));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18>>> value)
		{
			return CreateLong(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLong<T8, T9, T10, T11, T12, T13, T14, (T15, T16, T17, T18)>(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, ValueTuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3, value.Rest.Rest.Item4)));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19>>> value)
		{
			return CreateLong(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLong<T8, T9, T10, T11, T12, T13, T14, (T15, T16, T17, T18, T19)>(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, ValueTuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3, value.Rest.Rest.Item4, value.Rest.Rest.Item5)));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20>>> value)
		{
			return CreateLong(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLong<T8, T9, T10, T11, T12, T13, T14, (T15, T16, T17, T18, T19, T20)>(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, ValueTuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3, value.Rest.Rest.Item4, value.Rest.Rest.Item5, value.Rest.Rest.Item6)));
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) ToValueTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(this Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20, T21>>> value)
		{
			return CreateLong(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLong<T8, T9, T10, T11, T12, T13, T14, (T15, T16, T17, T18, T19, T20, T21)>(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, ValueTuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3, value.Rest.Rest.Item4, value.Rest.Rest.Item5, value.Rest.Rest.Item6, value.Rest.Rest.Item7)));
		}

		public static Tuple<T1> ToTuple<T1>(this ValueTuple<T1> value)
		{
			return Tuple.Create(value.Item1);
		}

		public static Tuple<T1, T2> ToTuple<T1, T2>(this (T1, T2) value)
		{
			return Tuple.Create(value.Item1, value.Item2);
		}

		public static Tuple<T1, T2, T3> ToTuple<T1, T2, T3>(this (T1, T2, T3) value)
		{
			return Tuple.Create(value.Item1, value.Item2, value.Item3);
		}

		public static Tuple<T1, T2, T3, T4> ToTuple<T1, T2, T3, T4>(this (T1, T2, T3, T4) value)
		{
			return Tuple.Create(value.Item1, value.Item2, value.Item3, value.Item4);
		}

		public static Tuple<T1, T2, T3, T4, T5> ToTuple<T1, T2, T3, T4, T5>(this (T1, T2, T3, T4, T5) value)
		{
			return Tuple.Create(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5);
		}

		public static Tuple<T1, T2, T3, T4, T5, T6> ToTuple<T1, T2, T3, T4, T5, T6>(this (T1, T2, T3, T4, T5, T6) value)
		{
			return Tuple.Create(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6);
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7> ToTuple<T1, T2, T3, T4, T5, T6, T7>(this (T1, T2, T3, T4, T5, T6, T7) value)
		{
			return Tuple.Create(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7);
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8>(this (T1, T2, T3, T4, T5, T6, T7, T8) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, Tuple.Create(value.Rest.Item1));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, Tuple.Create(value.Rest.Item1, value.Rest.Item2));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, Tuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, Tuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, Tuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, Tuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, Tuple.Create(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLongRef(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, Tuple.Create(value.Rest.Rest.Item1)));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLongRef(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, Tuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2)));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLongRef(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, Tuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3)));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLongRef(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, Tuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3, value.Rest.Rest.Item4)));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLongRef(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, Tuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3, value.Rest.Rest.Item4, value.Rest.Rest.Item5)));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLongRef(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, Tuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3, value.Rest.Rest.Item4, value.Rest.Rest.Item5, value.Rest.Rest.Item6)));
		}

		public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8, T9, T10, T11, T12, T13, T14, Tuple<T15, T16, T17, T18, T19, T20, T21>>> ToTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(this (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) value)
		{
			return CreateLongRef(value.Item1, value.Item2, value.Item3, value.Item4, value.Item5, value.Item6, value.Item7, CreateLongRef(value.Rest.Item1, value.Rest.Item2, value.Rest.Item3, value.Rest.Item4, value.Rest.Item5, value.Rest.Item6, value.Rest.Item7, Tuple.Create(value.Rest.Rest.Item1, value.Rest.Rest.Item2, value.Rest.Rest.Item3, value.Rest.Rest.Item4, value.Rest.Rest.Item5, value.Rest.Rest.Item6, value.Rest.Rest.Item7)));
		}

		private static ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> CreateLong<T1, T2, T3, T4, T5, T6, T7, TRest>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) where TRest : struct, ITuple?
		{
			return new ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>(item1, item2, item3, item4, item5, item6, item7, rest);
		}

		private static Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> CreateLongRef<T1, T2, T3, T4, T5, T6, T7, TRest>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) where TRest : ITuple?
		{
			return new Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>(item1, item2, item3, item4, item5, item6, item7, rest);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class TypeAccessException : TypeLoadException
	{
		public TypeAccessException()
			: base(SR.Arg_TypeAccessException)
		{
			base.HResult = -2146233021;
		}

		public TypeAccessException(string? message)
			: base(message)
		{
			base.HResult = -2146233021;
		}

		public TypeAccessException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233021;
		}

		protected TypeAccessException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public enum TypeCode
	{
		Empty = 0,
		Object = 1,
		DBNull = 2,
		Boolean = 3,
		Char = 4,
		SByte = 5,
		Byte = 6,
		Int16 = 7,
		UInt16 = 8,
		Int32 = 9,
		UInt32 = 10,
		Int64 = 11,
		UInt64 = 12,
		Single = 13,
		Double = 14,
		Decimal = 15,
		DateTime = 16,
		String = 18
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class TypeInitializationException : SystemException
	{
		private readonly string _typeName;

		public string TypeName => _typeName ?? string.Empty;

		private TypeInitializationException()
			: base(SR.TypeInitialization_Default)
		{
			base.HResult = -2146233036;
		}

		public TypeInitializationException(string? fullTypeName, Exception? innerException)
			: this(fullTypeName, SR.Format(SR.TypeInitialization_Type, fullTypeName), innerException)
		{
		}

		internal TypeInitializationException(string message)
			: base(message)
		{
			base.HResult = -2146233036;
		}

		internal TypeInitializationException(string fullTypeName, string message, Exception innerException)
			: base(message, innerException)
		{
			_typeName = fullTypeName;
			base.HResult = -2146233036;
		}

		private TypeInitializationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_typeName = info.GetString("TypeName");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("TypeName", TypeName, typeof(string));
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class TypeUnloadedException : SystemException
	{
		public TypeUnloadedException()
			: base(SR.Arg_TypeUnloadedException)
		{
			base.HResult = -2146234349;
		}

		public TypeUnloadedException(string? message)
			: base(message)
		{
			base.HResult = -2146234349;
		}

		public TypeUnloadedException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146234349;
		}

		protected TypeUnloadedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[CLSCompliant(false)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct UInt16 : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<ushort>, IEquatable<ushort>, IBinaryInteger<ushort>, IBinaryNumber<ushort>, IBitwiseOperators<ushort, ushort, ushort>, INumber<ushort>, IAdditionOperators<ushort, ushort, ushort>, IAdditiveIdentity<ushort, ushort>, IComparisonOperators<ushort, ushort>, IEqualityOperators<ushort, ushort>, IDecrementOperators<ushort>, IDivisionOperators<ushort, ushort, ushort>, IIncrementOperators<ushort>, IModulusOperators<ushort, ushort, ushort>, IMultiplicativeIdentity<ushort, ushort>, IMultiplyOperators<ushort, ushort, ushort>, ISpanParseable<ushort>, IParseable<ushort>, ISubtractionOperators<ushort, ushort, ushort>, IUnaryNegationOperators<ushort, ushort>, IUnaryPlusOperators<ushort, ushort>, IShiftOperators<ushort, ushort>, IMinMaxValue<ushort>, IUnsignedNumber<ushort>
	{
		private readonly ushort m_value;

		public const ushort MaxValue = 65535;

		public const ushort MinValue = 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IAdditiveIdentity<ushort, ushort>.AdditiveIdentity => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IMinMaxValue<ushort>.MinValue => 0;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IMinMaxValue<ushort>.MaxValue => ushort.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IMultiplicativeIdentity<ushort, ushort>.MultiplicativeIdentity => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.One => 1;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Zero => 0;

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is ushort)
			{
				return this - (ushort)value;
			}
			throw new ArgumentException(SR.Arg_MustBeUInt16);
		}

		public int CompareTo(ushort value)
		{
			return this - value;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is ushort))
			{
				return false;
			}
			return this == (ushort)obj;
		}

		[NonVersionable]
		public bool Equals(ushort obj)
		{
			return this == obj;
		}

		public override int GetHashCode()
		{
			return this;
		}

		public override string ToString()
		{
			return Number.UInt32ToDecStr(this);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.UInt32ToDecStr(this);
		}

		public string ToString(string? format)
		{
			return Number.FormatUInt32(this, format, null);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatUInt32(this, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatUInt32(this, format, provider, destination, out charsWritten);
		}

		public static ushort Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
		}

		public static ushort Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.CurrentInfo);
		}

		public static ushort Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
		}

		public static ushort Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static ushort Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Parse(s, style, NumberFormatInfo.GetInstance(provider));
		}

		private static ushort Parse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info)
		{
			uint result;
			Number.ParsingStatus parsingStatus = Number.TryParseUInt32(s, style, info, out result);
			if (parsingStatus != 0)
			{
				Number.ThrowOverflowOrFormatException(parsingStatus, TypeCode.UInt16);
			}
			if (result > 65535)
			{
				Number.ThrowOverflowException(TypeCode.UInt16);
			}
			return (ushort)result;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out ushort result)
		{
			if (s == null)
			{
				result = 0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, out ushort result)
		{
			return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out ushort result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				result = 0;
				return false;
			}
			return TryParse((ReadOnlySpan<char>)s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out ushort result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
		}

		private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out ushort result)
		{
			if (Number.TryParseUInt32(s, style, info, out var result2) != 0 || result2 > 65535)
			{
				result = 0;
				return false;
			}
			result = (ushort)result2;
			return true;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.UInt16;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return this;
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "UInt16", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IAdditionOperators<ushort, ushort, ushort>.op_Addition(ushort left, ushort right)
		{
			return (ushort)(left + right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBinaryInteger<ushort>.LeadingZeroCount(ushort value)
		{
			return (ushort)(BitOperations.LeadingZeroCount(value) - 16);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBinaryInteger<ushort>.PopCount(ushort value)
		{
			return (ushort)BitOperations.PopCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBinaryInteger<ushort>.RotateLeft(ushort value, int rotateAmount)
		{
			return (ushort)((value << (rotateAmount & 0xF)) | (value >> ((16 - rotateAmount) & 0xF)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBinaryInteger<ushort>.RotateRight(ushort value, int rotateAmount)
		{
			return (ushort)((value >> (rotateAmount & 0xF)) | (value << ((16 - rotateAmount) & 0xF)));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBinaryInteger<ushort>.TrailingZeroCount(ushort value)
		{
			return (ushort)(BitOperations.TrailingZeroCount(value << 16) - 16);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<ushort>.IsPow2(ushort value)
		{
			return BitOperations.IsPow2((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBinaryNumber<ushort>.Log2(ushort value)
		{
			return (ushort)BitOperations.Log2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBitwiseOperators<ushort, ushort, ushort>.op_BitwiseAnd(ushort left, ushort right)
		{
			return (ushort)(left & right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBitwiseOperators<ushort, ushort, ushort>.op_BitwiseOr(ushort left, ushort right)
		{
			return (ushort)(left | right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBitwiseOperators<ushort, ushort, ushort>.op_ExclusiveOr(ushort left, ushort right)
		{
			return (ushort)(left ^ right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IBitwiseOperators<ushort, ushort, ushort>.op_OnesComplement(ushort value)
		{
			return (ushort)(~value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<ushort, ushort>.op_LessThan(ushort left, ushort right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<ushort, ushort>.op_LessThanOrEqual(ushort left, ushort right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<ushort, ushort>.op_GreaterThan(ushort left, ushort right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<ushort, ushort>.op_GreaterThanOrEqual(ushort left, ushort right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IDecrementOperators<ushort>.op_Decrement(ushort value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IDivisionOperators<ushort, ushort, ushort>.op_Division(ushort left, ushort right)
		{
			return (ushort)(left / right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<ushort, ushort>.op_Equality(ushort left, ushort right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<ushort, ushort>.op_Inequality(ushort left, ushort right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IIncrementOperators<ushort>.op_Increment(ushort value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IModulusOperators<ushort, ushort, ushort>.op_Modulus(ushort left, ushort right)
		{
			return (ushort)(left % right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IMultiplyOperators<ushort, ushort, ushort>.op_Multiply(ushort left, ushort right)
		{
			return (ushort)(left * right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Abs(ushort value)
		{
			return value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Clamp(ushort value, ushort min, ushort max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (ushort)(decimal)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(double))
				{
					return (ushort)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (ushort)(short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (ushort)(int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (ushort)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (ushort)(nint)(IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (ushort)(sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (ushort)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (ushort)(uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (ushort)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (ushort)(nuint)(UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 65535m))
				{
					if (!(num < 0m))
					{
						return (ushort)num;
					}
					return 0;
				}
				return ushort.MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 65535.0))
				{
					if (!(num2 < 0.0))
					{
						return (ushort)num2;
					}
					return 0;
				}
				return ushort.MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 >= 0)
				{
					return (ushort)num3;
				}
				return 0;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 <= 65535)
				{
					if (num4 >= 0)
					{
						return (ushort)num4;
					}
					return 0;
				}
				return ushort.MaxValue;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 <= 65535)
				{
					if (num5 >= 0)
					{
						return (ushort)num5;
					}
					return 0;
				}
				return ushort.MaxValue;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr <= 65535)
				{
					if ((nint)intPtr >= 0)
					{
						return (ushort)(nint)intPtr;
					}
					return 0;
				}
				return ushort.MaxValue;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b >= 0)
				{
					return (ushort)b;
				}
				return 0;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (!(num6 > 65535f))
				{
					if (!(num6 < 0f))
					{
						return (ushort)num6;
					}
					return 0;
				}
				return ushort.MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num7 = (uint)(object)value;
				if (num7 <= 65535)
				{
					return (ushort)num7;
				}
				return ushort.MaxValue;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num8 = (ulong)(object)value;
				if (num8 <= 65535)
				{
					return (ushort)num8;
				}
				return ushort.MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr <= 65535)
				{
					return (ushort)(nuint)uIntPtr;
				}
				return ushort.MaxValue;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (ushort)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (ushort)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (ushort)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (ushort)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (ushort)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (ushort)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (ushort)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (ushort)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (ushort)(uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ushort)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (ushort)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (ushort Quotient, ushort Remainder) INumber<ushort>.DivRem(ushort left, ushort right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Max(ushort x, ushort y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Min(ushort x, ushort y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort INumber<ushort>.Sign(ushort value)
		{
			return (ushort)((value != 0) ? 1u : 0u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<ushort>.TryCreate<TOther>(TOther value, out ushort result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < 0m || num > 65535m)
				{
					result = 0;
					return false;
				}
				result = (ushort)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < 0.0 || num2 > 65535.0)
				{
					result = 0;
					return false;
				}
				result = (ushort)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 < 0)
				{
					result = 0;
					return false;
				}
				result = (ushort)num3;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 < 0 || num4 > 65535)
				{
					result = 0;
					return false;
				}
				result = (ushort)num4;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 < 0 || num5 > 65535)
				{
					result = 0;
					return false;
				}
				result = (ushort)num5;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < 0 || (nint)intPtr > 65535)
				{
					result = 0;
					return false;
				}
				result = (ushort)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b < 0)
				{
					result = 0;
					return false;
				}
				result = (ushort)b;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (num6 < 0f || num6 > 65535f)
				{
					result = 0;
					return false;
				}
				result = (ushort)num6;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				uint num7 = (uint)(object)value;
				if (num7 > 65535)
				{
					result = 0;
					return false;
				}
				result = (ushort)num7;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num8 = (ulong)(object)value;
				if (num8 > 65535)
				{
					result = 0;
					return false;
				}
				result = (ushort)num8;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr > 65535)
				{
					result = 0;
					return false;
				}
				result = (ushort)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<ushort>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out ushort result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<ushort>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out ushort result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IParseable<ushort>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<ushort>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out ushort result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IShiftOperators<ushort, ushort>.op_LeftShift(ushort value, int shiftAmount)
		{
			return (ushort)(value << shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IShiftOperators<ushort, ushort>.op_RightShift(ushort value, int shiftAmount)
		{
			return (ushort)(value >> shiftAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort ISpanParseable<ushort>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<ushort>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out ushort result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort ISubtractionOperators<ushort, ushort, ushort>.op_Subtraction(ushort left, ushort right)
		{
			return (ushort)(left - right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IUnaryNegationOperators<ushort, ushort>.op_UnaryNegation(ushort value)
		{
			return (ushort)(-value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ushort IUnaryPlusOperators<ushort, ushort>.op_UnaryPlus(ushort value)
		{
			return value;
		}
	}
	[Serializable]
	[CLSCompliant(false)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct UInt32 : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<uint>, IEquatable<uint>, IBinaryInteger<uint>, IBinaryNumber<uint>, IBitwiseOperators<uint, uint, uint>, INumber<uint>, IAdditionOperators<uint, uint, uint>, IAdditiveIdentity<uint, uint>, IComparisonOperators<uint, uint>, IEqualityOperators<uint, uint>, IDecrementOperators<uint>, IDivisionOperators<uint, uint, uint>, IIncrementOperators<uint>, IModulusOperators<uint, uint, uint>, IMultiplicativeIdentity<uint, uint>, IMultiplyOperators<uint, uint, uint>, ISpanParseable<uint>, IParseable<uint>, ISubtractionOperators<uint, uint, uint>, IUnaryNegationOperators<uint, uint>, IUnaryPlusOperators<uint, uint>, IShiftOperators<uint, uint>, IMinMaxValue<uint>, IUnsignedNumber<uint>
	{
		private readonly uint m_value;

		public const uint MaxValue = 4294967295u;

		public const uint MinValue = 0u;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IAdditiveIdentity<uint, uint>.AdditiveIdentity => 0u;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IMinMaxValue<uint>.MinValue => 0u;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IMinMaxValue<uint>.MaxValue => uint.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IMultiplicativeIdentity<uint, uint>.MultiplicativeIdentity => 1u;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.One => 1u;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Zero => 0u;

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is uint num)
			{
				if (this < num)
				{
					return -1;
				}
				if (this > num)
				{
					return 1;
				}
				return 0;
			}
			throw new ArgumentException(SR.Arg_MustBeUInt32);
		}

		public int CompareTo(uint value)
		{
			if (this < value)
			{
				return -1;
			}
			if (this > value)
			{
				return 1;
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is uint))
			{
				return false;
			}
			return this == (uint)obj;
		}

		[NonVersionable]
		public bool Equals(uint obj)
		{
			return this == obj;
		}

		public override int GetHashCode()
		{
			return (int)this;
		}

		public override string ToString()
		{
			return Number.UInt32ToDecStr(this);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.UInt32ToDecStr(this);
		}

		public string ToString(string? format)
		{
			return Number.FormatUInt32(this, format, null);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatUInt32(this, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatUInt32(this, format, provider, destination, out charsWritten);
		}

		public static uint Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseUInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
		}

		public static uint Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseUInt32(s, style, NumberFormatInfo.CurrentInfo);
		}

		public static uint Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseUInt32(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
		}

		public static uint Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseUInt32(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static uint Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Number.ParseUInt32(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out uint result)
		{
			if (s == null)
			{
				result = 0u;
				return false;
			}
			return Number.TryParseUInt32IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, out uint result)
		{
			return Number.TryParseUInt32IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out uint result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				result = 0u;
				return false;
			}
			return Number.TryParseUInt32(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out uint result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Number.TryParseUInt32(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.UInt32;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return this;
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "UInt32", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IAdditionOperators<uint, uint, uint>.op_Addition(uint left, uint right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBinaryInteger<uint>.LeadingZeroCount(uint value)
		{
			return (uint)BitOperations.LeadingZeroCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBinaryInteger<uint>.PopCount(uint value)
		{
			return (uint)BitOperations.PopCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBinaryInteger<uint>.RotateLeft(uint value, int rotateAmount)
		{
			return BitOperations.RotateLeft(value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBinaryInteger<uint>.RotateRight(uint value, int rotateAmount)
		{
			return BitOperations.RotateRight(value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBinaryInteger<uint>.TrailingZeroCount(uint value)
		{
			return (uint)BitOperations.TrailingZeroCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<uint>.IsPow2(uint value)
		{
			return BitOperations.IsPow2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBinaryNumber<uint>.Log2(uint value)
		{
			return (uint)BitOperations.Log2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBitwiseOperators<uint, uint, uint>.op_BitwiseAnd(uint left, uint right)
		{
			return left & right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBitwiseOperators<uint, uint, uint>.op_BitwiseOr(uint left, uint right)
		{
			return left | right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBitwiseOperators<uint, uint, uint>.op_ExclusiveOr(uint left, uint right)
		{
			return left ^ right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IBitwiseOperators<uint, uint, uint>.op_OnesComplement(uint value)
		{
			return ~value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<uint, uint>.op_LessThan(uint left, uint right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<uint, uint>.op_LessThanOrEqual(uint left, uint right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<uint, uint>.op_GreaterThan(uint left, uint right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<uint, uint>.op_GreaterThanOrEqual(uint left, uint right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IDecrementOperators<uint>.op_Decrement(uint value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IDivisionOperators<uint, uint, uint>.op_Division(uint left, uint right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<uint, uint>.op_Equality(uint left, uint right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<uint, uint>.op_Inequality(uint left, uint right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IIncrementOperators<uint>.op_Increment(uint value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IModulusOperators<uint, uint, uint>.op_Modulus(uint left, uint right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IMultiplyOperators<uint, uint, uint>.op_Multiply(uint left, uint right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Abs(uint value)
		{
			return value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Clamp(uint value, uint min, uint max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (uint)(decimal)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(double))
				{
					return (uint)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (uint)(short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (uint)(int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (uint)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (uint)(nint)(IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (uint)(sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (uint)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (uint)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (uint)(UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0u;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 4294967295m))
				{
					if (!(num < 0m))
					{
						return (uint)num;
					}
					return 0u;
				}
				return uint.MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 4294967295.0))
				{
					if (!(num2 < 0.0))
					{
						return (uint)num2;
					}
					return 0u;
				}
				return uint.MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 >= 0)
				{
					return (uint)num3;
				}
				return 0u;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 >= 0)
				{
					return (uint)num4;
				}
				return 0u;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 <= uint.MaxValue)
				{
					if (num5 >= 0)
					{
						return (uint)num5;
					}
					return 0u;
				}
				return uint.MaxValue;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr <= uint.MaxValue)
				{
					if ((nint)intPtr >= 0)
					{
						return (uint)(nint)intPtr;
					}
					return 0u;
				}
				return uint.MaxValue;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b >= 0)
				{
					return (uint)b;
				}
				return 0u;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (!(num6 > 4.2949673E+09f))
				{
					if (!(num6 < 0f))
					{
						return (uint)num6;
					}
					return 0u;
				}
				return uint.MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num7 = (ulong)(object)value;
				if (num7 <= uint.MaxValue)
				{
					return (uint)num7;
				}
				return uint.MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr <= uint.MaxValue)
				{
					return (uint)(nuint)uIntPtr;
				}
				return uint.MaxValue;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (uint)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (uint)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (uint)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (uint)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (uint)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (uint)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (uint)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (uint)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (uint)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (uint)(nuint)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0u;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (uint Quotient, uint Remainder) INumber<uint>.DivRem(uint left, uint right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Max(uint x, uint y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Min(uint x, uint y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint INumber<uint>.Sign(uint value)
		{
			if (value != 0)
			{
				return 1u;
			}
			return 0u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<uint>.TryCreate<TOther>(TOther value, out uint result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < 0m || num > 4294967295m)
				{
					result = 0u;
					return false;
				}
				result = (uint)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < 0.0 || num2 > 4294967295.0)
				{
					result = 0u;
					return false;
				}
				result = (uint)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 < 0)
				{
					result = 0u;
					return false;
				}
				result = (uint)num3;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 < 0)
				{
					result = 0u;
					return false;
				}
				result = (uint)num4;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 < 0 || num5 > uint.MaxValue)
				{
					result = 0u;
					return false;
				}
				result = (uint)num5;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < 0 || (nint)intPtr > uint.MaxValue)
				{
					result = 0u;
					return false;
				}
				result = (uint)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b < 0)
				{
					result = 0u;
					return false;
				}
				result = (uint)b;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (num6 < 0f || num6 > 4.2949673E+09f)
				{
					result = 0u;
					return false;
				}
				result = (uint)num6;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				result = (uint)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num7 = (ulong)(object)value;
				if (num7 > uint.MaxValue)
				{
					result = 0u;
					return false;
				}
				result = (uint)num7;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				UIntPtr uIntPtr = (UIntPtr)(object)value;
				if ((nuint)uIntPtr > uint.MaxValue)
				{
					result = 0u;
					return false;
				}
				result = (uint)(nuint)uIntPtr;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0u;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<uint>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out uint result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<uint>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out uint result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IParseable<uint>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<uint>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out uint result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IShiftOperators<uint, uint>.op_LeftShift(uint value, int shiftAmount)
		{
			return value << shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IShiftOperators<uint, uint>.op_RightShift(uint value, int shiftAmount)
		{
			return value >> shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint ISpanParseable<uint>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<uint>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out uint result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint ISubtractionOperators<uint, uint, uint>.op_Subtraction(uint left, uint right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IUnaryNegationOperators<uint, uint>.op_UnaryNegation(uint value)
		{
			return 0 - value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static uint IUnaryPlusOperators<uint, uint>.op_UnaryPlus(uint value)
		{
			return value;
		}
	}
	[Serializable]
	[CLSCompliant(false)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct UInt64 : IComparable, IConvertible, ISpanFormattable, IFormattable, IComparable<ulong>, IEquatable<ulong>, IBinaryInteger<ulong>, IBinaryNumber<ulong>, IBitwiseOperators<ulong, ulong, ulong>, INumber<ulong>, IAdditionOperators<ulong, ulong, ulong>, IAdditiveIdentity<ulong, ulong>, IComparisonOperators<ulong, ulong>, IEqualityOperators<ulong, ulong>, IDecrementOperators<ulong>, IDivisionOperators<ulong, ulong, ulong>, IIncrementOperators<ulong>, IModulusOperators<ulong, ulong, ulong>, IMultiplicativeIdentity<ulong, ulong>, IMultiplyOperators<ulong, ulong, ulong>, ISpanParseable<ulong>, IParseable<ulong>, ISubtractionOperators<ulong, ulong, ulong>, IUnaryNegationOperators<ulong, ulong>, IUnaryPlusOperators<ulong, ulong>, IShiftOperators<ulong, ulong>, IMinMaxValue<ulong>, IUnsignedNumber<ulong>
	{
		private readonly ulong m_value;

		public const ulong MaxValue = 18446744073709551615uL;

		public const ulong MinValue = 0uL;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IAdditiveIdentity<ulong, ulong>.AdditiveIdentity => 0uL;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IMinMaxValue<ulong>.MinValue => 0uL;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IMinMaxValue<ulong>.MaxValue => ulong.MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IMultiplicativeIdentity<ulong, ulong>.MultiplicativeIdentity => 1uL;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.One => 1uL;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Zero => 0uL;

		public int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is ulong num)
			{
				if (this < num)
				{
					return -1;
				}
				if (this > num)
				{
					return 1;
				}
				return 0;
			}
			throw new ArgumentException(SR.Arg_MustBeUInt64);
		}

		public int CompareTo(ulong value)
		{
			if (this < value)
			{
				return -1;
			}
			if (this > value)
			{
				return 1;
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is ulong))
			{
				return false;
			}
			return this == (ulong)obj;
		}

		[NonVersionable]
		public bool Equals(ulong obj)
		{
			return this == obj;
		}

		public override int GetHashCode()
		{
			return (int)this ^ (int)(this >> 32);
		}

		public override string ToString()
		{
			return Number.UInt64ToDecStr(this, -1);
		}

		public string ToString(IFormatProvider? provider)
		{
			return Number.UInt64ToDecStr(this, -1);
		}

		public string ToString(string? format)
		{
			return Number.FormatUInt64(this, format, null);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return Number.FormatUInt64(this, format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return Number.TryFormatUInt64(this, format, provider, destination, out charsWritten);
		}

		public static ulong Parse(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseUInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
		}

		public static ulong Parse(string s, NumberStyles style)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseUInt64(s, style, NumberFormatInfo.CurrentInfo);
		}

		public static ulong Parse(string s, IFormatProvider? provider)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseUInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
		}

		public static ulong Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return Number.ParseUInt64(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static ulong Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Number.ParseUInt64(s, style, NumberFormatInfo.GetInstance(provider));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out ulong result)
		{
			if (s == null)
			{
				result = 0uL;
				return false;
			}
			return Number.TryParseUInt64IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, out ulong result)
		{
			return Number.TryParseUInt64IntegerStyle(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out ulong result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			if (s == null)
			{
				result = 0uL;
				return false;
			}
			return Number.TryParseUInt64(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out ulong result)
		{
			NumberFormatInfo.ValidateParseStyleInteger(style);
			return Number.TryParseUInt64(s, style, NumberFormatInfo.GetInstance(provider), out result) == Number.ParsingStatus.OK;
		}

		public TypeCode GetTypeCode()
		{
			return TypeCode.UInt64;
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			return Convert.ToChar(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return this;
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return Convert.ToSingle(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "UInt64", "DateTime"));
		}

		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return Convert.DefaultToType(this, type, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IAdditionOperators<ulong, ulong, ulong>.op_Addition(ulong left, ulong right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBinaryInteger<ulong>.LeadingZeroCount(ulong value)
		{
			return (ulong)BitOperations.LeadingZeroCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBinaryInteger<ulong>.PopCount(ulong value)
		{
			return (ulong)BitOperations.PopCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBinaryInteger<ulong>.RotateLeft(ulong value, int rotateAmount)
		{
			return BitOperations.RotateLeft(value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBinaryInteger<ulong>.RotateRight(ulong value, int rotateAmount)
		{
			return BitOperations.RotateRight(value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBinaryInteger<ulong>.TrailingZeroCount(ulong value)
		{
			return (ulong)BitOperations.TrailingZeroCount(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<ulong>.IsPow2(ulong value)
		{
			return BitOperations.IsPow2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBinaryNumber<ulong>.Log2(ulong value)
		{
			return (ulong)BitOperations.Log2(value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBitwiseOperators<ulong, ulong, ulong>.op_BitwiseAnd(ulong left, ulong right)
		{
			return left & right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBitwiseOperators<ulong, ulong, ulong>.op_BitwiseOr(ulong left, ulong right)
		{
			return left | right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBitwiseOperators<ulong, ulong, ulong>.op_ExclusiveOr(ulong left, ulong right)
		{
			return left ^ right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IBitwiseOperators<ulong, ulong, ulong>.op_OnesComplement(ulong value)
		{
			return ~value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<ulong, ulong>.op_LessThan(ulong left, ulong right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<ulong, ulong>.op_LessThanOrEqual(ulong left, ulong right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<ulong, ulong>.op_GreaterThan(ulong left, ulong right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<ulong, ulong>.op_GreaterThanOrEqual(ulong left, ulong right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IDecrementOperators<ulong>.op_Decrement(ulong value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IDivisionOperators<ulong, ulong, ulong>.op_Division(ulong left, ulong right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<ulong, ulong>.op_Equality(ulong left, ulong right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<ulong, ulong>.op_Inequality(ulong left, ulong right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IIncrementOperators<ulong>.op_Increment(ulong value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IModulusOperators<ulong, ulong, ulong>.op_Modulus(ulong left, ulong right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IMultiplyOperators<ulong, ulong, ulong>.op_Multiply(ulong left, ulong right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Abs(ulong value)
		{
			return value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Clamp(ulong value, ulong min, ulong max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (ulong)(decimal)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(double))
				{
					return (ulong)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (ulong)(short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (ulong)(int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (ulong)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (ulong)(nint)(IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (ulong)(sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (ulong)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (ulong)(object)value;
				}
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (ulong)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0uL;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > 18446744073709551615m))
				{
					if (!(num < 0m))
					{
						return (ulong)num;
					}
					return 0uL;
				}
				return ulong.MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > 1.8446744073709552E+19))
				{
					if (!(num2 < 0.0))
					{
						return (ulong)num2;
					}
					return 0uL;
				}
				return ulong.MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 >= 0)
				{
					return (ulong)num3;
				}
				return 0uL;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 >= 0)
				{
					return (ulong)num4;
				}
				return 0uL;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 >= 0)
				{
					return (ulong)num5;
				}
				return 0uL;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr >= 0)
				{
					return (ulong)(nint)intPtr;
				}
				return 0uL;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b >= 0)
				{
					return (ulong)b;
				}
				return 0uL;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (!(num6 > 1.8446744E+19f))
				{
					if (!(num6 < 0f))
					{
						return (ulong)num6;
					}
					return 0uL;
				}
				return ulong.MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (ulong)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0uL;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (ulong)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (ulong)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (ulong)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (ulong)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (ulong)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (ulong)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (ulong)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (ulong)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (ulong)(UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0uL;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (ulong Quotient, ulong Remainder) INumber<ulong>.DivRem(ulong left, ulong right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Max(ulong x, ulong y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Min(ulong x, ulong y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong INumber<ulong>.Sign(ulong value)
		{
			return (ulong)((value != 0L) ? 1 : 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<ulong>.TryCreate<TOther>(TOther value, out ulong result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < 0m || num > 18446744073709551615m)
				{
					result = 0uL;
					return false;
				}
				result = (ulong)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < 0.0 || num2 > 1.8446744073709552E+19)
				{
					result = 0uL;
					return false;
				}
				result = (ulong)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 < 0)
				{
					result = 0uL;
					return false;
				}
				result = (ulong)num3;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 < 0)
				{
					result = 0uL;
					return false;
				}
				result = (ulong)num4;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 < 0)
				{
					result = 0uL;
					return false;
				}
				result = (ulong)num5;
				return true;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < 0)
				{
					result = 0uL;
					return false;
				}
				result = (ulong)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b < 0)
				{
					result = 0uL;
					return false;
				}
				result = (ulong)b;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (num6 < 0f || num6 > 1.8446744E+19f)
				{
					result = 0uL;
					return false;
				}
				result = (ulong)num6;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				result = (uint)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				result = (ulong)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				result = (ulong)(UIntPtr)(object)value;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0uL;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<ulong>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out ulong result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<ulong>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out ulong result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IParseable<ulong>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<ulong>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out ulong result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IShiftOperators<ulong, ulong>.op_LeftShift(ulong value, int shiftAmount)
		{
			return value << shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IShiftOperators<ulong, ulong>.op_RightShift(ulong value, int shiftAmount)
		{
			return value >> shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong ISpanParseable<ulong>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<ulong>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out ulong result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong ISubtractionOperators<ulong, ulong, ulong>.op_Subtraction(ulong left, ulong right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IUnaryNegationOperators<ulong, ulong>.op_UnaryNegation(ulong value)
		{
			return 0 - value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static ulong IUnaryPlusOperators<ulong, ulong>.op_UnaryPlus(ulong value)
		{
			return value;
		}
	}
	[Serializable]
	[CLSCompliant(false)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct UIntPtr : IEquatable<nuint>, IComparable, IComparable<nuint>, ISpanFormattable, IFormattable, ISerializable, IBinaryInteger<nuint>, IBinaryNumber<nuint>, IBitwiseOperators<nuint, nuint, nuint>, INumber<nuint>, IAdditionOperators<nuint, nuint, nuint>, IAdditiveIdentity<nuint, nuint>, IComparisonOperators<nuint, nuint>, IEqualityOperators<nuint, nuint>, IDecrementOperators<nuint>, IDivisionOperators<nuint, nuint, nuint>, IIncrementOperators<nuint>, IModulusOperators<nuint, nuint, nuint>, IMultiplicativeIdentity<nuint, nuint>, IMultiplyOperators<nuint, nuint, nuint>, ISpanParseable<nuint>, IParseable<nuint>, ISubtractionOperators<nuint, nuint, nuint>, IUnaryNegationOperators<nuint, nuint>, IUnaryPlusOperators<nuint, nuint>, IShiftOperators<nuint, nuint>, IMinMaxValue<nuint>, IUnsignedNumber<nuint>
	{
		private unsafe readonly void* _value;

		[Intrinsic]
		public static readonly UIntPtr Zero;

		public static int Size
		{
			[NonVersionable]
			get
			{
				return 4;
			}
		}

		public static UIntPtr MaxValue
		{
			[NonVersionable]
			get
			{
				return (UIntPtr)uint.MaxValue;
			}
		}

		public static UIntPtr MinValue
		{
			[NonVersionable]
			get
			{
				return (UIntPtr)0u;
			}
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IAdditiveIdentity<UIntPtr, UIntPtr>.AdditiveIdentity => 0u;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IMinMaxValue<UIntPtr>.MinValue => MinValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IMinMaxValue<UIntPtr>.MaxValue => MaxValue;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IMultiplicativeIdentity<UIntPtr, UIntPtr>.MultiplicativeIdentity => 1u;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.One => 1u;

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Zero => 0u;

		[NonVersionable]
		public unsafe UIntPtr(uint value)
		{
			_value = (void*)value;
		}

		[NonVersionable]
		public unsafe UIntPtr(ulong value)
		{
			_value = (void*)checked((uint)value);
		}

		[NonVersionable]
		public unsafe UIntPtr(void* value)
		{
			_value = value;
		}

		private unsafe UIntPtr(SerializationInfo info, StreamingContext context)
		{
			ulong uInt = info.GetUInt64("value");
			_ = Size;
			if (uInt > uint.MaxValue)
			{
				throw new ArgumentException(SR.Serialization_InvalidPtrValue);
			}
			_value = (void*)uInt;
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("value", ToUInt64());
		}

		public unsafe override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is UIntPtr)
			{
				return _value == ((UIntPtr)obj)._value;
			}
			return false;
		}

		public unsafe override int GetHashCode()
		{
			return (int)_value;
		}

		[NonVersionable]
		public unsafe uint ToUInt32()
		{
			return (uint)_value;
		}

		[NonVersionable]
		public unsafe ulong ToUInt64()
		{
			return (ulong)_value;
		}

		[NonVersionable]
		public static explicit operator UIntPtr(uint value)
		{
			return new UIntPtr(value);
		}

		[NonVersionable]
		public static explicit operator UIntPtr(ulong value)
		{
			return new UIntPtr(value);
		}

		[NonVersionable]
		public unsafe static explicit operator UIntPtr(void* value)
		{
			return new UIntPtr(value);
		}

		[NonVersionable]
		public unsafe static explicit operator void*(UIntPtr value)
		{
			return value._value;
		}

		[NonVersionable]
		public unsafe static explicit operator uint(UIntPtr value)
		{
			return (uint)value._value;
		}

		[NonVersionable]
		public unsafe static explicit operator ulong(UIntPtr value)
		{
			return (ulong)value._value;
		}

		[NonVersionable]
		public unsafe static bool operator ==(UIntPtr value1, UIntPtr value2)
		{
			return value1._value == value2._value;
		}

		[NonVersionable]
		public unsafe static bool operator !=(UIntPtr value1, UIntPtr value2)
		{
			return value1._value != value2._value;
		}

		[NonVersionable]
		public static UIntPtr Add(UIntPtr pointer, int offset)
		{
			return pointer + offset;
		}

		[NonVersionable]
		public unsafe static UIntPtr operator +(UIntPtr pointer, int offset)
		{
			return (UIntPtr)((byte*)pointer._value + offset);
		}

		[NonVersionable]
		public static UIntPtr Subtract(UIntPtr pointer, int offset)
		{
			return pointer - offset;
		}

		[NonVersionable]
		public unsafe static UIntPtr operator -(UIntPtr pointer, int offset)
		{
			return (UIntPtr)((byte*)pointer._value - offset);
		}

		[NonVersionable]
		public unsafe void* ToPointer()
		{
			return _value;
		}

		public unsafe int CompareTo(object? value)
		{
			if (value == null)
			{
				return 1;
			}
			if (value is UIntPtr uIntPtr)
			{
				if ((nuint)_value < (nuint)uIntPtr)
				{
					return -1;
				}
				if ((nuint)_value > (nuint)uIntPtr)
				{
					return 1;
				}
				return 0;
			}
			throw new ArgumentException(SR.Arg_MustBeUIntPtr);
		}

		public unsafe int CompareTo(UIntPtr value)
		{
			return ((uint)_value).CompareTo((uint)value);
		}

		[NonVersionable]
		public unsafe bool Equals(UIntPtr other)
		{
			return _value == (void*)other;
		}

		public unsafe override string ToString()
		{
			return ((uint)_value).ToString();
		}

		public unsafe string ToString(string? format)
		{
			return ((uint)_value).ToString(format);
		}

		public unsafe string ToString(IFormatProvider? provider)
		{
			return ((uint)_value).ToString(provider);
		}

		public unsafe string ToString(string? format, IFormatProvider? provider)
		{
			return ((uint)_value).ToString(format, provider);
		}

		public unsafe bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return ((uint)_value).TryFormat(destination, out charsWritten, format, provider);
		}

		public static UIntPtr Parse(string s)
		{
			return (UIntPtr)uint.Parse(s);
		}

		public static UIntPtr Parse(string s, NumberStyles style)
		{
			return (UIntPtr)uint.Parse(s, style);
		}

		public static UIntPtr Parse(string s, IFormatProvider? provider)
		{
			return (UIntPtr)uint.Parse(s, provider);
		}

		public static UIntPtr Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			return (UIntPtr)uint.Parse(s, style, provider);
		}

		public static UIntPtr Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
		{
			return (UIntPtr)uint.Parse(s, style, provider);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out UIntPtr result)
		{
			Unsafe.SkipInit<UIntPtr>(out result);
			return uint.TryParse(s, out Unsafe.As<UIntPtr, uint>(ref result));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out UIntPtr result)
		{
			Unsafe.SkipInit<UIntPtr>(out result);
			return uint.TryParse(s, style, provider, out Unsafe.As<UIntPtr, uint>(ref result));
		}

		public static bool TryParse(ReadOnlySpan<char> s, out UIntPtr result)
		{
			Unsafe.SkipInit<UIntPtr>(out result);
			return uint.TryParse(s, out Unsafe.As<UIntPtr, uint>(ref result));
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out UIntPtr result)
		{
			Unsafe.SkipInit<UIntPtr>(out result);
			return uint.TryParse(s, style, provider, out Unsafe.As<UIntPtr, uint>(ref result));
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IAdditionOperators<UIntPtr, UIntPtr, UIntPtr>.op_Addition(nuint left, nuint right)
		{
			return left + right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBinaryInteger<UIntPtr>.LeadingZeroCount(nuint value)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return (nuint)BitOperations.LeadingZeroCount((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBinaryInteger<UIntPtr>.PopCount(nuint value)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return (nuint)BitOperations.PopCount((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBinaryInteger<UIntPtr>.RotateLeft(nuint value, int rotateAmount)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return BitOperations.RotateLeft((uint)value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBinaryInteger<UIntPtr>.RotateRight(nuint value, int rotateAmount)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return BitOperations.RotateRight((uint)value, rotateAmount);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBinaryInteger<UIntPtr>.TrailingZeroCount(nuint value)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return (nuint)BitOperations.TrailingZeroCount((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IBinaryNumber<UIntPtr>.IsPow2(nuint value)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return BitOperations.IsPow2((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBinaryNumber<UIntPtr>.Log2(nuint value)
		{
			if (Environment.Is64BitProcess)
			{
			}
			return (nuint)BitOperations.Log2((uint)value);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBitwiseOperators<UIntPtr, UIntPtr, UIntPtr>.op_BitwiseAnd(nuint left, nuint right)
		{
			return left & right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBitwiseOperators<UIntPtr, UIntPtr, UIntPtr>.op_BitwiseOr(nuint left, nuint right)
		{
			return left | right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBitwiseOperators<UIntPtr, UIntPtr, UIntPtr>.op_ExclusiveOr(nuint left, nuint right)
		{
			return left ^ right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IBitwiseOperators<UIntPtr, UIntPtr, UIntPtr>.op_OnesComplement(nuint value)
		{
			return ~value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<UIntPtr, UIntPtr>.op_LessThan(nuint left, nuint right)
		{
			return left < right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<UIntPtr, UIntPtr>.op_LessThanOrEqual(nuint left, nuint right)
		{
			return left <= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<UIntPtr, UIntPtr>.op_GreaterThan(nuint left, nuint right)
		{
			return left > right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IComparisonOperators<UIntPtr, UIntPtr>.op_GreaterThanOrEqual(nuint left, nuint right)
		{
			return left >= right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IDecrementOperators<UIntPtr>.op_Decrement(nuint value)
		{
			return --value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IDivisionOperators<UIntPtr, UIntPtr, UIntPtr>.op_Division(nuint left, nuint right)
		{
			return left / right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<UIntPtr, UIntPtr>.op_Equality(nuint left, nuint right)
		{
			return left == right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IEqualityOperators<UIntPtr, UIntPtr>.op_Inequality(nuint left, nuint right)
		{
			return left != right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IIncrementOperators<UIntPtr>.op_Increment(nuint value)
		{
			return ++value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IModulusOperators<UIntPtr, UIntPtr, UIntPtr>.op_Modulus(nuint left, nuint right)
		{
			return left % right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IMultiplyOperators<UIntPtr, UIntPtr, UIntPtr>.op_Multiply(nuint left, nuint right)
		{
			return left * right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Abs(nuint value)
		{
			return value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Clamp(nuint value, nuint min, nuint max)
		{
			return Math.Clamp(value, min, max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Create<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			checked
			{
				if (typeof(TOther) == typeof(decimal))
				{
					return (nuint)(ulong)(decimal)(object)value;
				}
				if (typeof(TOther) == typeof(double))
				{
					return (nuint)(double)(object)value;
				}
				if (typeof(TOther) == typeof(short))
				{
					return (nuint)(short)(object)value;
				}
				if (typeof(TOther) == typeof(int))
				{
					return (nuint)(int)(object)value;
				}
				if (typeof(TOther) == typeof(long))
				{
					return (nuint)(long)(object)value;
				}
				if (typeof(TOther) == typeof(IntPtr))
				{
					return (nuint)(nint)(IntPtr)(object)value;
				}
				if (typeof(TOther) == typeof(sbyte))
				{
					return (nuint)(sbyte)(object)value;
				}
				if (typeof(TOther) == typeof(float))
				{
					return (nuint)(float)(object)value;
				}
				if (typeof(TOther) == typeof(ushort))
				{
					return (ushort)(object)value;
				}
				if (typeof(TOther) == typeof(uint))
				{
					return (uint)(object)value;
				}
				if (typeof(TOther) == typeof(ulong))
				{
					return (nuint)(ulong)(object)value;
				}
				if (typeof(TOther) == typeof(UIntPtr))
				{
					return (UIntPtr)(object)value;
				}
				ThrowHelper.ThrowNotSupportedException();
				return 0u;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.CreateSaturating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (!(num > (decimal)(ulong)MaxValue))
				{
					if (!(num < 0m))
					{
						return (nuint)(ulong)num;
					}
					return MinValue;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (!(num2 > (double)(nint)(nuint)MaxValue))
				{
					if (!(num2 < 0.0))
					{
						return (nuint)num2;
					}
					return MinValue;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 >= 0)
				{
					return (nuint)num3;
				}
				return MinValue;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 >= 0)
				{
					return (nuint)num4;
				}
				return MinValue;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				_ = Size;
				if (num5 <= uint.MaxValue)
				{
					if (num5 >= 0)
					{
						return (nuint)num5;
					}
					return MinValue;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr >= 0)
				{
					return (nuint)(nint)intPtr;
				}
				return MinValue;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b >= 0)
				{
					return (nuint)b;
				}
				return MinValue;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (!(num6 > (float)(nint)(nuint)MaxValue))
				{
					if (!(num6 < 0f))
					{
						return (nuint)num6;
					}
					return MinValue;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num7 = (ulong)(object)value;
				if (num7 <= (nuint)MaxValue)
				{
					return (nuint)num7;
				}
				return MaxValue;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.CreateTruncating<TOther>(TOther value)
		{
			if (typeof(TOther) == typeof(byte))
			{
				return (byte)(object)value;
			}
			if (typeof(TOther) == typeof(char))
			{
				return (char)(object)value;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				return (nuint)(ulong)(decimal)(object)value;
			}
			if (typeof(TOther) == typeof(double))
			{
				return (nuint)(double)(object)value;
			}
			if (typeof(TOther) == typeof(short))
			{
				return (nuint)(short)(object)value;
			}
			if (typeof(TOther) == typeof(int))
			{
				return (nuint)(int)(object)value;
			}
			if (typeof(TOther) == typeof(long))
			{
				return (nuint)(long)(object)value;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				return (nuint)(nint)(IntPtr)(object)value;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				return (nuint)(sbyte)(object)value;
			}
			if (typeof(TOther) == typeof(float))
			{
				return (nuint)(float)(object)value;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				return (ushort)(object)value;
			}
			if (typeof(TOther) == typeof(uint))
			{
				return (uint)(object)value;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				return (nuint)(ulong)(object)value;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				return (UIntPtr)(object)value;
			}
			ThrowHelper.ThrowNotSupportedException();
			return 0u;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static (nuint Quotient, nuint Remainder) INumber<UIntPtr>.DivRem(nuint left, nuint right)
		{
			return Math.DivRem(left, right);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Max(nuint x, nuint y)
		{
			return Math.Max(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Min(nuint x, nuint y)
		{
			return Math.Min(x, y);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider)
		{
			return Parse(s, style, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint INumber<UIntPtr>.Sign(nuint value)
		{
			return (nuint)(int)((value != 0) ? 1u : 0u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<UIntPtr>.TryCreate<TOther>(TOther value, out nuint result)
		{
			if (typeof(TOther) == typeof(byte))
			{
				result = (byte)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(char))
			{
				result = (char)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(decimal))
			{
				decimal num = (decimal)(object)value;
				if (num < 0m || num > (decimal)(ulong)MaxValue)
				{
					result = 0u;
					return false;
				}
				result = (nuint)(ulong)num;
				return true;
			}
			if (typeof(TOther) == typeof(double))
			{
				double num2 = (double)(object)value;
				if (num2 < 0.0 || num2 > (double)(nint)(nuint)MaxValue)
				{
					result = 0u;
					return false;
				}
				result = (nuint)num2;
				return true;
			}
			if (typeof(TOther) == typeof(short))
			{
				short num3 = (short)(object)value;
				if (num3 < 0)
				{
					result = 0u;
					return false;
				}
				result = (nuint)num3;
				return true;
			}
			if (typeof(TOther) == typeof(int))
			{
				int num4 = (int)(object)value;
				if (num4 < 0)
				{
					result = 0u;
					return false;
				}
				result = (nuint)num4;
				return true;
			}
			if (typeof(TOther) == typeof(long))
			{
				long num5 = (long)(object)value;
				if (num5 >= 0)
				{
					_ = Size;
					if (num5 <= uint.MaxValue)
					{
						result = (nuint)num5;
						return true;
					}
				}
				result = 0u;
				return false;
			}
			if (typeof(TOther) == typeof(IntPtr))
			{
				IntPtr intPtr = (IntPtr)(object)value;
				if ((nint)intPtr < 0)
				{
					result = 0u;
					return false;
				}
				result = (nuint)(nint)intPtr;
				return true;
			}
			if (typeof(TOther) == typeof(sbyte))
			{
				sbyte b = (sbyte)(object)value;
				if (b < 0)
				{
					result = 0u;
					return false;
				}
				result = (nuint)b;
				return true;
			}
			if (typeof(TOther) == typeof(float))
			{
				float num6 = (float)(object)value;
				if (num6 < 0f || num6 > (float)(nint)(nuint)MaxValue)
				{
					result = 0u;
					return false;
				}
				result = (nuint)num6;
				return true;
			}
			if (typeof(TOther) == typeof(ushort))
			{
				result = (ushort)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(uint))
			{
				result = (uint)(object)value;
				return true;
			}
			if (typeof(TOther) == typeof(ulong))
			{
				ulong num7 = (ulong)(object)value;
				if (num7 > (nuint)MaxValue)
				{
					result = 0u;
					return false;
				}
				result = (nuint)num7;
				return true;
			}
			if (typeof(TOther) == typeof(UIntPtr))
			{
				result = (UIntPtr)(object)value;
				return true;
			}
			ThrowHelper.ThrowNotSupportedException();
			result = 0u;
			return false;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<UIntPtr>.TryParse([NotNullWhen(true)] string s, NumberStyles style, IFormatProvider provider, out nuint result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool INumber<UIntPtr>.TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out nuint result)
		{
			return TryParse(s, style, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IParseable<UIntPtr>.Parse(string s, IFormatProvider provider)
		{
			return Parse(s, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool IParseable<UIntPtr>.TryParse([NotNullWhen(true)] string s, IFormatProvider provider, out nuint result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IShiftOperators<UIntPtr, UIntPtr>.op_LeftShift(nuint value, int shiftAmount)
		{
			return value << shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IShiftOperators<UIntPtr, UIntPtr>.op_RightShift(nuint value, int shiftAmount)
		{
			return value >> shiftAmount;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint ISpanParseable<UIntPtr>.Parse(ReadOnlySpan<char> s, IFormatProvider provider)
		{
			return Parse(s, NumberStyles.Integer, provider);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static bool ISpanParseable<UIntPtr>.TryParse(ReadOnlySpan<char> s, IFormatProvider provider, out nuint result)
		{
			return TryParse(s, NumberStyles.Integer, provider, out result);
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint ISubtractionOperators<UIntPtr, UIntPtr, UIntPtr>.op_Subtraction(nuint left, nuint right)
		{
			return left - right;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IUnaryNegationOperators<UIntPtr, UIntPtr>.op_UnaryNegation(nuint value)
		{
			return 0 - value;
		}

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		static nuint IUnaryPlusOperators<UIntPtr, UIntPtr>.op_UnaryPlus(nuint value)
		{
			return value;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class UnauthorizedAccessException : SystemException
	{
		public UnauthorizedAccessException()
			: base(SR.Arg_UnauthorizedAccessException)
		{
			base.HResult = -2147024891;
		}

		public UnauthorizedAccessException(string? message)
			: base(message)
		{
			base.HResult = -2147024891;
		}

		public UnauthorizedAccessException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147024891;
		}

		protected UnauthorizedAccessException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public class UnhandledExceptionEventArgs : EventArgs
	{
		private readonly object _exception;

		private readonly bool _isTerminating;

		public object ExceptionObject => _exception;

		public bool IsTerminating => _isTerminating;

		public UnhandledExceptionEventArgs(object exception, bool isTerminating)
		{
			_exception = exception;
			_isTerminating = isTerminating;
		}
	}
	public delegate void UnhandledExceptionEventHandler(object sender, UnhandledExceptionEventArgs e);
	[Serializable]
	public sealed class UnitySerializationHolder : ISerializable, IObjectReference
	{
		private readonly int _unityType;

		private readonly string _data;

		internal static void GetUnitySerializationInfo(SerializationInfo info, int unityType)
		{
			info.SetType(typeof(UnitySerializationHolder));
			info.AddValue("Data", null, typeof(string));
			info.AddValue("UnityType", unityType);
			info.AddValue("AssemblyName", string.Empty);
		}

		public UnitySerializationHolder(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_unityType = info.GetInt32("UnityType");
			_data = info.GetString("Data");
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new NotSupportedException(SR.NotSupported_UnitySerHolder);
		}

		public object GetRealObject(StreamingContext context)
		{
			if (_unityType != 2)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidUnity, _data ?? "UnityType"));
			}
			return DBNull.Value;
		}
	}
	internal interface IValueTupleInternal : ITuple
	{
		int GetHashCode(IEqualityComparer comparer);

		string ToStringEnd();
	}
	[Serializable]
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple : IEquatable<ValueTuple>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple>, IValueTupleInternal, ITuple
	{
		int ITuple.Length => 0;

		object? ITuple.this[int index]
		{
			get
			{
				throw new IndexOutOfRangeException();
			}
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return obj is ValueTuple;
		}

		public bool Equals(ValueTuple other)
		{
			return true;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			return other is ValueTuple;
		}

		int IComparable.CompareTo(object other)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is ValueTuple))
			{
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 0;
		}

		public int CompareTo(ValueTuple other)
		{
			return 0;
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other == null)
			{
				return 1;
			}
			if (!(other is ValueTuple))
			{
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 0;
		}

		public override int GetHashCode()
		{
			return 0;
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return 0;
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return 0;
		}

		public override string ToString()
		{
			return "()";
		}

		string IValueTupleInternal.ToStringEnd()
		{
			return ")";
		}

		public static ValueTuple Create()
		{
			return default(ValueTuple);
		}

		public static ValueTuple<T1> Create<T1>(T1 item1)
		{
			return new ValueTuple<T1>(item1);
		}

		public static (T1, T2) Create<T1, T2>(T1 item1, T2 item2)
		{
			return (item1, item2);
		}

		public static (T1, T2, T3) Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
		{
			return (item1, item2, item3);
		}

		public static (T1, T2, T3, T4) Create<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4)
		{
			return (item1, item2, item3, item4);
		}

		public static (T1, T2, T3, T4, T5) Create<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
		{
			return (item1, item2, item3, item4, item5);
		}

		public static (T1, T2, T3, T4, T5, T6) Create<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
		{
			return (item1, item2, item3, item4, item5, item6);
		}

		public static (T1, T2, T3, T4, T5, T6, T7) Create<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
		{
			return (item1, item2, item3, item4, item5, item6, item7);
		}

		public static (T1, T2, T3, T4, T5, T6, T7, T8) Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8)
		{
			return new ValueTuple<T1, T2, T3, T4, T5, T6, T7, ValueTuple<T8>>(item1, item2, item3, item4, item5, item6, item7, Create(item8));
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple<T1> : IEquatable<ValueTuple<T1>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1>>, IValueTupleInternal, ITuple
	{
		public T1 Item1;

		int ITuple.Length => 1;

		object? ITuple.this[int index]
		{
			get
			{
				if (index != 0)
				{
					throw new IndexOutOfRangeException();
				}
				return Item1;
			}
		}

		public ValueTuple(T1 item1)
		{
			Item1 = item1;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is ValueTuple<T1> other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(ValueTuple<T1> other)
		{
			return EqualityComparer<T1>.Default.Equals(Item1, other.Item1);
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other is ValueTuple<T1> valueTuple)
			{
				return comparer.Equals(Item1, valueTuple.Item1);
			}
			return false;
		}

		int IComparable.CompareTo(object other)
		{
			if (other != null)
			{
				if (other is ValueTuple<T1> valueTuple)
				{
					return Comparer<T1>.Default.Compare(Item1, valueTuple.Item1);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public int CompareTo(ValueTuple<T1> other)
		{
			return Comparer<T1>.Default.Compare(Item1, other.Item1);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other != null)
			{
				if (other is ValueTuple<T1> valueTuple)
				{
					return comparer.Compare(Item1, valueTuple.Item1);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public override int GetHashCode()
		{
			return Item1?.GetHashCode() ?? 0;
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return comparer.GetHashCode(Item1);
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return comparer.GetHashCode(Item1);
		}

		public override string ToString()
		{
			return "(" + Item1?.ToString() + ")";
		}

		string IValueTupleInternal.ToStringEnd()
		{
			return Item1?.ToString() + ")";
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple<T1, T2> : IEquatable<(T1, T2)>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<(T1, T2)>, IValueTupleInternal, ITuple
	{
		public T1 Item1;

		public T2 Item2;

		int ITuple.Length => 2;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public ValueTuple(T1 item1, T2 item2)
		{
			Item1 = item1;
			Item2 = item2;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is (T1, T2) other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals((T1, T2) other)
		{
			if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1))
			{
				return EqualityComparer<T2>.Default.Equals(Item2, other.Item2);
			}
			return false;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other is (T1, T2) tuple && comparer.Equals(Item1, tuple.Item1))
			{
				return comparer.Equals(Item2, tuple.Item2);
			}
			return false;
		}

		int IComparable.CompareTo(object other)
		{
			if (other != null)
			{
				if (other is (T1, T2) other2)
				{
					return CompareTo(other2);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public int CompareTo((T1, T2) other)
		{
			int num = Comparer<T1>.Default.Compare(Item1, other.Item1);
			if (num != 0)
			{
				return num;
			}
			return Comparer<T2>.Default.Compare(Item2, other.Item2);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other != null)
			{
				if (other is (T1, T2) tuple)
				{
					int num = comparer.Compare(Item1, tuple.Item1);
					if (num != 0)
					{
						return num;
					}
					return comparer.Compare(Item2, tuple.Item2);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Item1?.GetHashCode() ?? 0, Item2?.GetHashCode() ?? 0);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		private int GetHashCodeCore(IEqualityComparer comparer)
		{
			return HashCode.Combine(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2));
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		public override string ToString()
		{
			return "(" + Item1?.ToString() + ", " + Item2?.ToString() + ")";
		}

		string IValueTupleInternal.ToStringEnd()
		{
			return Item1?.ToString() + ", " + Item2?.ToString() + ")";
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple<T1, T2, T3> : IEquatable<(T1, T2, T3)>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<(T1, T2, T3)>, IValueTupleInternal, ITuple
	{
		public T1 Item1;

		public T2 Item2;

		public T3 Item3;

		int ITuple.Length => 3;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public ValueTuple(T1 item1, T2 item2, T3 item3)
		{
			Item1 = item1;
			Item2 = item2;
			Item3 = item3;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is (T1, T2, T3) other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals((T1, T2, T3) other)
		{
			if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2))
			{
				return EqualityComparer<T3>.Default.Equals(Item3, other.Item3);
			}
			return false;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other is (T1, T2, T3) tuple && comparer.Equals(Item1, tuple.Item1) && comparer.Equals(Item2, tuple.Item2))
			{
				return comparer.Equals(Item3, tuple.Item3);
			}
			return false;
		}

		int IComparable.CompareTo(object other)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3) other2)
				{
					return CompareTo(other2);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public int CompareTo((T1, T2, T3) other)
		{
			int num = Comparer<T1>.Default.Compare(Item1, other.Item1);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T2>.Default.Compare(Item2, other.Item2);
			if (num != 0)
			{
				return num;
			}
			return Comparer<T3>.Default.Compare(Item3, other.Item3);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3) tuple)
				{
					int num = comparer.Compare(Item1, tuple.Item1);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item2, tuple.Item2);
					if (num != 0)
					{
						return num;
					}
					return comparer.Compare(Item3, tuple.Item3);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Item1?.GetHashCode() ?? 0, Item2?.GetHashCode() ?? 0, Item3?.GetHashCode() ?? 0);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		private int GetHashCodeCore(IEqualityComparer comparer)
		{
			return HashCode.Combine(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3));
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		public override string ToString()
		{
			return "(" + Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ")";
		}

		string IValueTupleInternal.ToStringEnd()
		{
			return Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ")";
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple<T1, T2, T3, T4> : IEquatable<(T1, T2, T3, T4)>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<(T1, T2, T3, T4)>, IValueTupleInternal, ITuple
	{
		public T1 Item1;

		public T2 Item2;

		public T3 Item3;

		public T4 Item4;

		int ITuple.Length => 4;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4)
		{
			Item1 = item1;
			Item2 = item2;
			Item3 = item3;
			Item4 = item4;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is (T1, T2, T3, T4) other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals((T1, T2, T3, T4) other)
		{
			if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3))
			{
				return EqualityComparer<T4>.Default.Equals(Item4, other.Item4);
			}
			return false;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other is (T1, T2, T3, T4) tuple && comparer.Equals(Item1, tuple.Item1) && comparer.Equals(Item2, tuple.Item2) && comparer.Equals(Item3, tuple.Item3))
			{
				return comparer.Equals(Item4, tuple.Item4);
			}
			return false;
		}

		int IComparable.CompareTo(object other)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3, T4) other2)
				{
					return CompareTo(other2);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public int CompareTo((T1, T2, T3, T4) other)
		{
			int num = Comparer<T1>.Default.Compare(Item1, other.Item1);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T2>.Default.Compare(Item2, other.Item2);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T3>.Default.Compare(Item3, other.Item3);
			if (num != 0)
			{
				return num;
			}
			return Comparer<T4>.Default.Compare(Item4, other.Item4);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3, T4) tuple)
				{
					int num = comparer.Compare(Item1, tuple.Item1);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item2, tuple.Item2);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item3, tuple.Item3);
					if (num != 0)
					{
						return num;
					}
					return comparer.Compare(Item4, tuple.Item4);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Item1?.GetHashCode() ?? 0, Item2?.GetHashCode() ?? 0, Item3?.GetHashCode() ?? 0, Item4?.GetHashCode() ?? 0);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		private int GetHashCodeCore(IEqualityComparer comparer)
		{
			return HashCode.Combine(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3), comparer.GetHashCode(Item4));
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		public override string ToString()
		{
			return "(" + Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ", " + Item4?.ToString() + ")";
		}

		string IValueTupleInternal.ToStringEnd()
		{
			return Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ", " + Item4?.ToString() + ")";
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple<T1, T2, T3, T4, T5> : IEquatable<(T1, T2, T3, T4, T5)>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<(T1, T2, T3, T4, T5)>, IValueTupleInternal, ITuple
	{
		public T1 Item1;

		public T2 Item2;

		public T3 Item3;

		public T4 Item4;

		public T5 Item5;

		int ITuple.Length => 5;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			4 => Item5, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
		{
			Item1 = item1;
			Item2 = item2;
			Item3 = item3;
			Item4 = item4;
			Item5 = item5;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is (T1, T2, T3, T4, T5) other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals((T1, T2, T3, T4, T5) other)
		{
			if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3) && EqualityComparer<T4>.Default.Equals(Item4, other.Item4))
			{
				return EqualityComparer<T5>.Default.Equals(Item5, other.Item5);
			}
			return false;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other is (T1, T2, T3, T4, T5) tuple && comparer.Equals(Item1, tuple.Item1) && comparer.Equals(Item2, tuple.Item2) && comparer.Equals(Item3, tuple.Item3))
			{
				return comparer.Equals(Item5, tuple.Item5);
			}
			return false;
		}

		int IComparable.CompareTo(object other)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3, T4, T5) other2)
				{
					return CompareTo(other2);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public int CompareTo((T1, T2, T3, T4, T5) other)
		{
			int num = Comparer<T1>.Default.Compare(Item1, other.Item1);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T2>.Default.Compare(Item2, other.Item2);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T3>.Default.Compare(Item3, other.Item3);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T4>.Default.Compare(Item4, other.Item4);
			if (num != 0)
			{
				return num;
			}
			return Comparer<T5>.Default.Compare(Item5, other.Item5);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3, T4, T5) tuple)
				{
					int num = comparer.Compare(Item1, tuple.Item1);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item2, tuple.Item2);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item3, tuple.Item3);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item4, tuple.Item4);
					if (num != 0)
					{
						return num;
					}
					return comparer.Compare(Item5, tuple.Item5);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Item1?.GetHashCode() ?? 0, Item2?.GetHashCode() ?? 0, Item3?.GetHashCode() ?? 0, Item4?.GetHashCode() ?? 0, Item5?.GetHashCode() ?? 0);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		private int GetHashCodeCore(IEqualityComparer comparer)
		{
			return HashCode.Combine(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3), comparer.GetHashCode(Item4), comparer.GetHashCode(Item5));
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		public override string ToString()
		{
			return "(" + Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ", " + Item4?.ToString() + ", " + Item5?.ToString() + ")";
		}

		string IValueTupleInternal.ToStringEnd()
		{
			return Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ", " + Item4?.ToString() + ", " + Item5?.ToString() + ")";
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple<T1, T2, T3, T4, T5, T6> : IEquatable<(T1, T2, T3, T4, T5, T6)>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<(T1, T2, T3, T4, T5, T6)>, IValueTupleInternal, ITuple
	{
		public T1 Item1;

		public T2 Item2;

		public T3 Item3;

		public T4 Item4;

		public T5 Item5;

		public T6 Item6;

		int ITuple.Length => 6;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			4 => Item5, 
			5 => Item6, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
		{
			Item1 = item1;
			Item2 = item2;
			Item3 = item3;
			Item4 = item4;
			Item5 = item5;
			Item6 = item6;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is (T1, T2, T3, T4, T5, T6) other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals((T1, T2, T3, T4, T5, T6) other)
		{
			if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3) && EqualityComparer<T4>.Default.Equals(Item4, other.Item4) && EqualityComparer<T5>.Default.Equals(Item5, other.Item5))
			{
				return EqualityComparer<T6>.Default.Equals(Item6, other.Item6);
			}
			return false;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other is (T1, T2, T3, T4, T5, T6) tuple && comparer.Equals(Item1, tuple.Item1) && comparer.Equals(Item2, tuple.Item2) && comparer.Equals(Item3, tuple.Item3) && comparer.Equals(Item5, tuple.Item5))
			{
				return comparer.Equals(Item6, tuple.Item6);
			}
			return false;
		}

		int IComparable.CompareTo(object other)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3, T4, T5, T6) other2)
				{
					return CompareTo(other2);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public int CompareTo((T1, T2, T3, T4, T5, T6) other)
		{
			int num = Comparer<T1>.Default.Compare(Item1, other.Item1);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T2>.Default.Compare(Item2, other.Item2);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T3>.Default.Compare(Item3, other.Item3);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T4>.Default.Compare(Item4, other.Item4);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T5>.Default.Compare(Item5, other.Item5);
			if (num != 0)
			{
				return num;
			}
			return Comparer<T6>.Default.Compare(Item6, other.Item6);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3, T4, T5, T6) tuple)
				{
					int num = comparer.Compare(Item1, tuple.Item1);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item2, tuple.Item2);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item3, tuple.Item3);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item4, tuple.Item4);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item5, tuple.Item5);
					if (num != 0)
					{
						return num;
					}
					return comparer.Compare(Item6, tuple.Item6);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Item1?.GetHashCode() ?? 0, Item2?.GetHashCode() ?? 0, Item3?.GetHashCode() ?? 0, Item4?.GetHashCode() ?? 0, Item5?.GetHashCode() ?? 0, Item6?.GetHashCode() ?? 0);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		private int GetHashCodeCore(IEqualityComparer comparer)
		{
			return HashCode.Combine(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3), comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6));
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		public override string ToString()
		{
			return "(" + Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ", " + Item4?.ToString() + ", " + Item5?.ToString() + ", " + Item6?.ToString() + ")";
		}

		string IValueTupleInternal.ToStringEnd()
		{
			return Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ", " + Item4?.ToString() + ", " + Item5?.ToString() + ", " + Item6?.ToString() + ")";
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7> : IEquatable<(T1, T2, T3, T4, T5, T6, T7)>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<(T1, T2, T3, T4, T5, T6, T7)>, IValueTupleInternal, ITuple
	{
		public T1 Item1;

		public T2 Item2;

		public T3 Item3;

		public T4 Item4;

		public T5 Item5;

		public T6 Item6;

		public T7 Item7;

		int ITuple.Length => 7;

		object? ITuple.this[int index] => index switch
		{
			0 => Item1, 
			1 => Item2, 
			2 => Item3, 
			3 => Item4, 
			4 => Item5, 
			5 => Item6, 
			6 => Item7, 
			_ => throw new IndexOutOfRangeException(), 
		};

		public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
		{
			Item1 = item1;
			Item2 = item2;
			Item3 = item3;
			Item4 = item4;
			Item5 = item5;
			Item6 = item6;
			Item7 = item7;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is (T1, T2, T3, T4, T5, T6, T7) other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals((T1, T2, T3, T4, T5, T6, T7) other)
		{
			if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3) && EqualityComparer<T4>.Default.Equals(Item4, other.Item4) && EqualityComparer<T5>.Default.Equals(Item5, other.Item5) && EqualityComparer<T6>.Default.Equals(Item6, other.Item6))
			{
				return EqualityComparer<T7>.Default.Equals(Item7, other.Item7);
			}
			return false;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other is (T1, T2, T3, T4, T5, T6, T7) tuple && comparer.Equals(Item1, tuple.Item1) && comparer.Equals(Item2, tuple.Item2) && comparer.Equals(Item3, tuple.Item3) && comparer.Equals(Item5, tuple.Item5) && comparer.Equals(Item6, tuple.Item6))
			{
				return comparer.Equals(Item7, tuple.Item7);
			}
			return false;
		}

		int IComparable.CompareTo(object other)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3, T4, T5, T6, T7) other2)
				{
					return CompareTo(other2);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public int CompareTo((T1, T2, T3, T4, T5, T6, T7) other)
		{
			int num = Comparer<T1>.Default.Compare(Item1, other.Item1);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T2>.Default.Compare(Item2, other.Item2);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T3>.Default.Compare(Item3, other.Item3);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T4>.Default.Compare(Item4, other.Item4);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T5>.Default.Compare(Item5, other.Item5);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T6>.Default.Compare(Item6, other.Item6);
			if (num != 0)
			{
				return num;
			}
			return Comparer<T7>.Default.Compare(Item7, other.Item7);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other != null)
			{
				if (other is (T1, T2, T3, T4, T5, T6, T7) tuple)
				{
					int num = comparer.Compare(Item1, tuple.Item1);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item2, tuple.Item2);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item3, tuple.Item3);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item4, tuple.Item4);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item5, tuple.Item5);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item6, tuple.Item6);
					if (num != 0)
					{
						return num;
					}
					return comparer.Compare(Item7, tuple.Item7);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Item1?.GetHashCode() ?? 0, Item2?.GetHashCode() ?? 0, Item3?.GetHashCode() ?? 0, Item4?.GetHashCode() ?? 0, Item5?.GetHashCode() ?? 0, Item6?.GetHashCode() ?? 0, Item7?.GetHashCode() ?? 0);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		private int GetHashCodeCore(IEqualityComparer comparer)
		{
			return HashCode.Combine(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3), comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6), comparer.GetHashCode(Item7));
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		public override string ToString()
		{
			return "(" + Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ", " + Item4?.ToString() + ", " + Item5?.ToString() + ", " + Item6?.ToString() + ", " + Item7?.ToString() + ")";
		}

		string IValueTupleInternal.ToStringEnd()
		{
			return Item1?.ToString() + ", " + Item2?.ToString() + ", " + Item3?.ToString() + ", " + Item4?.ToString() + ", " + Item5?.ToString() + ", " + Item6?.ToString() + ", " + Item7?.ToString() + ")";
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IEquatable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IStructuralEquatable, IStructuralComparable, IComparable, IComparable<ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest>>, IValueTupleInternal, ITuple where TRest : struct
	{
		public T1 Item1;

		public T2 Item2;

		public T3 Item3;

		public T4 Item4;

		public T5 Item5;

		public T6 Item6;

		public T7 Item7;

		public TRest Rest;

		int ITuple.Length
		{
			get
			{
				if (!(Rest is IValueTupleInternal))
				{
					return 8;
				}
				return 7 + ((IValueTupleInternal)(object)Rest).Length;
			}
		}

		object? ITuple.this[int index]
		{
			get
			{
				switch (index)
				{
				case 0:
					return Item1;
				case 1:
					return Item2;
				case 2:
					return Item3;
				case 3:
					return Item4;
				case 4:
					return Item5;
				case 5:
					return Item6;
				case 6:
					return Item7;
				default:
					if (Rest is IValueTupleInternal)
					{
						return ((IValueTupleInternal)(object)Rest)[index - 7];
					}
					if (index == 7)
					{
						return Rest;
					}
					throw new IndexOutOfRangeException();
				}
			}
		}

		public ValueTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
		{
			if (!(rest is IValueTupleInternal))
			{
				throw new ArgumentException(SR.ArgumentException_ValueTupleLastArgumentNotAValueTuple);
			}
			Item1 = item1;
			Item2 = item2;
			Item3 = item3;
			Item4 = item4;
			Item5 = item5;
			Item6 = item6;
			Item7 = item7;
			Rest = rest;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> other)
		{
			if (EqualityComparer<T1>.Default.Equals(Item1, other.Item1) && EqualityComparer<T2>.Default.Equals(Item2, other.Item2) && EqualityComparer<T3>.Default.Equals(Item3, other.Item3) && EqualityComparer<T4>.Default.Equals(Item4, other.Item4) && EqualityComparer<T5>.Default.Equals(Item5, other.Item5) && EqualityComparer<T6>.Default.Equals(Item6, other.Item6) && EqualityComparer<T7>.Default.Equals(Item7, other.Item7))
			{
				return EqualityComparer<TRest>.Default.Equals(Rest, other.Rest);
			}
			return false;
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			if (other is ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> valueTuple && comparer.Equals(Item1, valueTuple.Item1) && comparer.Equals(Item2, valueTuple.Item2) && comparer.Equals(Item3, valueTuple.Item3) && comparer.Equals(Item5, valueTuple.Item5) && comparer.Equals(Item6, valueTuple.Item6) && comparer.Equals(Item7, valueTuple.Item7))
			{
				return comparer.Equals(Rest, valueTuple.Rest);
			}
			return false;
		}

		int IComparable.CompareTo(object other)
		{
			if (other != null)
			{
				if (other is ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> other2)
				{
					return CompareTo(other2);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public int CompareTo(ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> other)
		{
			int num = Comparer<T1>.Default.Compare(Item1, other.Item1);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T2>.Default.Compare(Item2, other.Item2);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T3>.Default.Compare(Item3, other.Item3);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T4>.Default.Compare(Item4, other.Item4);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T5>.Default.Compare(Item5, other.Item5);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T6>.Default.Compare(Item6, other.Item6);
			if (num != 0)
			{
				return num;
			}
			num = Comparer<T7>.Default.Compare(Item7, other.Item7);
			if (num != 0)
			{
				return num;
			}
			return Comparer<TRest>.Default.Compare(Rest, other.Rest);
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			if (other != null)
			{
				if (other is ValueTuple<T1, T2, T3, T4, T5, T6, T7, TRest> valueTuple)
				{
					int num = comparer.Compare(Item1, valueTuple.Item1);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item2, valueTuple.Item2);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item3, valueTuple.Item3);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item4, valueTuple.Item4);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item5, valueTuple.Item5);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item6, valueTuple.Item6);
					if (num != 0)
					{
						return num;
					}
					num = comparer.Compare(Item7, valueTuple.Item7);
					if (num != 0)
					{
						return num;
					}
					return comparer.Compare(Rest, valueTuple.Rest);
				}
				ThrowHelper.ThrowArgumentException_TupleIncorrectType(this);
			}
			return 1;
		}

		public override int GetHashCode()
		{
			T1 val;
			int value;
			if (!(Rest is IValueTupleInternal))
			{
				ref T1 reference = ref Item1;
				val = default(T1);
				if (val == null)
				{
					val = reference;
					reference = ref val;
					if (val == null)
					{
						value = 0;
						goto IL_004a;
					}
				}
				value = reference.GetHashCode();
				goto IL_004a;
			}
			int length = ((IValueTupleInternal)(object)Rest).Length;
			int hashCode = Rest.GetHashCode();
			if (length >= 8)
			{
				return hashCode;
			}
			T7 val2;
			int value24;
			T6 val7;
			int value12;
			T5 val5;
			int value10;
			T4 val3;
			int value5;
			T3 val6;
			int value26;
			T2 val4;
			int value27;
			int value2;
			ref T7 reference3;
			int value3;
			ref T4 reference4;
			int value4;
			int value6;
			int value7;
			int value8;
			ref T2 reference5;
			int value9;
			ref T5 reference7;
			int value11;
			int value13;
			ref T3 reference8;
			int value14;
			ref T6 reference9;
			int value15;
			ref T6 reference10;
			int value16;
			ref T5 reference11;
			int value17;
			ref T4 reference12;
			int value18;
			ref T6 reference13;
			int value19;
			ref T6 reference14;
			ref T7 reference15;
			ref T5 reference16;
			int value20;
			ref T7 reference18;
			int value21;
			ref T7 reference19;
			int value22;
			ref T6 reference20;
			int value23;
			ref T7 reference22;
			ref T7 reference23;
			int value25;
			int value28;
			int value29;
			ref T4 reference27;
			ref T3 reference28;
			ref T5 reference29;
			switch (8 - length)
			{
			case 1:
			{
				ref T7 reference21 = ref Item7;
				val2 = default(T7);
				if (val2 == null)
				{
					val2 = reference21;
					reference21 = ref val2;
					if (val2 == null)
					{
						value24 = 0;
						goto IL_0237;
					}
				}
				value24 = reference21.GetHashCode();
				goto IL_0237;
			}
			case 2:
			{
				ref T6 reference17 = ref Item6;
				val7 = default(T6);
				if (val7 == null)
				{
					val7 = reference17;
					reference17 = ref val7;
					if (val7 == null)
					{
						value12 = 0;
						goto IL_0276;
					}
				}
				value12 = reference17.GetHashCode();
				goto IL_0276;
			}
			case 3:
			{
				ref T5 reference6 = ref Item5;
				val5 = default(T5);
				if (val5 == null)
				{
					val5 = reference6;
					reference6 = ref val5;
					if (val5 == null)
					{
						value10 = 0;
						goto IL_02ed;
					}
				}
				value10 = reference6.GetHashCode();
				goto IL_02ed;
			}
			case 4:
			{
				ref T4 reference25 = ref Item4;
				val3 = default(T4);
				if (val3 == null)
				{
					val3 = reference25;
					reference25 = ref val3;
					if (val3 == null)
					{
						value5 = 0;
						goto IL_039c;
					}
				}
				value5 = reference25.GetHashCode();
				goto IL_039c;
			}
			case 5:
			{
				ref T3 reference24 = ref Item3;
				val6 = default(T3);
				if (val6 == null)
				{
					val6 = reference24;
					reference24 = ref val6;
					if (val6 == null)
					{
						value26 = 0;
						goto IL_0483;
					}
				}
				value26 = reference24.GetHashCode();
				goto IL_0483;
			}
			case 6:
			{
				ref T2 reference26 = ref Item2;
				val4 = default(T2);
				if (val4 == null)
				{
					val4 = reference26;
					reference26 = ref val4;
					if (val4 == null)
					{
						value27 = 0;
						goto IL_05a2;
					}
				}
				value27 = reference26.GetHashCode();
				goto IL_05a2;
			}
			case 7:
			case 8:
			{
				ref T1 reference2 = ref Item1;
				val = default(T1);
				if (val == null)
				{
					val = reference2;
					reference2 = ref val;
					if (val == null)
					{
						value2 = 0;
						goto IL_06f6;
					}
				}
				value2 = reference2.GetHashCode();
				goto IL_06f6;
			}
			default:
				{
					return -1;
				}
				IL_0325:
				reference3 = ref Item7;
				val2 = default(T7);
				if (val2 == null)
				{
					val2 = reference3;
					reference3 = ref val2;
					if (val2 == null)
					{
						value3 = 0;
						goto IL_035d;
					}
				}
				value3 = reference3.GetHashCode();
				goto IL_035d;
				IL_05da:
				reference4 = ref Item4;
				val3 = default(T4);
				if (val3 == null)
				{
					val3 = reference4;
					reference4 = ref val3;
					if (val3 == null)
					{
						value4 = 0;
						goto IL_0612;
					}
				}
				value4 = reference4.GetHashCode();
				goto IL_0612;
				IL_0444:
				return HashCode.Combine(value5, value6, value7, value8, hashCode);
				IL_06f6:
				reference5 = ref Item2;
				val4 = default(T2);
				if (val4 == null)
				{
					val4 = reference5;
					reference5 = ref val4;
					if (val4 == null)
					{
						value9 = 0;
						goto IL_072e;
					}
				}
				value9 = reference5.GetHashCode();
				goto IL_072e;
				IL_04bb:
				reference7 = ref Item5;
				val5 = default(T5);
				if (val5 == null)
				{
					val5 = reference7;
					reference7 = ref val5;
					if (val5 == null)
					{
						value11 = 0;
						goto IL_04f3;
					}
				}
				value11 = reference7.GetHashCode();
				goto IL_04f3;
				IL_02ae:
				return HashCode.Combine(value12, value13, hashCode);
				IL_072e:
				reference8 = ref Item3;
				val6 = default(T3);
				if (val6 == null)
				{
					val6 = reference8;
					reference8 = ref val6;
					if (val6 == null)
					{
						value14 = 0;
						goto IL_0766;
					}
				}
				value14 = reference8.GetHashCode();
				goto IL_0766;
				IL_04f3:
				reference9 = ref Item6;
				val7 = default(T6);
				if (val7 == null)
				{
					val7 = reference9;
					reference9 = ref val7;
					if (val7 == null)
					{
						value15 = 0;
						goto IL_052b;
					}
				}
				value15 = reference9.GetHashCode();
				goto IL_052b;
				IL_02ed:
				reference10 = ref Item6;
				val7 = default(T6);
				if (val7 == null)
				{
					val7 = reference10;
					reference10 = ref val7;
					if (val7 == null)
					{
						value16 = 0;
						goto IL_0325;
					}
				}
				value16 = reference10.GetHashCode();
				goto IL_0325;
				IL_0612:
				reference11 = ref Item5;
				val5 = default(T5);
				if (val5 == null)
				{
					val5 = reference11;
					reference11 = ref val5;
					if (val5 == null)
					{
						value17 = 0;
						goto IL_064a;
					}
				}
				value17 = reference11.GetHashCode();
				goto IL_064a;
				IL_0766:
				reference12 = ref Item4;
				val3 = default(T4);
				if (val3 == null)
				{
					val3 = reference12;
					reference12 = ref val3;
					if (val3 == null)
					{
						value18 = 0;
						goto IL_079e;
					}
				}
				value18 = reference12.GetHashCode();
				goto IL_079e;
				IL_064a:
				reference13 = ref Item6;
				val7 = default(T6);
				if (val7 == null)
				{
					val7 = reference13;
					reference13 = ref val7;
					if (val7 == null)
					{
						value19 = 0;
						goto IL_0682;
					}
				}
				value19 = reference13.GetHashCode();
				goto IL_0682;
				IL_03d4:
				reference14 = ref Item6;
				val7 = default(T6);
				if (val7 == null)
				{
					val7 = reference14;
					reference14 = ref val7;
					if (val7 == null)
					{
						value7 = 0;
						goto IL_040c;
					}
				}
				value7 = reference14.GetHashCode();
				goto IL_040c;
				IL_0276:
				reference15 = ref Item7;
				val2 = default(T7);
				if (val2 == null)
				{
					val2 = reference15;
					reference15 = ref val2;
					if (val2 == null)
					{
						value13 = 0;
						goto IL_02ae;
					}
				}
				value13 = reference15.GetHashCode();
				goto IL_02ae;
				IL_079e:
				reference16 = ref Item5;
				val5 = default(T5);
				if (val5 == null)
				{
					val5 = reference16;
					reference16 = ref val5;
					if (val5 == null)
					{
						value20 = 0;
						goto IL_07d6;
					}
				}
				value20 = reference16.GetHashCode();
				goto IL_07d6;
				IL_0682:
				reference18 = ref Item7;
				val2 = default(T7);
				if (val2 == null)
				{
					val2 = reference18;
					reference18 = ref val2;
					if (val2 == null)
					{
						value21 = 0;
						goto IL_06ba;
					}
				}
				value21 = reference18.GetHashCode();
				goto IL_06ba;
				IL_052b:
				reference19 = ref Item7;
				val2 = default(T7);
				if (val2 == null)
				{
					val2 = reference19;
					reference19 = ref val2;
					if (val2 == null)
					{
						value22 = 0;
						goto IL_0563;
					}
				}
				value22 = reference19.GetHashCode();
				goto IL_0563;
				IL_07d6:
				reference20 = ref Item6;
				val7 = default(T6);
				if (val7 == null)
				{
					val7 = reference20;
					reference20 = ref val7;
					if (val7 == null)
					{
						value23 = 0;
						goto IL_080e;
					}
				}
				value23 = reference20.GetHashCode();
				goto IL_080e;
				IL_040c:
				reference22 = ref Item7;
				val2 = default(T7);
				if (val2 == null)
				{
					val2 = reference22;
					reference22 = ref val2;
					if (val2 == null)
					{
						value8 = 0;
						goto IL_0444;
					}
				}
				value8 = reference22.GetHashCode();
				goto IL_0444;
				IL_035d:
				return HashCode.Combine(value10, value16, value3, hashCode);
				IL_080e:
				reference23 = ref Item7;
				val2 = default(T7);
				if (val2 == null)
				{
					val2 = reference23;
					reference23 = ref val2;
					if (val2 == null)
					{
						value25 = 0;
						goto IL_0846;
					}
				}
				value25 = reference23.GetHashCode();
				goto IL_0846;
				IL_06ba:
				return HashCode.Combine(value27, value28, value4, value17, value19, value21, hashCode);
				IL_0846:
				return HashCode.Combine(value2, value9, value14, value18, value20, value23, value25, hashCode);
				IL_0563:
				return HashCode.Combine(value26, value29, value11, value15, value22, hashCode);
				IL_0483:
				reference27 = ref Item4;
				val3 = default(T4);
				if (val3 == null)
				{
					val3 = reference27;
					reference27 = ref val3;
					if (val3 == null)
					{
						value29 = 0;
						goto IL_04bb;
					}
				}
				value29 = reference27.GetHashCode();
				goto IL_04bb;
				IL_0237:
				return HashCode.Combine(value24, hashCode);
				IL_05a2:
				reference28 = ref Item3;
				val6 = default(T3);
				if (val6 == null)
				{
					val6 = reference28;
					reference28 = ref val6;
					if (val6 == null)
					{
						value28 = 0;
						goto IL_05da;
					}
				}
				value28 = reference28.GetHashCode();
				goto IL_05da;
				IL_039c:
				reference29 = ref Item5;
				val5 = default(T5);
				if (val5 == null)
				{
					val5 = reference29;
					reference29 = ref val5;
					if (val5 == null)
					{
						value6 = 0;
						goto IL_03d4;
					}
				}
				value6 = reference29.GetHashCode();
				goto IL_03d4;
			}
			IL_00ba:
			ref T4 reference30 = ref Item4;
			val3 = default(T4);
			int value30;
			if (val3 == null)
			{
				val3 = reference30;
				reference30 = ref val3;
				if (val3 == null)
				{
					value30 = 0;
					goto IL_00f2;
				}
			}
			value30 = reference30.GetHashCode();
			goto IL_00f2;
			IL_0082:
			ref T3 reference31 = ref Item3;
			val6 = default(T3);
			int value31;
			if (val6 == null)
			{
				val6 = reference31;
				reference31 = ref val6;
				if (val6 == null)
				{
					value31 = 0;
					goto IL_00ba;
				}
			}
			value31 = reference31.GetHashCode();
			goto IL_00ba;
			IL_0162:
			ref T7 reference32 = ref Item7;
			val2 = default(T7);
			int value32;
			if (val2 == null)
			{
				val2 = reference32;
				reference32 = ref val2;
				if (val2 == null)
				{
					value32 = 0;
					goto IL_019a;
				}
			}
			value32 = reference32.GetHashCode();
			goto IL_019a;
			IL_00f2:
			ref T5 reference33 = ref Item5;
			val5 = default(T5);
			int value33;
			if (val5 == null)
			{
				val5 = reference33;
				reference33 = ref val5;
				if (val5 == null)
				{
					value33 = 0;
					goto IL_012a;
				}
			}
			value33 = reference33.GetHashCode();
			goto IL_012a;
			IL_004a:
			ref T2 reference34 = ref Item2;
			val4 = default(T2);
			int value34;
			if (val4 == null)
			{
				val4 = reference34;
				reference34 = ref val4;
				if (val4 == null)
				{
					value34 = 0;
					goto IL_0082;
				}
			}
			value34 = reference34.GetHashCode();
			goto IL_0082;
			IL_019a:
			int value35;
			return HashCode.Combine(value, value34, value31, value30, value33, value35, value32);
			IL_012a:
			ref T6 reference35 = ref Item6;
			val7 = default(T6);
			if (val7 == null)
			{
				val7 = reference35;
				reference35 = ref val7;
				if (val7 == null)
				{
					value35 = 0;
					goto IL_0162;
				}
			}
			value35 = reference35.GetHashCode();
			goto IL_0162;
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		private int GetHashCodeCore(IEqualityComparer comparer)
		{
			if (!((object)Rest is IValueTupleInternal valueTupleInternal))
			{
				return HashCode.Combine(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3), comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6), comparer.GetHashCode(Item7));
			}
			int length = valueTupleInternal.Length;
			int hashCode = valueTupleInternal.GetHashCode(comparer);
			if (length >= 8)
			{
				return hashCode;
			}
			switch (8 - length)
			{
			case 1:
				return HashCode.Combine(comparer.GetHashCode(Item7), hashCode);
			case 2:
				return HashCode.Combine(comparer.GetHashCode(Item6), comparer.GetHashCode(Item7), hashCode);
			case 3:
				return HashCode.Combine(comparer.GetHashCode(Item5), comparer.GetHashCode(Item6), comparer.GetHashCode(Item7), hashCode);
			case 4:
				return HashCode.Combine(comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6), comparer.GetHashCode(Item7), hashCode);
			case 5:
				return HashCode.Combine(comparer.GetHashCode(Item3), comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6), comparer.GetHashCode(Item7), hashCode);
			case 6:
				return HashCode.Combine(comparer.GetHashCode(Item2), comparer.GetHashCode(Item3), comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6), comparer.GetHashCode(Item7), hashCode);
			case 7:
			case 8:
				return HashCode.Combine(comparer.GetHashCode(Item1), comparer.GetHashCode(Item2), comparer.GetHashCode(Item3), comparer.GetHashCode(Item4), comparer.GetHashCode(Item5), comparer.GetHashCode(Item6), comparer.GetHashCode(Item7), hashCode);
			default:
				return -1;
			}
		}

		int IValueTupleInternal.GetHashCode(IEqualityComparer comparer)
		{
			return GetHashCodeCore(comparer);
		}

		public override string ToString()
		{
			string[] obj;
			T1 val;
			object obj2;
			if (Rest is IValueTupleInternal)
			{
				obj = new string[16]
				{
					"(", null, null, null, null, null, null, null, null, null,
					null, null, null, null, null, null
				};
				ref T1 reference = ref Item1;
				val = default(T1);
				if (val == null)
				{
					val = reference;
					reference = ref val;
					if (val == null)
					{
						obj2 = null;
						goto IL_005b;
					}
				}
				obj2 = reference.ToString();
				goto IL_005b;
			}
			string[] obj3 = new string[17]
			{
				"(", null, null, null, null, null, null, null, null, null,
				null, null, null, null, null, null, null
			};
			ref T1 reference2 = ref Item1;
			val = default(T1);
			object obj4;
			if (val == null)
			{
				val = reference2;
				reference2 = ref val;
				if (val == null)
				{
					obj4 = null;
					goto IL_0258;
				}
			}
			obj4 = reference2.ToString();
			goto IL_0258;
			IL_02d8:
			object obj5;
			obj3[5] = (string)obj5;
			obj3[6] = ", ";
			ref T4 reference3 = ref Item4;
			T4 val2 = default(T4);
			object obj6;
			if (val2 == null)
			{
				val2 = reference3;
				reference3 = ref val2;
				if (val2 == null)
				{
					obj6 = null;
					goto IL_0318;
				}
			}
			obj6 = reference3.ToString();
			goto IL_0318;
			IL_03e6:
			object obj7;
			obj3[13] = (string)obj7;
			obj3[14] = ", ";
			obj3[15] = Rest.ToString();
			obj3[16] = ")";
			return string.Concat(obj3);
			IL_03a1:
			object obj8;
			obj3[11] = (string)obj8;
			obj3[12] = ", ";
			ref T7 reference4 = ref Item7;
			T7 val3 = default(T7);
			if (val3 == null)
			{
				val3 = reference4;
				reference4 = ref val3;
				if (val3 == null)
				{
					obj7 = null;
					goto IL_03e6;
				}
			}
			obj7 = reference4.ToString();
			goto IL_03e6;
			IL_011b:
			object obj9;
			obj[7] = (string)obj9;
			obj[8] = ", ";
			ref T5 reference5 = ref Item5;
			T5 val4 = default(T5);
			object obj10;
			if (val4 == null)
			{
				val4 = reference5;
				reference5 = ref val4;
				if (val4 == null)
				{
					obj10 = null;
					goto IL_015f;
				}
			}
			obj10 = reference5.ToString();
			goto IL_015f;
			IL_005b:
			obj[1] = (string)obj2;
			obj[2] = ", ";
			ref T2 reference6 = ref Item2;
			T2 val5 = default(T2);
			object obj11;
			if (val5 == null)
			{
				val5 = reference6;
				reference6 = ref val5;
				if (val5 == null)
				{
					obj11 = null;
					goto IL_009b;
				}
			}
			obj11 = reference6.ToString();
			goto IL_009b;
			IL_015f:
			obj[9] = (string)obj10;
			obj[10] = ", ";
			ref T6 reference7 = ref Item6;
			T6 val6 = default(T6);
			object obj12;
			if (val6 == null)
			{
				val6 = reference7;
				reference7 = ref val6;
				if (val6 == null)
				{
					obj12 = null;
					goto IL_01a4;
				}
			}
			obj12 = reference7.ToString();
			goto IL_01a4;
			IL_0298:
			object obj13;
			obj3[3] = (string)obj13;
			obj3[4] = ", ";
			ref T3 reference8 = ref Item3;
			T3 val7 = default(T3);
			if (val7 == null)
			{
				val7 = reference8;
				reference8 = ref val7;
				if (val7 == null)
				{
					obj5 = null;
					goto IL_02d8;
				}
			}
			obj5 = reference8.ToString();
			goto IL_02d8;
			IL_01e9:
			object obj14;
			obj[13] = (string)obj14;
			obj[14] = ", ";
			obj[15] = ((IValueTupleInternal)(object)Rest).ToStringEnd();
			return string.Concat(obj);
			IL_009b:
			obj[3] = (string)obj11;
			obj[4] = ", ";
			ref T3 reference9 = ref Item3;
			val7 = default(T3);
			object obj15;
			if (val7 == null)
			{
				val7 = reference9;
				reference9 = ref val7;
				if (val7 == null)
				{
					obj15 = null;
					goto IL_00db;
				}
			}
			obj15 = reference9.ToString();
			goto IL_00db;
			IL_0318:
			obj3[7] = (string)obj6;
			obj3[8] = ", ";
			ref T5 reference10 = ref Item5;
			val4 = default(T5);
			object obj16;
			if (val4 == null)
			{
				val4 = reference10;
				reference10 = ref val4;
				if (val4 == null)
				{
					obj16 = null;
					goto IL_035c;
				}
			}
			obj16 = reference10.ToString();
			goto IL_035c;
			IL_01a4:
			obj[11] = (string)obj12;
			obj[12] = ", ";
			ref T7 reference11 = ref Item7;
			val3 = default(T7);
			if (val3 == null)
			{
				val3 = reference11;
				reference11 = ref val3;
				if (val3 == null)
				{
					obj14 = null;
					goto IL_01e9;
				}
			}
			obj14 = reference11.ToString();
			goto IL_01e9;
			IL_0258:
			obj3[1] = (string)obj4;
			obj3[2] = ", ";
			ref T2 reference12 = ref Item2;
			val5 = default(T2);
			if (val5 == null)
			{
				val5 = reference12;
				reference12 = ref val5;
				if (val5 == null)
				{
					obj13 = null;
					goto IL_0298;
				}
			}
			obj13 = reference12.ToString();
			goto IL_0298;
			IL_00db:
			obj[5] = (string)obj15;
			obj[6] = ", ";
			ref T4 reference13 = ref Item4;
			val2 = default(T4);
			if (val2 == null)
			{
				val2 = reference13;
				reference13 = ref val2;
				if (val2 == null)
				{
					obj9 = null;
					goto IL_011b;
				}
			}
			obj9 = reference13.ToString();
			goto IL_011b;
			IL_035c:
			obj3[9] = (string)obj16;
			obj3[10] = ", ";
			ref T6 reference14 = ref Item6;
			val6 = default(T6);
			if (val6 == null)
			{
				val6 = reference14;
				reference14 = ref val6;
				if (val6 == null)
				{
					obj8 = null;
					goto IL_03a1;
				}
			}
			obj8 = reference14.ToString();
			goto IL_03a1;
		}

		string IValueTupleInternal.ToStringEnd()
		{
			string[] array;
			T1 val;
			object obj;
			if (Rest is IValueTupleInternal)
			{
				array = new string[15];
				ref T1 reference = ref Item1;
				val = default(T1);
				if (val == null)
				{
					val = reference;
					reference = ref val;
					if (val == null)
					{
						obj = null;
						goto IL_0053;
					}
				}
				obj = reference.ToString();
				goto IL_0053;
			}
			string[] array2 = new string[16];
			ref T1 reference2 = ref Item1;
			val = default(T1);
			object obj2;
			if (val == null)
			{
				val = reference2;
				reference2 = ref val;
				if (val == null)
				{
					obj2 = null;
					goto IL_0247;
				}
			}
			obj2 = reference2.ToString();
			goto IL_0247;
			IL_02c7:
			object obj3;
			array2[4] = (string)obj3;
			array2[5] = ", ";
			ref T4 reference3 = ref Item4;
			T4 val2 = default(T4);
			object obj4;
			if (val2 == null)
			{
				val2 = reference3;
				reference3 = ref val2;
				if (val2 == null)
				{
					obj4 = null;
					goto IL_0307;
				}
			}
			obj4 = reference3.ToString();
			goto IL_0307;
			IL_03d4:
			object obj5;
			array2[12] = (string)obj5;
			array2[13] = ", ";
			array2[14] = Rest.ToString();
			array2[15] = ")";
			return string.Concat(array2);
			IL_038f:
			object obj6;
			array2[10] = (string)obj6;
			array2[11] = ", ";
			ref T7 reference4 = ref Item7;
			T7 val3 = default(T7);
			if (val3 == null)
			{
				val3 = reference4;
				reference4 = ref val3;
				if (val3 == null)
				{
					obj5 = null;
					goto IL_03d4;
				}
			}
			obj5 = reference4.ToString();
			goto IL_03d4;
			IL_0113:
			object obj7;
			array[6] = (string)obj7;
			array[7] = ", ";
			ref T5 reference5 = ref Item5;
			T5 val4 = default(T5);
			object obj8;
			if (val4 == null)
			{
				val4 = reference5;
				reference5 = ref val4;
				if (val4 == null)
				{
					obj8 = null;
					goto IL_0156;
				}
			}
			obj8 = reference5.ToString();
			goto IL_0156;
			IL_0053:
			array[0] = (string)obj;
			array[1] = ", ";
			ref T2 reference6 = ref Item2;
			T2 val5 = default(T2);
			object obj9;
			if (val5 == null)
			{
				val5 = reference6;
				reference6 = ref val5;
				if (val5 == null)
				{
					obj9 = null;
					goto IL_0093;
				}
			}
			obj9 = reference6.ToString();
			goto IL_0093;
			IL_0156:
			array[8] = (string)obj8;
			array[9] = ", ";
			ref T6 reference7 = ref Item6;
			T6 val6 = default(T6);
			object obj10;
			if (val6 == null)
			{
				val6 = reference7;
				reference7 = ref val6;
				if (val6 == null)
				{
					obj10 = null;
					goto IL_019b;
				}
			}
			obj10 = reference7.ToString();
			goto IL_019b;
			IL_0287:
			object obj11;
			array2[2] = (string)obj11;
			array2[3] = ", ";
			ref T3 reference8 = ref Item3;
			T3 val7 = default(T3);
			if (val7 == null)
			{
				val7 = reference8;
				reference8 = ref val7;
				if (val7 == null)
				{
					obj3 = null;
					goto IL_02c7;
				}
			}
			obj3 = reference8.ToString();
			goto IL_02c7;
			IL_01e0:
			object obj12;
			array[12] = (string)obj12;
			array[13] = ", ";
			array[14] = ((IValueTupleInternal)(object)Rest).ToStringEnd();
			return string.Concat(array);
			IL_0093:
			array[2] = (string)obj9;
			array[3] = ", ";
			ref T3 reference9 = ref Item3;
			val7 = default(T3);
			object obj13;
			if (val7 == null)
			{
				val7 = reference9;
				reference9 = ref val7;
				if (val7 == null)
				{
					obj13 = null;
					goto IL_00d3;
				}
			}
			obj13 = reference9.ToString();
			goto IL_00d3;
			IL_0307:
			array2[6] = (string)obj4;
			array2[7] = ", ";
			ref T5 reference10 = ref Item5;
			val4 = default(T5);
			object obj14;
			if (val4 == null)
			{
				val4 = reference10;
				reference10 = ref val4;
				if (val4 == null)
				{
					obj14 = null;
					goto IL_034a;
				}
			}
			obj14 = reference10.ToString();
			goto IL_034a;
			IL_019b:
			array[10] = (string)obj10;
			array[11] = ", ";
			ref T7 reference11 = ref Item7;
			val3 = default(T7);
			if (val3 == null)
			{
				val3 = reference11;
				reference11 = ref val3;
				if (val3 == null)
				{
					obj12 = null;
					goto IL_01e0;
				}
			}
			obj12 = reference11.ToString();
			goto IL_01e0;
			IL_0247:
			array2[0] = (string)obj2;
			array2[1] = ", ";
			ref T2 reference12 = ref Item2;
			val5 = default(T2);
			if (val5 == null)
			{
				val5 = reference12;
				reference12 = ref val5;
				if (val5 == null)
				{
					obj11 = null;
					goto IL_0287;
				}
			}
			obj11 = reference12.ToString();
			goto IL_0287;
			IL_00d3:
			array[4] = (string)obj13;
			array[5] = ", ";
			ref T4 reference13 = ref Item4;
			val2 = default(T4);
			if (val2 == null)
			{
				val2 = reference13;
				reference13 = ref val2;
				if (val2 == null)
				{
					obj7 = null;
					goto IL_0113;
				}
			}
			obj7 = reference13.ToString();
			goto IL_0113;
			IL_034a:
			array2[8] = (string)obj14;
			array2[9] = ", ";
			ref T6 reference14 = ref Item6;
			val6 = default(T6);
			if (val6 == null)
			{
				val6 = reference14;
				reference14 = ref val6;
				if (val6 == null)
				{
					obj6 = null;
					goto IL_038f;
				}
			}
			obj6 = reference14.ToString();
			goto IL_038f;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class Version : ICloneable, IComparable, IComparable<Version?>, IEquatable<Version?>, ISpanFormattable, IFormattable
	{
		private readonly int _Major;

		private readonly int _Minor;

		private readonly int _Build;

		private readonly int _Revision;

		public int Major => _Major;

		public int Minor => _Minor;

		public int Build => _Build;

		public int Revision => _Revision;

		public short MajorRevision => (short)(_Revision >> 16);

		public short MinorRevision => (short)(_Revision & 0xFFFF);

		private int DefaultFormatFieldCount
		{
			get
			{
				if (_Build != -1)
				{
					if (_Revision != -1)
					{
						return 4;
					}
					return 3;
				}
				return 2;
			}
		}

		public Version(int major, int minor, int build, int revision)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", SR.ArgumentOutOfRange_Version);
			}
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", SR.ArgumentOutOfRange_Version);
			}
			if (build < 0)
			{
				throw new ArgumentOutOfRangeException("build", SR.ArgumentOutOfRange_Version);
			}
			if (revision < 0)
			{
				throw new ArgumentOutOfRangeException("revision", SR.ArgumentOutOfRange_Version);
			}
			_Major = major;
			_Minor = minor;
			_Build = build;
			_Revision = revision;
		}

		public Version(int major, int minor, int build)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", SR.ArgumentOutOfRange_Version);
			}
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", SR.ArgumentOutOfRange_Version);
			}
			if (build < 0)
			{
				throw new ArgumentOutOfRangeException("build", SR.ArgumentOutOfRange_Version);
			}
			_Major = major;
			_Minor = minor;
			_Build = build;
			_Revision = -1;
		}

		public Version(int major, int minor)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", SR.ArgumentOutOfRange_Version);
			}
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", SR.ArgumentOutOfRange_Version);
			}
			_Major = major;
			_Minor = minor;
			_Build = -1;
			_Revision = -1;
		}

		public Version(string version)
		{
			Version version2 = Parse(version);
			_Major = version2.Major;
			_Minor = version2.Minor;
			_Build = version2.Build;
			_Revision = version2.Revision;
		}

		public Version()
		{
			_Build = -1;
			_Revision = -1;
		}

		private Version(Version version)
		{
			_Major = version._Major;
			_Minor = version._Minor;
			_Build = version._Build;
			_Revision = version._Revision;
		}

		public object Clone()
		{
			return new Version(this);
		}

		public int CompareTo(object? version)
		{
			if (version == null)
			{
				return 1;
			}
			if (version is Version value)
			{
				return CompareTo(value);
			}
			throw new ArgumentException(SR.Arg_MustBeVersion);
		}

		public int CompareTo(Version? value)
		{
			if ((object)value != this)
			{
				if ((object)value != null)
				{
					if (_Major == value._Major)
					{
						if (_Minor == value._Minor)
						{
							if (_Build == value._Build)
							{
								if (_Revision == value._Revision)
								{
									return 0;
								}
								if (_Revision <= value._Revision)
								{
									return -1;
								}
								return 1;
							}
							if (_Build <= value._Build)
							{
								return -1;
							}
							return 1;
						}
						if (_Minor <= value._Minor)
						{
							return -1;
						}
						return 1;
					}
					if (_Major <= value._Major)
					{
						return -1;
					}
					return 1;
				}
				return 1;
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj as Version);
		}

		public bool Equals([NotNullWhen(true)] Version? obj)
		{
			if ((object)obj != this)
			{
				if ((object)obj != null && _Major == obj._Major && _Minor == obj._Minor && _Build == obj._Build)
				{
					return _Revision == obj._Revision;
				}
				return false;
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = 0;
			num |= (_Major & 0xF) << 28;
			num |= (_Minor & 0xFF) << 20;
			num |= (_Build & 0xFF) << 12;
			return num | (_Revision & 0xFFF);
		}

		public override string ToString()
		{
			return ToString(DefaultFormatFieldCount);
		}

		public string ToString(int fieldCount)
		{
			Span<char> destination = stackalloc char[47];
			int charsWritten;
			bool flag = TryFormat(destination, fieldCount, out charsWritten);
			return destination.Slice(0, charsWritten).ToString();
		}

		string IFormattable.ToString(string format, IFormatProvider formatProvider)
		{
			return ToString();
		}

		public bool TryFormat(Span<char> destination, out int charsWritten)
		{
			return TryFormat(destination, DefaultFormatFieldCount, out charsWritten);
		}

		public bool TryFormat(Span<char> destination, int fieldCount, out int charsWritten)
		{
			switch (fieldCount)
			{
			default:
				ThrowArgumentException("4");
				break;
			case 3:
			case 4:
				if (_Build != -1)
				{
					if (fieldCount == 4 && _Revision == -1)
					{
						ThrowArgumentException("3");
					}
				}
				else
				{
					ThrowArgumentException("2");
				}
				break;
			case 0:
			case 1:
			case 2:
				break;
			}
			int num = 0;
			for (int i = 0; i < fieldCount; i++)
			{
				if (i != 0)
				{
					if (destination.IsEmpty)
					{
						charsWritten = 0;
						return false;
					}
					destination[0] = '.';
					destination = destination.Slice(1);
					num++;
				}
				if (!(i switch
				{
					0 => (uint)_Major, 
					1 => (uint)_Minor, 
					2 => (uint)_Build, 
					_ => (uint)_Revision, 
				}).TryFormat(destination, out var charsWritten2))
				{
					charsWritten = 0;
					return false;
				}
				num += charsWritten2;
				destination = destination.Slice(charsWritten2);
			}
			charsWritten = num;
			return true;
			static void ThrowArgumentException(string failureUpperBound)
			{
				throw new ArgumentException(SR.Format(SR.ArgumentOutOfRange_Bounds_Lower_Upper, "0", failureUpperBound), "fieldCount");
			}
		}

		bool ISpanFormattable.TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			return TryFormat(destination, DefaultFormatFieldCount, out charsWritten);
		}

		public static Version Parse(string input)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			return ParseVersion(input.AsSpan(), throwOnFailure: true);
		}

		public static Version Parse(ReadOnlySpan<char> input)
		{
			return ParseVersion(input, throwOnFailure: true);
		}

		public static bool TryParse([NotNullWhen(true)] string? input, [NotNullWhen(true)] out Version? result)
		{
			if (input == null)
			{
				result = null;
				return false;
			}
			return (result = ParseVersion(input.AsSpan(), throwOnFailure: false)) != null;
		}

		public static bool TryParse(ReadOnlySpan<char> input, [NotNullWhen(true)] out Version? result)
		{
			return (result = ParseVersion(input, throwOnFailure: false)) != null;
		}

		private static Version ParseVersion(ReadOnlySpan<char> input, bool throwOnFailure)
		{
			int num = input.IndexOf('.');
			if (num < 0)
			{
				if (throwOnFailure)
				{
					throw new ArgumentException(SR.Arg_VersionString, "input");
				}
				return null;
			}
			int num2 = -1;
			int num3 = input.Slice(num + 1).IndexOf('.');
			if (num3 != -1)
			{
				num3 += num + 1;
				num2 = input.Slice(num3 + 1).IndexOf('.');
				if (num2 != -1)
				{
					num2 += num3 + 1;
					if (input.Slice(num2 + 1).Contains('.'))
					{
						if (throwOnFailure)
						{
							throw new ArgumentException(SR.Arg_VersionString, "input");
						}
						return null;
					}
				}
			}
			if (!TryParseComponent(input.Slice(0, num), "input", throwOnFailure, out var parsedComponent))
			{
				return null;
			}
			int parsedComponent2;
			if (num3 != -1)
			{
				if (!TryParseComponent(input.Slice(num + 1, num3 - num - 1), "input", throwOnFailure, out parsedComponent2))
				{
					return null;
				}
				int parsedComponent3;
				if (num2 != -1)
				{
					if (!TryParseComponent(input.Slice(num3 + 1, num2 - num3 - 1), "build", throwOnFailure, out parsedComponent3) || !TryParseComponent(input.Slice(num2 + 1), "revision", throwOnFailure, out var parsedComponent4))
					{
						return null;
					}
					return new Version(parsedComponent, parsedComponent2, parsedComponent3, parsedComponent4);
				}
				if (!TryParseComponent(input.Slice(num3 + 1), "build", throwOnFailure, out parsedComponent3))
				{
					return null;
				}
				return new Version(parsedComponent, parsedComponent2, parsedComponent3);
			}
			if (!TryParseComponent(input.Slice(num + 1), "input", throwOnFailure, out parsedComponent2))
			{
				return null;
			}
			return new Version(parsedComponent, parsedComponent2);
		}

		private static bool TryParseComponent(ReadOnlySpan<char> component, string componentName, bool throwOnFailure, out int parsedComponent)
		{
			if (throwOnFailure)
			{
				if ((parsedComponent = int.Parse(component, NumberStyles.Integer, CultureInfo.InvariantCulture)) < 0)
				{
					throw new ArgumentOutOfRangeException(componentName, SR.ArgumentOutOfRange_Version);
				}
				return true;
			}
			if (int.TryParse(component, NumberStyles.Integer, CultureInfo.InvariantCulture, out parsedComponent))
			{
				return parsedComponent >= 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(Version? v1, Version? v2)
		{
			if ((object)v2 == null)
			{
				if ((object)v1 != null)
				{
					return false;
				}
				return true;
			}
			if ((object)v2 != v1)
			{
				return v2.Equals(v1);
			}
			return true;
		}

		public static bool operator !=(Version? v1, Version? v2)
		{
			return !(v1 == v2);
		}

		public static bool operator <(Version? v1, Version? v2)
		{
			if ((object)v1 == null)
			{
				return (object)v2 != null;
			}
			return v1.CompareTo(v2) < 0;
		}

		public static bool operator <=(Version? v1, Version? v2)
		{
			if ((object)v1 == null)
			{
				return true;
			}
			return v1.CompareTo(v2) <= 0;
		}

		public static bool operator >(Version? v1, Version? v2)
		{
			return v2 < v1;
		}

		public static bool operator >=(Version? v1, Version? v2)
		{
			return v2 <= v1;
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct Void
	{
	}
	internal static class NotImplemented
	{
		internal static Exception ByDesign => new NotImplementedException();
	}
	internal struct Sha1ForNonSecretPurposes
	{
		private long _length;

		private uint[] _w;

		private int _pos;

		public void Start()
		{
			if (_w == null)
			{
				_w = new uint[85];
			}
			_length = 0L;
			_pos = 0;
			_w[80] = 1732584193u;
			_w[81] = 4023233417u;
			_w[82] = 2562383102u;
			_w[83] = 271733878u;
			_w[84] = 3285377520u;
		}

		public void Append(byte input)
		{
			int num = _pos >> 2;
			_w[num] = (_w[num] << 8) | input;
			if (64 == ++_pos)
			{
				Drain();
			}
		}

		public void Append(ReadOnlySpan<byte> input)
		{
			ReadOnlySpan<byte> readOnlySpan = input;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				byte input2 = readOnlySpan[i];
				Append(input2);
			}
		}

		public void Finish(Span<byte> output)
		{
			long num = _length + 8 * _pos;
			Append(128);
			while (_pos != 56)
			{
				Append(0);
			}
			Append((byte)(num >> 56));
			Append((byte)(num >> 48));
			Append((byte)(num >> 40));
			Append((byte)(num >> 32));
			Append((byte)(num >> 24));
			Append((byte)(num >> 16));
			Append((byte)(num >> 8));
			Append((byte)num);
			int num2 = ((output.Length < 20) ? output.Length : 20);
			for (int i = 0; i != num2; i++)
			{
				uint num3 = _w[80 + i / 4];
				output[i] = (byte)(num3 >> 24);
				_w[80 + i / 4] = num3 << 8;
			}
		}

		private void Drain()
		{
			for (int i = 16; i != 80; i++)
			{
				_w[i] = BitOperations.RotateLeft(_w[i - 3] ^ _w[i - 8] ^ _w[i - 14] ^ _w[i - 16], 1);
			}
			uint num = _w[80];
			uint num2 = _w[81];
			uint num3 = _w[82];
			uint num4 = _w[83];
			uint num5 = _w[84];
			for (int j = 0; j != 20; j++)
			{
				uint num6 = (num2 & num3) | (~num2 & num4);
				uint num7 = BitOperations.RotateLeft(num, 5) + num6 + num5 + 1518500249 + _w[j];
				num5 = num4;
				num4 = num3;
				num3 = BitOperations.RotateLeft(num2, 30);
				num2 = num;
				num = num7;
			}
			for (int k = 20; k != 40; k++)
			{
				uint num8 = num2 ^ num3 ^ num4;
				uint num9 = BitOperations.RotateLeft(num, 5) + num8 + num5 + 1859775393 + _w[k];
				num5 = num4;
				num4 = num3;
				num3 = BitOperations.RotateLeft(num2, 30);
				num2 = num;
				num = num9;
			}
			for (int l = 40; l != 60; l++)
			{
				uint num10 = (num2 & num3) | (num2 & num4) | (num3 & num4);
				uint num11 = (uint)((int)(BitOperations.RotateLeft(num, 5) + num10 + num5) + -1894007588) + _w[l];
				num5 = num4;
				num4 = num3;
				num3 = BitOperations.RotateLeft(num2, 30);
				num2 = num;
				num = num11;
			}
			for (int m = 60; m != 80; m++)
			{
				uint num12 = num2 ^ num3 ^ num4;
				uint num13 = (uint)((int)(BitOperations.RotateLeft(num, 5) + num12 + num5) + -899497514) + _w[m];
				num5 = num4;
				num4 = num3;
				num3 = BitOperations.RotateLeft(num2, 30);
				num2 = num;
				num = num13;
			}
			_w[80] += num;
			_w[81] += num2;
			_w[82] += num3;
			_w[83] += num4;
			_w[84] += num5;
			_length += 512L;
			_pos = 0;
		}
	}
	internal static class HexConverter
	{
		public enum Casing : uint
		{
			Upper = 0u,
			Lower = 8224u
		}

		public static ReadOnlySpan<byte> CharToHexLookup => new byte[256]
		{
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 0, 1,
			2, 3, 4, 5, 6, 7, 8, 9, 255, 255,
			255, 255, 255, 255, 255, 10, 11, 12, 13, 14,
			15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 10, 11, 12,
			13, 14, 15, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255
		};

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ToBytesBuffer(byte value, Span<byte> buffer, int startingIndex = 0, Casing casing = Casing.Upper)
		{
			uint num = (uint)(((value & 0xF0) << 4) + (value & 0xF) - 35209);
			uint num2 = ((((0 - num) & 0x7070) >> 4) + num + 47545) | (uint)casing;
			buffer[startingIndex + 1] = (byte)num2;
			buffer[startingIndex] = (byte)(num2 >> 8);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ToCharsBuffer(byte value, Span<char> buffer, int startingIndex = 0, Casing casing = Casing.Upper)
		{
			uint num = (uint)(((value & 0xF0) << 4) + (value & 0xF) - 35209);
			uint num2 = ((((0 - num) & 0x7070) >> 4) + num + 47545) | (uint)casing;
			buffer[startingIndex + 1] = (char)(num2 & 0xFFu);
			buffer[startingIndex] = (char)(num2 >> 8);
		}

		private static void EncodeToUtf16_Ssse3(ReadOnlySpan<byte> bytes, Span<char> chars, Casing casing)
		{
			nint num = 0;
			Vector128<byte> mask = Vector128.Create(byte.MaxValue, byte.MaxValue, 0, byte.MaxValue, byte.MaxValue, byte.MaxValue, 1, byte.MaxValue, byte.MaxValue, byte.MaxValue, 2, byte.MaxValue, byte.MaxValue, byte.MaxValue, 3, byte.MaxValue);
			Vector128<byte> value = ((casing == Casing.Upper) ? Vector128.Create((byte)48, (byte)49, (byte)50, (byte)51, (byte)52, (byte)53, (byte)54, (byte)55, (byte)56, (byte)57, (byte)65, (byte)66, (byte)67, (byte)68, (byte)69, (byte)70) : Vector128.Create((byte)48, (byte)49, (byte)50, (byte)51, (byte)52, (byte)53, (byte)54, (byte)55, (byte)56, (byte)57, (byte)97, (byte)98, (byte)99, (byte)100, (byte)101, (byte)102));
			do
			{
				uint value2 = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref MemoryMarshal.GetReference(bytes), num));
				Vector128<byte> vector = Ssse3.Shuffle(Vector128.CreateScalarUnsafe(value2).AsByte(), mask);
				Vector128<byte> right = Sse2.ShiftRightLogical(Sse2.ShiftRightLogical128BitLane(vector, 2).AsInt32(), 4).AsByte();
				Vector128<byte> mask2 = Sse2.And(Sse2.Or(vector, right), Vector128.Create((byte)15));
				Vector128<byte> left = Ssse3.Shuffle(value, mask2);
				left = Sse2.And(left, Vector128.Create((ushort)255).AsByte());
				Unsafe.WriteUnaligned(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(chars), num * 2)), left);
				num += 4;
			}
			while (num < bytes.Length - 3);
			for (; num < bytes.Length; num++)
			{
				ToCharsBuffer(Unsafe.Add(ref MemoryMarshal.GetReference(bytes), num), chars, (int)num * 2, casing);
			}
		}

		public static void EncodeToUtf16(ReadOnlySpan<byte> bytes, Span<char> chars, Casing casing = Casing.Upper)
		{
			if (Ssse3.IsSupported && bytes.Length >= 4)
			{
				EncodeToUtf16_Ssse3(bytes, chars, casing);
				return;
			}
			for (int i = 0; i < bytes.Length; i++)
			{
				ToCharsBuffer(bytes[i], chars, i * 2, casing);
			}
		}

		public unsafe static string ToString(ReadOnlySpan<byte> bytes, Casing casing = Casing.Upper)
		{
			fixed (byte* ptr = bytes)
			{
				return string.Create(bytes.Length * 2, ((IntPtr)ptr, bytes.Length, casing), delegate(Span<char> chars, (IntPtr Ptr, int Length, Casing casing) args)
				{
					ReadOnlySpan<byte> bytes2 = new ReadOnlySpan<byte>((void*)args.Ptr, args.Length);
					EncodeToUtf16(bytes2, chars, args.casing);
				});
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char ToCharUpper(int value)
		{
			value &= 0xF;
			value += 48;
			if (value > 57)
			{
				value += 7;
			}
			return (char)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char ToCharLower(int value)
		{
			value &= 0xF;
			value += 48;
			if (value > 57)
			{
				value += 39;
			}
			return (char)value;
		}

		public static bool TryDecodeFromUtf16(ReadOnlySpan<char> chars, Span<byte> bytes)
		{
			int charsProcessed;
			return TryDecodeFromUtf16(chars, bytes, out charsProcessed);
		}

		public static bool TryDecodeFromUtf16(ReadOnlySpan<char> chars, Span<byte> bytes, out int charsProcessed)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			while (num2 < bytes.Length)
			{
				num3 = FromChar(chars[num + 1]);
				num4 = FromChar(chars[num]);
				if ((num3 | num4) == 255)
				{
					break;
				}
				bytes[num2++] = (byte)((num4 << 4) | num3);
				num += 2;
			}
			if (num3 == 255)
			{
				num++;
			}
			charsProcessed = num;
			return (num3 | num4) != 255;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int FromChar(int c)
		{
			if (c < CharToHexLookup.Length)
			{
				return CharToHexLookup[c];
			}
			return 255;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsHexChar(int c)
		{
			if (IntPtr.Size == 8)
			{
			}
			return FromChar(c) != 255;
		}
	}
	internal static class FixedBufferExtensions
	{
		internal unsafe static string GetStringFromFixedBuffer(this ReadOnlySpan<char> span)
		{
			fixed (char* value = &MemoryMarshal.GetReference(span))
			{
				return new string(value, 0, span.GetFixedBufferStringLength());
			}
		}

		internal static int GetFixedBufferStringLength(this ReadOnlySpan<char> span)
		{
			int num = span.IndexOf('\0');
			if (num >= 0)
			{
				return num;
			}
			return span.Length;
		}

		internal static bool FixedBufferEqualsString(this ReadOnlySpan<char> span, string value)
		{
			if (value == null || value.Length > span.Length)
			{
				return false;
			}
			int i;
			for (i = 0; i < value.Length; i++)
			{
				if (value[i] == '\0' || value[i] != span[i])
				{
					return false;
				}
			}
			if (i != span.Length)
			{
				return span[i] == '\0';
			}
			return true;
		}
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IAdditionOperators<TSelf, TOther, TResult> where TSelf : IAdditionOperators<TSelf, TOther, TResult>
	{
		static abstract TResult operator +(TSelf left, TOther right);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IAdditiveIdentity<TSelf, TResult> where TSelf : IAdditiveIdentity<TSelf, TResult>
	{
		static abstract TResult AdditiveIdentity { get; }
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IBitwiseOperators<TSelf, TOther, TResult> where TSelf : IBitwiseOperators<TSelf, TOther, TResult>
	{
		static abstract TResult operator &(TSelf left, TOther right);

		static abstract TResult operator |(TSelf left, TOther right);

		static abstract TResult operator ^(TSelf left, TOther right);

		static abstract TResult operator ~(TSelf value);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IComparisonOperators<TSelf, TOther> : IComparable, IComparable<TOther>, IEqualityOperators<TSelf, TOther>, IEquatable<TOther> where TSelf : IComparisonOperators<TSelf, TOther>
	{
		static abstract bool operator <(TSelf left, TOther right);

		static abstract bool operator <=(TSelf left, TOther right);

		static abstract bool operator >(TSelf left, TOther right);

		static abstract bool operator >=(TSelf left, TOther right);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IDecrementOperators<TSelf> where TSelf : IDecrementOperators<TSelf>
	{
		static abstract TSelf operator --(TSelf value);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IDivisionOperators<TSelf, TOther, TResult> where TSelf : IDivisionOperators<TSelf, TOther, TResult>
	{
		static abstract TResult operator /(TSelf left, TOther right);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IEqualityOperators<TSelf, TOther> : IEquatable<TOther> where TSelf : IEqualityOperators<TSelf, TOther>
	{
		static abstract bool operator ==(TSelf left, TOther right);

		static abstract bool operator !=(TSelf left, TOther right);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IFloatingPoint<TSelf> : ISignedNumber<TSelf>, INumber<TSelf>, IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparisonOperators<TSelf, TSelf>, IComparable, IComparable<TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, IFormattable, ISpanParseable<TSelf>, IParseable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IFloatingPoint<TSelf>
	{
		static abstract TSelf E { get; }

		static abstract TSelf Epsilon { get; }

		static abstract TSelf NaN { get; }

		static abstract TSelf NegativeInfinity { get; }

		static abstract TSelf NegativeZero { get; }

		static abstract TSelf Pi { get; }

		static abstract TSelf PositiveInfinity { get; }

		static abstract TSelf Tau { get; }

		static abstract TSelf Acos(TSelf x);

		static abstract TSelf Acosh(TSelf x);

		static abstract TSelf Asin(TSelf x);

		static abstract TSelf Asinh(TSelf x);

		static abstract TSelf Atan(TSelf x);

		static abstract TSelf Atan2(TSelf y, TSelf x);

		static abstract TSelf Atanh(TSelf x);

		static abstract TSelf BitDecrement(TSelf x);

		static abstract TSelf BitIncrement(TSelf x);

		static abstract TSelf Cbrt(TSelf x);

		static abstract TSelf Ceiling(TSelf x);

		static abstract TSelf CopySign(TSelf x, TSelf y);

		static abstract TSelf Cos(TSelf x);

		static abstract TSelf Cosh(TSelf x);

		static abstract TSelf Exp(TSelf x);

		static abstract TSelf Floor(TSelf x);

		static abstract TSelf FusedMultiplyAdd(TSelf left, TSelf right, TSelf addend);

		static abstract TSelf IEEERemainder(TSelf left, TSelf right);

		static abstract TInteger ILogB<TInteger>(TSelf x);

		static abstract bool IsFinite(TSelf value);

		static abstract bool IsInfinity(TSelf value);

		static abstract bool IsNaN(TSelf value);

		static abstract bool IsNegative(TSelf value);

		static abstract bool IsNegativeInfinity(TSelf value);

		static abstract bool IsNormal(TSelf value);

		static abstract bool IsPositiveInfinity(TSelf value);

		static abstract bool IsSubnormal(TSelf value);

		static abstract TSelf Log(TSelf x);

		static abstract TSelf Log(TSelf x, TSelf newBase);

		static abstract TSelf Log2(TSelf x);

		static abstract TSelf Log10(TSelf x);

		static abstract TSelf MaxMagnitude(TSelf x, TSelf y);

		static abstract TSelf MinMagnitude(TSelf x, TSelf y);

		static abstract TSelf Pow(TSelf x, TSelf y);

		static abstract TSelf Round(TSelf x);

		static abstract TSelf Round<TInteger>(TSelf x, TInteger digits);

		static abstract TSelf Round(TSelf x, MidpointRounding mode);

		static abstract TSelf Round<TInteger>(TSelf x, TInteger digits, MidpointRounding mode);

		static abstract TSelf ScaleB<TInteger>(TSelf x, TInteger n);

		static abstract TSelf Sin(TSelf x);

		static abstract TSelf Sinh(TSelf x);

		static abstract TSelf Sqrt(TSelf x);

		static abstract TSelf Tan(TSelf x);

		static abstract TSelf Tanh(TSelf x);

		static abstract TSelf Truncate(TSelf x);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IBinaryFloatingPoint<TSelf> : IBinaryNumber<TSelf>, IBitwiseOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparisonOperators<TSelf, TSelf>, IComparable, IComparable<TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, IFormattable, ISpanParseable<TSelf>, IParseable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf>, IFloatingPoint<TSelf>, ISignedNumber<TSelf> where TSelf : IBinaryFloatingPoint<TSelf>
	{
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IIncrementOperators<TSelf> where TSelf : IIncrementOperators<TSelf>
	{
		static abstract TSelf operator ++(TSelf value);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IBinaryInteger<TSelf> : IBinaryNumber<TSelf>, IBitwiseOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparisonOperators<TSelf, TSelf>, IComparable, IComparable<TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, IFormattable, ISpanParseable<TSelf>, IParseable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf>, IShiftOperators<TSelf, TSelf> where TSelf : IBinaryInteger<TSelf>
	{
		static abstract TSelf LeadingZeroCount(TSelf value);

		static abstract TSelf PopCount(TSelf value);

		static abstract TSelf RotateLeft(TSelf value, int rotateAmount);

		static abstract TSelf RotateRight(TSelf value, int rotateAmount);

		static abstract TSelf TrailingZeroCount(TSelf value);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IMinMaxValue<TSelf> where TSelf : IMinMaxValue<TSelf>
	{
		static abstract TSelf MinValue { get; }

		static abstract TSelf MaxValue { get; }
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IModulusOperators<TSelf, TOther, TResult> where TSelf : IModulusOperators<TSelf, TOther, TResult>
	{
		static abstract TResult operator %(TSelf left, TOther right);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IMultiplicativeIdentity<TSelf, TResult> where TSelf : IMultiplicativeIdentity<TSelf, TResult>
	{
		static abstract TResult MultiplicativeIdentity { get; }
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IMultiplyOperators<TSelf, TOther, TResult> where TSelf : IMultiplyOperators<TSelf, TOther, TResult>
	{
		static abstract TResult operator *(TSelf left, TOther right);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface INumber<TSelf> : IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparisonOperators<TSelf, TSelf>, IComparable, IComparable<TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, IFormattable, ISpanParseable<TSelf>, IParseable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : INumber<TSelf>
	{
		static abstract TSelf One { get; }

		static abstract TSelf Zero { get; }

		static abstract TSelf Abs(TSelf value);

		static abstract TSelf Clamp(TSelf value, TSelf min, TSelf max);

		static abstract TSelf Create<TOther>(TOther value);

		static abstract TSelf CreateSaturating<TOther>(TOther value);

		static abstract TSelf CreateTruncating<TOther>(TOther value);

		static abstract (TSelf Quotient, TSelf Remainder) DivRem(TSelf left, TSelf right);

		static abstract TSelf Max(TSelf x, TSelf y);

		static abstract TSelf Min(TSelf x, TSelf y);

		static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider);

		static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);

		static abstract TSelf Sign(TSelf value);

		static abstract bool TryCreate<TOther>(TOther value, out TSelf result);

		static abstract bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out TSelf result);

		static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IBinaryNumber<TSelf> : IBitwiseOperators<TSelf, TSelf, TSelf>, INumber<TSelf>, IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparisonOperators<TSelf, TSelf>, IComparable, IComparable<TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, IFormattable, ISpanParseable<TSelf>, IParseable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IBinaryNumber<TSelf>
	{
		static abstract bool IsPow2(TSelf value);

		static abstract TSelf Log2(TSelf value);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface ISignedNumber<TSelf> : INumber<TSelf>, IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparisonOperators<TSelf, TSelf>, IComparable, IComparable<TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, IFormattable, ISpanParseable<TSelf>, IParseable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : ISignedNumber<TSelf>
	{
		static abstract TSelf NegativeOne { get; }
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IUnsignedNumber<TSelf> : INumber<TSelf>, IAdditionOperators<TSelf, TSelf, TSelf>, IAdditiveIdentity<TSelf, TSelf>, IComparisonOperators<TSelf, TSelf>, IComparable, IComparable<TSelf>, IEqualityOperators<TSelf, TSelf>, IEquatable<TSelf>, IDecrementOperators<TSelf>, IDivisionOperators<TSelf, TSelf, TSelf>, IIncrementOperators<TSelf>, IModulusOperators<TSelf, TSelf, TSelf>, IMultiplicativeIdentity<TSelf, TSelf>, IMultiplyOperators<TSelf, TSelf, TSelf>, ISpanFormattable, IFormattable, ISpanParseable<TSelf>, IParseable<TSelf>, ISubtractionOperators<TSelf, TSelf, TSelf>, IUnaryNegationOperators<TSelf, TSelf>, IUnaryPlusOperators<TSelf, TSelf> where TSelf : IUnsignedNumber<TSelf>
	{
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IParseable<TSelf> where TSelf : IParseable<TSelf>
	{
		static abstract TSelf Parse(string s, IFormatProvider? provider);

		static abstract bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, out TSelf result);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IShiftOperators<TSelf, TResult> where TSelf : IShiftOperators<TSelf, TResult>
	{
		static abstract TResult operator <<(TSelf value, int shiftAmount);

		static abstract TResult operator >>(TSelf value, int shiftAmount);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface ISpanParseable<TSelf> : IParseable<TSelf> where TSelf : ISpanParseable<TSelf>
	{
		static abstract TSelf Parse(ReadOnlySpan<char> s, IFormatProvider? provider);

		static abstract bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out TSelf result);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface ISubtractionOperators<TSelf, TOther, TResult> where TSelf : ISubtractionOperators<TSelf, TOther, TResult>
	{
		static abstract TResult operator -(TSelf left, TOther right);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IUnaryNegationOperators<TSelf, TResult> where TSelf : IUnaryNegationOperators<TSelf, TResult>
	{
		static abstract TResult operator -(TSelf value);
	}
	[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
	public interface IUnaryPlusOperators<TSelf, TResult> where TSelf : IUnaryPlusOperators<TSelf, TResult>
	{
		static abstract TResult operator +(TSelf value);
	}
}
namespace System.Private.CoreLib
{
	internal static class Strings
	{
	}
}
namespace System.Numerics
{
	public static class BitOperations
	{
		private static ReadOnlySpan<byte> TrailingZeroCountDeBruijn => new byte[32]
		{
			0, 1, 28, 2, 29, 14, 24, 3, 30, 22,
			20, 15, 25, 17, 4, 8, 31, 27, 13, 23,
			21, 19, 16, 7, 26, 12, 18, 6, 11, 5,
			10, 9
		};

		private static ReadOnlySpan<byte> Log2DeBruijn => new byte[32]
		{
			0, 9, 1, 10, 13, 21, 2, 29, 11, 14,
			16, 18, 22, 25, 3, 30, 8, 12, 20, 28,
			15, 17, 24, 7, 19, 27, 23, 6, 26, 5,
			4, 31
		};

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPow2(int value)
		{
			if ((value & (value - 1)) == 0)
			{
				return value > 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool IsPow2(uint value)
		{
			if ((value & (value - 1)) == 0)
			{
				return value != 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPow2(long value)
		{
			if ((value & (value - 1)) == 0L)
			{
				return value > 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool IsPow2(ulong value)
		{
			if ((value & (value - 1)) == 0L)
			{
				return value != 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsPow2(nint value)
		{
			if ((value & (value - 1)) == 0)
			{
				return value > 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsPow2(nuint value)
		{
			if ((value & (value - 1)) == 0)
			{
				return value != 0;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint RoundUpToPowerOf2(uint value)
		{
			if (!Lzcnt.IsSupported)
			{
				_ = ArmBase.IsSupported;
				if (!X86Base.IsSupported)
				{
					value--;
					value |= value >> 1;
					value |= value >> 2;
					value |= value >> 4;
					value |= value >> 8;
					value |= value >> 16;
					return value + 1;
				}
			}
			int num = 32 - LeadingZeroCount(value - 1);
			return (uint)((1 ^ (num >> 5)) << num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong RoundUpToPowerOf2(ulong value)
		{
			if (Lzcnt.X64.IsSupported || ArmBase.Arm64.IsSupported)
			{
				int num = 64 - LeadingZeroCount(value - 1);
				return (1uL ^ (ulong)(num >> 6)) << num;
			}
			value--;
			value |= value >> 1;
			value |= value >> 2;
			value |= value >> 4;
			value |= value >> 8;
			value |= value >> 16;
			value |= value >> 32;
			return value + 1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static int LeadingZeroCount(uint value)
		{
			if (Lzcnt.IsSupported)
			{
				return (int)Lzcnt.LeadingZeroCount(value);
			}
			if (ArmBase.IsSupported)
			{
			}
			if (value == 0)
			{
				return 32;
			}
			if (X86Base.IsSupported)
			{
				return (int)(0x1F ^ X86Base.BitScanReverse(value));
			}
			return 0x1F ^ Log2SoftwareFallback(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static int LeadingZeroCount(ulong value)
		{
			if (Lzcnt.X64.IsSupported)
			{
				return (int)Lzcnt.X64.LeadingZeroCount(value);
			}
			if (ArmBase.Arm64.IsSupported)
			{
			}
			if (X86Base.X64.IsSupported)
			{
				if (value != 0L)
				{
					return 0x3F ^ (int)X86Base.X64.BitScanReverse(value);
				}
				return 64;
			}
			uint num = (uint)(value >> 32);
			if (num == 0)
			{
				return 32 + LeadingZeroCount((uint)value);
			}
			return LeadingZeroCount(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static int Log2(uint value)
		{
			value |= 1u;
			if (Lzcnt.IsSupported)
			{
				return (int)(0x1F ^ Lzcnt.LeadingZeroCount(value));
			}
			if (ArmBase.IsSupported)
			{
			}
			if (X86Base.IsSupported)
			{
				return (int)X86Base.BitScanReverse(value);
			}
			return Log2SoftwareFallback(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static int Log2(ulong value)
		{
			value |= 1;
			if (Lzcnt.X64.IsSupported)
			{
				return 0x3F ^ (int)Lzcnt.X64.LeadingZeroCount(value);
			}
			if (ArmBase.Arm64.IsSupported)
			{
			}
			if (X86Base.X64.IsSupported)
			{
				return (int)X86Base.X64.BitScanReverse(value);
			}
			uint num = (uint)(value >> 32);
			if (num == 0)
			{
				return Log2((uint)value);
			}
			return 32 + Log2(num);
		}

		private static int Log2SoftwareFallback(uint value)
		{
			value |= value >> 1;
			value |= value >> 2;
			value |= value >> 4;
			value |= value >> 8;
			value |= value >> 16;
			return Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(Log2DeBruijn), (IntPtr)(int)(value * 130329821 >> 27));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int Log2Ceiling(uint value)
		{
			int num = Log2(value);
			if (PopCount(value) != 1)
			{
				num++;
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int Log2Ceiling(ulong value)
		{
			int num = Log2(value);
			if (PopCount(value) != 1)
			{
				num++;
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[CLSCompliant(false)]
		public static int PopCount(uint value)
		{
			if (Popcnt.IsSupported)
			{
				return (int)Popcnt.PopCount(value);
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static int SoftwareFallback(uint value)
			{
				value -= (value >> 1) & 0x55555555;
				value = (value & 0x33333333) + ((value >> 2) & 0x33333333);
				value = ((value + (value >> 4)) & 0xF0F0F0F) * 16843009 >> 24;
				return (int)value;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[CLSCompliant(false)]
		public static int PopCount(ulong value)
		{
			if (Popcnt.X64.IsSupported)
			{
				return (int)Popcnt.X64.PopCount(value);
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return PopCount((uint)value) + PopCount((uint)(value >> 32));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int TrailingZeroCount(int value)
		{
			return TrailingZeroCount((uint)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static int TrailingZeroCount(uint value)
		{
			if (Bmi1.IsSupported)
			{
				return (int)Bmi1.TrailingZeroCount(value);
			}
			if (ArmBase.IsSupported)
			{
			}
			if (value == 0)
			{
				return 32;
			}
			if (X86Base.IsSupported)
			{
				return (int)X86Base.BitScanForward(value);
			}
			return Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(TrailingZeroCountDeBruijn), (IntPtr)(int)((value & (0 - value)) * 125613361 >> 27));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int TrailingZeroCount(long value)
		{
			return TrailingZeroCount((ulong)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static int TrailingZeroCount(ulong value)
		{
			if (Bmi1.X64.IsSupported)
			{
				return (int)Bmi1.X64.TrailingZeroCount(value);
			}
			if (ArmBase.Arm64.IsSupported)
			{
			}
			if (X86Base.X64.IsSupported)
			{
				if (value != 0L)
				{
					return (int)X86Base.X64.BitScanForward(value);
				}
				return 64;
			}
			uint num = (uint)value;
			if (num == 0)
			{
				return 32 + TrailingZeroCount((uint)(value >> 32));
			}
			return TrailingZeroCount(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint RotateLeft(uint value, int offset)
		{
			return (value << offset) | (value >> 32 - offset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong RotateLeft(ulong value, int offset)
		{
			return (value << offset) | (value >> 64 - offset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint RotateRight(uint value, int offset)
		{
			return (value >> offset) | (value << 32 - offset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong RotateRight(ulong value, int offset)
		{
			return (value >> offset) | (value << 64 - offset);
		}
	}
	[Intrinsic]
	public struct Matrix3x2 : IEquatable<Matrix3x2>
	{
		private static readonly Matrix3x2 _identity = new Matrix3x2(1f, 0f, 0f, 1f, 0f, 0f);

		public float M11;

		public float M12;

		public float M21;

		public float M22;

		public float M31;

		public float M32;

		public static Matrix3x2 Identity => _identity;

		public readonly bool IsIdentity => this == Identity;

		public Vector2 Translation
		{
			readonly get
			{
				return new Vector2(M31, M32);
			}
			set
			{
				M31 = value.X;
				M32 = value.Y;
			}
		}

		public Matrix3x2(float m11, float m12, float m21, float m22, float m31, float m32)
		{
			M11 = m11;
			M12 = m12;
			M21 = m21;
			M22 = m22;
			M31 = m31;
			M32 = m32;
		}

		public static Matrix3x2 operator +(Matrix3x2 value1, Matrix3x2 value2)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix3x2 result);
			result.M11 = value1.M11 + value2.M11;
			result.M12 = value1.M12 + value2.M12;
			result.M21 = value1.M21 + value2.M21;
			result.M22 = value1.M22 + value2.M22;
			result.M31 = value1.M31 + value2.M31;
			result.M32 = value1.M32 + value2.M32;
			return result;
		}

		public static bool operator ==(Matrix3x2 value1, Matrix3x2 value2)
		{
			if (value1.M11 == value2.M11 && value1.M22 == value2.M22 && value1.M12 == value2.M12 && value1.M21 == value2.M21 && value1.M31 == value2.M31)
			{
				return value1.M32 == value2.M32;
			}
			return false;
		}

		public static bool operator !=(Matrix3x2 value1, Matrix3x2 value2)
		{
			return !(value1 == value2);
		}

		public static Matrix3x2 operator *(Matrix3x2 value1, Matrix3x2 value2)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix3x2 result);
			result.M11 = value1.M11 * value2.M11 + value1.M12 * value2.M21;
			result.M12 = value1.M11 * value2.M12 + value1.M12 * value2.M22;
			result.M21 = value1.M21 * value2.M11 + value1.M22 * value2.M21;
			result.M22 = value1.M21 * value2.M12 + value1.M22 * value2.M22;
			result.M31 = value1.M31 * value2.M11 + value1.M32 * value2.M21 + value2.M31;
			result.M32 = value1.M31 * value2.M12 + value1.M32 * value2.M22 + value2.M32;
			return result;
		}

		public static Matrix3x2 operator *(Matrix3x2 value1, float value2)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix3x2 result);
			result.M11 = value1.M11 * value2;
			result.M12 = value1.M12 * value2;
			result.M21 = value1.M21 * value2;
			result.M22 = value1.M22 * value2;
			result.M31 = value1.M31 * value2;
			result.M32 = value1.M32 * value2;
			return result;
		}

		public static Matrix3x2 operator -(Matrix3x2 value1, Matrix3x2 value2)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix3x2 result);
			result.M11 = value1.M11 - value2.M11;
			result.M12 = value1.M12 - value2.M12;
			result.M21 = value1.M21 - value2.M21;
			result.M22 = value1.M22 - value2.M22;
			result.M31 = value1.M31 - value2.M31;
			result.M32 = value1.M32 - value2.M32;
			return result;
		}

		public static Matrix3x2 operator -(Matrix3x2 value)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix3x2 result);
			result.M11 = 0f - value.M11;
			result.M12 = 0f - value.M12;
			result.M21 = 0f - value.M21;
			result.M22 = 0f - value.M22;
			result.M31 = 0f - value.M31;
			result.M32 = 0f - value.M32;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix3x2 Add(Matrix3x2 value1, Matrix3x2 value2)
		{
			return value1 + value2;
		}

		public static Matrix3x2 CreateRotation(float radians)
		{
			radians = MathF.IEEERemainder(radians, (float)Math.PI * 2f);
			float num;
			float num2;
			if (radians > -1.7453294E-05f && radians < 1.7453294E-05f)
			{
				num = 1f;
				num2 = 0f;
			}
			else if (radians > 1.570779f && radians < 1.5708138f)
			{
				num = 0f;
				num2 = 1f;
			}
			else if (radians < -3.1415753f || radians > 3.1415753f)
			{
				num = -1f;
				num2 = 0f;
			}
			else if (radians > -1.5708138f && radians < -1.570779f)
			{
				num = 0f;
				num2 = -1f;
			}
			else
			{
				num = MathF.Cos(radians);
				num2 = MathF.Sin(radians);
			}
			Matrix3x2 identity = Identity;
			identity.M11 = num;
			identity.M12 = num2;
			identity.M21 = 0f - num2;
			identity.M22 = num;
			return identity;
		}

		public static Matrix3x2 CreateRotation(float radians, Vector2 centerPoint)
		{
			radians = MathF.IEEERemainder(radians, (float)Math.PI * 2f);
			float num;
			float num2;
			if (radians > -1.7453294E-05f && radians < 1.7453294E-05f)
			{
				num = 1f;
				num2 = 0f;
			}
			else if (radians > 1.570779f && radians < 1.5708138f)
			{
				num = 0f;
				num2 = 1f;
			}
			else if (radians < -3.1415753f || radians > 3.1415753f)
			{
				num = -1f;
				num2 = 0f;
			}
			else if (radians > -1.5708138f && radians < -1.570779f)
			{
				num = 0f;
				num2 = -1f;
			}
			else
			{
				num = MathF.Cos(radians);
				num2 = MathF.Sin(radians);
			}
			float m = centerPoint.X * (1f - num) + centerPoint.Y * num2;
			float m2 = centerPoint.Y * (1f - num) - centerPoint.X * num2;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix3x2 result);
			result.M11 = num;
			result.M12 = num2;
			result.M21 = 0f - num2;
			result.M22 = num;
			result.M31 = m;
			result.M32 = m2;
			return result;
		}

		public static Matrix3x2 CreateScale(Vector2 scales)
		{
			Matrix3x2 identity = Identity;
			identity.M11 = scales.X;
			identity.M22 = scales.Y;
			return identity;
		}

		public static Matrix3x2 CreateScale(float xScale, float yScale)
		{
			Matrix3x2 identity = Identity;
			identity.M11 = xScale;
			identity.M22 = yScale;
			return identity;
		}

		public static Matrix3x2 CreateScale(float xScale, float yScale, Vector2 centerPoint)
		{
			Matrix3x2 identity = Identity;
			float m = centerPoint.X * (1f - xScale);
			float m2 = centerPoint.Y * (1f - yScale);
			identity.M11 = xScale;
			identity.M22 = yScale;
			identity.M31 = m;
			identity.M32 = m2;
			return identity;
		}

		public static Matrix3x2 CreateScale(Vector2 scales, Vector2 centerPoint)
		{
			Matrix3x2 identity = Identity;
			float m = centerPoint.X * (1f - scales.X);
			float m2 = centerPoint.Y * (1f - scales.Y);
			identity.M11 = scales.X;
			identity.M22 = scales.Y;
			identity.M31 = m;
			identity.M32 = m2;
			return identity;
		}

		public static Matrix3x2 CreateScale(float scale)
		{
			Matrix3x2 identity = Identity;
			identity.M11 = scale;
			identity.M22 = scale;
			return identity;
		}

		public static Matrix3x2 CreateScale(float scale, Vector2 centerPoint)
		{
			Matrix3x2 identity = Identity;
			float m = centerPoint.X * (1f - scale);
			float m2 = centerPoint.Y * (1f - scale);
			identity.M11 = scale;
			identity.M22 = scale;
			identity.M31 = m;
			identity.M32 = m2;
			return identity;
		}

		public static Matrix3x2 CreateSkew(float radiansX, float radiansY)
		{
			Matrix3x2 identity = Identity;
			float m = MathF.Tan(radiansX);
			float m2 = MathF.Tan(radiansY);
			identity.M12 = m2;
			identity.M21 = m;
			return identity;
		}

		public static Matrix3x2 CreateSkew(float radiansX, float radiansY, Vector2 centerPoint)
		{
			Matrix3x2 identity = Identity;
			float num = MathF.Tan(radiansX);
			float num2 = MathF.Tan(radiansY);
			float m = (0f - centerPoint.Y) * num;
			float m2 = (0f - centerPoint.X) * num2;
			identity.M12 = num2;
			identity.M21 = num;
			identity.M31 = m;
			identity.M32 = m2;
			return identity;
		}

		public static Matrix3x2 CreateTranslation(Vector2 position)
		{
			Matrix3x2 identity = Identity;
			identity.M31 = position.X;
			identity.M32 = position.Y;
			return identity;
		}

		public static Matrix3x2 CreateTranslation(float xPosition, float yPosition)
		{
			Matrix3x2 identity = Identity;
			identity.M31 = xPosition;
			identity.M32 = yPosition;
			return identity;
		}

		public static bool Invert(Matrix3x2 matrix, out Matrix3x2 result)
		{
			float num = matrix.M11 * matrix.M22 - matrix.M21 * matrix.M12;
			if (MathF.Abs(num) < float.Epsilon)
			{
				result = new Matrix3x2(float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN);
				return false;
			}
			float num2 = 1f / num;
			result.M11 = matrix.M22 * num2;
			result.M12 = (0f - matrix.M12) * num2;
			result.M21 = (0f - matrix.M21) * num2;
			result.M22 = matrix.M11 * num2;
			result.M31 = (matrix.M21 * matrix.M32 - matrix.M31 * matrix.M22) * num2;
			result.M32 = (matrix.M31 * matrix.M12 - matrix.M11 * matrix.M32) * num2;
			return true;
		}

		public static Matrix3x2 Lerp(Matrix3x2 matrix1, Matrix3x2 matrix2, float amount)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix3x2 result);
			result.M11 = matrix1.M11 + (matrix2.M11 - matrix1.M11) * amount;
			result.M12 = matrix1.M12 + (matrix2.M12 - matrix1.M12) * amount;
			result.M21 = matrix1.M21 + (matrix2.M21 - matrix1.M21) * amount;
			result.M22 = matrix1.M22 + (matrix2.M22 - matrix1.M22) * amount;
			result.M31 = matrix1.M31 + (matrix2.M31 - matrix1.M31) * amount;
			result.M32 = matrix1.M32 + (matrix2.M32 - matrix1.M32) * amount;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix3x2 Multiply(Matrix3x2 value1, Matrix3x2 value2)
		{
			return value1 * value2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix3x2 Multiply(Matrix3x2 value1, float value2)
		{
			return value1 * value2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix3x2 Negate(Matrix3x2 value)
		{
			return -value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix3x2 Subtract(Matrix3x2 value1, Matrix3x2 value2)
		{
			return value1 - value2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override readonly bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Matrix3x2 other)
			{
				return Equals(other);
			}
			return false;
		}

		public readonly bool Equals(Matrix3x2 other)
		{
			return this == other;
		}

		public readonly float GetDeterminant()
		{
			return M11 * M22 - M21 * M12;
		}

		public override readonly int GetHashCode()
		{
			return HashCode.Combine(M11, M12, M21, M22, M31, M32);
		}

		public override readonly string ToString()
		{
			return $"{{ {{M11:{M11} M12:{M12}}} {{M21:{M21} M22:{M22}}} {{M31:{M31} M32:{M32}}} }}";
		}
	}
	[Intrinsic]
	public struct Matrix4x4 : IEquatable<Matrix4x4>
	{
		private struct CanonicalBasis
		{
			public Vector3 Row0;

			public Vector3 Row1;

			public Vector3 Row2;
		}

		private struct VectorBasis
		{
			public unsafe Vector3* Element0;

			public unsafe Vector3* Element1;

			public unsafe Vector3* Element2;
		}

		private static readonly Matrix4x4 _identity = new Matrix4x4(1f, 0f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 0f, 1f);

		public float M11;

		public float M12;

		public float M13;

		public float M14;

		public float M21;

		public float M22;

		public float M23;

		public float M24;

		public float M31;

		public float M32;

		public float M33;

		public float M34;

		public float M41;

		public float M42;

		public float M43;

		public float M44;

		public static Matrix4x4 Identity => _identity;

		public readonly bool IsIdentity
		{
			get
			{
				if (M11 == 1f && M22 == 1f && M33 == 1f && M44 == 1f && M12 == 0f && M13 == 0f && M14 == 0f && M21 == 0f && M23 == 0f && M24 == 0f && M31 == 0f && M32 == 0f && M34 == 0f && M41 == 0f && M42 == 0f)
				{
					return M43 == 0f;
				}
				return false;
			}
		}

		public Vector3 Translation
		{
			readonly get
			{
				return new Vector3(M41, M42, M43);
			}
			set
			{
				M41 = value.X;
				M42 = value.Y;
				M43 = value.Z;
			}
		}

		public Matrix4x4(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
		{
			M11 = m11;
			M12 = m12;
			M13 = m13;
			M14 = m14;
			M21 = m21;
			M22 = m22;
			M23 = m23;
			M24 = m24;
			M31 = m31;
			M32 = m32;
			M33 = m33;
			M34 = m34;
			M41 = m41;
			M42 = m42;
			M43 = m43;
			M44 = m44;
		}

		public Matrix4x4(Matrix3x2 value)
		{
			M11 = value.M11;
			M12 = value.M12;
			M13 = 0f;
			M14 = 0f;
			M21 = value.M21;
			M22 = value.M22;
			M23 = 0f;
			M24 = 0f;
			M31 = 0f;
			M32 = 0f;
			M33 = 1f;
			M34 = 0f;
			M41 = value.M31;
			M42 = value.M32;
			M43 = 0f;
			M44 = 1f;
		}

		public unsafe static Matrix4x4 operator +(Matrix4x4 value1, Matrix4x4 value2)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				Sse.Store(&value1.M11, Sse.Add(Sse.LoadVector128(&value1.M11), Sse.LoadVector128(&value2.M11)));
				Sse.Store(&value1.M21, Sse.Add(Sse.LoadVector128(&value1.M21), Sse.LoadVector128(&value2.M21)));
				Sse.Store(&value1.M31, Sse.Add(Sse.LoadVector128(&value1.M31), Sse.LoadVector128(&value2.M31)));
				Sse.Store(&value1.M41, Sse.Add(Sse.LoadVector128(&value1.M41), Sse.LoadVector128(&value2.M41)));
				return value1;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = value1.M11 + value2.M11;
			result.M12 = value1.M12 + value2.M12;
			result.M13 = value1.M13 + value2.M13;
			result.M14 = value1.M14 + value2.M14;
			result.M21 = value1.M21 + value2.M21;
			result.M22 = value1.M22 + value2.M22;
			result.M23 = value1.M23 + value2.M23;
			result.M24 = value1.M24 + value2.M24;
			result.M31 = value1.M31 + value2.M31;
			result.M32 = value1.M32 + value2.M32;
			result.M33 = value1.M33 + value2.M33;
			result.M34 = value1.M34 + value2.M34;
			result.M41 = value1.M41 + value2.M41;
			result.M42 = value1.M42 + value2.M42;
			result.M43 = value1.M43 + value2.M43;
			result.M44 = value1.M44 + value2.M44;
			return result;
		}

		public unsafe static bool operator ==(Matrix4x4 value1, Matrix4x4 value2)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				if (VectorMath.Equal(Sse.LoadVector128(&value1.M11), Sse.LoadVector128(&value2.M11)) && VectorMath.Equal(Sse.LoadVector128(&value1.M21), Sse.LoadVector128(&value2.M21)) && VectorMath.Equal(Sse.LoadVector128(&value1.M31), Sse.LoadVector128(&value2.M31)))
				{
					return VectorMath.Equal(Sse.LoadVector128(&value1.M41), Sse.LoadVector128(&value2.M41));
				}
				return false;
			}
			if (value1.M11 == value2.M11 && value1.M22 == value2.M22 && value1.M33 == value2.M33 && value1.M44 == value2.M44 && value1.M12 == value2.M12 && value1.M13 == value2.M13 && value1.M14 == value2.M14 && value1.M21 == value2.M21 && value1.M23 == value2.M23 && value1.M24 == value2.M24 && value1.M31 == value2.M31 && value1.M32 == value2.M32 && value1.M34 == value2.M34 && value1.M41 == value2.M41 && value1.M42 == value2.M42)
			{
				return value1.M43 == value2.M43;
			}
			return false;
		}

		public unsafe static bool operator !=(Matrix4x4 value1, Matrix4x4 value2)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				if (!VectorMath.NotEqual(Sse.LoadVector128(&value1.M11), Sse.LoadVector128(&value2.M11)) && !VectorMath.NotEqual(Sse.LoadVector128(&value1.M21), Sse.LoadVector128(&value2.M21)) && !VectorMath.NotEqual(Sse.LoadVector128(&value1.M31), Sse.LoadVector128(&value2.M31)))
				{
					return VectorMath.NotEqual(Sse.LoadVector128(&value1.M41), Sse.LoadVector128(&value2.M41));
				}
				return true;
			}
			if (value1.M11 == value2.M11 && value1.M12 == value2.M12 && value1.M13 == value2.M13 && value1.M14 == value2.M14 && value1.M21 == value2.M21 && value1.M22 == value2.M22 && value1.M23 == value2.M23 && value1.M24 == value2.M24 && value1.M31 == value2.M31 && value1.M32 == value2.M32 && value1.M33 == value2.M33 && value1.M34 == value2.M34 && value1.M41 == value2.M41 && value1.M42 == value2.M42 && value1.M43 == value2.M43)
			{
				return value1.M44 != value2.M44;
			}
			return true;
		}

		public unsafe static Matrix4x4 operator *(Matrix4x4 value1, Matrix4x4 value2)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				Vector128<float> vector = Sse.LoadVector128(&value1.M11);
				Sse.Store(&value1.M11, Sse.Add(Sse.Add(Sse.Multiply(Sse.Shuffle(vector, vector, 0), Sse.LoadVector128(&value2.M11)), Sse.Multiply(Sse.Shuffle(vector, vector, 85), Sse.LoadVector128(&value2.M21))), Sse.Add(Sse.Multiply(Sse.Shuffle(vector, vector, 170), Sse.LoadVector128(&value2.M31)), Sse.Multiply(Sse.Shuffle(vector, vector, byte.MaxValue), Sse.LoadVector128(&value2.M41)))));
				vector = Sse.LoadVector128(&value1.M21);
				Sse.Store(&value1.M21, Sse.Add(Sse.Add(Sse.Multiply(Sse.Shuffle(vector, vector, 0), Sse.LoadVector128(&value2.M11)), Sse.Multiply(Sse.Shuffle(vector, vector, 85), Sse.LoadVector128(&value2.M21))), Sse.Add(Sse.Multiply(Sse.Shuffle(vector, vector, 170), Sse.LoadVector128(&value2.M31)), Sse.Multiply(Sse.Shuffle(vector, vector, byte.MaxValue), Sse.LoadVector128(&value2.M41)))));
				vector = Sse.LoadVector128(&value1.M31);
				Sse.Store(&value1.M31, Sse.Add(Sse.Add(Sse.Multiply(Sse.Shuffle(vector, vector, 0), Sse.LoadVector128(&value2.M11)), Sse.Multiply(Sse.Shuffle(vector, vector, 85), Sse.LoadVector128(&value2.M21))), Sse.Add(Sse.Multiply(Sse.Shuffle(vector, vector, 170), Sse.LoadVector128(&value2.M31)), Sse.Multiply(Sse.Shuffle(vector, vector, byte.MaxValue), Sse.LoadVector128(&value2.M41)))));
				vector = Sse.LoadVector128(&value1.M41);
				Sse.Store(&value1.M41, Sse.Add(Sse.Add(Sse.Multiply(Sse.Shuffle(vector, vector, 0), Sse.LoadVector128(&value2.M11)), Sse.Multiply(Sse.Shuffle(vector, vector, 85), Sse.LoadVector128(&value2.M21))), Sse.Add(Sse.Multiply(Sse.Shuffle(vector, vector, 170), Sse.LoadVector128(&value2.M31)), Sse.Multiply(Sse.Shuffle(vector, vector, byte.MaxValue), Sse.LoadVector128(&value2.M41)))));
				return value1;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = value1.M11 * value2.M11 + value1.M12 * value2.M21 + value1.M13 * value2.M31 + value1.M14 * value2.M41;
			result.M12 = value1.M11 * value2.M12 + value1.M12 * value2.M22 + value1.M13 * value2.M32 + value1.M14 * value2.M42;
			result.M13 = value1.M11 * value2.M13 + value1.M12 * value2.M23 + value1.M13 * value2.M33 + value1.M14 * value2.M43;
			result.M14 = value1.M11 * value2.M14 + value1.M12 * value2.M24 + value1.M13 * value2.M34 + value1.M14 * value2.M44;
			result.M21 = value1.M21 * value2.M11 + value1.M22 * value2.M21 + value1.M23 * value2.M31 + value1.M24 * value2.M41;
			result.M22 = value1.M21 * value2.M12 + value1.M22 * value2.M22 + value1.M23 * value2.M32 + value1.M24 * value2.M42;
			result.M23 = value1.M21 * value2.M13 + value1.M22 * value2.M23 + value1.M23 * value2.M33 + value1.M24 * value2.M43;
			result.M24 = value1.M21 * value2.M14 + value1.M22 * value2.M24 + value1.M23 * value2.M34 + value1.M24 * value2.M44;
			result.M31 = value1.M31 * value2.M11 + value1.M32 * value2.M21 + value1.M33 * value2.M31 + value1.M34 * value2.M41;
			result.M32 = value1.M31 * value2.M12 + value1.M32 * value2.M22 + value1.M33 * value2.M32 + value1.M34 * value2.M42;
			result.M33 = value1.M31 * value2.M13 + value1.M32 * value2.M23 + value1.M33 * value2.M33 + value1.M34 * value2.M43;
			result.M34 = value1.M31 * value2.M14 + value1.M32 * value2.M24 + value1.M33 * value2.M34 + value1.M34 * value2.M44;
			result.M41 = value1.M41 * value2.M11 + value1.M42 * value2.M21 + value1.M43 * value2.M31 + value1.M44 * value2.M41;
			result.M42 = value1.M41 * value2.M12 + value1.M42 * value2.M22 + value1.M43 * value2.M32 + value1.M44 * value2.M42;
			result.M43 = value1.M41 * value2.M13 + value1.M42 * value2.M23 + value1.M43 * value2.M33 + value1.M44 * value2.M43;
			result.M44 = value1.M41 * value2.M14 + value1.M42 * value2.M24 + value1.M43 * value2.M34 + value1.M44 * value2.M44;
			return result;
		}

		public unsafe static Matrix4x4 operator *(Matrix4x4 value1, float value2)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				Vector128<float> right = Vector128.Create(value2);
				Sse.Store(&value1.M11, Sse.Multiply(Sse.LoadVector128(&value1.M11), right));
				Sse.Store(&value1.M21, Sse.Multiply(Sse.LoadVector128(&value1.M21), right));
				Sse.Store(&value1.M31, Sse.Multiply(Sse.LoadVector128(&value1.M31), right));
				Sse.Store(&value1.M41, Sse.Multiply(Sse.LoadVector128(&value1.M41), right));
				return value1;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = value1.M11 * value2;
			result.M12 = value1.M12 * value2;
			result.M13 = value1.M13 * value2;
			result.M14 = value1.M14 * value2;
			result.M21 = value1.M21 * value2;
			result.M22 = value1.M22 * value2;
			result.M23 = value1.M23 * value2;
			result.M24 = value1.M24 * value2;
			result.M31 = value1.M31 * value2;
			result.M32 = value1.M32 * value2;
			result.M33 = value1.M33 * value2;
			result.M34 = value1.M34 * value2;
			result.M41 = value1.M41 * value2;
			result.M42 = value1.M42 * value2;
			result.M43 = value1.M43 * value2;
			result.M44 = value1.M44 * value2;
			return result;
		}

		public unsafe static Matrix4x4 operator -(Matrix4x4 value1, Matrix4x4 value2)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				Sse.Store(&value1.M11, Sse.Subtract(Sse.LoadVector128(&value1.M11), Sse.LoadVector128(&value2.M11)));
				Sse.Store(&value1.M21, Sse.Subtract(Sse.LoadVector128(&value1.M21), Sse.LoadVector128(&value2.M21)));
				Sse.Store(&value1.M31, Sse.Subtract(Sse.LoadVector128(&value1.M31), Sse.LoadVector128(&value2.M31)));
				Sse.Store(&value1.M41, Sse.Subtract(Sse.LoadVector128(&value1.M41), Sse.LoadVector128(&value2.M41)));
				return value1;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = value1.M11 - value2.M11;
			result.M12 = value1.M12 - value2.M12;
			result.M13 = value1.M13 - value2.M13;
			result.M14 = value1.M14 - value2.M14;
			result.M21 = value1.M21 - value2.M21;
			result.M22 = value1.M22 - value2.M22;
			result.M23 = value1.M23 - value2.M23;
			result.M24 = value1.M24 - value2.M24;
			result.M31 = value1.M31 - value2.M31;
			result.M32 = value1.M32 - value2.M32;
			result.M33 = value1.M33 - value2.M33;
			result.M34 = value1.M34 - value2.M34;
			result.M41 = value1.M41 - value2.M41;
			result.M42 = value1.M42 - value2.M42;
			result.M43 = value1.M43 - value2.M43;
			result.M44 = value1.M44 - value2.M44;
			return result;
		}

		public unsafe static Matrix4x4 operator -(Matrix4x4 value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				Vector128<float> zero = Vector128<float>.Zero;
				Sse.Store(&value.M11, Sse.Subtract(zero, Sse.LoadVector128(&value.M11)));
				Sse.Store(&value.M21, Sse.Subtract(zero, Sse.LoadVector128(&value.M21)));
				Sse.Store(&value.M31, Sse.Subtract(zero, Sse.LoadVector128(&value.M31)));
				Sse.Store(&value.M41, Sse.Subtract(zero, Sse.LoadVector128(&value.M41)));
				return value;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = 0f - value.M11;
			result.M12 = 0f - value.M12;
			result.M13 = 0f - value.M13;
			result.M14 = 0f - value.M14;
			result.M21 = 0f - value.M21;
			result.M22 = 0f - value.M22;
			result.M23 = 0f - value.M23;
			result.M24 = 0f - value.M24;
			result.M31 = 0f - value.M31;
			result.M32 = 0f - value.M32;
			result.M33 = 0f - value.M33;
			result.M34 = 0f - value.M34;
			result.M41 = 0f - value.M41;
			result.M42 = 0f - value.M42;
			result.M43 = 0f - value.M43;
			result.M44 = 0f - value.M44;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix4x4 Add(Matrix4x4 value1, Matrix4x4 value2)
		{
			return value1 + value2;
		}

		public static Matrix4x4 CreateBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 cameraUpVector, Vector3 cameraForwardVector)
		{
			Vector3 left = objectPosition - cameraPosition;
			float num = left.LengthSquared();
			left = ((!(num < 0.0001f)) ? Vector3.Multiply(left, 1f / MathF.Sqrt(num)) : (-cameraForwardVector));
			Vector3 vector = Vector3.Normalize(Vector3.Cross(cameraUpVector, left));
			Vector3 vector2 = Vector3.Cross(left, vector);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = vector.X;
			result.M12 = vector.Y;
			result.M13 = vector.Z;
			result.M14 = 0f;
			result.M21 = vector2.X;
			result.M22 = vector2.Y;
			result.M23 = vector2.Z;
			result.M24 = 0f;
			result.M31 = left.X;
			result.M32 = left.Y;
			result.M33 = left.Z;
			result.M34 = 0f;
			result.M41 = objectPosition.X;
			result.M42 = objectPosition.Y;
			result.M43 = objectPosition.Z;
			result.M44 = 1f;
			return result;
		}

		public static Matrix4x4 CreateConstrainedBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 rotateAxis, Vector3 cameraForwardVector, Vector3 objectForwardVector)
		{
			Vector3 left = objectPosition - cameraPosition;
			float num = left.LengthSquared();
			left = ((!(num < 0.0001f)) ? Vector3.Multiply(left, 1f / MathF.Sqrt(num)) : (-cameraForwardVector));
			Vector3 vector = rotateAxis;
			float x = Vector3.Dot(rotateAxis, left);
			Vector3 vector3;
			Vector3 vector2;
			if (MathF.Abs(x) > 0.99825466f)
			{
				vector2 = objectForwardVector;
				x = Vector3.Dot(rotateAxis, vector2);
				if (MathF.Abs(x) > 0.99825466f)
				{
					vector2 = ((MathF.Abs(rotateAxis.Z) > 0.99825466f) ? new Vector3(1f, 0f, 0f) : new Vector3(0f, 0f, -1f));
				}
				vector3 = Vector3.Normalize(Vector3.Cross(rotateAxis, vector2));
				vector2 = Vector3.Normalize(Vector3.Cross(vector3, rotateAxis));
			}
			else
			{
				vector3 = Vector3.Normalize(Vector3.Cross(rotateAxis, left));
				vector2 = Vector3.Normalize(Vector3.Cross(vector3, vector));
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = vector3.X;
			result.M12 = vector3.Y;
			result.M13 = vector3.Z;
			result.M14 = 0f;
			result.M21 = vector.X;
			result.M22 = vector.Y;
			result.M23 = vector.Z;
			result.M24 = 0f;
			result.M31 = vector2.X;
			result.M32 = vector2.Y;
			result.M33 = vector2.Z;
			result.M34 = 0f;
			result.M41 = objectPosition.X;
			result.M42 = objectPosition.Y;
			result.M43 = objectPosition.Z;
			result.M44 = 1f;
			return result;
		}

		public static Matrix4x4 CreateFromAxisAngle(Vector3 axis, float angle)
		{
			float x = axis.X;
			float y = axis.Y;
			float z = axis.Z;
			float num = MathF.Sin(angle);
			float num2 = MathF.Cos(angle);
			float num3 = x * x;
			float num4 = y * y;
			float num5 = z * z;
			float num6 = x * y;
			float num7 = x * z;
			float num8 = y * z;
			Matrix4x4 identity = Identity;
			identity.M11 = num3 + num2 * (1f - num3);
			identity.M12 = num6 - num2 * num6 + num * z;
			identity.M13 = num7 - num2 * num7 - num * y;
			identity.M21 = num6 - num2 * num6 - num * z;
			identity.M22 = num4 + num2 * (1f - num4);
			identity.M23 = num8 - num2 * num8 + num * x;
			identity.M31 = num7 - num2 * num7 + num * y;
			identity.M32 = num8 - num2 * num8 - num * x;
			identity.M33 = num5 + num2 * (1f - num5);
			return identity;
		}

		public static Matrix4x4 CreateFromQuaternion(Quaternion quaternion)
		{
			Matrix4x4 identity = Identity;
			float num = quaternion.X * quaternion.X;
			float num2 = quaternion.Y * quaternion.Y;
			float num3 = quaternion.Z * quaternion.Z;
			float num4 = quaternion.X * quaternion.Y;
			float num5 = quaternion.Z * quaternion.W;
			float num6 = quaternion.Z * quaternion.X;
			float num7 = quaternion.Y * quaternion.W;
			float num8 = quaternion.Y * quaternion.Z;
			float num9 = quaternion.X * quaternion.W;
			identity.M11 = 1f - 2f * (num2 + num3);
			identity.M12 = 2f * (num4 + num5);
			identity.M13 = 2f * (num6 - num7);
			identity.M21 = 2f * (num4 - num5);
			identity.M22 = 1f - 2f * (num3 + num);
			identity.M23 = 2f * (num8 + num9);
			identity.M31 = 2f * (num6 + num7);
			identity.M32 = 2f * (num8 - num9);
			identity.M33 = 1f - 2f * (num2 + num);
			return identity;
		}

		public static Matrix4x4 CreateFromYawPitchRoll(float yaw, float pitch, float roll)
		{
			Quaternion quaternion = Quaternion.CreateFromYawPitchRoll(yaw, pitch, roll);
			return CreateFromQuaternion(quaternion);
		}

		public static Matrix4x4 CreateLookAt(Vector3 cameraPosition, Vector3 cameraTarget, Vector3 cameraUpVector)
		{
			Vector3 vector = Vector3.Normalize(cameraPosition - cameraTarget);
			Vector3 vector2 = Vector3.Normalize(Vector3.Cross(cameraUpVector, vector));
			Vector3 vector3 = Vector3.Cross(vector, vector2);
			Matrix4x4 identity = Identity;
			identity.M11 = vector2.X;
			identity.M12 = vector3.X;
			identity.M13 = vector.X;
			identity.M21 = vector2.Y;
			identity.M22 = vector3.Y;
			identity.M23 = vector.Y;
			identity.M31 = vector2.Z;
			identity.M32 = vector3.Z;
			identity.M33 = vector.Z;
			identity.M41 = 0f - Vector3.Dot(vector2, cameraPosition);
			identity.M42 = 0f - Vector3.Dot(vector3, cameraPosition);
			identity.M43 = 0f - Vector3.Dot(vector, cameraPosition);
			return identity;
		}

		public static Matrix4x4 CreateOrthographic(float width, float height, float zNearPlane, float zFarPlane)
		{
			Matrix4x4 identity = Identity;
			identity.M11 = 2f / width;
			identity.M22 = 2f / height;
			identity.M33 = 1f / (zNearPlane - zFarPlane);
			identity.M43 = zNearPlane / (zNearPlane - zFarPlane);
			return identity;
		}

		public static Matrix4x4 CreateOrthographicOffCenter(float left, float right, float bottom, float top, float zNearPlane, float zFarPlane)
		{
			Matrix4x4 identity = Identity;
			identity.M11 = 2f / (right - left);
			identity.M22 = 2f / (top - bottom);
			identity.M33 = 1f / (zNearPlane - zFarPlane);
			identity.M41 = (left + right) / (left - right);
			identity.M42 = (top + bottom) / (bottom - top);
			identity.M43 = zNearPlane / (zNearPlane - zFarPlane);
			return identity;
		}

		public static Matrix4x4 CreatePerspective(float width, float height, float nearPlaneDistance, float farPlaneDistance)
		{
			if (nearPlaneDistance <= 0f)
			{
				throw new ArgumentOutOfRangeException("nearPlaneDistance");
			}
			if (farPlaneDistance <= 0f)
			{
				throw new ArgumentOutOfRangeException("farPlaneDistance");
			}
			if (nearPlaneDistance >= farPlaneDistance)
			{
				throw new ArgumentOutOfRangeException("nearPlaneDistance");
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = 2f * nearPlaneDistance / width;
			result.M12 = (result.M13 = (result.M14 = 0f));
			result.M22 = 2f * nearPlaneDistance / height;
			result.M21 = (result.M23 = (result.M24 = 0f));
			float num = (result.M33 = (float.IsPositiveInfinity(farPlaneDistance) ? (-1f) : (farPlaneDistance / (nearPlaneDistance - farPlaneDistance))));
			result.M31 = (result.M32 = 0f);
			result.M34 = -1f;
			result.M41 = (result.M42 = (result.M44 = 0f));
			result.M43 = nearPlaneDistance * num;
			return result;
		}

		public static Matrix4x4 CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float nearPlaneDistance, float farPlaneDistance)
		{
			if (fieldOfView <= 0f || fieldOfView >= (float)Math.PI)
			{
				throw new ArgumentOutOfRangeException("fieldOfView");
			}
			if (nearPlaneDistance <= 0f)
			{
				throw new ArgumentOutOfRangeException("nearPlaneDistance");
			}
			if (farPlaneDistance <= 0f)
			{
				throw new ArgumentOutOfRangeException("farPlaneDistance");
			}
			if (nearPlaneDistance >= farPlaneDistance)
			{
				throw new ArgumentOutOfRangeException("nearPlaneDistance");
			}
			float num = 1f / MathF.Tan(fieldOfView * 0.5f);
			float m = num / aspectRatio;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = m;
			result.M12 = (result.M13 = (result.M14 = 0f));
			result.M22 = num;
			result.M21 = (result.M23 = (result.M24 = 0f));
			result.M31 = (result.M32 = 0f);
			float num2 = (result.M33 = (float.IsPositiveInfinity(farPlaneDistance) ? (-1f) : (farPlaneDistance / (nearPlaneDistance - farPlaneDistance))));
			result.M34 = -1f;
			result.M41 = (result.M42 = (result.M44 = 0f));
			result.M43 = nearPlaneDistance * num2;
			return result;
		}

		public static Matrix4x4 CreatePerspectiveOffCenter(float left, float right, float bottom, float top, float nearPlaneDistance, float farPlaneDistance)
		{
			if (nearPlaneDistance <= 0f)
			{
				throw new ArgumentOutOfRangeException("nearPlaneDistance");
			}
			if (farPlaneDistance <= 0f)
			{
				throw new ArgumentOutOfRangeException("farPlaneDistance");
			}
			if (nearPlaneDistance >= farPlaneDistance)
			{
				throw new ArgumentOutOfRangeException("nearPlaneDistance");
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = 2f * nearPlaneDistance / (right - left);
			result.M12 = (result.M13 = (result.M14 = 0f));
			result.M22 = 2f * nearPlaneDistance / (top - bottom);
			result.M21 = (result.M23 = (result.M24 = 0f));
			result.M31 = (left + right) / (right - left);
			result.M32 = (top + bottom) / (top - bottom);
			float num = (result.M33 = (float.IsPositiveInfinity(farPlaneDistance) ? (-1f) : (farPlaneDistance / (nearPlaneDistance - farPlaneDistance))));
			result.M34 = -1f;
			result.M43 = nearPlaneDistance * num;
			result.M41 = (result.M42 = (result.M44 = 0f));
			return result;
		}

		public static Matrix4x4 CreateReflection(Plane value)
		{
			value = Plane.Normalize(value);
			float x = value.Normal.X;
			float y = value.Normal.Y;
			float z = value.Normal.Z;
			float num = -2f * x;
			float num2 = -2f * y;
			float num3 = -2f * z;
			Matrix4x4 identity = Identity;
			identity.M11 = num * x + 1f;
			identity.M12 = num2 * x;
			identity.M13 = num3 * x;
			identity.M21 = num * y;
			identity.M22 = num2 * y + 1f;
			identity.M23 = num3 * y;
			identity.M31 = num * z;
			identity.M32 = num2 * z;
			identity.M33 = num3 * z + 1f;
			identity.M41 = num * value.D;
			identity.M42 = num2 * value.D;
			identity.M43 = num3 * value.D;
			return identity;
		}

		public static Matrix4x4 CreateRotationX(float radians)
		{
			Matrix4x4 identity = Identity;
			float num = MathF.Cos(radians);
			float num2 = MathF.Sin(radians);
			identity.M22 = num;
			identity.M23 = num2;
			identity.M32 = 0f - num2;
			identity.M33 = num;
			return identity;
		}

		public static Matrix4x4 CreateRotationX(float radians, Vector3 centerPoint)
		{
			Matrix4x4 identity = Identity;
			float num = MathF.Cos(radians);
			float num2 = MathF.Sin(radians);
			float m = centerPoint.Y * (1f - num) + centerPoint.Z * num2;
			float m2 = centerPoint.Z * (1f - num) - centerPoint.Y * num2;
			identity.M22 = num;
			identity.M23 = num2;
			identity.M32 = 0f - num2;
			identity.M33 = num;
			identity.M42 = m;
			identity.M43 = m2;
			return identity;
		}

		public static Matrix4x4 CreateRotationY(float radians)
		{
			Matrix4x4 identity = Identity;
			float num = MathF.Cos(radians);
			float num2 = MathF.Sin(radians);
			identity.M11 = num;
			identity.M13 = 0f - num2;
			identity.M31 = num2;
			identity.M33 = num;
			return identity;
		}

		public static Matrix4x4 CreateRotationY(float radians, Vector3 centerPoint)
		{
			Matrix4x4 identity = Identity;
			float num = MathF.Cos(radians);
			float num2 = MathF.Sin(radians);
			float m = centerPoint.X * (1f - num) - centerPoint.Z * num2;
			float m2 = centerPoint.Z * (1f - num) + centerPoint.X * num2;
			identity.M11 = num;
			identity.M13 = 0f - num2;
			identity.M31 = num2;
			identity.M33 = num;
			identity.M41 = m;
			identity.M43 = m2;
			return identity;
		}

		public static Matrix4x4 CreateRotationZ(float radians)
		{
			Matrix4x4 identity = Identity;
			float num = MathF.Cos(radians);
			float num2 = MathF.Sin(radians);
			identity.M11 = num;
			identity.M12 = num2;
			identity.M21 = 0f - num2;
			identity.M22 = num;
			return identity;
		}

		public static Matrix4x4 CreateRotationZ(float radians, Vector3 centerPoint)
		{
			Matrix4x4 identity = Identity;
			float num = MathF.Cos(radians);
			float num2 = MathF.Sin(radians);
			float m = centerPoint.X * (1f - num) + centerPoint.Y * num2;
			float m2 = centerPoint.Y * (1f - num) - centerPoint.X * num2;
			identity.M11 = num;
			identity.M12 = num2;
			identity.M21 = 0f - num2;
			identity.M22 = num;
			identity.M41 = m;
			identity.M42 = m2;
			return identity;
		}

		public static Matrix4x4 CreateScale(float xScale, float yScale, float zScale)
		{
			Matrix4x4 identity = Identity;
			identity.M11 = xScale;
			identity.M22 = yScale;
			identity.M33 = zScale;
			return identity;
		}

		public static Matrix4x4 CreateScale(float xScale, float yScale, float zScale, Vector3 centerPoint)
		{
			Matrix4x4 identity = Identity;
			float m = centerPoint.X * (1f - xScale);
			float m2 = centerPoint.Y * (1f - yScale);
			float m3 = centerPoint.Z * (1f - zScale);
			identity.M11 = xScale;
			identity.M22 = yScale;
			identity.M33 = zScale;
			identity.M41 = m;
			identity.M42 = m2;
			identity.M43 = m3;
			return identity;
		}

		public static Matrix4x4 CreateScale(Vector3 scales)
		{
			Matrix4x4 identity = Identity;
			identity.M11 = scales.X;
			identity.M22 = scales.Y;
			identity.M33 = scales.Z;
			return identity;
		}

		public static Matrix4x4 CreateScale(Vector3 scales, Vector3 centerPoint)
		{
			Matrix4x4 identity = Identity;
			float m = centerPoint.X * (1f - scales.X);
			float m2 = centerPoint.Y * (1f - scales.Y);
			float m3 = centerPoint.Z * (1f - scales.Z);
			identity.M11 = scales.X;
			identity.M22 = scales.Y;
			identity.M33 = scales.Z;
			identity.M41 = m;
			identity.M42 = m2;
			identity.M43 = m3;
			return identity;
		}

		public static Matrix4x4 CreateScale(float scale)
		{
			Matrix4x4 identity = Identity;
			identity.M11 = scale;
			identity.M22 = scale;
			identity.M33 = scale;
			return identity;
		}

		public static Matrix4x4 CreateScale(float scale, Vector3 centerPoint)
		{
			Matrix4x4 identity = Identity;
			float m = centerPoint.X * (1f - scale);
			float m2 = centerPoint.Y * (1f - scale);
			float m3 = centerPoint.Z * (1f - scale);
			identity.M11 = scale;
			identity.M22 = scale;
			identity.M33 = scale;
			identity.M41 = m;
			identity.M42 = m2;
			identity.M43 = m3;
			return identity;
		}

		public static Matrix4x4 CreateShadow(Vector3 lightDirection, Plane plane)
		{
			Plane plane2 = Plane.Normalize(plane);
			float num = plane2.Normal.X * lightDirection.X + plane2.Normal.Y * lightDirection.Y + plane2.Normal.Z * lightDirection.Z;
			float num2 = 0f - plane2.Normal.X;
			float num3 = 0f - plane2.Normal.Y;
			float num4 = 0f - plane2.Normal.Z;
			float num5 = 0f - plane2.D;
			Matrix4x4 identity = Identity;
			identity.M11 = num2 * lightDirection.X + num;
			identity.M21 = num3 * lightDirection.X;
			identity.M31 = num4 * lightDirection.X;
			identity.M41 = num5 * lightDirection.X;
			identity.M12 = num2 * lightDirection.Y;
			identity.M22 = num3 * lightDirection.Y + num;
			identity.M32 = num4 * lightDirection.Y;
			identity.M42 = num5 * lightDirection.Y;
			identity.M13 = num2 * lightDirection.Z;
			identity.M23 = num3 * lightDirection.Z;
			identity.M33 = num4 * lightDirection.Z + num;
			identity.M43 = num5 * lightDirection.Z;
			identity.M44 = num;
			return identity;
		}

		public static Matrix4x4 CreateTranslation(Vector3 position)
		{
			Matrix4x4 identity = Identity;
			identity.M41 = position.X;
			identity.M42 = position.Y;
			identity.M43 = position.Z;
			return identity;
		}

		public static Matrix4x4 CreateTranslation(float xPosition, float yPosition, float zPosition)
		{
			Matrix4x4 identity = Identity;
			identity.M41 = xPosition;
			identity.M42 = yPosition;
			identity.M43 = zPosition;
			return identity;
		}

		public static Matrix4x4 CreateWorld(Vector3 position, Vector3 forward, Vector3 up)
		{
			Vector3 vector = Vector3.Normalize(-forward);
			Vector3 vector2 = Vector3.Normalize(Vector3.Cross(up, vector));
			Vector3 vector3 = Vector3.Cross(vector, vector2);
			Matrix4x4 identity = Identity;
			identity.M11 = vector2.X;
			identity.M12 = vector2.Y;
			identity.M13 = vector2.Z;
			identity.M21 = vector3.X;
			identity.M22 = vector3.Y;
			identity.M23 = vector3.Z;
			identity.M31 = vector.X;
			identity.M32 = vector.Y;
			identity.M33 = vector.Z;
			identity.M41 = position.X;
			identity.M42 = position.Y;
			identity.M43 = position.Z;
			return identity;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Invert(Matrix4x4 matrix, out Matrix4x4 result)
		{
			if (Sse.IsSupported)
			{
				return SseImpl(matrix, out result);
			}
			return SoftwareFallback(matrix, out result);
			static bool SoftwareFallback(Matrix4x4 matrix, out Matrix4x4 result)
			{
				float m = matrix.M11;
				float m2 = matrix.M12;
				float m3 = matrix.M13;
				float m4 = matrix.M14;
				float m5 = matrix.M21;
				float m6 = matrix.M22;
				float m7 = matrix.M23;
				float m8 = matrix.M24;
				float m9 = matrix.M31;
				float m10 = matrix.M32;
				float m11 = matrix.M33;
				float m12 = matrix.M34;
				float m13 = matrix.M41;
				float m14 = matrix.M42;
				float m15 = matrix.M43;
				float m16 = matrix.M44;
				float num = m11 * m16 - m12 * m15;
				float num2 = m10 * m16 - m12 * m14;
				float num3 = m10 * m15 - m11 * m14;
				float num4 = m9 * m16 - m12 * m13;
				float num5 = m9 * m15 - m11 * m13;
				float num6 = m9 * m14 - m10 * m13;
				float num7 = m6 * num - m7 * num2 + m8 * num3;
				float num8 = 0f - (m5 * num - m7 * num4 + m8 * num5);
				float num9 = m5 * num2 - m6 * num4 + m8 * num6;
				float num10 = 0f - (m5 * num3 - m6 * num5 + m7 * num6);
				float num11 = m * num7 + m2 * num8 + m3 * num9 + m4 * num10;
				if (MathF.Abs(num11) < float.Epsilon)
				{
					result = new Matrix4x4(float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN);
					return false;
				}
				float num12 = 1f / num11;
				result.M11 = num7 * num12;
				result.M21 = num8 * num12;
				result.M31 = num9 * num12;
				result.M41 = num10 * num12;
				result.M12 = (0f - (m2 * num - m3 * num2 + m4 * num3)) * num12;
				result.M22 = (m * num - m3 * num4 + m4 * num5) * num12;
				result.M32 = (0f - (m * num2 - m2 * num4 + m4 * num6)) * num12;
				result.M42 = (m * num3 - m2 * num5 + m3 * num6) * num12;
				float num13 = m7 * m16 - m8 * m15;
				float num14 = m6 * m16 - m8 * m14;
				float num15 = m6 * m15 - m7 * m14;
				float num16 = m5 * m16 - m8 * m13;
				float num17 = m5 * m15 - m7 * m13;
				float num18 = m5 * m14 - m6 * m13;
				result.M13 = (m2 * num13 - m3 * num14 + m4 * num15) * num12;
				result.M23 = (0f - (m * num13 - m3 * num16 + m4 * num17)) * num12;
				result.M33 = (m * num14 - m2 * num16 + m4 * num18) * num12;
				result.M43 = (0f - (m * num15 - m2 * num17 + m3 * num18)) * num12;
				float num19 = m7 * m12 - m8 * m11;
				float num20 = m6 * m12 - m8 * m10;
				float num21 = m6 * m11 - m7 * m10;
				float num22 = m5 * m12 - m8 * m9;
				float num23 = m5 * m11 - m7 * m9;
				float num24 = m5 * m10 - m6 * m9;
				result.M14 = (0f - (m2 * num19 - m3 * num20 + m4 * num21)) * num12;
				result.M24 = (m * num19 - m3 * num22 + m4 * num23) * num12;
				result.M34 = (0f - (m * num20 - m2 * num22 + m4 * num24)) * num12;
				result.M44 = (m * num21 - m2 * num23 + m3 * num24) * num12;
				return true;
			}
			unsafe static bool SseImpl(Matrix4x4 matrix, out Matrix4x4 result)
			{
				if (!Sse.IsSupported)
				{
					throw new PlatformNotSupportedException();
				}
				Vector128<float> left = Sse.LoadVector128(&matrix.M11);
				Vector128<float> right = Sse.LoadVector128(&matrix.M21);
				Vector128<float> left2 = Sse.LoadVector128(&matrix.M31);
				Vector128<float> right2 = Sse.LoadVector128(&matrix.M41);
				Vector128<float> left3 = Sse.Shuffle(left, right, 68);
				Vector128<float> left4 = Sse.Shuffle(left, right, 238);
				Vector128<float> right3 = Sse.Shuffle(left2, right2, 68);
				Vector128<float> right4 = Sse.Shuffle(left2, right2, 238);
				left = Sse.Shuffle(left3, right3, 136);
				right = Sse.Shuffle(left3, right3, 221);
				left2 = Sse.Shuffle(left4, right4, 136);
				right2 = Sse.Shuffle(left4, right4, 221);
				Vector128<float> left5 = Permute(left2, 80);
				Vector128<float> right5 = Permute(right2, 238);
				Vector128<float> left6 = Permute(left, 80);
				Vector128<float> right6 = Permute(right, 238);
				Vector128<float> left7 = Sse.Shuffle(left2, left, 136);
				Vector128<float> right7 = Sse.Shuffle(right2, right, 221);
				Vector128<float> left8 = Sse.Multiply(left5, right5);
				Vector128<float> left9 = Sse.Multiply(left6, right6);
				Vector128<float> left10 = Sse.Multiply(left7, right7);
				left5 = Permute(left2, 238);
				right5 = Permute(right2, 80);
				left6 = Permute(left, 238);
				right6 = Permute(right, 80);
				left7 = Sse.Shuffle(left2, left, 221);
				right7 = Sse.Shuffle(right2, right, 136);
				left8 = Sse.Subtract(left8, Sse.Multiply(left5, right5));
				left9 = Sse.Subtract(left9, Sse.Multiply(left6, right6));
				left10 = Sse.Subtract(left10, Sse.Multiply(left7, right7));
				right6 = Sse.Shuffle(left8, left10, 93);
				left5 = Permute(right, 73);
				right5 = Sse.Shuffle(right6, left8, 50);
				left6 = Permute(left, 18);
				right6 = Sse.Shuffle(right6, left8, 153);
				Vector128<float> left11 = Sse.Shuffle(left9, left10, 253);
				left7 = Permute(right2, 73);
				right7 = Sse.Shuffle(left11, left9, 50);
				Vector128<float> left12 = Permute(left2, 18);
				left11 = Sse.Shuffle(left11, left9, 153);
				Vector128<float> left13 = Sse.Multiply(left5, right5);
				Vector128<float> left14 = Sse.Multiply(left6, right6);
				Vector128<float> left15 = Sse.Multiply(left7, right7);
				Vector128<float> left16 = Sse.Multiply(left12, left11);
				right6 = Sse.Shuffle(left8, left10, 4);
				left5 = Permute(right, 158);
				right5 = Sse.Shuffle(left8, right6, 147);
				left6 = Permute(left, 123);
				right6 = Sse.Shuffle(left8, right6, 38);
				left11 = Sse.Shuffle(left9, left10, 164);
				left7 = Permute(right2, 158);
				right7 = Sse.Shuffle(left9, left11, 147);
				left12 = Permute(left2, 123);
				left11 = Sse.Shuffle(left9, left11, 38);
				left13 = Sse.Subtract(left13, Sse.Multiply(left5, right5));
				left14 = Sse.Subtract(left14, Sse.Multiply(left6, right6));
				left15 = Sse.Subtract(left15, Sse.Multiply(left7, right7));
				left16 = Sse.Subtract(left16, Sse.Multiply(left12, left11));
				left5 = Permute(right, 51);
				right5 = Sse.Shuffle(left8, left10, 74);
				right5 = Permute(right5, 44);
				left6 = Permute(left, 141);
				right6 = Sse.Shuffle(left8, left10, 76);
				right6 = Permute(right6, 147);
				left7 = Permute(right2, 51);
				right7 = Sse.Shuffle(left9, left10, 234);
				right7 = Permute(right7, 44);
				left12 = Permute(left2, 141);
				left11 = Sse.Shuffle(left9, left10, 236);
				left11 = Permute(left11, 147);
				left5 = Sse.Multiply(left5, right5);
				left6 = Sse.Multiply(left6, right6);
				left7 = Sse.Multiply(left7, right7);
				left12 = Sse.Multiply(left12, left11);
				Vector128<float> right8 = Sse.Subtract(left13, left5);
				left13 = Sse.Add(left13, left5);
				Vector128<float> right9 = Sse.Add(left14, left6);
				left14 = Sse.Subtract(left14, left6);
				Vector128<float> right10 = Sse.Subtract(left15, left7);
				left15 = Sse.Add(left15, left7);
				Vector128<float> right11 = Sse.Add(left16, left12);
				left16 = Sse.Subtract(left16, left12);
				left13 = Sse.Shuffle(left13, right8, 216);
				left14 = Sse.Shuffle(left14, right9, 216);
				left15 = Sse.Shuffle(left15, right10, 216);
				left16 = Sse.Shuffle(left16, right11, 216);
				left13 = Permute(left13, 216);
				left14 = Permute(left14, 216);
				left15 = Permute(left15, 216);
				left16 = Permute(left16, 216);
				right3 = left;
				float num25 = Vector4.Dot(left13.AsVector4(), right3.AsVector4());
				if (MathF.Abs(num25) < float.Epsilon)
				{
					result = new Matrix4x4(float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN, float.NaN);
					return false;
				}
				Vector128<float> left17 = Vector128.Create(1f);
				Vector128<float> right12 = Vector128.Create(num25);
				right12 = Sse.Divide(left17, right12);
				left = Sse.Multiply(left13, right12);
				right = Sse.Multiply(left14, right12);
				left2 = Sse.Multiply(left15, right12);
				right2 = Sse.Multiply(left16, right12);
				Unsafe.SkipInit<Matrix4x4>(out result);
				ref Vector128<float> reference = ref Unsafe.As<Matrix4x4, Vector128<float>>(ref result);
				reference = left;
				Unsafe.Add(ref reference, 1) = right;
				Unsafe.Add(ref reference, 2) = left2;
				Unsafe.Add(ref reference, 3) = right2;
				return true;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix4x4 Multiply(Matrix4x4 value1, Matrix4x4 value2)
		{
			return value1 * value2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix4x4 Multiply(Matrix4x4 value1, float value2)
		{
			return value1 * value2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix4x4 Negate(Matrix4x4 value)
		{
			return -value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Matrix4x4 Subtract(Matrix4x4 value1, Matrix4x4 value2)
		{
			return value1 - value2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector128<float> Permute(Vector128<float> value, byte control)
		{
			if (Avx.IsSupported)
			{
				return Avx.Permute(value, control);
			}
			if (Sse.IsSupported)
			{
				return Sse.Shuffle(value, value, control);
			}
			throw new PlatformNotSupportedException();
		}

		public unsafe static bool Decompose(Matrix4x4 matrix, out Vector3 scale, out Quaternion rotation, out Vector3 translation)
		{
			bool result = true;
			fixed (Vector3* ptr = &scale)
			{
				float* ptr2 = (float*)ptr;
				System.Runtime.CompilerServices.Unsafe.SkipInit(out VectorBasis vectorBasis);
				Vector3** ptr3 = (Vector3**)(&vectorBasis);
				Matrix4x4 identity = Identity;
				CanonicalBasis canonicalBasis = default(CanonicalBasis);
				Vector3* ptr4 = &canonicalBasis.Row0;
				canonicalBasis.Row0 = new Vector3(1f, 0f, 0f);
				canonicalBasis.Row1 = new Vector3(0f, 1f, 0f);
				canonicalBasis.Row2 = new Vector3(0f, 0f, 1f);
				translation = new Vector3(matrix.M41, matrix.M42, matrix.M43);
				*ptr3 = (Vector3*)(&identity.M11);
				ptr3[1] = (Vector3*)(&identity.M21);
				ptr3[2] = (Vector3*)(&identity.M31);
				*(*ptr3) = new Vector3(matrix.M11, matrix.M12, matrix.M13);
				*ptr3[1] = new Vector3(matrix.M21, matrix.M22, matrix.M23);
				*ptr3[2] = new Vector3(matrix.M31, matrix.M32, matrix.M33);
				scale.X = (*ptr3)->Length();
				scale.Y = ptr3[1]->Length();
				scale.Z = ptr3[2]->Length();
				float num = *ptr2;
				float num2 = ptr2[1];
				float num3 = ptr2[2];
				uint num4;
				uint num5;
				uint num6;
				if (num < num2)
				{
					if (num2 < num3)
					{
						num4 = 2u;
						num5 = 1u;
						num6 = 0u;
					}
					else
					{
						num4 = 1u;
						if (num < num3)
						{
							num5 = 2u;
							num6 = 0u;
						}
						else
						{
							num5 = 0u;
							num6 = 2u;
						}
					}
				}
				else if (num < num3)
				{
					num4 = 2u;
					num5 = 0u;
					num6 = 1u;
				}
				else
				{
					num4 = 0u;
					if (num2 < num3)
					{
						num5 = 2u;
						num6 = 1u;
					}
					else
					{
						num5 = 1u;
						num6 = 2u;
					}
				}
				if (ptr2[num4] < 0.0001f)
				{
					*ptr3[num4] = ptr4[num4];
				}
				*ptr3[num4] = Vector3.Normalize(*ptr3[num4]);
				if (ptr2[num5] < 0.0001f)
				{
					float num7 = MathF.Abs(ptr3[num4]->X);
					float num8 = MathF.Abs(ptr3[num4]->Y);
					float num9 = MathF.Abs(ptr3[num4]->Z);
					uint num10 = ((num7 < num8) ? ((!(num8 < num9)) ? ((!(num7 < num9)) ? 2u : 0u) : 0u) : ((num7 < num9) ? 1u : ((num8 < num9) ? 1u : 2u)));
					*ptr3[num5] = Vector3.Cross(*ptr3[num4], ptr4[num10]);
				}
				*ptr3[num5] = Vector3.Normalize(*ptr3[num5]);
				if (ptr2[num6] < 0.0001f)
				{
					*ptr3[num6] = Vector3.Cross(*ptr3[num4], *ptr3[num5]);
				}
				*ptr3[num6] = Vector3.Normalize(*ptr3[num6]);
				float num11 = identity.GetDeterminant();
				if (num11 < 0f)
				{
					ptr2[num4] = 0f - ptr2[num4];
					*ptr3[num4] = -(*ptr3[num4]);
					num11 = 0f - num11;
				}
				num11 -= 1f;
				num11 *= num11;
				if (0.0001f < num11)
				{
					rotation = Quaternion.Identity;
					result = false;
				}
				else
				{
					rotation = Quaternion.CreateFromRotationMatrix(identity);
				}
			}
			return result;
		}

		public unsafe static Matrix4x4 Lerp(Matrix4x4 matrix1, Matrix4x4 matrix2, float amount)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				Vector128<float> t = Vector128.Create(amount);
				Sse.Store(&matrix1.M11, VectorMath.Lerp(Sse.LoadVector128(&matrix1.M11), Sse.LoadVector128(&matrix2.M11), t));
				Sse.Store(&matrix1.M21, VectorMath.Lerp(Sse.LoadVector128(&matrix1.M21), Sse.LoadVector128(&matrix2.M21), t));
				Sse.Store(&matrix1.M31, VectorMath.Lerp(Sse.LoadVector128(&matrix1.M31), Sse.LoadVector128(&matrix2.M31), t));
				Sse.Store(&matrix1.M41, VectorMath.Lerp(Sse.LoadVector128(&matrix1.M41), Sse.LoadVector128(&matrix2.M41), t));
				return matrix1;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = matrix1.M11 + (matrix2.M11 - matrix1.M11) * amount;
			result.M12 = matrix1.M12 + (matrix2.M12 - matrix1.M12) * amount;
			result.M13 = matrix1.M13 + (matrix2.M13 - matrix1.M13) * amount;
			result.M14 = matrix1.M14 + (matrix2.M14 - matrix1.M14) * amount;
			result.M21 = matrix1.M21 + (matrix2.M21 - matrix1.M21) * amount;
			result.M22 = matrix1.M22 + (matrix2.M22 - matrix1.M22) * amount;
			result.M23 = matrix1.M23 + (matrix2.M23 - matrix1.M23) * amount;
			result.M24 = matrix1.M24 + (matrix2.M24 - matrix1.M24) * amount;
			result.M31 = matrix1.M31 + (matrix2.M31 - matrix1.M31) * amount;
			result.M32 = matrix1.M32 + (matrix2.M32 - matrix1.M32) * amount;
			result.M33 = matrix1.M33 + (matrix2.M33 - matrix1.M33) * amount;
			result.M34 = matrix1.M34 + (matrix2.M34 - matrix1.M34) * amount;
			result.M41 = matrix1.M41 + (matrix2.M41 - matrix1.M41) * amount;
			result.M42 = matrix1.M42 + (matrix2.M42 - matrix1.M42) * amount;
			result.M43 = matrix1.M43 + (matrix2.M43 - matrix1.M43) * amount;
			result.M44 = matrix1.M44 + (matrix2.M44 - matrix1.M44) * amount;
			return result;
		}

		public static Matrix4x4 Transform(Matrix4x4 value, Quaternion rotation)
		{
			float num = rotation.X + rotation.X;
			float num2 = rotation.Y + rotation.Y;
			float num3 = rotation.Z + rotation.Z;
			float num4 = rotation.W * num;
			float num5 = rotation.W * num2;
			float num6 = rotation.W * num3;
			float num7 = rotation.X * num;
			float num8 = rotation.X * num2;
			float num9 = rotation.X * num3;
			float num10 = rotation.Y * num2;
			float num11 = rotation.Y * num3;
			float num12 = rotation.Z * num3;
			float num13 = 1f - num10 - num12;
			float num14 = num8 - num6;
			float num15 = num9 + num5;
			float num16 = num8 + num6;
			float num17 = 1f - num7 - num12;
			float num18 = num11 - num4;
			float num19 = num9 - num5;
			float num20 = num11 + num4;
			float num21 = 1f - num7 - num10;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = value.M11 * num13 + value.M12 * num14 + value.M13 * num15;
			result.M12 = value.M11 * num16 + value.M12 * num17 + value.M13 * num18;
			result.M13 = value.M11 * num19 + value.M12 * num20 + value.M13 * num21;
			result.M14 = value.M14;
			result.M21 = value.M21 * num13 + value.M22 * num14 + value.M23 * num15;
			result.M22 = value.M21 * num16 + value.M22 * num17 + value.M23 * num18;
			result.M23 = value.M21 * num19 + value.M22 * num20 + value.M23 * num21;
			result.M24 = value.M24;
			result.M31 = value.M31 * num13 + value.M32 * num14 + value.M33 * num15;
			result.M32 = value.M31 * num16 + value.M32 * num17 + value.M33 * num18;
			result.M33 = value.M31 * num19 + value.M32 * num20 + value.M33 * num21;
			result.M34 = value.M34;
			result.M41 = value.M41 * num13 + value.M42 * num14 + value.M43 * num15;
			result.M42 = value.M41 * num16 + value.M42 * num17 + value.M43 * num18;
			result.M43 = value.M41 * num19 + value.M42 * num20 + value.M43 * num21;
			result.M44 = value.M44;
			return result;
		}

		public unsafe static Matrix4x4 Transpose(Matrix4x4 matrix)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				Vector128<float> left = Sse.LoadVector128(&matrix.M11);
				Vector128<float> right = Sse.LoadVector128(&matrix.M21);
				Vector128<float> left2 = Sse.LoadVector128(&matrix.M31);
				Vector128<float> right2 = Sse.LoadVector128(&matrix.M41);
				Vector128<float> vector = Sse.UnpackLow(left, right);
				Vector128<float> vector2 = Sse.UnpackLow(left2, right2);
				Vector128<float> vector3 = Sse.UnpackHigh(left, right);
				Vector128<float> vector4 = Sse.UnpackHigh(left2, right2);
				Sse.Store(&matrix.M11, Sse.MoveLowToHigh(vector, vector2));
				Sse.Store(&matrix.M21, Sse.MoveHighToLow(vector2, vector));
				Sse.Store(&matrix.M31, Sse.MoveLowToHigh(vector3, vector4));
				Sse.Store(&matrix.M41, Sse.MoveHighToLow(vector4, vector3));
				return matrix;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Matrix4x4 result);
			result.M11 = matrix.M11;
			result.M12 = matrix.M21;
			result.M13 = matrix.M31;
			result.M14 = matrix.M41;
			result.M21 = matrix.M12;
			result.M22 = matrix.M22;
			result.M23 = matrix.M32;
			result.M24 = matrix.M42;
			result.M31 = matrix.M13;
			result.M32 = matrix.M23;
			result.M33 = matrix.M33;
			result.M34 = matrix.M43;
			result.M41 = matrix.M14;
			result.M42 = matrix.M24;
			result.M43 = matrix.M34;
			result.M44 = matrix.M44;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override readonly bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Matrix4x4 other)
			{
				return Equals(other);
			}
			return false;
		}

		public readonly bool Equals(Matrix4x4 other)
		{
			return this == other;
		}

		public readonly float GetDeterminant()
		{
			float m = M11;
			float m2 = M12;
			float m3 = M13;
			float m4 = M14;
			float m5 = M21;
			float m6 = M22;
			float m7 = M23;
			float m8 = M24;
			float m9 = M31;
			float m10 = M32;
			float m11 = M33;
			float m12 = M34;
			float m13 = M41;
			float m14 = M42;
			float m15 = M43;
			float m16 = M44;
			float num = m11 * m16 - m12 * m15;
			float num2 = m10 * m16 - m12 * m14;
			float num3 = m10 * m15 - m11 * m14;
			float num4 = m9 * m16 - m12 * m13;
			float num5 = m9 * m15 - m11 * m13;
			float num6 = m9 * m14 - m10 * m13;
			return m * (m6 * num - m7 * num2 + m8 * num3) - m2 * (m5 * num - m7 * num4 + m8 * num5) + m3 * (m5 * num2 - m6 * num4 + m8 * num6) - m4 * (m5 * num3 - m6 * num5 + m7 * num6);
		}

		public override readonly int GetHashCode()
		{
			HashCode hashCode = default(HashCode);
			hashCode.Add(M11);
			hashCode.Add(M12);
			hashCode.Add(M13);
			hashCode.Add(M14);
			hashCode.Add(M21);
			hashCode.Add(M22);
			hashCode.Add(M23);
			hashCode.Add(M24);
			hashCode.Add(M31);
			hashCode.Add(M32);
			hashCode.Add(M33);
			hashCode.Add(M34);
			hashCode.Add(M41);
			hashCode.Add(M42);
			hashCode.Add(M43);
			hashCode.Add(M44);
			return hashCode.ToHashCode();
		}

		public override readonly string ToString()
		{
			return $"{{ {{M11:{M11} M12:{M12} M13:{M13} M14:{M14}}} {{M21:{M21} M22:{M22} M23:{M23} M24:{M24}}} {{M31:{M31} M32:{M32} M33:{M33} M34:{M34}}} {{M41:{M41} M42:{M42} M43:{M43} M44:{M44}}} }}";
		}
	}
	[Intrinsic]
	public struct Plane : IEquatable<Plane>
	{
		public Vector3 Normal;

		public float D;

		public Plane(float x, float y, float z, float d)
		{
			Normal = new Vector3(x, y, z);
			D = d;
		}

		public Plane(Vector3 normal, float d)
		{
			Normal = normal;
			D = d;
		}

		public Plane(Vector4 value)
		{
			Normal = new Vector3(value.X, value.Y, value.Z);
			D = value.W;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Plane CreateFromVertices(Vector3 point1, Vector3 point2, Vector3 point3)
		{
			if (Vector.IsHardwareAccelerated)
			{
				Vector3 vector = point2 - point1;
				Vector3 vector2 = point3 - point1;
				Vector3 value = Vector3.Cross(vector, vector2);
				Vector3 vector3 = Vector3.Normalize(value);
				float d = 0f - Vector3.Dot(vector3, point1);
				return new Plane(vector3, d);
			}
			float num = point2.X - point1.X;
			float num2 = point2.Y - point1.Y;
			float num3 = point2.Z - point1.Z;
			float num4 = point3.X - point1.X;
			float num5 = point3.Y - point1.Y;
			float num6 = point3.Z - point1.Z;
			float num7 = num2 * num6 - num3 * num5;
			float num8 = num3 * num4 - num * num6;
			float num9 = num * num5 - num2 * num4;
			float x = num7 * num7 + num8 * num8 + num9 * num9;
			float num10 = 1f / MathF.Sqrt(x);
			Vector3 normal = new Vector3(num7 * num10, num8 * num10, num9 * num10);
			return new Plane(normal, 0f - (normal.X * point1.X + normal.Y * point1.Y + normal.Z * point1.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Dot(Plane plane, Vector4 value)
		{
			return plane.Normal.X * value.X + plane.Normal.Y * value.Y + plane.Normal.Z * value.Z + plane.D * value.W;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DotCoordinate(Plane plane, Vector3 value)
		{
			if (Vector.IsHardwareAccelerated)
			{
				return Vector3.Dot(plane.Normal, value) + plane.D;
			}
			return plane.Normal.X * value.X + plane.Normal.Y * value.Y + plane.Normal.Z * value.Z + plane.D;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DotNormal(Plane plane, Vector3 value)
		{
			if (Vector.IsHardwareAccelerated)
			{
				return Vector3.Dot(plane.Normal, value);
			}
			return plane.Normal.X * value.X + plane.Normal.Y * value.Y + plane.Normal.Z * value.Z;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Plane Normalize(Plane value)
		{
			if (Vector.IsHardwareAccelerated)
			{
				float num = value.Normal.LengthSquared();
				if (MathF.Abs(num - 1f) < 1.1920929E-07f)
				{
					return value;
				}
				float num2 = MathF.Sqrt(num);
				return new Plane(value.Normal / num2, value.D / num2);
			}
			float num3 = value.Normal.X * value.Normal.X + value.Normal.Y * value.Normal.Y + value.Normal.Z * value.Normal.Z;
			if (MathF.Abs(num3 - 1f) < 1.1920929E-07f)
			{
				return value;
			}
			float num4 = 1f / MathF.Sqrt(num3);
			return new Plane(value.Normal.X * num4, value.Normal.Y * num4, value.Normal.Z * num4, value.D * num4);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Plane Transform(Plane plane, Matrix4x4 matrix)
		{
			Matrix4x4.Invert(matrix, out var result);
			float x = plane.Normal.X;
			float y = plane.Normal.Y;
			float z = plane.Normal.Z;
			float d = plane.D;
			return new Plane(x * result.M11 + y * result.M12 + z * result.M13 + d * result.M14, x * result.M21 + y * result.M22 + z * result.M23 + d * result.M24, x * result.M31 + y * result.M32 + z * result.M33 + d * result.M34, x * result.M41 + y * result.M42 + z * result.M43 + d * result.M44);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Plane Transform(Plane plane, Quaternion rotation)
		{
			float num = rotation.X + rotation.X;
			float num2 = rotation.Y + rotation.Y;
			float num3 = rotation.Z + rotation.Z;
			float num4 = rotation.W * num;
			float num5 = rotation.W * num2;
			float num6 = rotation.W * num3;
			float num7 = rotation.X * num;
			float num8 = rotation.X * num2;
			float num9 = rotation.X * num3;
			float num10 = rotation.Y * num2;
			float num11 = rotation.Y * num3;
			float num12 = rotation.Z * num3;
			float num13 = 1f - num10 - num12;
			float num14 = num8 - num6;
			float num15 = num9 + num5;
			float num16 = num8 + num6;
			float num17 = 1f - num7 - num12;
			float num18 = num11 - num4;
			float num19 = num9 - num5;
			float num20 = num11 + num4;
			float num21 = 1f - num7 - num10;
			float x = plane.Normal.X;
			float y = plane.Normal.Y;
			float z = plane.Normal.Z;
			return new Plane(x * num13 + y * num14 + z * num15, x * num16 + y * num17 + z * num18, x * num19 + y * num20 + z * num21, plane.D);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(Plane value1, Plane value2)
		{
			if (value1.Normal.X == value2.Normal.X && value1.Normal.Y == value2.Normal.Y && value1.Normal.Z == value2.Normal.Z)
			{
				return value1.D == value2.D;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator !=(Plane value1, Plane value2)
		{
			return !(value1 == value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override readonly bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Plane other)
			{
				return Equals(other);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public readonly bool Equals(Plane other)
		{
			if (Vector.IsHardwareAccelerated)
			{
				if (Normal.Equals(other.Normal))
				{
					return D == other.D;
				}
				return false;
			}
			if (Normal.X == other.Normal.X && Normal.Y == other.Normal.Y && Normal.Z == other.Normal.Z)
			{
				return D == other.D;
			}
			return false;
		}

		public override readonly int GetHashCode()
		{
			return Normal.GetHashCode() + D.GetHashCode();
		}

		public override readonly string ToString()
		{
			return $"{{Normal:{Normal} D:{D}}}";
		}
	}
	[Intrinsic]
	public struct Quaternion : IEquatable<Quaternion>
	{
		public float X;

		public float Y;

		public float Z;

		public float W;

		public static Quaternion Identity => new Quaternion(0f, 0f, 0f, 1f);

		public readonly bool IsIdentity => this == Identity;

		public Quaternion(float x, float y, float z, float w)
		{
			X = x;
			Y = y;
			Z = z;
			W = w;
		}

		public Quaternion(Vector3 vectorPart, float scalarPart)
		{
			X = vectorPart.X;
			Y = vectorPart.Y;
			Z = vectorPart.Z;
			W = scalarPart;
		}

		public static Quaternion operator +(Quaternion value1, Quaternion value2)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = value1.X + value2.X;
			result.Y = value1.Y + value2.Y;
			result.Z = value1.Z + value2.Z;
			result.W = value1.W + value2.W;
			return result;
		}

		public static Quaternion operator /(Quaternion value1, Quaternion value2)
		{
			float x = value1.X;
			float y = value1.Y;
			float z = value1.Z;
			float w = value1.W;
			float num = value2.X * value2.X + value2.Y * value2.Y + value2.Z * value2.Z + value2.W * value2.W;
			float num2 = 1f / num;
			float num3 = (0f - value2.X) * num2;
			float num4 = (0f - value2.Y) * num2;
			float num5 = (0f - value2.Z) * num2;
			float num6 = value2.W * num2;
			float num7 = y * num5 - z * num4;
			float num8 = z * num3 - x * num5;
			float num9 = x * num4 - y * num3;
			float num10 = x * num3 + y * num4 + z * num5;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = x * num6 + num3 * w + num7;
			result.Y = y * num6 + num4 * w + num8;
			result.Z = z * num6 + num5 * w + num9;
			result.W = w * num6 - num10;
			return result;
		}

		public static bool operator ==(Quaternion value1, Quaternion value2)
		{
			if (value1.X == value2.X && value1.Y == value2.Y && value1.Z == value2.Z)
			{
				return value1.W == value2.W;
			}
			return false;
		}

		public static bool operator !=(Quaternion value1, Quaternion value2)
		{
			return !(value1 == value2);
		}

		public static Quaternion operator *(Quaternion value1, Quaternion value2)
		{
			float x = value1.X;
			float y = value1.Y;
			float z = value1.Z;
			float w = value1.W;
			float x2 = value2.X;
			float y2 = value2.Y;
			float z2 = value2.Z;
			float w2 = value2.W;
			float num = y * z2 - z * y2;
			float num2 = z * x2 - x * z2;
			float num3 = x * y2 - y * x2;
			float num4 = x * x2 + y * y2 + z * z2;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = x * w2 + x2 * w + num;
			result.Y = y * w2 + y2 * w + num2;
			result.Z = z * w2 + z2 * w + num3;
			result.W = w * w2 - num4;
			return result;
		}

		public static Quaternion operator *(Quaternion value1, float value2)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = value1.X * value2;
			result.Y = value1.Y * value2;
			result.Z = value1.Z * value2;
			result.W = value1.W * value2;
			return result;
		}

		public static Quaternion operator -(Quaternion value1, Quaternion value2)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = value1.X - value2.X;
			result.Y = value1.Y - value2.Y;
			result.Z = value1.Z - value2.Z;
			result.W = value1.W - value2.W;
			return result;
		}

		public static Quaternion operator -(Quaternion value)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = 0f - value.X;
			result.Y = 0f - value.Y;
			result.Z = 0f - value.Z;
			result.W = 0f - value.W;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Quaternion Add(Quaternion value1, Quaternion value2)
		{
			return value1 + value2;
		}

		public static Quaternion Concatenate(Quaternion value1, Quaternion value2)
		{
			float x = value2.X;
			float y = value2.Y;
			float z = value2.Z;
			float w = value2.W;
			float x2 = value1.X;
			float y2 = value1.Y;
			float z2 = value1.Z;
			float w2 = value1.W;
			float num = y * z2 - z * y2;
			float num2 = z * x2 - x * z2;
			float num3 = x * y2 - y * x2;
			float num4 = x * x2 + y * y2 + z * z2;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = x * w2 + x2 * w + num;
			result.Y = y * w2 + y2 * w + num2;
			result.Z = z * w2 + z2 * w + num3;
			result.W = w * w2 - num4;
			return result;
		}

		public static Quaternion Conjugate(Quaternion value)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = 0f - value.X;
			result.Y = 0f - value.Y;
			result.Z = 0f - value.Z;
			result.W = value.W;
			return result;
		}

		public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle)
		{
			float x = angle * 0.5f;
			float num = MathF.Sin(x);
			float w = MathF.Cos(x);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = axis.X * num;
			result.Y = axis.Y * num;
			result.Z = axis.Z * num;
			result.W = w;
			return result;
		}

		public static Quaternion CreateFromRotationMatrix(Matrix4x4 matrix)
		{
			float num = matrix.M11 + matrix.M22 + matrix.M33;
			Quaternion result = default(Quaternion);
			if (num > 0f)
			{
				float num2 = MathF.Sqrt(num + 1f);
				result.W = num2 * 0.5f;
				num2 = 0.5f / num2;
				result.X = (matrix.M23 - matrix.M32) * num2;
				result.Y = (matrix.M31 - matrix.M13) * num2;
				result.Z = (matrix.M12 - matrix.M21) * num2;
			}
			else if (matrix.M11 >= matrix.M22 && matrix.M11 >= matrix.M33)
			{
				float num3 = MathF.Sqrt(1f + matrix.M11 - matrix.M22 - matrix.M33);
				float num4 = 0.5f / num3;
				result.X = 0.5f * num3;
				result.Y = (matrix.M12 + matrix.M21) * num4;
				result.Z = (matrix.M13 + matrix.M31) * num4;
				result.W = (matrix.M23 - matrix.M32) * num4;
			}
			else if (matrix.M22 > matrix.M33)
			{
				float num5 = MathF.Sqrt(1f + matrix.M22 - matrix.M11 - matrix.M33);
				float num6 = 0.5f / num5;
				result.X = (matrix.M21 + matrix.M12) * num6;
				result.Y = 0.5f * num5;
				result.Z = (matrix.M32 + matrix.M23) * num6;
				result.W = (matrix.M31 - matrix.M13) * num6;
			}
			else
			{
				float num7 = MathF.Sqrt(1f + matrix.M33 - matrix.M11 - matrix.M22);
				float num8 = 0.5f / num7;
				result.X = (matrix.M31 + matrix.M13) * num8;
				result.Y = (matrix.M32 + matrix.M23) * num8;
				result.Z = 0.5f * num7;
				result.W = (matrix.M12 - matrix.M21) * num8;
			}
			return result;
		}

		public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll)
		{
			float x = roll * 0.5f;
			float num = MathF.Sin(x);
			float num2 = MathF.Cos(x);
			float x2 = pitch * 0.5f;
			float num3 = MathF.Sin(x2);
			float num4 = MathF.Cos(x2);
			float x3 = yaw * 0.5f;
			float num5 = MathF.Sin(x3);
			float num6 = MathF.Cos(x3);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = num6 * num3 * num2 + num5 * num4 * num;
			result.Y = num5 * num4 * num2 - num6 * num3 * num;
			result.Z = num6 * num4 * num - num5 * num3 * num2;
			result.W = num6 * num4 * num2 + num5 * num3 * num;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Quaternion Divide(Quaternion value1, Quaternion value2)
		{
			return value1 / value2;
		}

		public static float Dot(Quaternion quaternion1, Quaternion quaternion2)
		{
			return quaternion1.X * quaternion2.X + quaternion1.Y * quaternion2.Y + quaternion1.Z * quaternion2.Z + quaternion1.W * quaternion2.W;
		}

		public static Quaternion Inverse(Quaternion value)
		{
			float num = value.X * value.X + value.Y * value.Y + value.Z * value.Z + value.W * value.W;
			float num2 = 1f / num;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = (0f - value.X) * num2;
			result.Y = (0f - value.Y) * num2;
			result.Z = (0f - value.Z) * num2;
			result.W = value.W * num2;
			return result;
		}

		public static Quaternion Lerp(Quaternion quaternion1, Quaternion quaternion2, float amount)
		{
			float num = 1f - amount;
			Quaternion result = default(Quaternion);
			float num2 = quaternion1.X * quaternion2.X + quaternion1.Y * quaternion2.Y + quaternion1.Z * quaternion2.Z + quaternion1.W * quaternion2.W;
			if (num2 >= 0f)
			{
				result.X = num * quaternion1.X + amount * quaternion2.X;
				result.Y = num * quaternion1.Y + amount * quaternion2.Y;
				result.Z = num * quaternion1.Z + amount * quaternion2.Z;
				result.W = num * quaternion1.W + amount * quaternion2.W;
			}
			else
			{
				result.X = num * quaternion1.X - amount * quaternion2.X;
				result.Y = num * quaternion1.Y - amount * quaternion2.Y;
				result.Z = num * quaternion1.Z - amount * quaternion2.Z;
				result.W = num * quaternion1.W - amount * quaternion2.W;
			}
			float x = result.X * result.X + result.Y * result.Y + result.Z * result.Z + result.W * result.W;
			float num3 = 1f / MathF.Sqrt(x);
			result.X *= num3;
			result.Y *= num3;
			result.Z *= num3;
			result.W *= num3;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Quaternion Multiply(Quaternion value1, Quaternion value2)
		{
			return value1 * value2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Quaternion Multiply(Quaternion value1, float value2)
		{
			return value1 * value2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Quaternion Negate(Quaternion value)
		{
			return -value;
		}

		public static Quaternion Normalize(Quaternion value)
		{
			float x = value.X * value.X + value.Y * value.Y + value.Z * value.Z + value.W * value.W;
			float num = 1f / MathF.Sqrt(x);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = value.X * num;
			result.Y = value.Y * num;
			result.Z = value.Z * num;
			result.W = value.W * num;
			return result;
		}

		public static Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, float amount)
		{
			float num = quaternion1.X * quaternion2.X + quaternion1.Y * quaternion2.Y + quaternion1.Z * quaternion2.Z + quaternion1.W * quaternion2.W;
			bool flag = false;
			if (num < 0f)
			{
				flag = true;
				num = 0f - num;
			}
			float num2;
			float num3;
			if (num > 0.999999f)
			{
				num2 = 1f - amount;
				num3 = (flag ? (0f - amount) : amount);
			}
			else
			{
				float num4 = MathF.Acos(num);
				float num5 = 1f / MathF.Sin(num4);
				num2 = MathF.Sin((1f - amount) * num4) * num5;
				num3 = (flag ? ((0f - MathF.Sin(amount * num4)) * num5) : (MathF.Sin(amount * num4) * num5));
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Quaternion result);
			result.X = num2 * quaternion1.X + num3 * quaternion2.X;
			result.Y = num2 * quaternion1.Y + num3 * quaternion2.Y;
			result.Z = num2 * quaternion1.Z + num3 * quaternion2.Z;
			result.W = num2 * quaternion1.W + num3 * quaternion2.W;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Quaternion Subtract(Quaternion value1, Quaternion value2)
		{
			return value1 - value2;
		}

		public override readonly bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Quaternion other)
			{
				return Equals(other);
			}
			return false;
		}

		public readonly bool Equals(Quaternion other)
		{
			return this == other;
		}

		public override readonly int GetHashCode()
		{
			return X.GetHashCode() + Y.GetHashCode() + Z.GetHashCode() + W.GetHashCode();
		}

		public readonly float Length()
		{
			float x = LengthSquared();
			return MathF.Sqrt(x);
		}

		public readonly float LengthSquared()
		{
			return X * X + Y * Y + Z * Z + W * W;
		}

		public override readonly string ToString()
		{
			return $"{{X:{X} Y:{Y} Z:{Z} W:{W}}}";
		}
	}
	[StructLayout(LayoutKind.Explicit)]
	internal struct Register
	{
		[FieldOffset(0)]
		internal byte byte_0;

		[FieldOffset(1)]
		internal byte byte_1;

		[FieldOffset(2)]
		internal byte byte_2;

		[FieldOffset(3)]
		internal byte byte_3;

		[FieldOffset(4)]
		internal byte byte_4;

		[FieldOffset(5)]
		internal byte byte_5;

		[FieldOffset(6)]
		internal byte byte_6;

		[FieldOffset(7)]
		internal byte byte_7;

		[FieldOffset(8)]
		internal byte byte_8;

		[FieldOffset(9)]
		internal byte byte_9;

		[FieldOffset(10)]
		internal byte byte_10;

		[FieldOffset(11)]
		internal byte byte_11;

		[FieldOffset(12)]
		internal byte byte_12;

		[FieldOffset(13)]
		internal byte byte_13;

		[FieldOffset(14)]
		internal byte byte_14;

		[FieldOffset(15)]
		internal byte byte_15;

		[FieldOffset(0)]
		internal sbyte sbyte_0;

		[FieldOffset(1)]
		internal sbyte sbyte_1;

		[FieldOffset(2)]
		internal sbyte sbyte_2;

		[FieldOffset(3)]
		internal sbyte sbyte_3;

		[FieldOffset(4)]
		internal sbyte sbyte_4;

		[FieldOffset(5)]
		internal sbyte sbyte_5;

		[FieldOffset(6)]
		internal sbyte sbyte_6;

		[FieldOffset(7)]
		internal sbyte sbyte_7;

		[FieldOffset(8)]
		internal sbyte sbyte_8;

		[FieldOffset(9)]
		internal sbyte sbyte_9;

		[FieldOffset(10)]
		internal sbyte sbyte_10;

		[FieldOffset(11)]
		internal sbyte sbyte_11;

		[FieldOffset(12)]
		internal sbyte sbyte_12;

		[FieldOffset(13)]
		internal sbyte sbyte_13;

		[FieldOffset(14)]
		internal sbyte sbyte_14;

		[FieldOffset(15)]
		internal sbyte sbyte_15;

		[FieldOffset(0)]
		internal ushort uint16_0;

		[FieldOffset(2)]
		internal ushort uint16_1;

		[FieldOffset(4)]
		internal ushort uint16_2;

		[FieldOffset(6)]
		internal ushort uint16_3;

		[FieldOffset(8)]
		internal ushort uint16_4;

		[FieldOffset(10)]
		internal ushort uint16_5;

		[FieldOffset(12)]
		internal ushort uint16_6;

		[FieldOffset(14)]
		internal ushort uint16_7;

		[FieldOffset(0)]
		internal short int16_0;

		[FieldOffset(2)]
		internal short int16_1;

		[FieldOffset(4)]
		internal short int16_2;

		[FieldOffset(6)]
		internal short int16_3;

		[FieldOffset(8)]
		internal short int16_4;

		[FieldOffset(10)]
		internal short int16_5;

		[FieldOffset(12)]
		internal short int16_6;

		[FieldOffset(14)]
		internal short int16_7;

		[FieldOffset(0)]
		internal uint uint32_0;

		[FieldOffset(4)]
		internal uint uint32_1;

		[FieldOffset(8)]
		internal uint uint32_2;

		[FieldOffset(12)]
		internal uint uint32_3;

		[FieldOffset(0)]
		internal int int32_0;

		[FieldOffset(4)]
		internal int int32_1;

		[FieldOffset(8)]
		internal int int32_2;

		[FieldOffset(12)]
		internal int int32_3;

		[FieldOffset(0)]
		internal ulong uint64_0;

		[FieldOffset(8)]
		internal ulong uint64_1;

		[FieldOffset(0)]
		internal long int64_0;

		[FieldOffset(8)]
		internal long int64_1;

		[FieldOffset(0)]
		internal float single_0;

		[FieldOffset(4)]
		internal float single_1;

		[FieldOffset(8)]
		internal float single_2;

		[FieldOffset(12)]
		internal float single_3;

		[FieldOffset(0)]
		internal double double_0;

		[FieldOffset(8)]
		internal double double_1;
	}
	[Intrinsic]
	public static class Vector
	{
		public static bool IsHardwareAccelerated
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<float> ConditionalSelect(Vector<int> condition, Vector<float> left, Vector<float> right)
		{
			return Vector<float>.ConditionalSelect((Vector<float>)condition, left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<double> ConditionalSelect(Vector<long> condition, Vector<double> left, Vector<double> right)
		{
			return Vector<double>.ConditionalSelect((Vector<double>)condition, left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> ConditionalSelect<T>(Vector<T> condition, Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.ConditionalSelect(condition, left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> Equals<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> Equals(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> Equals(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> Equals(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> Equals(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.Equals(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EqualsAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left == right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EqualsAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !Vector<T>.Equals(left, right).Equals(Vector<T>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> LessThan<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> LessThan(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> LessThan(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> LessThan(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> LessThan(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.LessThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LessThanAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return ((Vector<int>)Vector<T>.LessThan(left, right)).Equals(Vector<int>.AllBitsSet);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LessThanAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !((Vector<int>)Vector<T>.LessThan(left, right)).Equals(Vector<int>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> LessThanOrEqual<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> LessThanOrEqual(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> LessThanOrEqual(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> LessThanOrEqual(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> LessThanOrEqual(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.LessThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LessThanOrEqualAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return ((Vector<int>)Vector<T>.LessThanOrEqual(left, right)).Equals(Vector<int>.AllBitsSet);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool LessThanOrEqualAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !((Vector<int>)Vector<T>.LessThanOrEqual(left, right)).Equals(Vector<int>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> GreaterThan<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> GreaterThan(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> GreaterThan(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> GreaterThan(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> GreaterThan(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.GreaterThan(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool GreaterThanAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return ((Vector<int>)Vector<T>.GreaterThan(left, right)).Equals(Vector<int>.AllBitsSet);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool GreaterThanAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !((Vector<int>)Vector<T>.GreaterThan(left, right)).Equals(Vector<int>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> GreaterThanOrEqual<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> GreaterThanOrEqual(Vector<float> left, Vector<float> right)
		{
			return (Vector<int>)Vector<float>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<int> GreaterThanOrEqual(Vector<int> left, Vector<int> right)
		{
			return Vector<int>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> GreaterThanOrEqual(Vector<long> left, Vector<long> right)
		{
			return Vector<long>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<long> GreaterThanOrEqual(Vector<double> left, Vector<double> right)
		{
			return (Vector<long>)Vector<double>.GreaterThanOrEqual(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool GreaterThanOrEqualAll<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return ((Vector<int>)Vector<T>.GreaterThanOrEqual(left, right)).Equals(Vector<int>.AllBitsSet);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool GreaterThanOrEqualAny<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return !((Vector<int>)Vector<T>.GreaterThanOrEqual(left, right)).Equals(Vector<int>.Zero);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> Abs<T>(Vector<T> value) where T : struct
		{
			return Vector<T>.Abs(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> Min<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.Min(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> Max<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.Max(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static T Dot<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return Vector<T>.Dot(left, right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> SquareRoot<T>(Vector<T> value) where T : struct
		{
			return Vector<T>.SquareRoot(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<float> Ceiling(Vector<float> value)
		{
			return Vector<float>.Ceiling(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<double> Ceiling(Vector<double> value)
		{
			return Vector<double>.Ceiling(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<float> Floor(Vector<float> value)
		{
			return Vector<float>.Floor(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<double> Floor(Vector<double> value)
		{
			return Vector<double>.Floor(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Add<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left + right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Subtract<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left - right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Multiply<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Multiply<T>(Vector<T> left, T right) where T : struct
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Multiply<T>(T left, Vector<T> right) where T : struct
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Divide<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left / right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Negate<T>(Vector<T> value) where T : struct
		{
			return -value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> BitwiseAnd<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left & right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> BitwiseOr<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left | right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> OnesComplement<T>(Vector<T> value) where T : struct
		{
			return ~value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T> Xor<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left ^ right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T> AndNot<T>(Vector<T> left, Vector<T> right) where T : struct
		{
			return left & ~right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<byte> AsVectorByte<T>(Vector<T> value) where T : struct
		{
			return (Vector<byte>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<sbyte> AsVectorSByte<T>(Vector<T> value) where T : struct
		{
			return (Vector<sbyte>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<ushort> AsVectorUInt16<T>(Vector<T> value) where T : struct
		{
			return (Vector<ushort>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<short> AsVectorInt16<T>(Vector<T> value) where T : struct
		{
			return (Vector<short>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<uint> AsVectorUInt32<T>(Vector<T> value) where T : struct
		{
			return (Vector<uint>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<int> AsVectorInt32<T>(Vector<T> value) where T : struct
		{
			return (Vector<int>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<ulong> AsVectorUInt64<T>(Vector<T> value) where T : struct
		{
			return (Vector<ulong>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<long> AsVectorInt64<T>(Vector<T> value) where T : struct
		{
			return (Vector<long>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<float> AsVectorSingle<T>(Vector<T> value) where T : struct
		{
			return (Vector<float>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<double> AsVectorDouble<T>(Vector<T> value) where T : struct
		{
			return (Vector<double>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector<nuint> AsVectorNUInt<T>(Vector<T> value) where T : struct
		{
			return (Vector<nuint>)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<nint> AsVectorNInt<T>(Vector<T> value) where T : struct
		{
			return (Vector<nint>)value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static void Widen(Vector<byte> source, out Vector<ushort> low, out Vector<ushort> high)
		{
			int count = Vector<byte>.Count;
			ushort* ptr = stackalloc ushort[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			ushort* ptr2 = stackalloc ushort[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = *(Vector<ushort>*)ptr;
			high = *(Vector<ushort>*)ptr2;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static void Widen(Vector<ushort> source, out Vector<uint> low, out Vector<uint> high)
		{
			int count = Vector<ushort>.Count;
			uint* ptr = stackalloc uint[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			uint* ptr2 = stackalloc uint[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = *(Vector<uint>*)ptr;
			high = *(Vector<uint>*)ptr2;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static void Widen(Vector<uint> source, out Vector<ulong> low, out Vector<ulong> high)
		{
			int count = Vector<uint>.Count;
			ulong* ptr = stackalloc ulong[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			ulong* ptr2 = stackalloc ulong[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = *(Vector<ulong>*)ptr;
			high = *(Vector<ulong>*)ptr2;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static void Widen(Vector<sbyte> source, out Vector<short> low, out Vector<short> high)
		{
			int count = Vector<sbyte>.Count;
			short* ptr = stackalloc short[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			short* ptr2 = stackalloc short[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = *(Vector<short>*)ptr;
			high = *(Vector<short>*)ptr2;
		}

		[Intrinsic]
		public unsafe static void Widen(Vector<short> source, out Vector<int> low, out Vector<int> high)
		{
			int count = Vector<short>.Count;
			int* ptr = stackalloc int[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			int* ptr2 = stackalloc int[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = *(Vector<int>*)ptr;
			high = *(Vector<int>*)ptr2;
		}

		[Intrinsic]
		public unsafe static void Widen(Vector<int> source, out Vector<long> low, out Vector<long> high)
		{
			int count = Vector<int>.Count;
			long* ptr = stackalloc long[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			long* ptr2 = stackalloc long[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = *(Vector<long>*)ptr;
			high = *(Vector<long>*)ptr2;
		}

		[Intrinsic]
		public unsafe static void Widen(Vector<float> source, out Vector<double> low, out Vector<double> high)
		{
			int count = Vector<float>.Count;
			double* ptr = stackalloc double[count / 2];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = source[i];
			}
			double* ptr2 = stackalloc double[count / 2];
			for (int j = 0; j < count / 2; j++)
			{
				ptr2[j] = source[j + count / 2];
			}
			low = *(Vector<double>*)ptr;
			high = *(Vector<double>*)ptr2;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector<byte> Narrow(Vector<ushort> low, Vector<ushort> high)
		{
			int count = Vector<byte>.Count;
			byte* ptr = stackalloc byte[(int)(uint)count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (byte)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (byte)high[j];
			}
			return *(Vector<byte>*)ptr;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector<ushort> Narrow(Vector<uint> low, Vector<uint> high)
		{
			int count = Vector<ushort>.Count;
			ushort* ptr = stackalloc ushort[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (ushort)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (ushort)high[j];
			}
			return *(Vector<ushort>*)ptr;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector<uint> Narrow(Vector<ulong> low, Vector<ulong> high)
		{
			int count = Vector<uint>.Count;
			uint* ptr = stackalloc uint[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (uint)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (uint)high[j];
			}
			return *(Vector<uint>*)ptr;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector<sbyte> Narrow(Vector<short> low, Vector<short> high)
		{
			int count = Vector<sbyte>.Count;
			sbyte* ptr = stackalloc sbyte[(int)(uint)count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (sbyte)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (sbyte)high[j];
			}
			return *(Vector<sbyte>*)ptr;
		}

		[Intrinsic]
		public unsafe static Vector<short> Narrow(Vector<int> low, Vector<int> high)
		{
			int count = Vector<short>.Count;
			short* ptr = stackalloc short[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (short)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (short)high[j];
			}
			return *(Vector<short>*)ptr;
		}

		[Intrinsic]
		public unsafe static Vector<int> Narrow(Vector<long> low, Vector<long> high)
		{
			int count = Vector<int>.Count;
			int* ptr = stackalloc int[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (int)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (int)high[j];
			}
			return *(Vector<int>*)ptr;
		}

		[Intrinsic]
		public unsafe static Vector<float> Narrow(Vector<double> low, Vector<double> high)
		{
			int count = Vector<float>.Count;
			float* ptr = stackalloc float[count];
			for (int i = 0; i < count / 2; i++)
			{
				ptr[i] = (float)low[i];
			}
			for (int j = 0; j < count / 2; j++)
			{
				ptr[j + count / 2] = (float)high[j];
			}
			return *(Vector<float>*)ptr;
		}

		[Intrinsic]
		public unsafe static Vector<float> ConvertToSingle(Vector<int> value)
		{
			int count = Vector<float>.Count;
			float* ptr = stackalloc float[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = value[i];
			}
			return *(Vector<float>*)ptr;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector<float> ConvertToSingle(Vector<uint> value)
		{
			int count = Vector<float>.Count;
			float* ptr = stackalloc float[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = value[i];
			}
			return *(Vector<float>*)ptr;
		}

		[Intrinsic]
		public unsafe static Vector<double> ConvertToDouble(Vector<long> value)
		{
			int count = Vector<double>.Count;
			double* ptr = stackalloc double[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = value[i];
			}
			return *(Vector<double>*)ptr;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector<double> ConvertToDouble(Vector<ulong> value)
		{
			int count = Vector<double>.Count;
			double* ptr = stackalloc double[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = value[i];
			}
			return *(Vector<double>*)ptr;
		}

		[Intrinsic]
		public unsafe static Vector<int> ConvertToInt32(Vector<float> value)
		{
			int count = Vector<int>.Count;
			int* ptr = stackalloc int[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = (int)value[i];
			}
			return *(Vector<int>*)ptr;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector<uint> ConvertToUInt32(Vector<float> value)
		{
			int count = Vector<uint>.Count;
			uint* ptr = stackalloc uint[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = (uint)value[i];
			}
			return *(Vector<uint>*)ptr;
		}

		[Intrinsic]
		public unsafe static Vector<long> ConvertToInt64(Vector<double> value)
		{
			int count = Vector<long>.Count;
			long* ptr = stackalloc long[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = (long)value[i];
			}
			return *(Vector<long>*)ptr;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector<ulong> ConvertToUInt64(Vector<double> value)
		{
			int count = Vector<ulong>.Count;
			ulong* ptr = stackalloc ulong[count];
			for (int i = 0; i < count; i++)
			{
				ptr[i] = (ulong)value[i];
			}
			return *(Vector<ulong>*)ptr;
		}

		[DoesNotReturn]
		internal static void ThrowInsufficientNumberOfElementsException(int requiredElementCount)
		{
			throw new IndexOutOfRangeException(SR.Format(SR.Arg_InsufficientNumberOfElements, requiredElementCount, "values"));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<TTo> As<TFrom, TTo>(this Vector<TFrom> vector) where TFrom : struct where TTo : struct
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<TFrom>();
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<TTo>();
			return Unsafe.As<Vector<TFrom>, Vector<TTo>>(ref vector);
		}

		[Intrinsic]
		public static T Sum<T>(Vector<T> value) where T : struct
		{
			return Vector<T>.Sum(value);
		}
	}
	[Intrinsic]
	public struct Vector<T> : IEquatable<Vector<T>>, IFormattable where T : struct
	{
		private Register register;

		public static int Count
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
				return Unsafe.SizeOf<Vector<T>>() / Unsafe.SizeOf<T>();
			}
		}

		public static Vector<T> Zero
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
				return default(Vector<T>);
			}
		}

		public static Vector<T> One
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
				return new Vector<T>(GetOneValue());
			}
		}

		internal static Vector<T> AllBitsSet
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
				return new Vector<T>(GetAllBitsSetValue());
			}
		}

		public readonly T this[int index]
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
				if ((uint)index >= (uint)Count)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
				}
				return GetElement(index);
			}
		}

		[Intrinsic]
		public Vector(T value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			Unsafe.SkipInit<Vector<T>>(out this);
			for (nint num = 0; num < Count; num++)
			{
				SetElement(num, value);
			}
		}

		[Intrinsic]
		public Vector(T[] values)
			: this(values, 0)
		{
		}

		[Intrinsic]
		public Vector(T[] values, int index)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			if (values == null)
			{
				throw new NullReferenceException(SR.Arg_NullArgumentNullRef);
			}
			if (index < 0 || values.Length - index < Count)
			{
				Vector.ThrowInsufficientNumberOfElementsException(Count);
			}
			this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref values[index]));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Vector(ReadOnlySpan<byte> values)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			if (values.Length < Vector<byte>.Count)
			{
				Vector.ThrowInsufficientNumberOfElementsException(Vector<byte>.Count);
			}
			this = Unsafe.ReadUnaligned<Vector<T>>(ref MemoryMarshal.GetReference(values));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Vector(ReadOnlySpan<T> values)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			if (values.Length < Count)
			{
				Vector.ThrowInsufficientNumberOfElementsException(Count);
			}
			this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Vector(Span<T> values)
			: this((ReadOnlySpan<T>)values)
		{
		}

		public readonly void CopyTo(Span<byte> destination)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			if ((uint)destination.Length < (uint)Vector<byte>.Count)
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), this);
		}

		public readonly void CopyTo(Span<T> destination)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			if ((uint)destination.Length < (uint)Count)
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), this);
		}

		[Intrinsic]
		public readonly void CopyTo(T[] destination)
		{
			CopyTo(destination, 0);
		}

		[Intrinsic]
		public readonly void CopyTo(T[] destination, int startIndex)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			if (destination == null)
			{
				throw new NullReferenceException(SR.Arg_NullArgumentNullRef);
			}
			if ((uint)startIndex >= (uint)destination.Length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.Format(SR.Arg_ArgumentOutOfRangeException, startIndex));
			}
			if (destination.Length - startIndex < Count)
			{
				throw new ArgumentException(SR.Format(SR.Arg_ElementsInSourceIsGreaterThanDestination, startIndex));
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override readonly bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Vector<T> other)
			{
				return Equals(other);
			}
			return false;
		}

		[Intrinsic]
		public readonly bool Equals(Vector<T> other)
		{
			return this == other;
		}

		public override readonly int GetHashCode()
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			HashCode hashCode = default(HashCode);
			for (nint num = 0; num < Count; num++)
			{
				hashCode.Add(GetElement(num));
			}
			return hashCode.ToHashCode();
		}

		public override readonly string ToString()
		{
			return ToString("G", CultureInfo.CurrentCulture);
		}

		public readonly string ToString(string? format)
		{
			return ToString(format, CultureInfo.CurrentCulture);
		}

		public readonly string ToString(string? format, IFormatProvider? formatProvider)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			StringBuilder stringBuilder = new StringBuilder();
			string numberGroupSeparator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
			stringBuilder.Append('<');
			for (int i = 0; i < Count - 1; i++)
			{
				stringBuilder.Append(((IFormattable)(object)GetElement(i)).ToString(format, formatProvider));
				stringBuilder.Append(numberGroupSeparator);
				stringBuilder.Append(' ');
			}
			stringBuilder.Append(((IFormattable)(object)GetElement(Count - 1)).ToString(format, formatProvider));
			stringBuilder.Append('>');
			return stringBuilder.ToString();
		}

		public readonly bool TryCopyTo(Span<byte> destination)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			if ((uint)destination.Length < (uint)Vector<byte>.Count)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), this);
			return true;
		}

		public readonly bool TryCopyTo(Span<T> destination)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			if ((uint)destination.Length < (uint)Count)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), this);
			return true;
		}

		[Intrinsic]
		public static Vector<T>operator +(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarAdd(left.GetElement(num), right.GetElement(num)));
			}
			return result;
		}

		[Intrinsic]
		public static Vector<T>operator -(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarSubtract(left.GetElement(num), right.GetElement(num)));
			}
			return result;
		}

		[Intrinsic]
		public static Vector<T>operator *(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarMultiply(left.GetElement(num), right.GetElement(num)));
			}
			return result;
		}

		[Intrinsic]
		public static Vector<T>operator *(Vector<T> value, T factor)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarMultiply(value.GetElement(num), factor));
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector<T>operator *(T factor, Vector<T> value)
		{
			return value * factor;
		}

		[Intrinsic]
		public static Vector<T>operator /(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarDivide(left.GetElement(num), right.GetElement(num)));
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T>operator -(Vector<T> value)
		{
			return Zero - value;
		}

		[Intrinsic]
		public static Vector<T>operator &(Vector<T> left, Vector<T> right)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			Vector<T> result = default(Vector<T>);
			result.register.uint64_0 = left.register.uint64_0 & right.register.uint64_0;
			result.register.uint64_1 = left.register.uint64_1 & right.register.uint64_1;
			return result;
		}

		[Intrinsic]
		public static Vector<T>operator |(Vector<T> left, Vector<T> right)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			Vector<T> result = default(Vector<T>);
			result.register.uint64_0 = left.register.uint64_0 | right.register.uint64_0;
			result.register.uint64_1 = left.register.uint64_1 | right.register.uint64_1;
			return result;
		}

		[Intrinsic]
		public static Vector<T>operator ^(Vector<T> left, Vector<T> right)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			Vector<T> result = default(Vector<T>);
			result.register.uint64_0 = left.register.uint64_0 ^ right.register.uint64_0;
			result.register.uint64_1 = left.register.uint64_1 ^ right.register.uint64_1;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector<T>operator ~(Vector<T> value)
		{
			return AllBitsSet ^ value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static bool operator ==(Vector<T> left, Vector<T> right)
		{
			for (nint num = 0; num < Count; num++)
			{
				if (!ScalarEquals(left.GetElement(num), right.GetElement(num)))
				{
					return false;
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static bool operator !=(Vector<T> left, Vector<T> right)
		{
			return !(left == right);
		}

		[Intrinsic]
		public static explicit operator Vector<byte>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<byte>>(ref value);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public static explicit operator Vector<sbyte>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<sbyte>>(ref value);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public static explicit operator Vector<ushort>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<ushort>>(ref value);
		}

		[Intrinsic]
		public static explicit operator Vector<short>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<short>>(ref value);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public static explicit operator Vector<uint>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<uint>>(ref value);
		}

		[Intrinsic]
		public static explicit operator Vector<int>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<int>>(ref value);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public static explicit operator Vector<ulong>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<ulong>>(ref value);
		}

		[Intrinsic]
		public static explicit operator Vector<long>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<long>>(ref value);
		}

		[Intrinsic]
		public static explicit operator Vector<float>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<float>>(ref value);
		}

		[Intrinsic]
		public static explicit operator Vector<double>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<double>>(ref value);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public static explicit operator Vector<nuint>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<UIntPtr>>(ref value);
		}

		[Intrinsic]
		public static explicit operator Vector<nint>(Vector<T> value)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector<IntPtr>>(ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		internal static Vector<T> Equals(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				T value = (ScalarEquals(left.GetElement(num), right.GetElement(num)) ? GetAllBitsSetValue() : default(T));
				result.SetElement(num, value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		internal static Vector<T> LessThan(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				T value = (ScalarLessThan(left.GetElement(num), right.GetElement(num)) ? GetAllBitsSetValue() : default(T));
				result.SetElement(num, value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		internal static Vector<T> GreaterThan(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				T value = (ScalarGreaterThan(left.GetElement(num), right.GetElement(num)) ? GetAllBitsSetValue() : default(T));
				result.SetElement(num, value);
			}
			return result;
		}

		[Intrinsic]
		internal static Vector<T> GreaterThanOrEqual(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				T value = (ScalarGreaterThanOrEqual(left.GetElement(num), right.GetElement(num)) ? GetAllBitsSetValue() : default(T));
				result.SetElement(num, value);
			}
			return result;
		}

		[Intrinsic]
		internal static Vector<T> LessThanOrEqual(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				T value = (ScalarLessThanOrEqual(left.GetElement(num), right.GetElement(num)) ? GetAllBitsSetValue() : default(T));
				result.SetElement(num, value);
			}
			return result;
		}

		[Intrinsic]
		internal static Vector<T> ConditionalSelect(Vector<T> condition, Vector<T> left, Vector<T> right)
		{
			ThrowHelper.ThrowForUnsupportedNumericsVectorBaseType<T>();
			Vector<T> result = default(Vector<T>);
			result.register.uint64_0 = (left.register.uint64_0 & condition.register.uint64_0) | (right.register.uint64_0 & ~condition.register.uint64_0);
			result.register.uint64_1 = (left.register.uint64_1 & condition.register.uint64_1) | (right.register.uint64_1 & ~condition.register.uint64_1);
			return result;
		}

		[Intrinsic]
		internal static Vector<T> Abs(Vector<T> value)
		{
			if (typeof(T) == typeof(byte))
			{
				return value;
			}
			if (typeof(T) == typeof(ushort))
			{
				return value;
			}
			if (typeof(T) == typeof(uint))
			{
				return value;
			}
			if (typeof(T) == typeof(ulong))
			{
				return value;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return value;
			}
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarAbs(value.GetElement(num)));
			}
			return result;
		}

		[Intrinsic]
		internal static Vector<T> Min(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				T value = (ScalarLessThan(left.GetElement(num), right.GetElement(num)) ? left.GetElement(num) : right.GetElement(num));
				result.SetElement(num, value);
			}
			return result;
		}

		[Intrinsic]
		internal static Vector<T> Max(Vector<T> left, Vector<T> right)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				T value = (ScalarGreaterThan(left.GetElement(num), right.GetElement(num)) ? left.GetElement(num) : right.GetElement(num));
				result.SetElement(num, value);
			}
			return result;
		}

		[Intrinsic]
		internal static T Dot(Vector<T> left, Vector<T> right)
		{
			T val = default(T);
			for (nint num = 0; num < Count; num++)
			{
				val = ScalarAdd(val, ScalarMultiply(left.GetElement(num), right.GetElement(num)));
			}
			return val;
		}

		[Intrinsic]
		internal static T Sum(Vector<T> value)
		{
			T val = default(T);
			for (nint num = 0; num < Count; num++)
			{
				val = ScalarAdd(val, value.GetElement(num));
			}
			return val;
		}

		[Intrinsic]
		internal static Vector<T> SquareRoot(Vector<T> value)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarSqrt(value.GetElement(num)));
			}
			return result;
		}

		[Intrinsic]
		internal static Vector<T> Ceiling(Vector<T> value)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarCeiling(value.GetElement(num)));
			}
			return result;
		}

		[Intrinsic]
		internal static Vector<T> Floor(Vector<T> value)
		{
			Vector<T> result = default(Vector<T>);
			for (nint num = 0; num < Count; num++)
			{
				result.SetElement(num, ScalarFloor(value.GetElement(num)));
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ScalarEquals(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (byte)(object)left == (byte)(object)right;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (sbyte)(object)left == (sbyte)(object)right;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (ushort)(object)left == (ushort)(object)right;
			}
			if (typeof(T) == typeof(short))
			{
				return (short)(object)left == (short)(object)right;
			}
			if (typeof(T) == typeof(uint))
			{
				return (uint)(object)left == (uint)(object)right;
			}
			if (typeof(T) == typeof(int))
			{
				return (int)(object)left == (int)(object)right;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (ulong)(object)left == (ulong)(object)right;
			}
			if (typeof(T) == typeof(long))
			{
				return (long)(object)left == (long)(object)right;
			}
			if (typeof(T) == typeof(float))
			{
				return (float)(object)left == (float)(object)right;
			}
			if (typeof(T) == typeof(double))
			{
				return (double)(object)left == (double)(object)right;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (UIntPtr)(object)left == (UIntPtr)(object)right;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (IntPtr)(object)left == (IntPtr)(object)right;
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ScalarLessThan(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (byte)(object)left < (byte)(object)right;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (sbyte)(object)left < (sbyte)(object)right;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (ushort)(object)left < (ushort)(object)right;
			}
			if (typeof(T) == typeof(short))
			{
				return (short)(object)left < (short)(object)right;
			}
			if (typeof(T) == typeof(uint))
			{
				return (uint)(object)left < (uint)(object)right;
			}
			if (typeof(T) == typeof(int))
			{
				return (int)(object)left < (int)(object)right;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (ulong)(object)left < (ulong)(object)right;
			}
			if (typeof(T) == typeof(long))
			{
				return (long)(object)left < (long)(object)right;
			}
			if (typeof(T) == typeof(float))
			{
				return (float)(object)left < (float)(object)right;
			}
			if (typeof(T) == typeof(double))
			{
				return (double)(object)left < (double)(object)right;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (nuint)(UIntPtr)(object)left < (nuint)(UIntPtr)(object)right;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)left < (nint)(IntPtr)(object)right;
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ScalarLessThanOrEqual(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (byte)(object)left <= (byte)(object)right;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (sbyte)(object)left <= (sbyte)(object)right;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (ushort)(object)left <= (ushort)(object)right;
			}
			if (typeof(T) == typeof(short))
			{
				return (short)(object)left <= (short)(object)right;
			}
			if (typeof(T) == typeof(uint))
			{
				return (uint)(object)left <= (uint)(object)right;
			}
			if (typeof(T) == typeof(int))
			{
				return (int)(object)left <= (int)(object)right;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (ulong)(object)left <= (ulong)(object)right;
			}
			if (typeof(T) == typeof(long))
			{
				return (long)(object)left <= (long)(object)right;
			}
			if (typeof(T) == typeof(float))
			{
				return (float)(object)left <= (float)(object)right;
			}
			if (typeof(T) == typeof(double))
			{
				return (double)(object)left <= (double)(object)right;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (nuint)(UIntPtr)(object)left <= (nuint)(UIntPtr)(object)right;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)left <= (nint)(IntPtr)(object)right;
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ScalarGreaterThan(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (byte)(object)left > (byte)(object)right;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (sbyte)(object)left > (sbyte)(object)right;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (ushort)(object)left > (ushort)(object)right;
			}
			if (typeof(T) == typeof(short))
			{
				return (short)(object)left > (short)(object)right;
			}
			if (typeof(T) == typeof(uint))
			{
				return (uint)(object)left > (uint)(object)right;
			}
			if (typeof(T) == typeof(int))
			{
				return (int)(object)left > (int)(object)right;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (ulong)(object)left > (ulong)(object)right;
			}
			if (typeof(T) == typeof(long))
			{
				return (long)(object)left > (long)(object)right;
			}
			if (typeof(T) == typeof(float))
			{
				return (float)(object)left > (float)(object)right;
			}
			if (typeof(T) == typeof(double))
			{
				return (double)(object)left > (double)(object)right;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (nuint)(UIntPtr)(object)left > (nuint)(UIntPtr)(object)right;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)left > (nint)(IntPtr)(object)right;
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ScalarGreaterThanOrEqual(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (byte)(object)left >= (byte)(object)right;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (sbyte)(object)left >= (sbyte)(object)right;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (ushort)(object)left >= (ushort)(object)right;
			}
			if (typeof(T) == typeof(short))
			{
				return (short)(object)left >= (short)(object)right;
			}
			if (typeof(T) == typeof(uint))
			{
				return (uint)(object)left >= (uint)(object)right;
			}
			if (typeof(T) == typeof(int))
			{
				return (int)(object)left >= (int)(object)right;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (ulong)(object)left >= (ulong)(object)right;
			}
			if (typeof(T) == typeof(long))
			{
				return (long)(object)left >= (long)(object)right;
			}
			if (typeof(T) == typeof(float))
			{
				return (float)(object)left >= (float)(object)right;
			}
			if (typeof(T) == typeof(double))
			{
				return (double)(object)left >= (double)(object)right;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (nuint)(UIntPtr)(object)left >= (nuint)(UIntPtr)(object)right;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (nint)(IntPtr)(object)left >= (nint)(IntPtr)(object)right;
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarAdd(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)((byte)(object)left + (byte)(object)right);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)((sbyte)(object)left + (sbyte)(object)right);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)((ushort)(object)left + (ushort)(object)right);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)((short)(object)left + (short)(object)right);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)((uint)(object)left + (uint)(object)right);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)((int)(object)left + (int)(object)right);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)((ulong)(object)left + (ulong)(object)right);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)((long)(object)left + (long)(object)right);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)((float)(object)left + (float)(object)right);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)((double)(object)left + (double)(object)right);
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (T)(object)(nuint)((nint)(nuint)(UIntPtr)(object)left + (nint)(nuint)(UIntPtr)(object)right);
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (T)(object)((nint)(IntPtr)(object)left + (nint)(IntPtr)(object)right);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarSubtract(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)((byte)(object)left - (byte)(object)right);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)((sbyte)(object)left - (sbyte)(object)right);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)((ushort)(object)left - (ushort)(object)right);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)((short)(object)left - (short)(object)right);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)((uint)(object)left - (uint)(object)right);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)((int)(object)left - (int)(object)right);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)((ulong)(object)left - (ulong)(object)right);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)((long)(object)left - (long)(object)right);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)((float)(object)left - (float)(object)right);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)((double)(object)left - (double)(object)right);
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (T)(object)(nuint)((nint)(nuint)(UIntPtr)(object)left - (nint)(nuint)(UIntPtr)(object)right);
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (T)(object)((nint)(IntPtr)(object)left - (nint)(IntPtr)(object)right);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarMultiply(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)((byte)(object)left * (byte)(object)right);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)((sbyte)(object)left * (sbyte)(object)right);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)((ushort)(object)left * (ushort)(object)right);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)((short)(object)left * (short)(object)right);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)((uint)(object)left * (uint)(object)right);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)((int)(object)left * (int)(object)right);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)((ulong)(object)left * (ulong)(object)right);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)((long)(object)left * (long)(object)right);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)((float)(object)left * (float)(object)right);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)((double)(object)left * (double)(object)right);
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (T)(object)(nuint)((nint)(nuint)(UIntPtr)(object)left * (nint)(nuint)(UIntPtr)(object)right);
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (T)(object)((nint)(IntPtr)(object)left * (nint)(IntPtr)(object)right);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarDivide(T left, T right)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)((byte)(object)left / (byte)(object)right);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)((sbyte)(object)left / (sbyte)(object)right);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)((ushort)(object)left / (ushort)(object)right);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)((short)(object)left / (short)(object)right);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)((uint)(object)left / (uint)(object)right);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)((int)(object)left / (int)(object)right);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)((ulong)(object)left / (ulong)(object)right);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)((long)(object)left / (long)(object)right);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)((float)(object)left / (float)(object)right);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)((double)(object)left / (double)(object)right);
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (T)(object)((nuint)(UIntPtr)(object)left / (nuint)(UIntPtr)(object)right);
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (T)(object)((nint)(IntPtr)(object)left / (nint)(IntPtr)(object)right);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T GetOneValue()
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)1;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)1;
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)1;
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)1;
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)1u;
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)1;
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)1uL;
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)1L;
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)1f;
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)1.0;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (T)(object)(nuint)1u;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (T)(object)(nint)1;
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T GetAllBitsSetValue()
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)byte.MaxValue;
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)(-1);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)ushort.MaxValue;
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)(-1);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)uint.MaxValue;
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)(-1);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)ulong.MaxValue;
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)(-1L);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)BitConverter.Int32BitsToSingle(-1);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)BitConverter.Int64BitsToDouble(-1L);
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (T)(object)UIntPtr.MaxValue;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (T)(object)(nint)(-1);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarAbs(T value)
		{
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)Math.Abs((sbyte)(object)value);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)Math.Abs((short)(object)value);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)Math.Abs((int)(object)value);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)Math.Abs((long)(object)value);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)Math.Abs((float)(object)value);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)Math.Abs((double)(object)value);
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (T)(object)Math.Abs((IntPtr)(object)value);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarSqrt(T value)
		{
			if (typeof(T) == typeof(byte))
			{
				return (T)(object)(byte)Math.Sqrt((int)(byte)(object)value);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return (T)(object)(sbyte)Math.Sqrt((sbyte)(object)value);
			}
			if (typeof(T) == typeof(ushort))
			{
				return (T)(object)(ushort)Math.Sqrt((int)(ushort)(object)value);
			}
			if (typeof(T) == typeof(short))
			{
				return (T)(object)(short)Math.Sqrt((short)(object)value);
			}
			if (typeof(T) == typeof(uint))
			{
				return (T)(object)(uint)Math.Sqrt((uint)(object)value);
			}
			if (typeof(T) == typeof(int))
			{
				return (T)(object)(int)Math.Sqrt((int)(object)value);
			}
			if (typeof(T) == typeof(ulong))
			{
				return (T)(object)(ulong)Math.Sqrt((ulong)(object)value);
			}
			if (typeof(T) == typeof(long))
			{
				return (T)(object)(long)Math.Sqrt((long)(object)value);
			}
			if (typeof(T) == typeof(float))
			{
				return (T)(object)(float)Math.Sqrt((float)(object)value);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)Math.Sqrt((double)(object)value);
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				return (T)(object)(UIntPtr)Math.Sqrt((nint)(nuint)(UIntPtr)(object)value);
			}
			if (typeof(T) == typeof(IntPtr))
			{
				return (T)(object)(IntPtr)Math.Sqrt((nint)(IntPtr)(object)value);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarCeiling(T value)
		{
			if (typeof(T) == typeof(float))
			{
				return (T)(object)MathF.Ceiling((float)(object)value);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)Math.Ceiling((double)(object)value);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static T ScalarFloor(T value)
		{
			if (typeof(T) == typeof(float))
			{
				return (T)(object)MathF.Floor((float)(object)value);
			}
			if (typeof(T) == typeof(double))
			{
				return (T)(object)Math.Floor((double)(object)value);
			}
			throw new NotSupportedException(SR.Arg_TypeNotSupported);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private readonly T GetElement(nint index)
		{
			return Unsafe.Add(ref Unsafe.As<Vector<T>, T>(ref Unsafe.AsRef(in this)), index);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void SetElement(nint index, T value)
		{
			Unsafe.Add(ref Unsafe.As<Vector<T>, T>(ref Unsafe.AsRef(in this)), index) = value;
		}
	}
	[Intrinsic]
	public struct Vector2 : IEquatable<Vector2>, IFormattable
	{
		public float X;

		public float Y;

		public static Vector2 Zero
		{
			[Intrinsic]
			get
			{
				return default(Vector2);
			}
		}

		public static Vector2 One
		{
			[Intrinsic]
			get
			{
				return new Vector2(1f);
			}
		}

		public static Vector2 UnitX => new Vector2(1f, 0f);

		public static Vector2 UnitY => new Vector2(0f, 1f);

		[Intrinsic]
		public Vector2(float value)
			: this(value, value)
		{
		}

		[Intrinsic]
		public Vector2(float x, float y)
		{
			X = x;
			Y = y;
		}

		public Vector2(ReadOnlySpan<float> values)
		{
			if (values.Length < 2)
			{
				Vector.ThrowInsufficientNumberOfElementsException(2);
			}
			this = Unsafe.ReadUnaligned<Vector2>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector2 operator +(Vector2 left, Vector2 right)
		{
			return new Vector2(left.X + right.X, left.Y + right.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector2 operator /(Vector2 left, Vector2 right)
		{
			return new Vector2(left.X / right.X, left.Y / right.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 operator /(Vector2 value1, float value2)
		{
			return value1 / new Vector2(value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static bool operator ==(Vector2 left, Vector2 right)
		{
			if (left.X == right.X)
			{
				return left.Y == right.Y;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static bool operator !=(Vector2 left, Vector2 right)
		{
			return !(left == right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector2 operator *(Vector2 left, Vector2 right)
		{
			return new Vector2(left.X * right.X, left.Y * right.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 operator *(Vector2 left, float right)
		{
			return left * new Vector2(right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 operator *(float left, Vector2 right)
		{
			return right * left;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector2 operator -(Vector2 left, Vector2 right)
		{
			return new Vector2(left.X - right.X, left.Y - right.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 operator -(Vector2 value)
		{
			return Zero - value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector2 Abs(Vector2 value)
		{
			return new Vector2(MathF.Abs(value.X), MathF.Abs(value.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Add(Vector2 left, Vector2 right)
		{
			return left + right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max)
		{
			return Min(Max(value1, min), max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Distance(Vector2 value1, Vector2 value2)
		{
			float x = DistanceSquared(value1, value2);
			return MathF.Sqrt(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceSquared(Vector2 value1, Vector2 value2)
		{
			Vector2 vector = value1 - value2;
			return Dot(vector, vector);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Divide(Vector2 left, Vector2 right)
		{
			return left / right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Divide(Vector2 left, float divisor)
		{
			return left / divisor;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static float Dot(Vector2 value1, Vector2 value2)
		{
			return value1.X * value2.X + value1.Y * value2.Y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Lerp(Vector2 value1, Vector2 value2, float amount)
		{
			return value1 * (1f - amount) + value2 * amount;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector2 Max(Vector2 value1, Vector2 value2)
		{
			return new Vector2((value1.X > value2.X) ? value1.X : value2.X, (value1.Y > value2.Y) ? value1.Y : value2.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector2 Min(Vector2 value1, Vector2 value2)
		{
			return new Vector2((value1.X < value2.X) ? value1.X : value2.X, (value1.Y < value2.Y) ? value1.Y : value2.Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Multiply(Vector2 left, Vector2 right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Multiply(Vector2 left, float right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Multiply(float left, Vector2 right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Negate(Vector2 value)
		{
			return -value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Normalize(Vector2 value)
		{
			return value / value.Length();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Reflect(Vector2 vector, Vector2 normal)
		{
			float num = Dot(vector, normal);
			return vector - 2f * num * normal;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector2 SquareRoot(Vector2 value)
		{
			return new Vector2(MathF.Sqrt(value.X), MathF.Sqrt(value.Y));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Subtract(Vector2 left, Vector2 right)
		{
			return left - right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Transform(Vector2 position, Matrix3x2 matrix)
		{
			return new Vector2(position.X * matrix.M11 + position.Y * matrix.M21 + matrix.M31, position.X * matrix.M12 + position.Y * matrix.M22 + matrix.M32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Transform(Vector2 position, Matrix4x4 matrix)
		{
			return new Vector2(position.X * matrix.M11 + position.Y * matrix.M21 + matrix.M41, position.X * matrix.M12 + position.Y * matrix.M22 + matrix.M42);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 Transform(Vector2 value, Quaternion rotation)
		{
			float num = rotation.X + rotation.X;
			float num2 = rotation.Y + rotation.Y;
			float num3 = rotation.Z + rotation.Z;
			float num4 = rotation.W * num3;
			float num5 = rotation.X * num;
			float num6 = rotation.X * num2;
			float num7 = rotation.Y * num2;
			float num8 = rotation.Z * num3;
			return new Vector2(value.X * (1f - num7 - num8) + value.Y * (num6 - num4), value.X * (num6 + num4) + value.Y * (1f - num5 - num8));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 TransformNormal(Vector2 normal, Matrix3x2 matrix)
		{
			return new Vector2(normal.X * matrix.M11 + normal.Y * matrix.M21, normal.X * matrix.M12 + normal.Y * matrix.M22);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector2 TransformNormal(Vector2 normal, Matrix4x4 matrix)
		{
			return new Vector2(normal.X * matrix.M11 + normal.Y * matrix.M21, normal.X * matrix.M12 + normal.Y * matrix.M22);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public readonly void CopyTo(float[] array)
		{
			CopyTo(array, 0);
		}

		[Intrinsic]
		public readonly void CopyTo(float[] array, int index)
		{
			if (array == null)
			{
				throw new NullReferenceException(SR.Arg_NullArgumentNullRef);
			}
			if (index < 0 || index >= array.Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.Format(SR.Arg_ArgumentOutOfRangeException, index));
			}
			if (array.Length - index < 2)
			{
				throw new ArgumentException(SR.Format(SR.Arg_ElementsInSourceIsGreaterThanDestination, index));
			}
			array[index] = X;
			array[index + 1] = Y;
		}

		public readonly void CopyTo(Span<float> destination)
		{
			if (destination.Length < 2)
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
		}

		public readonly bool TryCopyTo(Span<float> destination)
		{
			if (destination.Length < 2)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override readonly bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Vector2 other)
			{
				return Equals(other);
			}
			return false;
		}

		[Intrinsic]
		public readonly bool Equals(Vector2 other)
		{
			return this == other;
		}

		public override readonly int GetHashCode()
		{
			return HashCode.Combine(X, Y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public readonly float Length()
		{
			float x = LengthSquared();
			return MathF.Sqrt(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public readonly float LengthSquared()
		{
			return Dot(this, this);
		}

		public override readonly string ToString()
		{
			return ToString("G", CultureInfo.CurrentCulture);
		}

		public readonly string ToString(string? format)
		{
			return ToString(format, CultureInfo.CurrentCulture);
		}

		public readonly string ToString(string? format, IFormatProvider? formatProvider)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string numberGroupSeparator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
			stringBuilder.Append('<');
			stringBuilder.Append(X.ToString(format, formatProvider));
			stringBuilder.Append(numberGroupSeparator);
			stringBuilder.Append(' ');
			stringBuilder.Append(Y.ToString(format, formatProvider));
			stringBuilder.Append('>');
			return stringBuilder.ToString();
		}
	}
	[Intrinsic]
	public struct Vector3 : IEquatable<Vector3>, IFormattable
	{
		public float X;

		public float Y;

		public float Z;

		public static Vector3 Zero
		{
			[Intrinsic]
			get
			{
				return default(Vector3);
			}
		}

		public static Vector3 One
		{
			[Intrinsic]
			get
			{
				return new Vector3(1f);
			}
		}

		public static Vector3 UnitX => new Vector3(1f, 0f, 0f);

		public static Vector3 UnitY => new Vector3(0f, 1f, 0f);

		public static Vector3 UnitZ => new Vector3(0f, 0f, 1f);

		[Intrinsic]
		public Vector3(float value)
			: this(value, value, value)
		{
		}

		[Intrinsic]
		public Vector3(Vector2 value, float z)
			: this(value.X, value.Y, z)
		{
		}

		[Intrinsic]
		public Vector3(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}

		public Vector3(ReadOnlySpan<float> values)
		{
			if (values.Length < 3)
			{
				Vector.ThrowInsufficientNumberOfElementsException(3);
			}
			this = Unsafe.ReadUnaligned<Vector3>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector3 operator +(Vector3 left, Vector3 right)
		{
			return new Vector3(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector3 operator /(Vector3 left, Vector3 right)
		{
			return new Vector3(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 operator /(Vector3 value1, float value2)
		{
			return value1 / new Vector3(value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static bool operator ==(Vector3 left, Vector3 right)
		{
			if (left.X == right.X && left.Y == right.Y)
			{
				return left.Z == right.Z;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static bool operator !=(Vector3 left, Vector3 right)
		{
			return !(left == right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector3 operator *(Vector3 left, Vector3 right)
		{
			return new Vector3(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 operator *(Vector3 left, float right)
		{
			return left * new Vector3(right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 operator *(float left, Vector3 right)
		{
			return right * left;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector3 operator -(Vector3 left, Vector3 right)
		{
			return new Vector3(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 operator -(Vector3 value)
		{
			return Zero - value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector3 Abs(Vector3 value)
		{
			return new Vector3(MathF.Abs(value.X), MathF.Abs(value.Y), MathF.Abs(value.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Add(Vector3 left, Vector3 right)
		{
			return left + right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Clamp(Vector3 value1, Vector3 min, Vector3 max)
		{
			return Min(Max(value1, min), max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Cross(Vector3 vector1, Vector3 vector2)
		{
			return new Vector3(vector1.Y * vector2.Z - vector1.Z * vector2.Y, vector1.Z * vector2.X - vector1.X * vector2.Z, vector1.X * vector2.Y - vector1.Y * vector2.X);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Distance(Vector3 value1, Vector3 value2)
		{
			float x = DistanceSquared(value1, value2);
			return MathF.Sqrt(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceSquared(Vector3 value1, Vector3 value2)
		{
			Vector3 vector = value1 - value2;
			return Dot(vector, vector);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Divide(Vector3 left, Vector3 right)
		{
			return left / right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Divide(Vector3 left, float divisor)
		{
			return left / divisor;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static float Dot(Vector3 vector1, Vector3 vector2)
		{
			return vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Lerp(Vector3 value1, Vector3 value2, float amount)
		{
			return value1 * (1f - amount) + value2 * amount;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector3 Max(Vector3 value1, Vector3 value2)
		{
			return new Vector3((value1.X > value2.X) ? value1.X : value2.X, (value1.Y > value2.Y) ? value1.Y : value2.Y, (value1.Z > value2.Z) ? value1.Z : value2.Z);
		}

		[Intrinsic]
		public static Vector3 Min(Vector3 value1, Vector3 value2)
		{
			return new Vector3((value1.X < value2.X) ? value1.X : value2.X, (value1.Y < value2.Y) ? value1.Y : value2.Y, (value1.Z < value2.Z) ? value1.Z : value2.Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Multiply(Vector3 left, Vector3 right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Multiply(Vector3 left, float right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Multiply(float left, Vector3 right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Negate(Vector3 value)
		{
			return -value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Normalize(Vector3 value)
		{
			return value / value.Length();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Reflect(Vector3 vector, Vector3 normal)
		{
			float num = Dot(vector, normal);
			return vector - 2f * num * normal;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector3 SquareRoot(Vector3 value)
		{
			return new Vector3(MathF.Sqrt(value.X), MathF.Sqrt(value.Y), MathF.Sqrt(value.Z));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Subtract(Vector3 left, Vector3 right)
		{
			return left - right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Transform(Vector3 position, Matrix4x4 matrix)
		{
			return new Vector3(position.X * matrix.M11 + position.Y * matrix.M21 + position.Z * matrix.M31 + matrix.M41, position.X * matrix.M12 + position.Y * matrix.M22 + position.Z * matrix.M32 + matrix.M42, position.X * matrix.M13 + position.Y * matrix.M23 + position.Z * matrix.M33 + matrix.M43);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 Transform(Vector3 value, Quaternion rotation)
		{
			float num = rotation.X + rotation.X;
			float num2 = rotation.Y + rotation.Y;
			float num3 = rotation.Z + rotation.Z;
			float num4 = rotation.W * num;
			float num5 = rotation.W * num2;
			float num6 = rotation.W * num3;
			float num7 = rotation.X * num;
			float num8 = rotation.X * num2;
			float num9 = rotation.X * num3;
			float num10 = rotation.Y * num2;
			float num11 = rotation.Y * num3;
			float num12 = rotation.Z * num3;
			return new Vector3(value.X * (1f - num10 - num12) + value.Y * (num8 - num6) + value.Z * (num9 + num5), value.X * (num8 + num6) + value.Y * (1f - num7 - num12) + value.Z * (num11 - num4), value.X * (num9 - num5) + value.Y * (num11 + num4) + value.Z * (1f - num7 - num10));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector3 TransformNormal(Vector3 normal, Matrix4x4 matrix)
		{
			return new Vector3(normal.X * matrix.M11 + normal.Y * matrix.M21 + normal.Z * matrix.M31, normal.X * matrix.M12 + normal.Y * matrix.M22 + normal.Z * matrix.M32, normal.X * matrix.M13 + normal.Y * matrix.M23 + normal.Z * matrix.M33);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public readonly void CopyTo(float[] array)
		{
			CopyTo(array, 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public readonly void CopyTo(float[] array, int index)
		{
			if (array == null)
			{
				throw new NullReferenceException(SR.Arg_NullArgumentNullRef);
			}
			if (index < 0 || index >= array.Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.Format(SR.Arg_ArgumentOutOfRangeException, index));
			}
			if (array.Length - index < 3)
			{
				throw new ArgumentException(SR.Format(SR.Arg_ElementsInSourceIsGreaterThanDestination, index));
			}
			array[index] = X;
			array[index + 1] = Y;
			array[index + 2] = Z;
		}

		public readonly void CopyTo(Span<float> destination)
		{
			if (destination.Length < 3)
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
		}

		public readonly bool TryCopyTo(Span<float> destination)
		{
			if (destination.Length < 3)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override readonly bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Vector3 other)
			{
				return Equals(other);
			}
			return false;
		}

		[Intrinsic]
		public readonly bool Equals(Vector3 other)
		{
			return this == other;
		}

		public override readonly int GetHashCode()
		{
			return HashCode.Combine(X, Y, Z);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public readonly float Length()
		{
			float x = LengthSquared();
			return MathF.Sqrt(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public readonly float LengthSquared()
		{
			return Dot(this, this);
		}

		public override readonly string ToString()
		{
			return ToString("G", CultureInfo.CurrentCulture);
		}

		public readonly string ToString(string? format)
		{
			return ToString(format, CultureInfo.CurrentCulture);
		}

		public readonly string ToString(string? format, IFormatProvider? formatProvider)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string numberGroupSeparator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
			stringBuilder.Append('<');
			stringBuilder.Append(X.ToString(format, formatProvider));
			stringBuilder.Append(numberGroupSeparator);
			stringBuilder.Append(' ');
			stringBuilder.Append(Y.ToString(format, formatProvider));
			stringBuilder.Append(numberGroupSeparator);
			stringBuilder.Append(' ');
			stringBuilder.Append(Z.ToString(format, formatProvider));
			stringBuilder.Append('>');
			return stringBuilder.ToString();
		}
	}
	[Intrinsic]
	public struct Vector4 : IEquatable<Vector4>, IFormattable
	{
		public float X;

		public float Y;

		public float Z;

		public float W;

		public static Vector4 Zero
		{
			[Intrinsic]
			get
			{
				return default(Vector4);
			}
		}

		public static Vector4 One
		{
			[Intrinsic]
			get
			{
				return new Vector4(1f);
			}
		}

		public static Vector4 UnitX => new Vector4(1f, 0f, 0f, 0f);

		public static Vector4 UnitY => new Vector4(0f, 1f, 0f, 0f);

		public static Vector4 UnitZ => new Vector4(0f, 0f, 1f, 0f);

		public static Vector4 UnitW => new Vector4(0f, 0f, 0f, 1f);

		[Intrinsic]
		public Vector4(float value)
			: this(value, value, value, value)
		{
		}

		[Intrinsic]
		public Vector4(Vector2 value, float z, float w)
			: this(value.X, value.Y, z, w)
		{
		}

		[Intrinsic]
		public Vector4(Vector3 value, float w)
			: this(value.X, value.Y, value.Z, w)
		{
		}

		[Intrinsic]
		public Vector4(float x, float y, float z, float w)
		{
			X = x;
			Y = y;
			Z = z;
			W = w;
		}

		public Vector4(ReadOnlySpan<float> values)
		{
			if (values.Length < 4)
			{
				Vector.ThrowInsufficientNumberOfElementsException(4);
			}
			this = Unsafe.ReadUnaligned<Vector4>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector4 operator +(Vector4 left, Vector4 right)
		{
			return new Vector4(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector4 operator /(Vector4 left, Vector4 right)
		{
			return new Vector4(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 operator /(Vector4 value1, float value2)
		{
			return value1 / new Vector4(value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static bool operator ==(Vector4 left, Vector4 right)
		{
			if (left.X == right.X && left.Y == right.Y && left.Z == right.Z)
			{
				return left.W == right.W;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static bool operator !=(Vector4 left, Vector4 right)
		{
			return !(left == right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector4 operator *(Vector4 left, Vector4 right)
		{
			return new Vector4(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 operator *(Vector4 left, float right)
		{
			return left * new Vector4(right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 operator *(float left, Vector4 right)
		{
			return right * left;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector4 operator -(Vector4 left, Vector4 right)
		{
			return new Vector4(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 operator -(Vector4 value)
		{
			return Zero - value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector4 Abs(Vector4 value)
		{
			return new Vector4(MathF.Abs(value.X), MathF.Abs(value.Y), MathF.Abs(value.Z), MathF.Abs(value.W));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Add(Vector4 left, Vector4 right)
		{
			return left + right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Clamp(Vector4 value1, Vector4 min, Vector4 max)
		{
			return Min(Max(value1, min), max);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Distance(Vector4 value1, Vector4 value2)
		{
			float x = DistanceSquared(value1, value2);
			return MathF.Sqrt(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float DistanceSquared(Vector4 value1, Vector4 value2)
		{
			Vector4 vector = value1 - value2;
			return Dot(vector, vector);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Divide(Vector4 left, Vector4 right)
		{
			return left / right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Divide(Vector4 left, float divisor)
		{
			return left / divisor;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static float Dot(Vector4 vector1, Vector4 vector2)
		{
			return vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z + vector1.W * vector2.W;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Lerp(Vector4 value1, Vector4 value2, float amount)
		{
			return value1 * (1f - amount) + value2 * amount;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector4 Max(Vector4 value1, Vector4 value2)
		{
			return new Vector4((value1.X > value2.X) ? value1.X : value2.X, (value1.Y > value2.Y) ? value1.Y : value2.Y, (value1.Z > value2.Z) ? value1.Z : value2.Z, (value1.W > value2.W) ? value1.W : value2.W);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector4 Min(Vector4 value1, Vector4 value2)
		{
			return new Vector4((value1.X < value2.X) ? value1.X : value2.X, (value1.Y < value2.Y) ? value1.Y : value2.Y, (value1.Z < value2.Z) ? value1.Z : value2.Z, (value1.W < value2.W) ? value1.W : value2.W);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Multiply(Vector4 left, Vector4 right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Multiply(Vector4 left, float right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Multiply(float left, Vector4 right)
		{
			return left * right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Negate(Vector4 value)
		{
			return -value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Normalize(Vector4 vector)
		{
			return vector / vector.Length();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector4 SquareRoot(Vector4 value)
		{
			return new Vector4(MathF.Sqrt(value.X), MathF.Sqrt(value.Y), MathF.Sqrt(value.Z), MathF.Sqrt(value.W));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Subtract(Vector4 left, Vector4 right)
		{
			return left - right;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Transform(Vector2 position, Matrix4x4 matrix)
		{
			return new Vector4(position.X * matrix.M11 + position.Y * matrix.M21 + matrix.M41, position.X * matrix.M12 + position.Y * matrix.M22 + matrix.M42, position.X * matrix.M13 + position.Y * matrix.M23 + matrix.M43, position.X * matrix.M14 + position.Y * matrix.M24 + matrix.M44);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Transform(Vector2 value, Quaternion rotation)
		{
			float num = rotation.X + rotation.X;
			float num2 = rotation.Y + rotation.Y;
			float num3 = rotation.Z + rotation.Z;
			float num4 = rotation.W * num;
			float num5 = rotation.W * num2;
			float num6 = rotation.W * num3;
			float num7 = rotation.X * num;
			float num8 = rotation.X * num2;
			float num9 = rotation.X * num3;
			float num10 = rotation.Y * num2;
			float num11 = rotation.Y * num3;
			float num12 = rotation.Z * num3;
			return new Vector4(value.X * (1f - num10 - num12) + value.Y * (num8 - num6), value.X * (num8 + num6) + value.Y * (1f - num7 - num12), value.X * (num9 - num5) + value.Y * (num11 + num4), 1f);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Transform(Vector3 position, Matrix4x4 matrix)
		{
			return new Vector4(position.X * matrix.M11 + position.Y * matrix.M21 + position.Z * matrix.M31 + matrix.M41, position.X * matrix.M12 + position.Y * matrix.M22 + position.Z * matrix.M32 + matrix.M42, position.X * matrix.M13 + position.Y * matrix.M23 + position.Z * matrix.M33 + matrix.M43, position.X * matrix.M14 + position.Y * matrix.M24 + position.Z * matrix.M34 + matrix.M44);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Transform(Vector3 value, Quaternion rotation)
		{
			float num = rotation.X + rotation.X;
			float num2 = rotation.Y + rotation.Y;
			float num3 = rotation.Z + rotation.Z;
			float num4 = rotation.W * num;
			float num5 = rotation.W * num2;
			float num6 = rotation.W * num3;
			float num7 = rotation.X * num;
			float num8 = rotation.X * num2;
			float num9 = rotation.X * num3;
			float num10 = rotation.Y * num2;
			float num11 = rotation.Y * num3;
			float num12 = rotation.Z * num3;
			return new Vector4(value.X * (1f - num10 - num12) + value.Y * (num8 - num6) + value.Z * (num9 + num5), value.X * (num8 + num6) + value.Y * (1f - num7 - num12) + value.Z * (num11 - num4), value.X * (num9 - num5) + value.Y * (num11 + num4) + value.Z * (1f - num7 - num10), 1f);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Transform(Vector4 vector, Matrix4x4 matrix)
		{
			return new Vector4(vector.X * matrix.M11 + vector.Y * matrix.M21 + vector.Z * matrix.M31 + vector.W * matrix.M41, vector.X * matrix.M12 + vector.Y * matrix.M22 + vector.Z * matrix.M32 + vector.W * matrix.M42, vector.X * matrix.M13 + vector.Y * matrix.M23 + vector.Z * matrix.M33 + vector.W * matrix.M43, vector.X * matrix.M14 + vector.Y * matrix.M24 + vector.Z * matrix.M34 + vector.W * matrix.M44);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector4 Transform(Vector4 value, Quaternion rotation)
		{
			float num = rotation.X + rotation.X;
			float num2 = rotation.Y + rotation.Y;
			float num3 = rotation.Z + rotation.Z;
			float num4 = rotation.W * num;
			float num5 = rotation.W * num2;
			float num6 = rotation.W * num3;
			float num7 = rotation.X * num;
			float num8 = rotation.X * num2;
			float num9 = rotation.X * num3;
			float num10 = rotation.Y * num2;
			float num11 = rotation.Y * num3;
			float num12 = rotation.Z * num3;
			return new Vector4(value.X * (1f - num10 - num12) + value.Y * (num8 - num6) + value.Z * (num9 + num5), value.X * (num8 + num6) + value.Y * (1f - num7 - num12) + value.Z * (num11 - num4), value.X * (num9 - num5) + value.Y * (num11 + num4) + value.Z * (1f - num7 - num10), value.W);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public readonly void CopyTo(float[] array)
		{
			CopyTo(array, 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public readonly void CopyTo(float[] array, int index)
		{
			if (array == null)
			{
				throw new NullReferenceException(SR.Arg_NullArgumentNullRef);
			}
			if (index < 0 || index >= array.Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.Format(SR.Arg_ArgumentOutOfRangeException, index));
			}
			if (array.Length - index < 4)
			{
				throw new ArgumentException(SR.Format(SR.Arg_ElementsInSourceIsGreaterThanDestination, index));
			}
			array[index] = X;
			array[index + 1] = Y;
			array[index + 2] = Z;
			array[index + 3] = W;
		}

		public readonly void CopyTo(Span<float> destination)
		{
			if (destination.Length < 4)
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
		}

		public readonly bool TryCopyTo(Span<float> destination)
		{
			if (destination.Length < 4)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
			return true;
		}

		[Intrinsic]
		public readonly bool Equals(Vector4 other)
		{
			return this == other;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override readonly bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Vector4 other)
			{
				return Equals(other);
			}
			return false;
		}

		public override readonly int GetHashCode()
		{
			return HashCode.Combine(X, Y, Z, W);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public readonly float Length()
		{
			float x = LengthSquared();
			return MathF.Sqrt(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public readonly float LengthSquared()
		{
			return Dot(this, this);
		}

		public override readonly string ToString()
		{
			return ToString("G", CultureInfo.CurrentCulture);
		}

		public readonly string ToString(string? format)
		{
			return ToString(format, CultureInfo.CurrentCulture);
		}

		public readonly string ToString(string? format, IFormatProvider? formatProvider)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string numberGroupSeparator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
			stringBuilder.Append('<');
			stringBuilder.Append(X.ToString(format, formatProvider));
			stringBuilder.Append(numberGroupSeparator);
			stringBuilder.Append(' ');
			stringBuilder.Append(Y.ToString(format, formatProvider));
			stringBuilder.Append(numberGroupSeparator);
			stringBuilder.Append(' ');
			stringBuilder.Append(Z.ToString(format, formatProvider));
			stringBuilder.Append(numberGroupSeparator);
			stringBuilder.Append(' ');
			stringBuilder.Append(W.ToString(format, formatProvider));
			stringBuilder.Append('>');
			return stringBuilder.ToString();
		}
	}
	internal static class VectorMath
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<float> ConditionalSelectBitwise(Vector128<float> selector, Vector128<float> ifTrue, Vector128<float> ifFalse)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				return Sse.Or(Sse.And(ifTrue, selector), Sse.AndNot(selector, ifFalse));
			}
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<double> ConditionalSelectBitwise(Vector128<double> selector, Vector128<double> ifTrue, Vector128<double> ifFalse)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.IsSupported)
			{
				return Sse2.Or(Sse2.And(ifTrue, selector), Sse2.AndNot(selector, ifFalse));
			}
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Equal(Vector128<float> vector1, Vector128<float> vector2)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				return Sse.MoveMask(Sse.CompareNotEqual(vector1, vector2)) == 0;
			}
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<float> Lerp(Vector128<float> a, Vector128<float> b, Vector128<float> t)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Fma.IsSupported)
			{
				return Fma.MultiplyAdd(Sse.Subtract(b, a), t, a);
			}
			if (Sse.IsSupported)
			{
				return Sse.Add(Sse.Multiply(a, Sse.Subtract(Vector128.Create(1f), t)), Sse.Multiply(b, t));
			}
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool NotEqual(Vector128<float> vector1, Vector128<float> vector2)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				return Sse.MoveMask(Sse.CompareNotEqual(vector1, vector2)) != 0;
			}
			throw new PlatformNotSupportedException();
		}
	}
}
namespace System.Net
{
	public static class WebUtility
	{
		private struct UrlDecoder
		{
			private readonly int _bufferSize;

			private int _numChars;

			private char[] _charBuffer;

			private int _numBytes;

			private byte[] _byteBuffer;

			private readonly Encoding _encoding;

			private void FlushBytes()
			{
				if (_charBuffer == null)
				{
					_charBuffer = new char[_bufferSize];
				}
				_numChars += _encoding.GetChars(_byteBuffer, 0, _numBytes, _charBuffer, _numChars);
				_numBytes = 0;
			}

			internal UrlDecoder(int bufferSize, Encoding encoding)
			{
				_bufferSize = bufferSize;
				_encoding = encoding;
				_charBuffer = null;
				_numChars = 0;
				_numBytes = 0;
				_byteBuffer = null;
			}

			internal void AddChar(char ch)
			{
				if (_numBytes > 0)
				{
					FlushBytes();
				}
				if (_charBuffer == null)
				{
					_charBuffer = new char[_bufferSize];
				}
				_charBuffer[_numChars++] = ch;
			}

			internal void AddByte(byte b)
			{
				if (_byteBuffer == null)
				{
					_byteBuffer = new byte[_bufferSize];
				}
				_byteBuffer[_numBytes++] = b;
			}

			internal string GetString()
			{
				if (_numBytes > 0)
				{
					FlushBytes();
				}
				return new string(_charBuffer, 0, _numChars);
			}
		}

		private static class HtmlEntities
		{
			private static readonly Dictionary<ulong, char> s_lookupTable = InitializeLookupTable();

			private static Dictionary<ulong, char> InitializeLookupTable()
			{
				ReadOnlySpan<byte> source = new byte[2530]
				{
					116, 111, 117, 113, 0, 0, 0, 0, 34, 0,
					112, 109, 97, 0, 0, 0, 0, 0, 38, 0,
					115, 111, 112, 97, 0, 0, 0, 0, 39, 0,
					116, 108, 0, 0, 0, 0, 0, 0, 60, 0,
					116, 103, 0, 0, 0, 0, 0, 0, 62, 0,
					112, 115, 98, 110, 0, 0, 0, 0, 160, 0,
					108, 99, 120, 101, 105, 0, 0, 0, 161, 0,
					116, 110, 101, 99, 0, 0, 0, 0, 162, 0,
					100, 110, 117, 111, 112, 0, 0, 0, 163, 0,
					110, 101, 114, 114, 117, 99, 0, 0, 164, 0,
					110, 101, 121, 0, 0, 0, 0, 0, 165, 0,
					114, 97, 98, 118, 114, 98, 0, 0, 166, 0,
					116, 99, 101, 115, 0, 0, 0, 0, 167, 0,
					108, 109, 117, 0, 0, 0, 0, 0, 168, 0,
					121, 112, 111, 99, 0, 0, 0, 0, 169, 0,
					102, 100, 114, 111, 0, 0, 0, 0, 170, 0,
					111, 117, 113, 97, 108, 0, 0, 0, 171, 0,
					116, 111, 110, 0, 0, 0, 0, 0, 172, 0,
					121, 104, 115, 0, 0, 0, 0, 0, 173, 0,
					103, 101, 114, 0, 0, 0, 0, 0, 174, 0,
					114, 99, 97, 109, 0, 0, 0, 0, 175, 0,
					103, 101, 100, 0, 0, 0, 0, 0, 176, 0,
					110, 109, 115, 117, 108, 112, 0, 0, 177, 0,
					50, 112, 117, 115, 0, 0, 0, 0, 178, 0,
					51, 112, 117, 115, 0, 0, 0, 0, 179, 0,
					101, 116, 117, 99, 97, 0, 0, 0, 180, 0,
					111, 114, 99, 105, 109, 0, 0, 0, 181, 0,
					97, 114, 97, 112, 0, 0, 0, 0, 182, 0,
					116, 111, 100, 100, 105, 109, 0, 0, 183, 0,
					108, 105, 100, 101, 99, 0, 0, 0, 184, 0,
					49, 112, 117, 115, 0, 0, 0, 0, 185, 0,
					109, 100, 114, 111, 0, 0, 0, 0, 186, 0,
					111, 117, 113, 97, 114, 0, 0, 0, 187, 0,
					52, 49, 99, 97, 114, 102, 0, 0, 188, 0,
					50, 49, 99, 97, 114, 102, 0, 0, 189, 0,
					52, 51, 99, 97, 114, 102, 0, 0, 190, 0,
					116, 115, 101, 117, 113, 105, 0, 0, 191, 0,
					101, 118, 97, 114, 103, 65, 0, 0, 192, 0,
					101, 116, 117, 99, 97, 65, 0, 0, 193, 0,
					99, 114, 105, 99, 65, 0, 0, 0, 194, 0,
					101, 100, 108, 105, 116, 65, 0, 0, 195, 0,
					108, 109, 117, 65, 0, 0, 0, 0, 196, 0,
					103, 110, 105, 114, 65, 0, 0, 0, 197, 0,
					103, 105, 108, 69, 65, 0, 0, 0, 198, 0,
					108, 105, 100, 101, 99, 67, 0, 0, 199, 0,
					101, 118, 97, 114, 103, 69, 0, 0, 200, 0,
					101, 116, 117, 99, 97, 69, 0, 0, 201, 0,
					99, 114, 105, 99, 69, 0, 0, 0, 202, 0,
					108, 109, 117, 69, 0, 0, 0, 0, 203, 0,
					101, 118, 97, 114, 103, 73, 0, 0, 204, 0,
					101, 116, 117, 99, 97, 73, 0, 0, 205, 0,
					99, 114, 105, 99, 73, 0, 0, 0, 206, 0,
					108, 109, 117, 73, 0, 0, 0, 0, 207, 0,
					72, 84, 69, 0, 0, 0, 0, 0, 208, 0,
					101, 100, 108, 105, 116, 78, 0, 0, 209, 0,
					101, 118, 97, 114, 103, 79, 0, 0, 210, 0,
					101, 116, 117, 99, 97, 79, 0, 0, 211, 0,
					99, 114, 105, 99, 79, 0, 0, 0, 212, 0,
					101, 100, 108, 105, 116, 79, 0, 0, 213, 0,
					108, 109, 117, 79, 0, 0, 0, 0, 214, 0,
					115, 101, 109, 105, 116, 0, 0, 0, 215, 0,
					104, 115, 97, 108, 115, 79, 0, 0, 216, 0,
					101, 118, 97, 114, 103, 85, 0, 0, 217, 0,
					101, 116, 117, 99, 97, 85, 0, 0, 218, 0,
					99, 114, 105, 99, 85, 0, 0, 0, 219, 0,
					108, 109, 117, 85, 0, 0, 0, 0, 220, 0,
					101, 116, 117, 99, 97, 89, 0, 0, 221, 0,
					78, 82, 79, 72, 84, 0, 0, 0, 222, 0,
					103, 105, 108, 122, 115, 0, 0, 0, 223, 0,
					101, 118, 97, 114, 103, 97, 0, 0, 224, 0,
					101, 116, 117, 99, 97, 97, 0, 0, 225, 0,
					99, 114, 105, 99, 97, 0, 0, 0, 226, 0,
					101, 100, 108, 105, 116, 97, 0, 0, 227, 0,
					108, 109, 117, 97, 0, 0, 0, 0, 228, 0,
					103, 110, 105, 114, 97, 0, 0, 0, 229, 0,
					103, 105, 108, 101, 97, 0, 0, 0, 230, 0,
					108, 105, 100, 101, 99, 99, 0, 0, 231, 0,
					101, 118, 97, 114, 103, 101, 0, 0, 232, 0,
					101, 116, 117, 99, 97, 101, 0, 0, 233, 0,
					99, 114, 105, 99, 101, 0, 0, 0, 234, 0,
					108, 109, 117, 101, 0, 0, 0, 0, 235, 0,
					101, 118, 97, 114, 103, 105, 0, 0, 236, 0,
					101, 116, 117, 99, 97, 105, 0, 0, 237, 0,
					99, 114, 105, 99, 105, 0, 0, 0, 238, 0,
					108, 109, 117, 105, 0, 0, 0, 0, 239, 0,
					104, 116, 101, 0, 0, 0, 0, 0, 240, 0,
					101, 100, 108, 105, 116, 110, 0, 0, 241, 0,
					101, 118, 97, 114, 103, 111, 0, 0, 242, 0,
					101, 116, 117, 99, 97, 111, 0, 0, 243, 0,
					99, 114, 105, 99, 111, 0, 0, 0, 244, 0,
					101, 100, 108, 105, 116, 111, 0, 0, 245, 0,
					108, 109, 117, 111, 0, 0, 0, 0, 246, 0,
					101, 100, 105, 118, 105, 100, 0, 0, 247, 0,
					104, 115, 97, 108, 115, 111, 0, 0, 248, 0,
					101, 118, 97, 114, 103, 117, 0, 0, 249, 0,
					101, 116, 117, 99, 97, 117, 0, 0, 250, 0,
					99, 114, 105, 99, 117, 0, 0, 0, 251, 0,
					108, 109, 117, 117, 0, 0, 0, 0, 252, 0,
					101, 116, 117, 99, 97, 121, 0, 0, 253, 0,
					110, 114, 111, 104, 116, 0, 0, 0, 254, 0,
					108, 109, 117, 121, 0, 0, 0, 0, 255, 0,
					103, 105, 108, 69, 79, 0, 0, 0, 82, 1,
					103, 105, 108, 101, 111, 0, 0, 0, 83, 1,
					110, 111, 114, 97, 99, 83, 0, 0, 96, 1,
					110, 111, 114, 97, 99, 115, 0, 0, 97, 1,
					108, 109, 117, 89, 0, 0, 0, 0, 120, 1,
					102, 111, 110, 102, 0, 0, 0, 0, 146, 1,
					99, 114, 105, 99, 0, 0, 0, 0, 198, 2,
					101, 100, 108, 105, 116, 0, 0, 0, 220, 2,
					97, 104, 112, 108, 65, 0, 0, 0, 145, 3,
					97, 116, 101, 66, 0, 0, 0, 0, 146, 3,
					97, 109, 109, 97, 71, 0, 0, 0, 147, 3,
					97, 116, 108, 101, 68, 0, 0, 0, 148, 3,
					110, 111, 108, 105, 115, 112, 69, 0, 149, 3,
					97, 116, 101, 90, 0, 0, 0, 0, 150, 3,
					97, 116, 69, 0, 0, 0, 0, 0, 151, 3,
					97, 116, 101, 104, 84, 0, 0, 0, 152, 3,
					97, 116, 111, 73, 0, 0, 0, 0, 153, 3,
					97, 112, 112, 97, 75, 0, 0, 0, 154, 3,
					97, 100, 98, 109, 97, 76, 0, 0, 155, 3,
					117, 77, 0, 0, 0, 0, 0, 0, 156, 3,
					117, 78, 0, 0, 0, 0, 0, 0, 157, 3,
					105, 88, 0, 0, 0, 0, 0, 0, 158, 3,
					110, 111, 114, 99, 105, 109, 79, 0, 159, 3,
					105, 80, 0, 0, 0, 0, 0, 0, 160, 3,
					111, 104, 82, 0, 0, 0, 0, 0, 161, 3,
					97, 109, 103, 105, 83, 0, 0, 0, 163, 3,
					117, 97, 84, 0, 0, 0, 0, 0, 164, 3,
					110, 111, 108, 105, 115, 112, 85, 0, 165, 3,
					105, 104, 80, 0, 0, 0, 0, 0, 166, 3,
					105, 104, 67, 0, 0, 0, 0, 0, 167, 3,
					105, 115, 80, 0, 0, 0, 0, 0, 168, 3,
					97, 103, 101, 109, 79, 0, 0, 0, 169, 3,
					97, 104, 112, 108, 97, 0, 0, 0, 177, 3,
					97, 116, 101, 98, 0, 0, 0, 0, 178, 3,
					97, 109, 109, 97, 103, 0, 0, 0, 179, 3,
					97, 116, 108, 101, 100, 0, 0, 0, 180, 3,
					110, 111, 108, 105, 115, 112, 101, 0, 181, 3,
					97, 116, 101, 122, 0, 0, 0, 0, 182, 3,
					97, 116, 101, 0, 0, 0, 0, 0, 183, 3,
					97, 116, 101, 104, 116, 0, 0, 0, 184, 3,
					97, 116, 111, 105, 0, 0, 0, 0, 185, 3,
					97, 112, 112, 97, 107, 0, 0, 0, 186, 3,
					97, 100, 98, 109, 97, 108, 0, 0, 187, 3,
					117, 109, 0, 0, 0, 0, 0, 0, 188, 3,
					117, 110, 0, 0, 0, 0, 0, 0, 189, 3,
					105, 120, 0, 0, 0, 0, 0, 0, 190, 3,
					110, 111, 114, 99, 105, 109, 111, 0, 191, 3,
					105, 112, 0, 0, 0, 0, 0, 0, 192, 3,
					111, 104, 114, 0, 0, 0, 0, 0, 193, 3,
					102, 97, 109, 103, 105, 115, 0, 0, 194, 3,
					97, 109, 103, 105, 115, 0, 0, 0, 195, 3,
					117, 97, 116, 0, 0, 0, 0, 0, 196, 3,
					110, 111, 108, 105, 115, 112, 117, 0, 197, 3,
					105, 104, 112, 0, 0, 0, 0, 0, 198, 3,
					105, 104, 99, 0, 0, 0, 0, 0, 199, 3,
					105, 115, 112, 0, 0, 0, 0, 0, 200, 3,
					97, 103, 101, 109, 111, 0, 0, 0, 201, 3,
					109, 121, 115, 97, 116, 101, 104, 116, 209, 3,
					104, 105, 115, 112, 117, 0, 0, 0, 210, 3,
					118, 105, 112, 0, 0, 0, 0, 0, 214, 3,
					112, 115, 110, 101, 0, 0, 0, 0, 2, 32,
					112, 115, 109, 101, 0, 0, 0, 0, 3, 32,
					112, 115, 110, 105, 104, 116, 0, 0, 9, 32,
					106, 110, 119, 122, 0, 0, 0, 0, 12, 32,
					106, 119, 122, 0, 0, 0, 0, 0, 13, 32,
					109, 114, 108, 0, 0, 0, 0, 0, 14, 32,
					109, 108, 114, 0, 0, 0, 0, 0, 15, 32,
					104, 115, 97, 100, 110, 0, 0, 0, 19, 32,
					104, 115, 97, 100, 109, 0, 0, 0, 20, 32,
					111, 117, 113, 115, 108, 0, 0, 0, 24, 32,
					111, 117, 113, 115, 114, 0, 0, 0, 25, 32,
					111, 117, 113, 98, 115, 0, 0, 0, 26, 32,
					111, 117, 113, 100, 108, 0, 0, 0, 28, 32,
					111, 117, 113, 100, 114, 0, 0, 0, 29, 32,
					111, 117, 113, 100, 98, 0, 0, 0, 30, 32,
					114, 101, 103, 103, 97, 100, 0, 0, 32, 32,
					114, 101, 103, 103, 97, 68, 0, 0, 33, 32,
					108, 108, 117, 98, 0, 0, 0, 0, 34, 32,
					112, 105, 108, 108, 101, 104, 0, 0, 38, 32,
					108, 105, 109, 114, 101, 112, 0, 0, 48, 32,
					101, 109, 105, 114, 112, 0, 0, 0, 50, 32,
					101, 109, 105, 114, 80, 0, 0, 0, 51, 32,
					111, 117, 113, 97, 115, 108, 0, 0, 57, 32,
					111, 117, 113, 97, 115, 114, 0, 0, 58, 32,
					101, 110, 105, 108, 111, 0, 0, 0, 62, 32,
					108, 115, 97, 114, 102, 0, 0, 0, 68, 32,
					111, 114, 117, 101, 0, 0, 0, 0, 172, 32,
					101, 103, 97, 109, 105, 0, 0, 0, 17, 33,
					112, 114, 101, 105, 101, 119, 0, 0, 24, 33,
					108, 97, 101, 114, 0, 0, 0, 0, 28, 33,
					101, 100, 97, 114, 116, 0, 0, 0, 34, 33,
					109, 121, 115, 102, 101, 108, 97, 0, 53, 33,
					114, 114, 97, 108, 0, 0, 0, 0, 144, 33,
					114, 114, 97, 117, 0, 0, 0, 0, 145, 33,
					114, 114, 97, 114, 0, 0, 0, 0, 146, 33,
					114, 114, 97, 100, 0, 0, 0, 0, 147, 33,
					114, 114, 97, 104, 0, 0, 0, 0, 148, 33,
					114, 114, 97, 114, 99, 0, 0, 0, 181, 33,
					114, 114, 65, 108, 0, 0, 0, 0, 208, 33,
					114, 114, 65, 117, 0, 0, 0, 0, 209, 33,
					114, 114, 65, 114, 0, 0, 0, 0, 210, 33,
					114, 114, 65, 100, 0, 0, 0, 0, 211, 33,
					114, 114, 65, 104, 0, 0, 0, 0, 212, 33,
					108, 108, 97, 114, 111, 102, 0, 0, 0, 34,
					116, 114, 97, 112, 0, 0, 0, 0, 2, 34,
					116, 115, 105, 120, 101, 0, 0, 0, 3, 34,
					121, 116, 112, 109, 101, 0, 0, 0, 5, 34,
					97, 108, 98, 97, 110, 0, 0, 0, 7, 34,
					110, 105, 115, 105, 0, 0, 0, 0, 8, 34,
					110, 105, 116, 111, 110, 0, 0, 0, 9, 34,
					105, 110, 0, 0, 0, 0, 0, 0, 11, 34,
					100, 111, 114, 112, 0, 0, 0, 0, 15, 34,
					109, 117, 115, 0, 0, 0, 0, 0, 17, 34,
					115, 117, 110, 105, 109, 0, 0, 0, 18, 34,
					116, 115, 97, 119, 111, 108, 0, 0, 23, 34,
					99, 105, 100, 97, 114, 0, 0, 0, 26, 34,
					112, 111, 114, 112, 0, 0, 0, 0, 29, 34,
					110, 105, 102, 110, 105, 0, 0, 0, 30, 34,
					103, 110, 97, 0, 0, 0, 0, 0, 32, 34,
					100, 110, 97, 0, 0, 0, 0, 0, 39, 34,
					114, 111, 0, 0, 0, 0, 0, 0, 40, 34,
					112, 97, 99, 0, 0, 0, 0, 0, 41, 34,
					112, 117, 99, 0, 0, 0, 0, 0, 42, 34,
					116, 110, 105, 0, 0, 0, 0, 0, 43, 34,
					52, 101, 114, 101, 104, 116, 0, 0, 52, 34,
					109, 105, 115, 0, 0, 0, 0, 0, 60, 34,
					103, 110, 111, 99, 0, 0, 0, 0, 69, 34,
					112, 109, 121, 115, 97, 0, 0, 0, 72, 34,
					101, 110, 0, 0, 0, 0, 0, 0, 96, 34,
					118, 105, 117, 113, 101, 0, 0, 0, 97, 34,
					101, 108, 0, 0, 0, 0, 0, 0, 100, 34,
					101, 103, 0, 0, 0, 0, 0, 0, 101, 34,
					98, 117, 115, 0, 0, 0, 0, 0, 130, 34,
					112, 117, 115, 0, 0, 0, 0, 0, 131, 34,
					98, 117, 115, 110, 0, 0, 0, 0, 132, 34,
					101, 98, 117, 115, 0, 0, 0, 0, 134, 34,
					101, 112, 117, 115, 0, 0, 0, 0, 135, 34,
					115, 117, 108, 112, 111, 0, 0, 0, 149, 34,
					115, 101, 109, 105, 116, 111, 0, 0, 151, 34,
					112, 114, 101, 112, 0, 0, 0, 0, 165, 34,
					116, 111, 100, 115, 0, 0, 0, 0, 197, 34,
					108, 105, 101, 99, 108, 0, 0, 0, 8, 35,
					108, 105, 101, 99, 114, 0, 0, 0, 9, 35,
					114, 111, 111, 108, 102, 108, 0, 0, 10, 35,
					114, 111, 111, 108, 102, 114, 0, 0, 11, 35,
					103, 110, 97, 108, 0, 0, 0, 0, 41, 35,
					103, 110, 97, 114, 0, 0, 0, 0, 42, 35,
					122, 111, 108, 0, 0, 0, 0, 0, 202, 37,
					115, 101, 100, 97, 112, 115, 0, 0, 96, 38,
					115, 98, 117, 108, 99, 0, 0, 0, 99, 38,
					115, 116, 114, 97, 101, 104, 0, 0, 101, 38,
					115, 109, 97, 105, 100, 0, 0, 0, 102, 38
				};
				Dictionary<ulong, char> dictionary = new Dictionary<ulong, char>(source.Length / 10);
				while (!source.IsEmpty)
				{
					ulong key = BinaryPrimitives.ReadUInt64LittleEndian(source);
					char value = (char)BinaryPrimitives.ReadUInt16LittleEndian(source.Slice(8));
					dictionary[key] = value;
					source = source.Slice(10);
				}
				return dictionary;
			}

			public static char Lookup(ReadOnlySpan<char> entity)
			{
				if (entity.Length <= 8)
				{
					s_lookupTable.TryGetValue(ToUInt64Key(entity), out var value);
					return value;
				}
				return '\0';
			}

			private static ulong ToUInt64Key(ReadOnlySpan<char> entity)
			{
				ulong num = 0uL;
				for (int i = 0; i < entity.Length; i++)
				{
					if (entity[i] > 'ÿ')
					{
						return 0uL;
					}
					num = (num << 8) | entity[i];
				}
				return num;
			}
		}

		[return: NotNullIfNotNull("value")]
		public static string? HtmlEncode(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			ReadOnlySpan<char> input = value.AsSpan();
			int num = IndexOfHtmlEncodingChars(input);
			if (num == -1)
			{
				return value;
			}
			ValueStringBuilder valueStringBuilder;
			if (value.Length < 80)
			{
				Span<char> initialBuffer = stackalloc char[256];
				valueStringBuilder = new ValueStringBuilder(initialBuffer);
			}
			else
			{
				valueStringBuilder = new ValueStringBuilder(value.Length + 200);
			}
			ValueStringBuilder output = valueStringBuilder;
			output.Append(input.Slice(0, num));
			HtmlEncode(input.Slice(num), ref output);
			return output.ToString();
		}

		public static void HtmlEncode(string? value, TextWriter output)
		{
			if (output == null)
			{
				throw new ArgumentNullException("output");
			}
			if (string.IsNullOrEmpty(value))
			{
				output.Write(value);
				return;
			}
			ReadOnlySpan<char> input = value.AsSpan();
			int num = IndexOfHtmlEncodingChars(input);
			if (num == -1)
			{
				output.Write(value);
				return;
			}
			ValueStringBuilder valueStringBuilder;
			if (value.Length < 80)
			{
				Span<char> initialBuffer = stackalloc char[256];
				valueStringBuilder = new ValueStringBuilder(initialBuffer);
			}
			else
			{
				valueStringBuilder = new ValueStringBuilder(value.Length + 200);
			}
			ValueStringBuilder output2 = valueStringBuilder;
			output2.Append(input.Slice(0, num));
			HtmlEncode(input.Slice(num), ref output2);
			output.Write(output2.AsSpan());
			output2.Dispose();
		}

		private static void HtmlEncode(ReadOnlySpan<char> input, ref ValueStringBuilder output)
		{
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (c <= '>')
				{
					switch (c)
					{
					case '<':
						output.Append("&lt;");
						break;
					case '>':
						output.Append("&gt;");
						break;
					case '"':
						output.Append("&quot;");
						break;
					case '\'':
						output.Append("&#39;");
						break;
					case '&':
						output.Append("&amp;");
						break;
					default:
						output.Append(c);
						break;
					}
					continue;
				}
				int num = -1;
				if (c >= '\u00a0' && c < 'Ā')
				{
					num = c;
				}
				else if (char.IsSurrogate(c))
				{
					int nextUnicodeScalarValueFromUtf16Surrogate = GetNextUnicodeScalarValueFromUtf16Surrogate(input, ref i);
					if (nextUnicodeScalarValueFromUtf16Surrogate >= 65536)
					{
						num = nextUnicodeScalarValueFromUtf16Surrogate;
					}
					else
					{
						c = (char)nextUnicodeScalarValueFromUtf16Surrogate;
					}
				}
				if (num >= 0)
				{
					output.Append("&#");
					Span<char> destination = output.AppendSpan(10);
					num.TryFormat(destination, out var charsWritten);
					output.Length -= 10 - charsWritten;
					output.Append(';');
				}
				else
				{
					output.Append(c);
				}
			}
		}

		[return: NotNullIfNotNull("value")]
		public static string? HtmlDecode(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			ReadOnlySpan<char> input = value.AsSpan();
			int num = IndexOfHtmlDecodingChars(input);
			if (num == -1)
			{
				return value;
			}
			ValueStringBuilder valueStringBuilder;
			if (value.Length <= 256)
			{
				Span<char> initialBuffer = stackalloc char[256];
				valueStringBuilder = new ValueStringBuilder(initialBuffer);
			}
			else
			{
				valueStringBuilder = new ValueStringBuilder(value.Length);
			}
			ValueStringBuilder output = valueStringBuilder;
			output.Append(input.Slice(0, num));
			HtmlDecode(input.Slice(num), ref output);
			return output.ToString();
		}

		public static void HtmlDecode(string? value, TextWriter output)
		{
			if (output == null)
			{
				throw new ArgumentNullException("output");
			}
			if (string.IsNullOrEmpty(value))
			{
				output.Write(value);
				return;
			}
			ReadOnlySpan<char> input = value.AsSpan();
			int num = IndexOfHtmlDecodingChars(input);
			if (num == -1)
			{
				output.Write(value);
				return;
			}
			ValueStringBuilder valueStringBuilder;
			if (value.Length <= 256)
			{
				Span<char> initialBuffer = stackalloc char[256];
				valueStringBuilder = new ValueStringBuilder(initialBuffer);
			}
			else
			{
				valueStringBuilder = new ValueStringBuilder(value.Length);
			}
			ValueStringBuilder output2 = valueStringBuilder;
			output2.Append(input.Slice(0, num));
			HtmlDecode(input.Slice(num), ref output2);
			output.Write(output2.AsSpan());
			output2.Dispose();
		}

		private static void HtmlDecode(ReadOnlySpan<char> input, ref ValueStringBuilder output)
		{
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (c == '&')
				{
					ReadOnlySpan<char> span = input.Slice(i + 1);
					int num = span.IndexOfAny(';', '&');
					if (num >= 0 && span[num] == ';')
					{
						int num2 = i + 1 + num;
						if (num > 1 && span[0] == '#')
						{
							uint result;
							bool flag = ((span[1] == 'x' || span[1] == 'X') ? uint.TryParse(span.Slice(2, num - 2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out result) : uint.TryParse(span.Slice(1, num - 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out result));
							if (flag)
							{
								flag = result < 55296 || (57343 < result && result <= 1114111);
							}
							if (flag)
							{
								if (result <= 65535)
								{
									output.Append((char)result);
								}
								else
								{
									ConvertSmpToUtf16(result, out var leadingSurrogate, out var trailingSurrogate);
									output.Append(leadingSurrogate);
									output.Append(trailingSurrogate);
								}
								i = num2;
								continue;
							}
						}
						else
						{
							ReadOnlySpan<char> readOnlySpan = span.Slice(0, num);
							i = num2;
							char c2 = HtmlEntities.Lookup(readOnlySpan);
							if (c2 == '\0')
							{
								output.Append('&');
								output.Append(readOnlySpan);
								output.Append(';');
								continue;
							}
							c = c2;
						}
					}
				}
				output.Append(c);
			}
		}

		private static int IndexOfHtmlEncodingChars(ReadOnlySpan<char> input)
		{
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (c <= '>')
				{
					switch (c)
					{
					case '"':
					case '&':
					case '\'':
					case '<':
					case '>':
						return i;
					}
					continue;
				}
				if (c >= '\u00a0' && c < 'Ā')
				{
					return i;
				}
				if (char.IsSurrogate(c))
				{
					return i;
				}
			}
			return -1;
		}

		private static void GetEncodedBytes(byte[] originalBytes, int offset, int count, byte[] expandedBytes)
		{
			int num = 0;
			int num2 = offset + count;
			for (int i = offset; i < num2; i++)
			{
				byte b = originalBytes[i];
				char c = (char)b;
				if (IsUrlSafeChar(c))
				{
					expandedBytes[num++] = b;
					continue;
				}
				if (c == ' ')
				{
					expandedBytes[num++] = 43;
					continue;
				}
				expandedBytes[num++] = 37;
				expandedBytes[num++] = (byte)HexConverter.ToCharUpper(b >> 4);
				expandedBytes[num++] = (byte)HexConverter.ToCharUpper(b);
			}
		}

		[return: NotNullIfNotNull("value")]
		public static string? UrlEncode(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			int num = 0;
			int num2 = 0;
			foreach (char c in value)
			{
				if (IsUrlSafeChar(c))
				{
					num++;
				}
				else if (c == ' ')
				{
					num2++;
				}
			}
			int num3 = num + num2;
			if (num3 == value.Length)
			{
				if (num2 != 0)
				{
					return value.Replace(' ', '+');
				}
				return value;
			}
			int byteCount = Encoding.UTF8.GetByteCount(value);
			int num4 = byteCount - num3;
			int num5 = num4 * 2;
			byte[] array = new byte[byteCount + num5];
			Encoding.UTF8.GetBytes(value, 0, value.Length, array, num5);
			GetEncodedBytes(array, num5, byteCount, array);
			return Encoding.UTF8.GetString(array);
		}

		[return: NotNullIfNotNull("value")]
		public static byte[]? UrlEncodeToBytes(byte[]? value, int offset, int count)
		{
			if (!ValidateUrlEncodingParameters(value, offset, count))
			{
				return null;
			}
			bool flag = false;
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				char c = (char)value[offset + i];
				if (c == ' ')
				{
					flag = true;
				}
				else if (!IsUrlSafeChar(c))
				{
					num++;
				}
			}
			if (!flag && num == 0)
			{
				byte[] array = new byte[count];
				Buffer.BlockCopy(value, offset, array, 0, count);
				return array;
			}
			byte[] array2 = new byte[count + num * 2];
			GetEncodedBytes(value, offset, count, array2);
			return array2;
		}

		[return: NotNullIfNotNull("value")]
		private static string UrlDecodeInternal(string value, Encoding encoding)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			int length = value.Length;
			UrlDecoder urlDecoder = new UrlDecoder(length, encoding);
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < length; i++)
			{
				char c = value[i];
				switch (c)
				{
				case '+':
					flag2 = true;
					c = ' ';
					break;
				case '%':
					if (i < length - 2)
					{
						int num = HexConverter.FromChar(value[i + 1]);
						int num2 = HexConverter.FromChar(value[i + 2]);
						if ((num | num2) != 255)
						{
							byte b = (byte)((num << 4) | num2);
							i += 2;
							urlDecoder.AddByte(b);
							flag = true;
							continue;
						}
					}
					break;
				}
				if ((c & 0xFF80) == 0)
				{
					urlDecoder.AddByte((byte)c);
				}
				else
				{
					urlDecoder.AddChar(c);
				}
			}
			if (!flag)
			{
				if (flag2)
				{
					return value.Replace('+', ' ');
				}
				return value;
			}
			return urlDecoder.GetString();
		}

		[return: NotNullIfNotNull("bytes")]
		private static byte[] UrlDecodeInternal(byte[] bytes, int offset, int count)
		{
			if (!ValidateUrlEncodingParameters(bytes, offset, count))
			{
				return null;
			}
			int num = 0;
			byte[] array = new byte[count];
			for (int i = 0; i < count; i++)
			{
				int num2 = offset + i;
				byte b = bytes[num2];
				switch (b)
				{
				case 43:
					b = 32;
					break;
				case 37:
					if (i < count - 2)
					{
						int num3 = HexConverter.FromChar(bytes[num2 + 1]);
						int num4 = HexConverter.FromChar(bytes[num2 + 2]);
						if ((num3 | num4) != 255)
						{
							b = (byte)((num3 << 4) | num4);
							i += 2;
						}
					}
					break;
				}
				array[num++] = b;
			}
			if (num < array.Length)
			{
				Array.Resize(ref array, num);
			}
			return array;
		}

		[return: NotNullIfNotNull("encodedValue")]
		public static string? UrlDecode(string? encodedValue)
		{
			return UrlDecodeInternal(encodedValue, Encoding.UTF8);
		}

		[return: NotNullIfNotNull("encodedValue")]
		public static byte[]? UrlDecodeToBytes(byte[]? encodedValue, int offset, int count)
		{
			return UrlDecodeInternal(encodedValue, offset, count);
		}

		private static void ConvertSmpToUtf16(uint smpChar, out char leadingSurrogate, out char trailingSurrogate)
		{
			int num = (int)(smpChar - 65536);
			leadingSurrogate = (char)(num / 1024 + 55296);
			trailingSurrogate = (char)(num % 1024 + 56320);
		}

		private static int GetNextUnicodeScalarValueFromUtf16Surrogate(ReadOnlySpan<char> input, ref int index)
		{
			if (input.Length - index <= 1)
			{
				return 65533;
			}
			char c = input[index];
			char c2 = input[index + 1];
			if (!char.IsSurrogatePair(c, c2))
			{
				return 65533;
			}
			index++;
			return (c - 55296) * 1024 + (c2 - 56320) + 65536;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsUrlSafeChar(char ch)
		{
			if ((uint)(ch - 97) > 25u && (uint)(ch - 65) > 25u && ((uint)(ch - 32) > 25u || ((1 << ch - 32) & 0x3FF6702) == 0))
			{
				return ch == '_';
			}
			return true;
		}

		private static bool ValidateUrlEncodingParameters(byte[] bytes, int offset, int count)
		{
			if (bytes == null && count == 0)
			{
				return false;
			}
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes");
			}
			if (offset < 0 || offset > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("offset");
			}
			if (count < 0 || offset + count > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("count");
			}
			return true;
		}

		private static int IndexOfHtmlDecodingChars(ReadOnlySpan<char> input)
		{
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (c == '&' || char.IsSurrogate(c))
				{
					return i;
				}
			}
			return -1;
		}
	}
}
namespace System.Globalization
{
	public abstract class Calendar : ICloneable
	{
		private int _currentEraValue = -1;

		private bool _isReadOnly;

		public const int CurrentEra = 0;

		internal int _twoDigitYearMax = -1;

		public virtual DateTime MinSupportedDateTime => DateTime.MinValue;

		public virtual DateTime MaxSupportedDateTime => DateTime.MaxValue;

		public virtual CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.Unknown;

		internal virtual CalendarId ID => CalendarId.UNINITIALIZED_VALUE;

		internal virtual CalendarId BaseCalendarID => ID;

		public bool IsReadOnly => _isReadOnly;

		internal virtual int CurrentEraValue
		{
			get
			{
				if (_currentEraValue == -1)
				{
					_currentEraValue = CalendarData.GetCalendarCurrentEra(this);
				}
				return _currentEraValue;
			}
		}

		public abstract int[] Eras { get; }

		protected virtual int DaysInYearBeforeMinSupportedYear => 365;

		public virtual int TwoDigitYearMax
		{
			get
			{
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				_twoDigitYearMax = value;
			}
		}

		public virtual object Clone()
		{
			object obj = MemberwiseClone();
			((Calendar)obj).SetReadOnlyState(readOnly: false);
			return obj;
		}

		public static Calendar ReadOnly(Calendar calendar)
		{
			if (calendar == null)
			{
				throw new ArgumentNullException("calendar");
			}
			if (calendar.IsReadOnly)
			{
				return calendar;
			}
			Calendar calendar2 = (Calendar)calendar.MemberwiseClone();
			calendar2.SetReadOnlyState(readOnly: true);
			return calendar2;
		}

		internal void VerifyWritable()
		{
			if (_isReadOnly)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
			}
		}

		internal void SetReadOnlyState(bool readOnly)
		{
			_isReadOnly = readOnly;
		}

		internal static void CheckAddResult(long ticks, DateTime minValue, DateTime maxValue)
		{
			if (ticks < minValue.Ticks || ticks > maxValue.Ticks)
			{
				throw new ArgumentException(SR.Format(SR.Argument_ResultCalendarRange, minValue, maxValue));
			}
		}

		internal DateTime Add(DateTime time, double value, int scale)
		{
			double num = value * (double)scale + ((value >= 0.0) ? 0.5 : (-0.5));
			if (!(num > -315537897600000.0) || !(num < 315537897600000.0))
			{
				throw new ArgumentOutOfRangeException("value", value, SR.ArgumentOutOfRange_AddValue);
			}
			long num2 = (long)num;
			long ticks = time.Ticks + num2 * 10000;
			CheckAddResult(ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return new DateTime(ticks);
		}

		public virtual DateTime AddMilliseconds(DateTime time, double milliseconds)
		{
			return Add(time, milliseconds, 1);
		}

		public virtual DateTime AddDays(DateTime time, int days)
		{
			return Add(time, days, 86400000);
		}

		public virtual DateTime AddHours(DateTime time, int hours)
		{
			return Add(time, hours, 3600000);
		}

		public virtual DateTime AddMinutes(DateTime time, int minutes)
		{
			return Add(time, minutes, 60000);
		}

		public abstract DateTime AddMonths(DateTime time, int months);

		public virtual DateTime AddSeconds(DateTime time, int seconds)
		{
			return Add(time, seconds, 1000);
		}

		public virtual DateTime AddWeeks(DateTime time, int weeks)
		{
			return AddDays(time, weeks * 7);
		}

		public abstract DateTime AddYears(DateTime time, int years);

		public abstract int GetDayOfMonth(DateTime time);

		public abstract DayOfWeek GetDayOfWeek(DateTime time);

		public abstract int GetDayOfYear(DateTime time);

		public virtual int GetDaysInMonth(int year, int month)
		{
			return GetDaysInMonth(year, month, 0);
		}

		public abstract int GetDaysInMonth(int year, int month, int era);

		public virtual int GetDaysInYear(int year)
		{
			return GetDaysInYear(year, 0);
		}

		public abstract int GetDaysInYear(int year, int era);

		public abstract int GetEra(DateTime time);

		public virtual int GetHour(DateTime time)
		{
			return (int)(time.Ticks / 36000000000L % 24);
		}

		public virtual double GetMilliseconds(DateTime time)
		{
			return time.Ticks / 10000 % 1000;
		}

		public virtual int GetMinute(DateTime time)
		{
			return (int)(time.Ticks / 600000000 % 60);
		}

		public abstract int GetMonth(DateTime time);

		public virtual int GetMonthsInYear(int year)
		{
			return GetMonthsInYear(year, 0);
		}

		public abstract int GetMonthsInYear(int year, int era);

		public virtual int GetSecond(DateTime time)
		{
			return (int)(time.Ticks / 10000000 % 60);
		}

		internal int GetFirstDayWeekOfYear(DateTime time, int firstDayOfWeek)
		{
			int num = GetDayOfYear(time) - 1;
			int num2 = (int)(GetDayOfWeek(time) - num % 7);
			int num3 = (num2 - firstDayOfWeek + 14) % 7;
			return (num + num3) / 7 + 1;
		}

		private int GetWeekOfYearFullDays(DateTime time, int firstDayOfWeek, int fullDays)
		{
			int num = GetDayOfYear(time) - 1;
			int num2 = (int)(GetDayOfWeek(time) - num % 7);
			int num3 = (firstDayOfWeek - num2 + 14) % 7;
			if (num3 != 0 && num3 >= fullDays)
			{
				num3 -= 7;
			}
			int num4 = num - num3;
			if (num4 >= 0)
			{
				return num4 / 7 + 1;
			}
			if (time <= MinSupportedDateTime.AddDays(num))
			{
				return GetWeekOfYearOfMinSupportedDateTime(firstDayOfWeek, fullDays);
			}
			return GetWeekOfYearFullDays(time.AddDays(-(num + 1)), firstDayOfWeek, fullDays);
		}

		private int GetWeekOfYearOfMinSupportedDateTime(int firstDayOfWeek, int minimumDaysInFirstWeek)
		{
			int num = GetDayOfYear(MinSupportedDateTime) - 1;
			int num2 = (int)(GetDayOfWeek(MinSupportedDateTime) - num % 7);
			int num3 = (firstDayOfWeek + 7 - num2) % 7;
			if (num3 == 0 || num3 >= minimumDaysInFirstWeek)
			{
				return 1;
			}
			int num4 = DaysInYearBeforeMinSupportedYear - 1;
			int num5 = num2 - 1 - num4 % 7;
			int num6 = (firstDayOfWeek - num5 + 14) % 7;
			int num7 = num4 - num6;
			if (num6 >= minimumDaysInFirstWeek)
			{
				num7 += 7;
			}
			return num7 / 7 + 1;
		}

		public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
		{
			if (firstDayOfWeek < DayOfWeek.Sunday || firstDayOfWeek > DayOfWeek.Saturday)
			{
				throw new ArgumentOutOfRangeException("firstDayOfWeek", firstDayOfWeek, SR.Format(SR.ArgumentOutOfRange_Range, DayOfWeek.Sunday, DayOfWeek.Saturday));
			}
			return rule switch
			{
				CalendarWeekRule.FirstDay => GetFirstDayWeekOfYear(time, (int)firstDayOfWeek), 
				CalendarWeekRule.FirstFullWeek => GetWeekOfYearFullDays(time, (int)firstDayOfWeek, 7), 
				CalendarWeekRule.FirstFourDayWeek => GetWeekOfYearFullDays(time, (int)firstDayOfWeek, 4), 
				_ => throw new ArgumentOutOfRangeException("rule", rule, SR.Format(SR.ArgumentOutOfRange_Range, CalendarWeekRule.FirstDay, CalendarWeekRule.FirstFourDayWeek)), 
			};
		}

		public abstract int GetYear(DateTime time);

		public virtual bool IsLeapDay(int year, int month, int day)
		{
			return IsLeapDay(year, month, day, 0);
		}

		public abstract bool IsLeapDay(int year, int month, int day, int era);

		public virtual bool IsLeapMonth(int year, int month)
		{
			return IsLeapMonth(year, month, 0);
		}

		public abstract bool IsLeapMonth(int year, int month, int era);

		public virtual int GetLeapMonth(int year)
		{
			return GetLeapMonth(year, 0);
		}

		public virtual int GetLeapMonth(int year, int era)
		{
			if (!IsLeapYear(year, era))
			{
				return 0;
			}
			int monthsInYear = GetMonthsInYear(year, era);
			for (int i = 1; i <= monthsInYear; i++)
			{
				if (IsLeapMonth(year, i, era))
				{
					return i;
				}
			}
			return 0;
		}

		public virtual bool IsLeapYear(int year)
		{
			return IsLeapYear(year, 0);
		}

		public abstract bool IsLeapYear(int year, int era);

		public virtual DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond)
		{
			return ToDateTime(year, month, day, hour, minute, second, millisecond, 0);
		}

		public abstract DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era);

		internal virtual bool TryToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era, out DateTime result)
		{
			result = DateTime.MinValue;
			try
			{
				result = ToDateTime(year, month, day, hour, minute, second, millisecond, era);
				return true;
			}
			catch (ArgumentException)
			{
				return false;
			}
		}

		internal virtual bool IsValidYear(int year, int era)
		{
			if (year >= GetYear(MinSupportedDateTime))
			{
				return year <= GetYear(MaxSupportedDateTime);
			}
			return false;
		}

		internal virtual bool IsValidMonth(int year, int month, int era)
		{
			if (IsValidYear(year, era) && month >= 1)
			{
				return month <= GetMonthsInYear(year, era);
			}
			return false;
		}

		internal virtual bool IsValidDay(int year, int month, int day, int era)
		{
			if (IsValidMonth(year, month, era) && day >= 1)
			{
				return day <= GetDaysInMonth(year, month, era);
			}
			return false;
		}

		public virtual int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (year < 100)
			{
				return (TwoDigitYearMax / 100 - ((year > TwoDigitYearMax % 100) ? 1 : 0)) * 100 + year;
			}
			return year;
		}

		internal static long TimeToTicks(int hour, int minute, int second, int millisecond)
		{
			if (hour < 0 || hour >= 24 || minute < 0 || minute >= 60 || second < 0 || second >= 60)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadHourMinuteSecond);
			}
			if (millisecond < 0 || millisecond >= 1000)
			{
				throw new ArgumentOutOfRangeException("millisecond", millisecond, SR.Format(SR.ArgumentOutOfRange_Range, 0, 999));
			}
			return InternalGlobalizationHelper.TimeToTicks(hour, minute, second) + (long)millisecond * 10000L;
		}

		internal static int GetSystemTwoDigitYearSetting(CalendarId CalID, int defaultYearValue)
		{
			int num = (GlobalizationMode.UseNls ? CalendarData.NlsGetTwoDigitYearMax(CalID) : CalendarData.IcuGetTwoDigitYearMax(CalID));
			if (num < 0)
			{
				return defaultYearValue;
			}
			return num;
		}
	}
	public enum CalendarAlgorithmType
	{
		Unknown,
		SolarCalendar,
		LunarCalendar,
		LunisolarCalendar
	}
	internal sealed class CalendarData
	{
		private struct IcuEnumCalendarsData
		{
			public List<string> Results;

			public bool DisallowDuplicates;
		}

		private struct EnumData
		{
			public string userOverride;

			public List<string> strings;
		}

		public struct NlsEnumCalendarsData
		{
			public int userOverride;

			public List<int> calendars;
		}

		internal string sNativeName;

		internal string[] saShortDates;

		internal string[] saYearMonths;

		internal string[] saLongDates;

		internal string sMonthDay;

		internal string[] saEraNames;

		internal string[] saAbbrevEraNames;

		internal string[] saAbbrevEnglishEraNames;

		internal string[] saDayNames;

		internal string[] saAbbrevDayNames;

		internal string[] saSuperShortDayNames;

		internal string[] saMonthNames;

		internal string[] saAbbrevMonthNames;

		internal string[] saMonthGenitiveNames;

		internal string[] saAbbrevMonthGenitiveNames;

		internal string[] saLeapYearMonthNames;

		internal int iTwoDigitYearMax = 2029;

		private int iCurrentEra;

		internal bool bUseUserOverrides;

		internal static readonly CalendarData Invariant = CreateInvariant();

		private CalendarData()
		{
		}

		private static CalendarData CreateInvariant()
		{
			CalendarData calendarData = new CalendarData();
			calendarData.sNativeName = "Gregorian Calendar";
			calendarData.iTwoDigitYearMax = 2029;
			calendarData.iCurrentEra = 1;
			calendarData.saShortDates = new string[2] { "MM/dd/yyyy", "yyyy-MM-dd" };
			calendarData.saLongDates = new string[1] { "dddd, dd MMMM yyyy" };
			calendarData.saYearMonths = new string[1] { "yyyy MMMM" };
			calendarData.sMonthDay = "MMMM dd";
			calendarData.saEraNames = new string[1] { "A.D." };
			calendarData.saAbbrevEraNames = new string[1] { "AD" };
			calendarData.saAbbrevEnglishEraNames = new string[1] { "AD" };
			calendarData.saDayNames = new string[7] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
			calendarData.saAbbrevDayNames = new string[7] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
			calendarData.saSuperShortDayNames = new string[7] { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
			calendarData.saMonthNames = new string[13]
			{
				"January",
				"February",
				"March",
				"April",
				"May",
				"June",
				"July",
				"August",
				"September",
				"October",
				"November",
				"December",
				string.Empty
			};
			calendarData.saAbbrevMonthNames = new string[13]
			{
				"Jan",
				"Feb",
				"Mar",
				"Apr",
				"May",
				"Jun",
				"Jul",
				"Aug",
				"Sep",
				"Oct",
				"Nov",
				"Dec",
				string.Empty
			};
			calendarData.saMonthGenitiveNames = calendarData.saMonthNames;
			calendarData.saAbbrevMonthGenitiveNames = calendarData.saAbbrevMonthNames;
			calendarData.saLeapYearMonthNames = calendarData.saMonthNames;
			calendarData.bUseUserOverrides = false;
			return calendarData;
		}

		internal CalendarData(string localeName, CalendarId calendarId, bool bUseUserOverrides)
		{
			this.bUseUserOverrides = bUseUserOverrides;
			if (!LoadCalendarDataFromSystemCore(localeName, calendarId))
			{
				if (sNativeName == null)
				{
					sNativeName = string.Empty;
				}
				if (saShortDates == null)
				{
					saShortDates = Invariant.saShortDates;
				}
				if (saYearMonths == null)
				{
					saYearMonths = Invariant.saYearMonths;
				}
				if (saLongDates == null)
				{
					saLongDates = Invariant.saLongDates;
				}
				if (sMonthDay == null)
				{
					sMonthDay = Invariant.sMonthDay;
				}
				if (saEraNames == null)
				{
					saEraNames = Invariant.saEraNames;
				}
				if (saAbbrevEraNames == null)
				{
					saAbbrevEraNames = Invariant.saAbbrevEraNames;
				}
				if (saAbbrevEnglishEraNames == null)
				{
					saAbbrevEnglishEraNames = Invariant.saAbbrevEnglishEraNames;
				}
				if (saDayNames == null)
				{
					saDayNames = Invariant.saDayNames;
				}
				if (saAbbrevDayNames == null)
				{
					saAbbrevDayNames = Invariant.saAbbrevDayNames;
				}
				if (saSuperShortDayNames == null)
				{
					saSuperShortDayNames = Invariant.saSuperShortDayNames;
				}
				if (saMonthNames == null)
				{
					saMonthNames = Invariant.saMonthNames;
				}
				if (saAbbrevMonthNames == null)
				{
					saAbbrevMonthNames = Invariant.saAbbrevMonthNames;
				}
			}
			if (calendarId == CalendarId.TAIWAN)
			{
				if (SystemSupportsTaiwaneseCalendar())
				{
					sNativeName = "中華民國曆";
				}
				else
				{
					sNativeName = string.Empty;
				}
			}
			if (saMonthGenitiveNames == null || saMonthGenitiveNames.Length == 0 || string.IsNullOrEmpty(saMonthGenitiveNames[0]))
			{
				saMonthGenitiveNames = saMonthNames;
			}
			if (saAbbrevMonthGenitiveNames == null || saAbbrevMonthGenitiveNames.Length == 0 || string.IsNullOrEmpty(saAbbrevMonthGenitiveNames[0]))
			{
				saAbbrevMonthGenitiveNames = saAbbrevMonthNames;
			}
			if (saLeapYearMonthNames == null || saLeapYearMonthNames.Length == 0 || string.IsNullOrEmpty(saLeapYearMonthNames[0]))
			{
				saLeapYearMonthNames = saMonthNames;
			}
			InitializeEraNames(localeName, calendarId);
			InitializeAbbreviatedEraNames(localeName, calendarId);
			if (calendarId == CalendarId.JAPAN)
			{
				saAbbrevEnglishEraNames = JapaneseCalendar.EnglishEraNames();
			}
			else
			{
				saAbbrevEnglishEraNames = new string[1] { "" };
			}
			iCurrentEra = saEraNames.Length;
		}

		private void InitializeEraNames(string localeName, CalendarId calendarId)
		{
			switch (calendarId)
			{
			case CalendarId.GREGORIAN:
				if (saEraNames == null || saEraNames.Length == 0 || string.IsNullOrEmpty(saEraNames[0]))
				{
					saEraNames = new string[1] { "A.D." };
				}
				break;
			case CalendarId.GREGORIAN_US:
			case CalendarId.JULIAN:
				saEraNames = new string[1] { "A.D." };
				break;
			case CalendarId.HEBREW:
				saEraNames = new string[1] { "C.E." };
				break;
			case CalendarId.HIJRI:
			case CalendarId.UMALQURA:
				if (localeName == "dv-MV")
				{
					saEraNames = new string[1] { "ހ\u07a8ޖ\u07b0ރ\u07a9" };
				}
				else
				{
					saEraNames = new string[1] { "بعد الهجرة" };
				}
				break;
			case CalendarId.GREGORIAN_ARABIC:
			case CalendarId.GREGORIAN_XLIT_ENGLISH:
			case CalendarId.GREGORIAN_XLIT_FRENCH:
				saEraNames = new string[1] { "م" };
				break;
			case CalendarId.GREGORIAN_ME_FRENCH:
				saEraNames = new string[1] { "ap. J.-C." };
				break;
			case CalendarId.TAIWAN:
				if (SystemSupportsTaiwaneseCalendar())
				{
					saEraNames = new string[1] { "中華民國" };
				}
				else
				{
					saEraNames = new string[1] { string.Empty };
				}
				break;
			case CalendarId.KOREA:
				saEraNames = new string[1] { "단기" };
				break;
			case CalendarId.THAI:
				saEraNames = new string[1] { "พ.ศ." };
				break;
			case CalendarId.JAPAN:
			case CalendarId.JAPANESELUNISOLAR:
				saEraNames = JapaneseCalendar.EraNames();
				break;
			case CalendarId.PERSIAN:
				if (saEraNames == null || saEraNames.Length == 0 || string.IsNullOrEmpty(saEraNames[0]))
				{
					saEraNames = new string[1] { "ه.ش" };
				}
				break;
			default:
				saEraNames = Invariant.saEraNames;
				break;
			}
		}

		private void InitializeAbbreviatedEraNames(string localeName, CalendarId calendarId)
		{
			switch (calendarId)
			{
			case CalendarId.GREGORIAN:
				if (saAbbrevEraNames == null || saAbbrevEraNames.Length == 0 || string.IsNullOrEmpty(saAbbrevEraNames[0]))
				{
					saAbbrevEraNames = new string[1] { "AD" };
				}
				break;
			case CalendarId.GREGORIAN_US:
			case CalendarId.JULIAN:
				saAbbrevEraNames = new string[1] { "AD" };
				break;
			case CalendarId.JAPAN:
			case CalendarId.JAPANESELUNISOLAR:
				saAbbrevEraNames = JapaneseCalendar.AbbrevEraNames();
				break;
			case CalendarId.HIJRI:
			case CalendarId.UMALQURA:
				if (localeName == "dv-MV")
				{
					saAbbrevEraNames = new string[1] { "ހ." };
				}
				else
				{
					saAbbrevEraNames = new string[1] { "هـ" };
				}
				break;
			case CalendarId.TAIWAN:
				saAbbrevEraNames = new string[1];
				if (saEraNames[0].Length == 4)
				{
					saAbbrevEraNames[0] = saEraNames[0].Substring(2, 2);
				}
				else
				{
					saAbbrevEraNames[0] = saEraNames[0];
				}
				break;
			case CalendarId.PERSIAN:
				if (saAbbrevEraNames == null || saAbbrevEraNames.Length == 0 || string.IsNullOrEmpty(saAbbrevEraNames[0]))
				{
					saAbbrevEraNames = saEraNames;
				}
				break;
			default:
				saAbbrevEraNames = saEraNames;
				break;
			}
		}

		internal static int GetCalendarCurrentEra(Calendar calendar)
		{
			if (GlobalizationMode.Invariant)
			{
				return Invariant.iCurrentEra;
			}
			CalendarId baseCalendarID = calendar.BaseCalendarID;
			string name = CalendarIdToCultureName(baseCalendarID);
			return CultureInfo.GetCultureInfo(name)._cultureData.GetCalendar(baseCalendarID).iCurrentEra;
		}

		private static string CalendarIdToCultureName(CalendarId calendarId)
		{
			switch (calendarId)
			{
			case CalendarId.GREGORIAN_US:
				return "fa-IR";
			case CalendarId.JAPAN:
				return "ja-JP";
			case CalendarId.TAIWAN:
				return "zh-TW";
			case CalendarId.KOREA:
				return "ko-KR";
			case CalendarId.HIJRI:
			case CalendarId.GREGORIAN_ARABIC:
			case CalendarId.UMALQURA:
				return "ar-SA";
			case CalendarId.THAI:
				return "th-TH";
			case CalendarId.HEBREW:
				return "he-IL";
			case CalendarId.GREGORIAN_ME_FRENCH:
				return "ar-DZ";
			case CalendarId.GREGORIAN_XLIT_ENGLISH:
			case CalendarId.GREGORIAN_XLIT_FRENCH:
				return "ar-IQ";
			default:
				return "en-US";
			}
		}

		private static bool SystemSupportsTaiwaneseCalendar()
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuSystemSupportsTaiwaneseCalendar();
			}
			return NlsSystemSupportsTaiwaneseCalendar();
		}

		private bool IcuLoadCalendarDataFromSystem(string localeName, CalendarId calendarId)
		{
			bool flag = true;
			flag &= GetCalendarInfo(localeName, calendarId, CalendarDataType.NativeName, out sNativeName);
			flag &= GetCalendarInfo(localeName, calendarId, CalendarDataType.MonthDay, out sMonthDay);
			if (sMonthDay != null)
			{
				sMonthDay = NormalizeDatePattern(sMonthDay);
			}
			flag &= EnumDatePatterns(localeName, calendarId, CalendarDataType.ShortDates, out saShortDates);
			flag &= EnumDatePatterns(localeName, calendarId, CalendarDataType.LongDates, out saLongDates);
			flag &= EnumDatePatterns(localeName, calendarId, CalendarDataType.YearMonths, out saYearMonths);
			flag &= EnumCalendarInfo(localeName, calendarId, CalendarDataType.DayNames, out saDayNames);
			flag &= EnumCalendarInfo(localeName, calendarId, CalendarDataType.AbbrevDayNames, out saAbbrevDayNames);
			flag &= EnumCalendarInfo(localeName, calendarId, CalendarDataType.SuperShortDayNames, out saSuperShortDayNames);
			string leapHebrewMonthName = null;
			flag &= EnumMonthNames(localeName, calendarId, CalendarDataType.MonthNames, out saMonthNames, ref leapHebrewMonthName);
			if (leapHebrewMonthName != null)
			{
				saLeapYearMonthNames = (string[])saMonthNames.Clone();
				saLeapYearMonthNames[6] = leapHebrewMonthName;
				saMonthNames[5] = saMonthNames[6];
				saMonthNames[6] = leapHebrewMonthName;
			}
			flag &= EnumMonthNames(localeName, calendarId, CalendarDataType.AbbrevMonthNames, out saAbbrevMonthNames, ref leapHebrewMonthName);
			flag &= EnumMonthNames(localeName, calendarId, CalendarDataType.MonthGenitiveNames, out saMonthGenitiveNames, ref leapHebrewMonthName);
			flag &= EnumMonthNames(localeName, calendarId, CalendarDataType.AbbrevMonthGenitiveNames, out saAbbrevMonthGenitiveNames, ref leapHebrewMonthName);
			flag &= EnumEraNames(localeName, calendarId, CalendarDataType.EraNames, out saEraNames);
			return flag & EnumEraNames(localeName, calendarId, CalendarDataType.AbbrevEraNames, out saAbbrevEraNames);
		}

		internal static int IcuGetTwoDigitYearMax(CalendarId calendarId)
		{
			return -1;
		}

		internal static int IcuGetCalendars(string localeName, CalendarId[] calendars)
		{
			int num = Interop.Globalization.GetCalendars(localeName, calendars, calendars.Length);
			if (num == 0 && calendars.Length != 0)
			{
				calendars[0] = CalendarId.GREGORIAN;
				num = 1;
			}
			return num;
		}

		private static bool IcuSystemSupportsTaiwaneseCalendar()
		{
			return true;
		}

		private unsafe static bool GetCalendarInfo(string localeName, CalendarId calendarId, CalendarDataType dataType, out string calendarString)
		{
			return Interop.CallStringMethod(delegate(Span<char> buffer, string locale, CalendarId id, CalendarDataType type)
			{
				fixed (char* result = buffer)
				{
					return Interop.Globalization.GetCalendarInfo(locale, id, type, result, buffer.Length);
				}
			}, localeName, calendarId, dataType, out calendarString);
		}

		private static bool EnumDatePatterns(string localeName, CalendarId calendarId, CalendarDataType dataType, out string[] datePatterns)
		{
			datePatterns = null;
			IcuEnumCalendarsData callbackContext = default(IcuEnumCalendarsData);
			callbackContext.Results = new List<string>();
			callbackContext.DisallowDuplicates = true;
			bool flag = EnumCalendarInfo(localeName, calendarId, dataType, ref callbackContext);
			if (flag)
			{
				List<string> results = callbackContext.Results;
				for (int i = 0; i < results.Count; i++)
				{
					results[i] = NormalizeDatePattern(results[i]);
				}
				if (dataType == CalendarDataType.ShortDates)
				{
					FixDefaultShortDatePattern(results);
				}
				datePatterns = results.ToArray();
			}
			return flag;
		}

		private static void FixDefaultShortDatePattern(List<string> shortDatePatterns)
		{
			if (shortDatePatterns.Count == 0)
			{
				return;
			}
			string text = shortDatePatterns[0];
			if (text.Length > 100)
			{
				return;
			}
			Span<char> span = stackalloc char[text.Length + 2];
			int i;
			for (i = 0; i < text.Length; i++)
			{
				if (text[i] == '\'')
				{
					do
					{
						span[i] = text[i];
						i++;
					}
					while (i < text.Length && text[i] != '\'');
					if (i >= text.Length)
					{
						return;
					}
				}
				else if (text[i] == 'y')
				{
					span[i] = 'y';
					break;
				}
				span[i] = text[i];
			}
			if (i >= text.Length - 1 || text[i + 1] != 'y' || (i + 2 < text.Length && text[i + 2] == 'y'))
			{
				return;
			}
			span[i + 1] = 'y';
			span[i + 2] = 'y';
			span[i + 3] = 'y';
			for (i += 2; i < text.Length; i++)
			{
				span[i + 2] = text[i];
			}
			shortDatePatterns[0] = span.ToString();
			for (int j = 1; j < shortDatePatterns.Count; j++)
			{
				if (shortDatePatterns[j] == shortDatePatterns[0])
				{
					shortDatePatterns[j] = text;
					return;
				}
			}
			shortDatePatterns.Add(text);
		}

		private static string NormalizeDatePattern(string input)
		{
			StringBuilder stringBuilder = StringBuilderCache.Acquire(input.Length);
			int index = 0;
			while (index < input.Length)
			{
				switch (input[index])
				{
				case '\'':
					stringBuilder.Append(input[index++]);
					while (index < input.Length)
					{
						char c = input[index++];
						stringBuilder.Append(c);
						if (c == '\'')
						{
							break;
						}
					}
					break;
				case 'E':
				case 'c':
				case 'e':
					NormalizeDayOfWeek(input, stringBuilder, ref index);
					break;
				case 'L':
				case 'M':
				{
					int num = CountOccurrences(input, input[index], ref index);
					if (num > 4)
					{
						num = 3;
					}
					stringBuilder.Append('M', num);
					break;
				}
				case 'G':
				{
					int num = CountOccurrences(input, 'G', ref index);
					stringBuilder.Append('g');
					break;
				}
				case 'y':
				{
					int num = CountOccurrences(input, 'y', ref index);
					if (num == 1)
					{
						num = 4;
					}
					stringBuilder.Append('y', num);
					break;
				}
				default:
					stringBuilder.Append(input[index++]);
					break;
				}
			}
			return StringBuilderCache.GetStringAndRelease(stringBuilder);
		}

		private static void NormalizeDayOfWeek(string input, StringBuilder destination, ref int index)
		{
			char value = input[index];
			int val = CountOccurrences(input, value, ref index);
			val = Math.Max(val, 3);
			if (val > 4)
			{
				val = 3;
			}
			destination.Append('d', val);
		}

		private static int CountOccurrences(string input, char value, ref int index)
		{
			int num = index;
			while (index < input.Length && input[index] == value)
			{
				index++;
			}
			return index - num;
		}

		private static bool EnumMonthNames(string localeName, CalendarId calendarId, CalendarDataType dataType, out string[] monthNames, ref string leapHebrewMonthName)
		{
			monthNames = null;
			IcuEnumCalendarsData callbackContext = default(IcuEnumCalendarsData);
			callbackContext.Results = new List<string>();
			bool flag = EnumCalendarInfo(localeName, calendarId, dataType, ref callbackContext);
			if (flag)
			{
				if (callbackContext.Results.Count == 12)
				{
					callbackContext.Results.Add(string.Empty);
				}
				if (callbackContext.Results.Count > 13)
				{
					if (calendarId == CalendarId.HEBREW)
					{
						leapHebrewMonthName = callbackContext.Results[13];
					}
					callbackContext.Results.RemoveRange(13, callbackContext.Results.Count - 13);
				}
				monthNames = callbackContext.Results.ToArray();
			}
			return flag;
		}

		private static bool EnumEraNames(string localeName, CalendarId calendarId, CalendarDataType dataType, out string[] eraNames)
		{
			bool result = EnumCalendarInfo(localeName, calendarId, dataType, out eraNames);
			if (calendarId != CalendarId.JAPAN && calendarId != CalendarId.JAPANESELUNISOLAR)
			{
				string[] obj = eraNames;
				if (obj != null && obj.Length != 0)
				{
					string[] array = new string[1] { eraNames[eraNames.Length - 1] };
					eraNames = array;
				}
			}
			return result;
		}

		internal static bool EnumCalendarInfo(string localeName, CalendarId calendarId, CalendarDataType dataType, out string[] calendarData)
		{
			calendarData = null;
			IcuEnumCalendarsData callbackContext = default(IcuEnumCalendarsData);
			callbackContext.Results = new List<string>();
			bool flag = EnumCalendarInfo(localeName, calendarId, dataType, ref callbackContext);
			if (flag)
			{
				calendarData = callbackContext.Results.ToArray();
			}
			return flag;
		}

		private unsafe static bool EnumCalendarInfo(string localeName, CalendarId calendarId, CalendarDataType dataType, ref IcuEnumCalendarsData callbackContext)
		{
			return Interop.Globalization.EnumCalendarInfo((delegate* unmanaged<char*, IntPtr, void>)(delegate*<char*, IntPtr, void>)(&EnumCalendarInfoCallback), localeName, calendarId, dataType, (IntPtr)Unsafe.AsPointer(ref callbackContext));
		}

		[UnmanagedCallersOnly]
		private unsafe static void EnumCalendarInfoCallback(char* calendarStringPtr, IntPtr context)
		{
			try
			{
				ReadOnlySpan<char> strA = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(calendarStringPtr);
				ref IcuEnumCalendarsData reference = ref Unsafe.As<byte, IcuEnumCalendarsData>(ref *(byte*)(void*)context);
				if (reference.DisallowDuplicates)
				{
					foreach (string result in reference.Results)
					{
						if (string.CompareOrdinal(strA, result) == 0)
						{
							return;
						}
					}
				}
				reference.Results.Add(strA.ToString());
			}
			catch (Exception)
			{
			}
		}

		internal static int NlsGetTwoDigitYearMax(CalendarId calendarId)
		{
			if (!GlobalizationMode.Invariant)
			{
				if (!CallGetCalendarInfoEx((string)null, calendarId, 48u, out int data))
				{
					return -1;
				}
				return data;
			}
			return Invariant.iTwoDigitYearMax;
		}

		private static bool NlsSystemSupportsTaiwaneseCalendar()
		{
			string data;
			return CallGetCalendarInfoEx("zh-TW", CalendarId.TAIWAN, 2u, out data);
		}

		private static bool CallGetCalendarInfoEx(string localeName, CalendarId calendar, uint calType, out int data)
		{
			return Interop.Kernel32.GetCalendarInfoEx(localeName, (uint)calendar, IntPtr.Zero, calType | 0x20000000u, IntPtr.Zero, 0, out data) != 0;
		}

		private unsafe static bool CallGetCalendarInfoEx(string localeName, CalendarId calendar, uint calType, out string data)
		{
			char* ptr = stackalloc char[80];
			int num = Interop.Kernel32.GetCalendarInfoEx(localeName, (uint)calendar, IntPtr.Zero, calType, (IntPtr)ptr, 80, IntPtr.Zero);
			if (num > 0)
			{
				if (ptr[num - 1] == '\0')
				{
					num--;
				}
				data = new string(ptr, 0, num);
				return true;
			}
			data = "";
			return false;
		}

		[UnmanagedCallersOnly]
		private unsafe static Interop.BOOL EnumCalendarInfoCallback(char* lpCalendarInfoString, uint calendar, IntPtr pReserved, void* lParam)
		{
			ref EnumData reference = ref Unsafe.As<byte, EnumData>(ref *(byte*)lParam);
			try
			{
				string text = new string(lpCalendarInfoString);
				if (reference.userOverride != text)
				{
					reference.strings.Add(text);
				}
				return Interop.BOOL.TRUE;
			}
			catch (Exception)
			{
				return Interop.BOOL.FALSE;
			}
		}

		[UnmanagedCallersOnly]
		private unsafe static Interop.BOOL EnumCalendarsCallback(char* lpCalendarInfoString, uint calendar, IntPtr reserved, void* lParam)
		{
			ref NlsEnumCalendarsData reference = ref Unsafe.As<byte, NlsEnumCalendarsData>(ref *(byte*)lParam);
			try
			{
				if (reference.userOverride != calendar)
				{
					reference.calendars.Add((int)calendar);
				}
				return Interop.BOOL.TRUE;
			}
			catch (Exception)
			{
				return Interop.BOOL.FALSE;
			}
		}

		private bool LoadCalendarDataFromSystemCore(string localeName, CalendarId calendarId)
		{
			if (GlobalizationMode.UseNls)
			{
				return NlsLoadCalendarDataFromSystem(localeName, calendarId);
			}
			bool flag = IcuLoadCalendarDataFromSystem(localeName, calendarId);
			if (flag && bUseUserOverrides)
			{
				NormalizeCalendarId(ref calendarId, ref localeName);
				flag &= CallGetCalendarInfoEx(localeName, calendarId, 48u, out iTwoDigitYearMax);
				CalendarId calendarId2 = (CalendarId)CultureData.GetLocaleInfoExInt(localeName, 4105u);
				if (calendarId2 == calendarId)
				{
					string value = CultureData.ReescapeWin32String(CultureData.GetLocaleInfoEx(localeName, 31u));
					string value2 = CultureData.ReescapeWin32String(CultureData.GetLocaleInfoEx(localeName, 32u));
					InsertOrSwapOverride(value, ref saShortDates);
					InsertOrSwapOverride(value2, ref saLongDates);
				}
			}
			return flag;
		}

		private void InsertOrSwapOverride(string value, ref string[] destination)
		{
			if (value == null)
			{
				return;
			}
			for (int i = 0; i < destination.Length; i++)
			{
				if (destination[i] == value)
				{
					if (i > 0)
					{
						string text = destination[0];
						destination[0] = value;
						destination[i] = text;
					}
					return;
				}
			}
			string[] array = new string[destination.Length + 1];
			array[0] = value;
			Array.Copy(destination, 0, array, 1, destination.Length);
			destination = array;
		}

		private bool NlsLoadCalendarDataFromSystem(string localeName, CalendarId calendarId)
		{
			bool flag = true;
			uint num = ((!bUseUserOverrides) ? 2147483648u : 0u);
			NormalizeCalendarId(ref calendarId, ref localeName);
			flag &= CallGetCalendarInfoEx(localeName, calendarId, 0x30u | num, out iTwoDigitYearMax);
			flag &= CallGetCalendarInfoEx(localeName, calendarId, 2u, out sNativeName);
			flag &= CallGetCalendarInfoEx(localeName, calendarId, 56u, out sMonthDay);
			flag &= CallEnumCalendarInfo(localeName, calendarId, 5u, 0x1Fu | num, out saShortDates);
			flag &= CallEnumCalendarInfo(localeName, calendarId, 6u, 0x20u | num, out saLongDates);
			flag &= CallEnumCalendarInfo(localeName, calendarId, 47u, 4102u, out saYearMonths);
			flag &= GetCalendarDayInfo(localeName, calendarId, 13u, out saDayNames);
			flag &= GetCalendarDayInfo(localeName, calendarId, 20u, out saAbbrevDayNames);
			flag &= GetCalendarMonthInfo(localeName, calendarId, 21u, out saMonthNames);
			flag &= GetCalendarMonthInfo(localeName, calendarId, 34u, out saAbbrevMonthNames);
			GetCalendarDayInfo(localeName, calendarId, 55u, out saSuperShortDayNames);
			if (calendarId == CalendarId.GREGORIAN)
			{
				GetCalendarMonthInfo(localeName, calendarId, 268435477u, out saMonthGenitiveNames);
				GetCalendarMonthInfo(localeName, calendarId, 268435490u, out saAbbrevMonthGenitiveNames);
			}
			CallEnumCalendarInfo(localeName, calendarId, 4u, 0u, out saEraNames);
			CallEnumCalendarInfo(localeName, calendarId, 57u, 0u, out saAbbrevEraNames);
			saShortDates = CultureData.ReescapeWin32Strings(saShortDates);
			saLongDates = CultureData.ReescapeWin32Strings(saLongDates);
			saYearMonths = CultureData.ReescapeWin32Strings(saYearMonths);
			sMonthDay = CultureData.ReescapeWin32String(sMonthDay);
			return flag;
		}

		private static void NormalizeCalendarId(ref CalendarId calendarId, ref string localeName)
		{
			switch (calendarId)
			{
			case CalendarId.JAPANESELUNISOLAR:
				calendarId = CalendarId.JAPAN;
				break;
			case CalendarId.JULIAN:
			case CalendarId.CHINESELUNISOLAR:
			case CalendarId.SAKA:
			case CalendarId.LUNAR_ETO_CHN:
			case CalendarId.LUNAR_ETO_KOR:
			case CalendarId.LUNAR_ETO_ROKUYOU:
			case CalendarId.KOREANLUNISOLAR:
			case CalendarId.TAIWANLUNISOLAR:
				calendarId = CalendarId.GREGORIAN_US;
				break;
			}
			CheckSpecialCalendar(ref calendarId, ref localeName);
		}

		private static void CheckSpecialCalendar(ref CalendarId calendar, ref string localeName)
		{
			switch (calendar)
			{
			case CalendarId.GREGORIAN_US:
			{
				if (!CallGetCalendarInfoEx(localeName, calendar, 2u, out string data))
				{
					localeName = "fa-IR";
					if (!CallGetCalendarInfoEx(localeName, calendar, 2u, out data))
					{
						localeName = "en-US";
						calendar = CalendarId.GREGORIAN;
					}
				}
				break;
			}
			case CalendarId.TAIWAN:
				if (!NlsSystemSupportsTaiwaneseCalendar())
				{
					calendar = CalendarId.GREGORIAN;
				}
				break;
			}
		}

		private unsafe static bool CallEnumCalendarInfo(string localeName, CalendarId calendar, uint calType, uint lcType, out string[] data)
		{
			EnumData value = default(EnumData);
			value.userOverride = null;
			value.strings = new List<string>();
			if (lcType != 0 && (lcType & 0x80000000u) == 0)
			{
				CalendarId calendarId = (CalendarId)CultureData.GetLocaleInfoExInt(localeName, 4105u);
				if (calendarId == calendar)
				{
					string localeInfoEx = CultureData.GetLocaleInfoEx(localeName, lcType);
					if (localeInfoEx != null)
					{
						value.userOverride = localeInfoEx;
						value.strings.Add(localeInfoEx);
					}
				}
			}
			Interop.Kernel32.EnumCalendarInfoExEx((delegate* unmanaged<char*, uint, IntPtr, void*, Interop.BOOL>)(delegate*<char*, uint, IntPtr, void*, Interop.BOOL>)(&EnumCalendarInfoCallback), localeName, (uint)calendar, null, calType, Unsafe.AsPointer(ref value));
			if (value.strings.Count == 0)
			{
				data = null;
				return false;
			}
			string[] array = value.strings.ToArray();
			if (calType == 57 || calType == 4)
			{
				Array.Reverse(array, 0, array.Length);
			}
			data = array;
			return true;
		}

		private static bool GetCalendarDayInfo(string localeName, CalendarId calendar, uint calType, out string[] outputStrings)
		{
			bool flag = true;
			string[] array = new string[7];
			int num = 0;
			while (num < 7)
			{
				flag &= CallGetCalendarInfoEx(localeName, calendar, calType, out array[num]);
				if (num == 0)
				{
					calType -= 7;
				}
				num++;
				calType++;
			}
			outputStrings = array;
			return flag;
		}

		private static bool GetCalendarMonthInfo(string localeName, CalendarId calendar, uint calType, out string[] outputStrings)
		{
			string[] array = new string[13];
			int num = 0;
			while (num < 13)
			{
				if (!CallGetCalendarInfoEx(localeName, calendar, calType, out array[num]))
				{
					array[num] = "";
				}
				num++;
				calType++;
			}
			outputStrings = array;
			return true;
		}

		internal static int GetCalendarsCore(string localeName, bool useUserOverride, CalendarId[] calendars)
		{
			if (GlobalizationMode.UseNls)
			{
				return NlsGetCalendars(localeName, useUserOverride, calendars);
			}
			int num = IcuGetCalendars(localeName, calendars);
			if (useUserOverride)
			{
				int localeInfoExInt = CultureData.GetLocaleInfoExInt(localeName, 4105u);
				if (localeInfoExInt != 0 && (uint)(ushort)localeInfoExInt != (uint)calendars[0])
				{
					CalendarId calendarId = (CalendarId)localeInfoExInt;
					for (int i = 1; i < calendars.Length; i++)
					{
						if (calendars[i] == calendarId)
						{
							CalendarId calendarId2 = calendars[0];
							calendars[0] = calendarId;
							calendars[i] = calendarId2;
							return num;
						}
					}
					num = ((num < calendars.Length) ? (num + 1) : num);
					Span<CalendarId> span = stackalloc CalendarId[num];
					span[0] = calendarId;
					calendars.AsSpan(0, num - 1).CopyTo(span.Slice(1));
					span.CopyTo(calendars);
				}
			}
			return num;
		}

		private unsafe static int NlsGetCalendars(string localeName, bool useUserOverride, CalendarId[] calendars)
		{
			NlsEnumCalendarsData value = default(NlsEnumCalendarsData);
			value.userOverride = 0;
			value.calendars = new List<int>();
			if (useUserOverride)
			{
				int localeInfoExInt = CultureData.GetLocaleInfoExInt(localeName, 4105u);
				if (localeInfoExInt != 0)
				{
					value.userOverride = localeInfoExInt;
					value.calendars.Add(localeInfoExInt);
				}
			}
			Interop.Kernel32.EnumCalendarInfoExEx((delegate* unmanaged<char*, uint, IntPtr, void*, Interop.BOOL>)(delegate*<char*, uint, IntPtr, void*, Interop.BOOL>)(&EnumCalendarsCallback), localeName, uint.MaxValue, null, 1u, Unsafe.AsPointer(ref value));
			for (int i = 0; i < Math.Min(calendars.Length, value.calendars.Count); i++)
			{
				calendars[i] = (CalendarId)value.calendars[i];
			}
			return value.calendars.Count;
		}
	}
	internal enum CalendarDataType
	{
		Uninitialized,
		NativeName,
		MonthDay,
		ShortDates,
		LongDates,
		YearMonths,
		DayNames,
		AbbrevDayNames,
		MonthNames,
		AbbrevMonthNames,
		SuperShortDayNames,
		MonthGenitiveNames,
		AbbrevMonthGenitiveNames,
		EraNames,
		AbbrevEraNames
	}
	public enum CalendarWeekRule
	{
		FirstDay,
		FirstFullWeek,
		FirstFourDayWeek
	}
	internal static class CalendricalCalculationsHelper
	{
		private enum CorrectionAlgorithm
		{
			Default,
			Year1988to2019,
			Year1900to1987,
			Year1800to1899,
			Year1700to1799,
			Year1620to1699
		}

		private struct EphemerisCorrectionAlgorithmMap
		{
			internal int _lowestYear;

			internal CorrectionAlgorithm _algorithm;

			public EphemerisCorrectionAlgorithmMap(int year, CorrectionAlgorithm algorithm)
			{
				_lowestYear = year;
				_algorithm = algorithm;
			}
		}

		private static readonly long s_startOf1810 = GetNumberOfDays(new DateTime(1810, 1, 1));

		private static readonly long s_startOf1900Century = GetNumberOfDays(new DateTime(1900, 1, 1));

		private static readonly double[] s_coefficients1900to1987 = new double[8] { -2E-05, 0.000297, 0.025184, -0.181133, 0.55304, -0.861938, 0.677066, -0.212591 };

		private static readonly double[] s_coefficients1800to1899 = new double[11]
		{
			-9E-06, 0.003844, 0.083563, 0.865736, 4.867575, 15.845535, 31.332267, 38.291999, 28.316289, 11.636204,
			2.043794
		};

		private static readonly double[] s_coefficients1700to1799 = new double[4] { 8.118780842, -0.005092142, 0.003336121, -2.66484E-05 };

		private static readonly double[] s_coefficients1620to1699 = new double[3] { 196.58333, -4.0675, 0.0219167 };

		private static readonly double[] s_lambdaCoefficients = new double[3] { 280.46645, 36000.76983, 0.0003032 };

		private static readonly double[] s_anomalyCoefficients = new double[4] { 357.5291, 35999.0503, -0.0001559, -4.8E-07 };

		private static readonly double[] s_eccentricityCoefficients = new double[3] { 0.016708617, -4.2037E-05, -1.236E-07 };

		private static readonly double[] s_coefficients = new double[4]
		{
			Angle(23, 26, 21.448),
			Angle(0, 0, -46.815),
			Angle(0, 0, -0.00059),
			Angle(0, 0, 0.001813)
		};

		private static readonly double[] s_coefficientsA = new double[3] { 124.9, -1934.134, 0.002063 };

		private static readonly double[] s_coefficientsB = new double[3] { 201.11, 72001.5377, 0.00057 };

		private static readonly EphemerisCorrectionAlgorithmMap[] s_ephemerisCorrectionTable = new EphemerisCorrectionAlgorithmMap[7]
		{
			new EphemerisCorrectionAlgorithmMap(2020, CorrectionAlgorithm.Default),
			new EphemerisCorrectionAlgorithmMap(1988, CorrectionAlgorithm.Year1988to2019),
			new EphemerisCorrectionAlgorithmMap(1900, CorrectionAlgorithm.Year1900to1987),
			new EphemerisCorrectionAlgorithmMap(1800, CorrectionAlgorithm.Year1800to1899),
			new EphemerisCorrectionAlgorithmMap(1700, CorrectionAlgorithm.Year1700to1799),
			new EphemerisCorrectionAlgorithmMap(1620, CorrectionAlgorithm.Year1620to1699),
			new EphemerisCorrectionAlgorithmMap(int.MinValue, CorrectionAlgorithm.Default)
		};

		private static double RadiansFromDegrees(double degree)
		{
			return degree * Math.PI / 180.0;
		}

		private static double SinOfDegree(double degree)
		{
			return Math.Sin(RadiansFromDegrees(degree));
		}

		private static double CosOfDegree(double degree)
		{
			return Math.Cos(RadiansFromDegrees(degree));
		}

		private static double TanOfDegree(double degree)
		{
			return Math.Tan(RadiansFromDegrees(degree));
		}

		public static double Angle(int degrees, int minutes, double seconds)
		{
			return (seconds / 60.0 + (double)minutes) / 60.0 + (double)degrees;
		}

		private static double Obliquity(double julianCenturies)
		{
			return PolynomialSum(s_coefficients, julianCenturies);
		}

		internal static long GetNumberOfDays(DateTime date)
		{
			return date.Ticks / 864000000000L;
		}

		private static int GetGregorianYear(double numberOfDays)
		{
			return new DateTime(Math.Min((long)(Math.Floor(numberOfDays) * 864000000000.0), DateTime.MaxValue.Ticks)).Year;
		}

		private static double Reminder(double divisor, double dividend)
		{
			double num = Math.Floor(divisor / dividend);
			return divisor - dividend * num;
		}

		private static double NormalizeLongitude(double longitude)
		{
			longitude = Reminder(longitude, 360.0);
			if (longitude < 0.0)
			{
				longitude += 360.0;
			}
			return longitude;
		}

		public static double AsDayFraction(double longitude)
		{
			return longitude / 360.0;
		}

		private static double PolynomialSum(double[] coefficients, double indeterminate)
		{
			double num = coefficients[0];
			double num2 = 1.0;
			for (int i = 1; i < coefficients.Length; i++)
			{
				num2 *= indeterminate;
				num += coefficients[i] * num2;
			}
			return num;
		}

		private static double CenturiesFrom1900(int gregorianYear)
		{
			long numberOfDays = GetNumberOfDays(new DateTime(gregorianYear, 7, 1));
			return (double)(numberOfDays - s_startOf1900Century) / 36525.0;
		}

		private static double DefaultEphemerisCorrection(int gregorianYear)
		{
			long numberOfDays = GetNumberOfDays(new DateTime(gregorianYear, 1, 1));
			double num = numberOfDays - s_startOf1810;
			double x = 0.5 + num;
			return (Math.Pow(x, 2.0) / 41048480.0 - 15.0) / 86400.0;
		}

		private static double EphemerisCorrection1988to2019(int gregorianYear)
		{
			return (double)(gregorianYear - 1933) / 86400.0;
		}

		private static double EphemerisCorrection1900to1987(int gregorianYear)
		{
			double indeterminate = CenturiesFrom1900(gregorianYear);
			return PolynomialSum(s_coefficients1900to1987, indeterminate);
		}

		private static double EphemerisCorrection1800to1899(int gregorianYear)
		{
			double indeterminate = CenturiesFrom1900(gregorianYear);
			return PolynomialSum(s_coefficients1800to1899, indeterminate);
		}

		private static double EphemerisCorrection1700to1799(int gregorianYear)
		{
			double indeterminate = gregorianYear - 1700;
			return PolynomialSum(s_coefficients1700to1799, indeterminate) / 86400.0;
		}

		private static double EphemerisCorrection1620to1699(int gregorianYear)
		{
			double indeterminate = gregorianYear - 1600;
			return PolynomialSum(s_coefficients1620to1699, indeterminate) / 86400.0;
		}

		private static double EphemerisCorrection(double time)
		{
			int gregorianYear = GetGregorianYear(time);
			EphemerisCorrectionAlgorithmMap[] array = s_ephemerisCorrectionTable;
			for (int i = 0; i < array.Length; i++)
			{
				EphemerisCorrectionAlgorithmMap ephemerisCorrectionAlgorithmMap = array[i];
				if (ephemerisCorrectionAlgorithmMap._lowestYear <= gregorianYear)
				{
					switch (ephemerisCorrectionAlgorithmMap._algorithm)
					{
					case CorrectionAlgorithm.Default:
						return DefaultEphemerisCorrection(gregorianYear);
					case CorrectionAlgorithm.Year1988to2019:
						return EphemerisCorrection1988to2019(gregorianYear);
					case CorrectionAlgorithm.Year1900to1987:
						return EphemerisCorrection1900to1987(gregorianYear);
					case CorrectionAlgorithm.Year1800to1899:
						return EphemerisCorrection1800to1899(gregorianYear);
					case CorrectionAlgorithm.Year1700to1799:
						return EphemerisCorrection1700to1799(gregorianYear);
					case CorrectionAlgorithm.Year1620to1699:
						return EphemerisCorrection1620to1699(gregorianYear);
					}
					break;
				}
			}
			return DefaultEphemerisCorrection(gregorianYear);
		}

		public static double JulianCenturies(double moment)
		{
			double num = moment + EphemerisCorrection(moment);
			return (num - 730120.5) / 36525.0;
		}

		private static bool IsNegative(double value)
		{
			return Math.Sign(value) == -1;
		}

		private static double CopySign(double value, double sign)
		{
			if (IsNegative(value) != IsNegative(sign))
			{
				return 0.0 - value;
			}
			return value;
		}

		private static double EquationOfTime(double time)
		{
			double num = JulianCenturies(time);
			double num2 = PolynomialSum(s_lambdaCoefficients, num);
			double num3 = PolynomialSum(s_anomalyCoefficients, num);
			double num4 = PolynomialSum(s_eccentricityCoefficients, num);
			double num5 = Obliquity(num);
			double num6 = TanOfDegree(num5 / 2.0);
			double num7 = num6 * num6;
			double num8 = num7 * SinOfDegree(2.0 * num2) - 2.0 * num4 * SinOfDegree(num3) + 4.0 * num4 * num7 * SinOfDegree(num3) * CosOfDegree(2.0 * num2) - 0.5 * Math.Pow(num7, 2.0) * SinOfDegree(4.0 * num2) - 1.25 * Math.Pow(num4, 2.0) * SinOfDegree(2.0 * num3);
			double num9 = num8 / (Math.PI * 2.0);
			return CopySign(Math.Min(Math.Abs(num9), 0.5), num9);
		}

		private static double AsLocalTime(double apparentMidday, double longitude)
		{
			double time = apparentMidday - AsDayFraction(longitude);
			return apparentMidday - EquationOfTime(time);
		}

		public static double Midday(double date, double longitude)
		{
			return AsLocalTime(date + 0.5, longitude) - AsDayFraction(longitude);
		}

		private static double InitLongitude(double longitude)
		{
			return NormalizeLongitude(longitude + 180.0) - 180.0;
		}

		public static double MiddayAtPersianObservationSite(double date)
		{
			return Midday(date, InitLongitude(52.5));
		}

		private static double PeriodicTerm(double julianCenturies, int x, double y, double z)
		{
			return (double)x * SinOfDegree(y + z * julianCenturies);
		}

		private static double SumLongSequenceOfPeriodicTerms(double julianCenturies)
		{
			double num = 0.0;
			num += PeriodicTerm(julianCenturies, 403406, 270.54861, 0.9287892);
			num += PeriodicTerm(julianCenturies, 195207, 340.19128, 35999.1376958);
			num += PeriodicTerm(julianCenturies, 119433, 63.91854, 35999.4089666);
			num += PeriodicTerm(julianCenturies, 112392, 331.2622, 35998.7287385);
			num += PeriodicTerm(julianCenturies, 3891, 317.843, 71998.20261);
			num += PeriodicTerm(julianCenturies, 2819, 86.631, 71998.4403);
			num += PeriodicTerm(julianCenturies, 1721, 240.052, 36000.35726);
			num += PeriodicTerm(julianCenturies, 660, 310.26, 71997.4812);
			num += PeriodicTerm(julianCenturies, 350, 247.23, 32964.4678);
			num += PeriodicTerm(julianCenturies, 334, 260.87, -19.441);
			num += PeriodicTerm(julianCenturies, 314, 297.82, 445267.1117);
			num += PeriodicTerm(julianCenturies, 268, 343.14, 45036.884);
			num += PeriodicTerm(julianCenturies, 242, 166.79, 3.1008);
			num += PeriodicTerm(julianCenturies, 234, 81.53, 22518.4434);
			num += PeriodicTerm(julianCenturies, 158, 3.5, -19.9739);
			num += PeriodicTerm(julianCenturies, 132, 132.75, 65928.9345);
			num += PeriodicTerm(julianCenturies, 129, 182.95, 9038.0293);
			num += PeriodicTerm(julianCenturies, 114, 162.03, 3034.7684);
			num += PeriodicTerm(julianCenturies, 99, 29.8, 33718.148);
			num += PeriodicTerm(julianCenturies, 93, 266.4, 3034.448);
			num += PeriodicTerm(julianCenturies, 86, 249.2, -2280.773);
			num += PeriodicTerm(julianCenturies, 78, 157.6, 29929.992);
			num += PeriodicTerm(julianCenturies, 72, 257.8, 31556.493);
			num += PeriodicTerm(julianCenturies, 68, 185.1, 149.588);
			num += PeriodicTerm(julianCenturies, 64, 69.9, 9037.75);
			num += PeriodicTerm(julianCenturies, 46, 8.0, 107997.405);
			num += PeriodicTerm(julianCenturies, 38, 197.1, -4444.176);
			num += PeriodicTerm(julianCenturies, 37, 250.4, 151.771);
			num += PeriodicTerm(julianCenturies, 32, 65.3, 67555.316);
			num += PeriodicTerm(julianCenturies, 29, 162.7, 31556.08);
			num += PeriodicTerm(julianCenturies, 28, 341.5, -4561.54);
			num += PeriodicTerm(julianCenturies, 27, 291.6, 107996.706);
			num += PeriodicTerm(julianCenturies, 27, 98.5, 1221.655);
			num += PeriodicTerm(julianCenturies, 25, 146.7, 62894.167);
			num += PeriodicTerm(julianCenturies, 24, 110.0, 31437.369);
			num += PeriodicTerm(julianCenturies, 21, 5.2, 14578.298);
			num += PeriodicTerm(julianCenturies, 21, 342.6, -31931.757);
			num += PeriodicTerm(julianCenturies, 20, 230.9, 34777.243);
			num += PeriodicTerm(julianCenturies, 18, 256.1, 1221.999);
			num += PeriodicTerm(julianCenturies, 17, 45.3, 62894.511);
			num += PeriodicTerm(julianCenturies, 14, 242.9, -4442.039);
			num += PeriodicTerm(julianCenturies, 13, 115.2, 107997.909);
			num += PeriodicTerm(julianCenturies, 13, 151.8, 119.066);
			num += PeriodicTerm(julianCenturies, 13, 285.3, 16859.071);
			num += PeriodicTerm(julianCenturies, 12, 53.3, -4.578);
			num += PeriodicTerm(julianCenturies, 10, 126.6, 26895.292);
			num += PeriodicTerm(julianCenturies, 10, 205.7, -39.127);
			num += PeriodicTerm(julianCenturies, 10, 85.9, 12297.536);
			return num + PeriodicTerm(julianCenturies, 10, 146.1, 90073.778);
		}

		private static double Aberration(double julianCenturies)
		{
			return 9.74E-05 * CosOfDegree(177.63 + 35999.01848 * julianCenturies) - 0.005575;
		}

		private static double Nutation(double julianCenturies)
		{
			double degree = PolynomialSum(s_coefficientsA, julianCenturies);
			double degree2 = PolynomialSum(s_coefficientsB, julianCenturies);
			return -0.004778 * SinOfDegree(degree) - 0.0003667 * SinOfDegree(degree2);
		}

		public static double Compute(double time)
		{
			double num = JulianCenturies(time);
			double num2 = 282.7771834 + 36000.76953744 * num + 5.729577951308232E-06 * SumLongSequenceOfPeriodicTerms(num);
			double longitude = num2 + Aberration(num) + Nutation(num);
			return InitLongitude(longitude);
		}

		public static double AsSeason(double longitude)
		{
			if (!(longitude < 0.0))
			{
				return longitude;
			}
			return longitude + 360.0;
		}

		private static double EstimatePrior(double longitude, double time)
		{
			double num = time - 1.0145616361111112 * AsSeason(InitLongitude(Compute(time) - longitude));
			double num2 = InitLongitude(Compute(num) - longitude);
			return Math.Min(time, num - 1.0145616361111112 * num2);
		}

		internal static long PersianNewYearOnOrBefore(long numberOfDays)
		{
			double date = numberOfDays;
			double d = EstimatePrior(0.0, MiddayAtPersianObservationSite(date));
			long num = (long)Math.Floor(d) - 1;
			long num2 = num + 3;
			long num3;
			for (num3 = num; num3 != num2; num3++)
			{
				double time = MiddayAtPersianObservationSite(num3);
				double num4 = Compute(time);
				if (0.0 <= num4 && num4 <= 2.0)
				{
					break;
				}
			}
			return num3 - 1;
		}
	}
	public static class CharUnicodeInfo
	{
		private static ReadOnlySpan<byte> CategoryCasingLevel1Index => new byte[2176]
		{
			0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
			10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
			20, 21, 22, 23, 24, 25, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 27, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 28,
			29, 26, 30, 31, 32, 33, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 34, 35, 35,
			35, 35, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 37, 38, 39, 40, 41, 42,
			43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
			53, 54, 55, 56, 26, 57, 58, 59, 59, 59,
			59, 59, 26, 26, 60, 59, 59, 59, 59, 59,
			59, 59, 26, 61, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			26, 62, 59, 63, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 64, 26, 26, 65, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 66, 67, 59, 59,
			59, 59, 68, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 69, 70, 71, 72, 73, 74, 59, 59,
			75, 76, 59, 59, 77, 78, 79, 80, 81, 82,
			83, 84, 85, 86, 59, 87, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 88,
			26, 26, 26, 26, 26, 26, 26, 89, 90, 26,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 91,
			26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 92, 59, 59, 59, 59, 59, 59,
			26, 93, 59, 87, 26, 26, 26, 26, 26, 26,
			26, 26, 26, 94, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 87, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 87,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 87, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 87, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 87, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 87, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 87,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 87, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 87, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 87, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 87, 95, 96, 96, 96, 96, 96, 96, 96,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
			59, 59, 59, 59, 59, 59, 59, 59, 59, 87,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 97, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
			36, 36, 36, 36, 36, 97
		};

		private static ReadOnlySpan<byte> CategoryCasingLevel2Index => new byte[6272]
		{
			0, 0, 1, 0, 2, 0, 3, 0, 4, 0,
			5, 0, 6, 0, 7, 0, 8, 0, 1, 0,
			9, 0, 10, 0, 11, 0, 12, 0, 13, 0,
			14, 0, 15, 0, 15, 0, 15, 0, 16, 0,
			17, 0, 15, 0, 15, 0, 18, 0, 19, 0,
			20, 0, 21, 0, 22, 0, 23, 0, 24, 0,
			15, 0, 25, 0, 15, 0, 15, 0, 26, 0,
			27, 0, 28, 0, 29, 0, 30, 0, 31, 0,
			32, 0, 33, 0, 34, 0, 35, 0, 36, 0,
			37, 0, 38, 0, 39, 0, 40, 0, 40, 0,
			40, 0, 40, 0, 41, 0, 40, 0, 40, 0,
			42, 0, 43, 0, 44, 0, 45, 0, 46, 0,
			47, 0, 48, 0, 15, 0, 49, 0, 50, 0,
			11, 0, 11, 0, 13, 0, 13, 0, 51, 0,
			15, 0, 15, 0, 52, 0, 15, 0, 15, 0,
			15, 0, 53, 0, 15, 0, 15, 0, 15, 0,
			15, 0, 15, 0, 15, 0, 54, 0, 55, 0,
			56, 0, 57, 0, 58, 0, 59, 0, 60, 0,
			40, 0, 61, 0, 62, 0, 63, 0, 64, 0,
			65, 0, 66, 0, 67, 0, 63, 0, 63, 0,
			68, 0, 40, 0, 69, 0, 70, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 63, 0, 71, 0,
			72, 0, 73, 0, 74, 0, 75, 0, 63, 0,
			40, 0, 76, 0, 63, 0, 63, 0, 63, 0,
			63, 0, 63, 0, 77, 0, 78, 0, 79, 0,
			63, 0, 80, 0, 81, 0, 63, 0, 82, 0,
			83, 0, 84, 0, 63, 0, 85, 0, 86, 0,
			87, 0, 87, 0, 87, 0, 63, 0, 88, 0,
			89, 0, 90, 0, 91, 0, 40, 0, 92, 0,
			93, 0, 93, 0, 94, 0, 95, 0, 96, 0,
			97, 0, 98, 0, 99, 0, 100, 0, 101, 0,
			102, 0, 103, 0, 104, 0, 105, 0, 106, 0,
			107, 0, 100, 0, 101, 0, 108, 0, 109, 0,
			110, 0, 111, 0, 112, 0, 113, 0, 114, 0,
			101, 0, 115, 0, 116, 0, 117, 0, 105, 0,
			118, 0, 119, 0, 100, 0, 101, 0, 120, 0,
			121, 0, 122, 0, 105, 0, 123, 0, 124, 0,
			125, 0, 126, 0, 127, 0, 128, 0, 129, 0,
			111, 0, 130, 0, 131, 0, 132, 0, 101, 0,
			133, 0, 134, 0, 135, 0, 105, 0, 136, 0,
			137, 0, 132, 0, 101, 0, 138, 0, 139, 0,
			140, 0, 105, 0, 141, 0, 142, 0, 132, 0,
			93, 0, 143, 0, 144, 0, 145, 0, 105, 0,
			146, 0, 147, 0, 148, 0, 93, 0, 149, 0,
			150, 0, 151, 0, 111, 0, 152, 0, 153, 0,
			93, 0, 93, 0, 154, 0, 155, 0, 156, 0,
			157, 0, 157, 0, 158, 0, 93, 0, 159, 0,
			160, 0, 161, 0, 162, 0, 157, 0, 157, 0,
			163, 0, 164, 0, 165, 0, 166, 0, 167, 0,
			93, 0, 168, 0, 169, 0, 170, 0, 171, 0,
			40, 0, 172, 0, 173, 0, 174, 0, 157, 0,
			157, 0, 93, 0, 93, 0, 175, 0, 176, 0,
			177, 0, 178, 0, 179, 0, 180, 0, 181, 0,
			182, 0, 183, 0, 183, 0, 184, 0, 185, 0,
			185, 0, 186, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 187, 0, 188, 0, 93, 0,
			93, 0, 187, 0, 93, 0, 93, 0, 189, 0,
			190, 0, 191, 0, 93, 0, 93, 0, 93, 0,
			190, 0, 93, 0, 93, 0, 93, 0, 192, 0,
			193, 0, 194, 0, 93, 0, 195, 0, 196, 0,
			196, 0, 196, 0, 196, 0, 196, 0, 197, 0,
			198, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 199, 0, 93, 0,
			200, 0, 201, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 202, 0, 203, 0, 204, 0, 205, 0,
			93, 0, 206, 0, 93, 0, 207, 0, 204, 0,
			208, 0, 93, 0, 93, 0, 93, 0, 209, 0,
			210, 0, 211, 0, 212, 0, 213, 0, 214, 0,
			212, 0, 93, 0, 93, 0, 215, 0, 93, 0,
			93, 0, 216, 0, 217, 0, 93, 0, 218, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 219, 0,
			93, 0, 220, 0, 221, 0, 222, 0, 223, 0,
			93, 0, 224, 0, 225, 0, 93, 0, 93, 0,
			226, 0, 93, 0, 227, 0, 228, 0, 229, 0,
			229, 0, 93, 0, 230, 0, 93, 0, 93, 0,
			93, 0, 231, 0, 232, 0, 233, 0, 212, 0,
			212, 0, 234, 0, 235, 0, 236, 0, 157, 0,
			157, 0, 157, 0, 237, 0, 93, 0, 93, 0,
			238, 0, 239, 0, 177, 0, 240, 0, 241, 0,
			242, 0, 93, 0, 243, 0, 244, 0, 93, 0,
			93, 0, 245, 0, 246, 0, 93, 0, 93, 0,
			247, 0, 248, 0, 249, 0, 244, 0, 93, 0,
			250, 0, 251, 0, 252, 0, 252, 0, 253, 0,
			254, 0, 255, 0, 0, 1, 1, 1, 34, 0,
			34, 0, 2, 1, 3, 1, 3, 1, 3, 1,
			4, 1, 5, 1, 6, 1, 7, 1, 3, 1,
			3, 1, 40, 0, 40, 0, 40, 0, 8, 1,
			15, 0, 15, 0, 15, 0, 15, 0, 15, 0,
			15, 0, 15, 0, 15, 0, 15, 0, 9, 1,
			15, 0, 15, 0, 15, 0, 15, 0, 15, 0,
			15, 0, 10, 1, 11, 1, 10, 1, 10, 1,
			11, 1, 12, 1, 10, 1, 13, 1, 14, 1,
			14, 1, 14, 1, 15, 1, 16, 1, 17, 1,
			18, 1, 19, 1, 20, 1, 21, 1, 22, 1,
			23, 1, 24, 1, 25, 1, 26, 1, 27, 1,
			28, 1, 29, 1, 30, 1, 30, 1, 31, 1,
			32, 1, 33, 1, 236, 0, 34, 1, 35, 1,
			36, 1, 37, 1, 38, 1, 39, 1, 40, 1,
			41, 1, 42, 1, 43, 1, 44, 1, 229, 0,
			45, 1, 46, 1, 229, 0, 47, 1, 48, 1,
			48, 1, 48, 1, 48, 1, 48, 1, 48, 1,
			48, 1, 48, 1, 48, 1, 48, 1, 48, 1,
			48, 1, 48, 1, 48, 1, 48, 1, 48, 1,
			49, 1, 229, 0, 50, 1, 51, 1, 52, 1,
			52, 1, 52, 1, 53, 1, 229, 0, 54, 1,
			48, 1, 55, 1, 229, 0, 56, 1, 57, 1,
			229, 0, 229, 0, 229, 0, 58, 1, 157, 0,
			59, 1, 157, 0, 39, 1, 39, 1, 39, 1,
			60, 1, 52, 1, 61, 1, 62, 1, 63, 1,
			64, 1, 39, 1, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 65, 1, 66, 1,
			229, 0, 229, 0, 67, 1, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 68, 1,
			229, 0, 229, 0, 229, 0, 69, 1, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			70, 1, 71, 1, 39, 1, 72, 1, 229, 0,
			229, 0, 73, 1, 48, 1, 74, 1, 48, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 48, 1, 48, 1, 48, 1, 48, 1,
			48, 1, 48, 1, 48, 1, 48, 1, 75, 1,
			76, 1, 48, 1, 48, 1, 48, 1, 77, 1,
			48, 1, 78, 1, 48, 1, 48, 1, 48, 1,
			48, 1, 48, 1, 48, 1, 48, 1, 48, 1,
			48, 1, 48, 1, 48, 1, 48, 1, 48, 1,
			48, 1, 48, 1, 48, 1, 229, 0, 229, 0,
			229, 0, 48, 1, 79, 1, 229, 0, 229, 0,
			80, 1, 229, 0, 81, 1, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 55, 0,
			55, 0, 82, 1, 58, 0, 58, 0, 83, 1,
			84, 1, 85, 1, 15, 0, 15, 0, 15, 0,
			15, 0, 15, 0, 15, 0, 86, 1, 87, 1,
			88, 1, 88, 1, 89, 1, 93, 0, 93, 0,
			93, 0, 90, 1, 91, 1, 93, 0, 92, 1,
			93, 1, 93, 1, 93, 1, 93, 1, 40, 0,
			40, 0, 94, 1, 95, 1, 96, 1, 97, 1,
			98, 1, 99, 1, 157, 0, 157, 0, 229, 0,
			100, 1, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 101, 1, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			102, 1, 157, 0, 103, 1, 104, 1, 105, 1,
			106, 1, 107, 1, 153, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 108, 1, 198, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 109, 1, 110, 1,
			93, 0, 93, 0, 153, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 220, 0, 111, 1, 93, 0,
			93, 0, 229, 0, 229, 0, 101, 1, 93, 0,
			52, 1, 112, 1, 113, 1, 52, 1, 114, 1,
			115, 1, 52, 1, 116, 1, 113, 1, 52, 1,
			52, 1, 117, 1, 118, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 119, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 120, 1,
			52, 1, 121, 1, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 168, 0, 93, 0, 122, 1,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 168, 0, 229, 0,
			229, 0, 229, 0, 58, 1, 93, 0, 93, 0,
			250, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 123, 1, 93, 0, 124, 1,
			157, 0, 15, 0, 15, 0, 125, 1, 126, 1,
			15, 0, 127, 1, 93, 0, 93, 0, 93, 0,
			93, 0, 128, 1, 129, 1, 39, 0, 130, 1,
			131, 1, 132, 1, 15, 0, 15, 0, 15, 0,
			133, 1, 134, 1, 135, 1, 136, 1, 137, 1,
			138, 1, 157, 0, 157, 0, 139, 1, 140, 1,
			93, 0, 141, 1, 142, 1, 93, 0, 93, 0,
			93, 0, 143, 1, 144, 1, 93, 0, 93, 0,
			145, 1, 146, 1, 212, 0, 40, 0, 147, 1,
			244, 0, 93, 0, 148, 1, 93, 0, 149, 1,
			150, 1, 93, 0, 168, 0, 92, 0, 93, 0,
			93, 0, 151, 1, 152, 1, 153, 1, 154, 1,
			155, 1, 93, 0, 93, 0, 156, 1, 157, 1,
			158, 1, 159, 1, 93, 0, 160, 1, 93, 0,
			93, 0, 93, 0, 161, 1, 162, 1, 163, 1,
			164, 1, 165, 1, 166, 1, 167, 1, 93, 1,
			34, 0, 34, 0, 168, 1, 169, 1, 170, 1,
			170, 1, 170, 1, 170, 1, 170, 1, 93, 0,
			93, 0, 171, 1, 212, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 172, 1,
			93, 0, 173, 1, 93, 0, 93, 0, 226, 0,
			174, 1, 174, 1, 174, 1, 174, 1, 174, 1,
			174, 1, 174, 1, 174, 1, 174, 1, 174, 1,
			174, 1, 174, 1, 174, 1, 174, 1, 174, 1,
			174, 1, 174, 1, 174, 1, 174, 1, 174, 1,
			174, 1, 174, 1, 174, 1, 174, 1, 174, 1,
			174, 1, 174, 1, 174, 1, 174, 1, 174, 1,
			174, 1, 174, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 224, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 227, 0,
			157, 0, 157, 0, 176, 1, 177, 1, 178, 1,
			179, 1, 180, 1, 63, 0, 63, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 181, 1, 182, 1,
			183, 1, 63, 0, 63, 0, 63, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
			63, 0, 63, 0, 184, 1, 87, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 185, 1, 63, 0,
			63, 0, 89, 0, 31, 1, 31, 1, 186, 1,
			40, 0, 187, 1, 40, 0, 188, 1, 189, 1,
			190, 1, 191, 1, 88, 0, 63, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
			192, 1, 193, 1, 3, 0, 4, 0, 5, 0,
			6, 0, 194, 1, 195, 1, 196, 1, 93, 0,
			197, 1, 93, 0, 220, 0, 198, 1, 199, 1,
			200, 1, 201, 1, 202, 1, 93, 0, 191, 0,
			203, 1, 224, 0, 224, 0, 157, 0, 157, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 204, 1, 205, 1, 206, 1,
			206, 1, 207, 1, 208, 1, 208, 1, 208, 1,
			209, 1, 210, 1, 211, 1, 212, 1, 157, 0,
			157, 0, 52, 1, 52, 1, 213, 1, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 93, 0, 168, 0, 93, 0,
			93, 0, 93, 0, 117, 0, 214, 1, 215, 1,
			93, 0, 93, 0, 216, 1, 93, 0, 217, 1,
			93, 0, 93, 0, 218, 1, 93, 0, 219, 1,
			93, 0, 93, 0, 220, 1, 221, 1, 157, 0,
			157, 0, 222, 1, 222, 1, 223, 1, 224, 1,
			224, 1, 93, 0, 93, 0, 93, 0, 93, 0,
			224, 0, 212, 0, 222, 1, 222, 1, 225, 1,
			224, 1, 226, 1, 93, 0, 93, 0, 227, 1,
			93, 0, 93, 0, 93, 0, 228, 1, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 92, 1, 93, 0, 219, 0,
			227, 1, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			229, 1, 63, 0, 63, 0, 230, 1, 63, 0,
			231, 1, 63, 0, 232, 1, 63, 0, 233, 1,
			234, 1, 87, 0, 87, 0, 87, 0, 63, 0,
			235, 1, 63, 0, 236, 1, 63, 0, 237, 1,
			87, 0, 87, 0, 87, 0, 87, 0, 63, 0,
			63, 0, 63, 0, 238, 1, 239, 1, 240, 1,
			239, 1, 239, 1, 241, 1, 242, 1, 63, 0,
			243, 1, 244, 1, 245, 1, 63, 0, 246, 1,
			63, 0, 247, 1, 87, 0, 87, 0, 248, 1,
			63, 0, 249, 1, 250, 1, 63, 0, 63, 0,
			63, 0, 251, 1, 63, 0, 252, 1, 63, 0,
			253, 1, 63, 0, 254, 1, 255, 1, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 0, 2, 87, 0,
			87, 0, 87, 0, 1, 2, 1, 2, 1, 2,
			2, 2, 3, 2, 3, 2, 3, 2, 4, 2,
			63, 0, 63, 0, 5, 2, 6, 2, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 39, 1, 7, 2, 63, 0,
			63, 0, 8, 2, 9, 2, 87, 0, 87, 0,
			87, 0, 87, 0, 63, 0, 247, 1, 10, 2,
			63, 0, 77, 0, 11, 2, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 63, 0, 12, 2,
			87, 0, 63, 0, 13, 2, 14, 2, 93, 0,
			93, 0, 15, 2, 16, 2, 17, 2, 18, 2,
			19, 2, 242, 0, 93, 0, 93, 0, 20, 2,
			21, 2, 93, 0, 216, 0, 212, 0, 22, 2,
			93, 0, 23, 2, 24, 2, 25, 2, 93, 0,
			93, 0, 26, 2, 242, 0, 93, 0, 93, 0,
			27, 2, 28, 2, 29, 2, 30, 2, 31, 2,
			93, 0, 114, 0, 32, 2, 33, 2, 157, 0,
			157, 0, 157, 0, 157, 0, 34, 2, 35, 2,
			36, 2, 93, 0, 93, 0, 37, 2, 38, 2,
			212, 0, 39, 2, 100, 0, 101, 0, 40, 2,
			41, 2, 42, 2, 43, 2, 44, 2, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 93, 0, 93, 0, 93, 0,
			45, 2, 46, 2, 47, 2, 48, 2, 157, 0,
			93, 0, 93, 0, 93, 0, 49, 2, 50, 2,
			212, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 93, 0, 93, 0, 51, 2, 52, 2,
			53, 2, 54, 2, 157, 0, 157, 0, 93, 0,
			93, 0, 93, 0, 55, 2, 56, 2, 212, 0,
			57, 2, 157, 0, 93, 0, 93, 0, 58, 2,
			59, 2, 212, 0, 157, 0, 157, 0, 157, 0,
			93, 0, 192, 0, 60, 2, 61, 2, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 93, 0, 93, 0, 32, 2, 62, 2,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 11, 0, 11, 0, 13, 0, 13, 0,
			165, 0, 63, 2, 64, 2, 65, 2, 93, 0,
			66, 2, 67, 2, 212, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 68, 2, 93, 0, 93, 0,
			69, 2, 70, 2, 157, 0, 71, 2, 93, 0,
			93, 0, 72, 2, 73, 2, 74, 2, 93, 0,
			93, 0, 75, 2, 76, 2, 77, 2, 157, 0,
			93, 0, 93, 0, 93, 0, 216, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			101, 0, 93, 0, 51, 2, 78, 2, 79, 2,
			165, 0, 194, 0, 80, 2, 93, 0, 81, 2,
			82, 2, 83, 2, 157, 0, 157, 0, 157, 0,
			157, 0, 84, 2, 93, 0, 93, 0, 85, 2,
			86, 2, 212, 0, 87, 2, 93, 0, 88, 2,
			89, 2, 212, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 93, 0, 90, 2, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 117, 0,
			206, 1, 91, 2, 92, 2, 93, 2, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 227, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 94, 2, 94, 2, 94, 2, 94, 2,
			94, 2, 94, 2, 95, 2, 96, 2, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 172, 1, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			93, 0, 93, 0, 220, 0, 97, 2, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 92, 1, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 93, 0,
			93, 0, 93, 0, 216, 0, 93, 0, 220, 0,
			153, 1, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 93, 0, 224, 0, 98, 2,
			93, 0, 93, 0, 93, 0, 99, 2, 100, 2,
			101, 2, 102, 2, 103, 2, 93, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			11, 0, 11, 0, 13, 0, 13, 0, 206, 1,
			104, 2, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 105, 2, 106, 2, 107, 2, 107, 2,
			108, 2, 109, 2, 157, 0, 157, 0, 157, 0,
			157, 0, 110, 2, 111, 2, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 227, 1,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 219, 0, 157, 0,
			157, 0, 216, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 220, 0,
			157, 0, 157, 0, 157, 0, 112, 2, 113, 2,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 226, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 204, 1, 168, 0, 216, 0,
			114, 2, 115, 2, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 116, 2, 52, 1,
			52, 1, 117, 2, 52, 1, 52, 1, 52, 1,
			118, 2, 119, 2, 120, 2, 52, 1, 121, 2,
			52, 1, 52, 1, 52, 1, 122, 2, 157, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 123, 2,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 206, 1,
			124, 2, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 58, 1, 206, 1, 125, 2, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 126, 2, 127, 2, 34, 0,
			128, 2, 129, 2, 130, 2, 131, 2, 126, 2,
			132, 2, 133, 2, 134, 2, 135, 2, 136, 2,
			126, 2, 127, 2, 34, 0, 137, 2, 138, 2,
			34, 0, 139, 2, 140, 2, 141, 2, 142, 2,
			126, 2, 143, 2, 34, 0, 126, 2, 127, 2,
			34, 0, 128, 2, 129, 2, 34, 0, 131, 2,
			126, 2, 132, 2, 142, 2, 126, 2, 143, 2,
			34, 0, 126, 2, 127, 2, 34, 0, 144, 2,
			126, 2, 145, 2, 146, 2, 147, 2, 148, 2,
			34, 0, 149, 2, 126, 2, 150, 2, 151, 2,
			152, 2, 153, 2, 34, 0, 154, 2, 126, 2,
			155, 2, 34, 0, 156, 2, 157, 2, 157, 2,
			157, 2, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
			52, 1, 52, 1, 52, 1, 40, 0, 40, 0,
			40, 0, 158, 2, 40, 0, 40, 0, 159, 2,
			160, 2, 161, 2, 162, 2, 163, 2, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			164, 2, 165, 2, 166, 2, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 93, 0, 93, 0, 168, 0, 167, 2,
			168, 2, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 93, 0,
			93, 0, 169, 2, 170, 2, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
			63, 0, 63, 0, 63, 0, 63, 0, 63, 0,
			63, 0, 171, 2, 172, 2, 87, 0, 87, 0,
			173, 2, 173, 2, 174, 2, 175, 2, 176, 2,
			177, 2, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			178, 2, 239, 1, 239, 1, 179, 2, 180, 2,
			87, 0, 87, 0, 87, 0, 87, 0, 178, 2,
			239, 1, 181, 2, 182, 2, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			183, 2, 63, 0, 184, 2, 185, 2, 186, 2,
			187, 2, 188, 2, 189, 2, 190, 2, 191, 2,
			192, 2, 191, 2, 87, 0, 87, 0, 87, 0,
			193, 2, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 87, 0, 87, 0, 87, 0,
			87, 0, 87, 0, 229, 0, 229, 0, 103, 1,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 101, 1, 194, 2, 195, 2, 195, 2,
			195, 2, 229, 0, 102, 1, 196, 2, 52, 1,
			121, 1, 52, 1, 52, 1, 52, 1, 197, 2,
			52, 1, 52, 1, 52, 1, 198, 2, 157, 0,
			157, 0, 157, 0, 199, 2, 52, 1, 200, 2,
			52, 1, 52, 1, 201, 2, 122, 2, 202, 2,
			102, 1, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			203, 2, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 204, 2, 211, 1, 211, 1, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 101, 1, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 205, 2, 103, 1, 157, 0,
			103, 1, 229, 0, 229, 0, 229, 0, 204, 2,
			195, 0, 229, 0, 229, 0, 204, 2, 229, 0,
			206, 2, 207, 2, 157, 0, 157, 0, 157, 0,
			157, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 208, 2, 229, 0,
			229, 0, 229, 0, 229, 0, 209, 2, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 101, 1, 206, 2, 210, 2,
			58, 1, 229, 0, 205, 2, 58, 1, 211, 2,
			58, 1, 157, 0, 157, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 229, 0, 229, 0, 229, 0,
			229, 0, 229, 0, 212, 2, 229, 0, 229, 0,
			59, 1, 157, 0, 157, 0, 213, 2, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			214, 2, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 224, 0,
			157, 0, 157, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 225, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 224, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 48, 2, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 117, 0,
			157, 0, 93, 0, 224, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 93, 0, 93, 0,
			93, 0, 93, 0, 93, 0, 204, 1, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			157, 0, 157, 0, 157, 0, 157, 0, 157, 0,
			215, 2, 31, 1, 216, 2, 216, 2, 216, 2,
			216, 2, 216, 2, 216, 2, 31, 1, 31, 1,
			31, 1, 31, 1, 31, 1, 31, 1, 31, 1,
			31, 1, 40, 0, 40, 0, 40, 0, 40, 0,
			40, 0, 40, 0, 40, 0, 40, 0, 40, 0,
			40, 0, 40, 0, 40, 0, 40, 0, 40, 0,
			40, 0, 31, 1, 31, 1, 31, 1, 31, 1,
			31, 1, 31, 1, 31, 1, 31, 1, 31, 1,
			31, 1, 31, 1, 31, 1, 31, 1, 31, 1,
			31, 1, 31, 1, 31, 1, 31, 1, 31, 1,
			31, 1, 31, 1, 31, 1, 31, 1, 31, 1,
			31, 1, 31, 1, 31, 1, 31, 1, 31, 1,
			31, 1, 31, 1, 31, 1, 31, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			175, 1, 175, 1, 175, 1, 175, 1, 175, 1,
			217, 2
		};

		private static ReadOnlySpan<byte> CategoryCasingLevel3Index => new byte[11680]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
			1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 2, 3, 3, 3, 4, 3, 3, 3,
			5, 6, 3, 7, 3, 8, 3, 3, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 3, 3,
			7, 7, 7, 3, 3, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 5, 3, 6, 11, 12, 11, 13, 13, 13,
			13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
			13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
			13, 13, 13, 5, 7, 6, 7, 0, 0, 0,
			0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 2, 3, 4, 4, 4, 4,
			14, 3, 11, 14, 15, 16, 7, 17, 14, 11,
			14, 7, 18, 18, 11, 19, 3, 3, 11, 18,
			15, 20, 18, 18, 18, 3, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 7,
			10, 10, 10, 10, 10, 10, 10, 21, 13, 13,
			13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
			13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
			13, 7, 13, 13, 13, 13, 13, 13, 13, 22,
			23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
			23, 24, 23, 24, 23, 24, 25, 21, 23, 24,
			23, 24, 23, 24, 21, 23, 24, 23, 24, 23,
			24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
			24, 21, 23, 24, 23, 24, 23, 24, 23, 24,
			23, 24, 23, 24, 23, 24, 26, 23, 24, 23,
			24, 23, 24, 21, 27, 28, 23, 24, 23, 24,
			29, 23, 24, 30, 30, 23, 24, 21, 31, 32,
			33, 23, 24, 30, 34, 35, 36, 37, 23, 24,
			38, 21, 36, 39, 40, 41, 23, 24, 23, 24,
			23, 24, 42, 23, 24, 42, 21, 21, 23, 24,
			42, 23, 24, 43, 43, 23, 24, 23, 24, 44,
			23, 24, 21, 15, 23, 24, 21, 45, 15, 15,
			15, 15, 46, 47, 48, 46, 47, 48, 46, 47,
			48, 23, 24, 23, 24, 23, 24, 23, 24, 23,
			24, 23, 24, 23, 24, 23, 24, 49, 23, 24,
			21, 46, 47, 48, 23, 24, 50, 51, 23, 24,
			23, 24, 23, 24, 23, 24, 52, 21, 23, 24,
			23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
			23, 24, 23, 24, 23, 24, 21, 21, 21, 21,
			21, 21, 53, 23, 24, 54, 55, 56, 56, 23,
			24, 57, 58, 59, 23, 24, 23, 24, 23, 24,
			23, 24, 23, 24, 60, 61, 62, 63, 64, 21,
			65, 65, 21, 66, 21, 67, 68, 21, 21, 21,
			65, 69, 21, 70, 21, 71, 72, 21, 73, 74,
			72, 75, 76, 21, 21, 74, 21, 77, 78, 21,
			21, 79, 21, 21, 21, 21, 21, 21, 21, 80,
			21, 21, 81, 21, 82, 81, 21, 21, 21, 83,
			81, 84, 85, 85, 86, 21, 21, 21, 21, 21,
			87, 21, 15, 21, 21, 21, 21, 21, 21, 21,
			21, 88, 89, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			90, 90, 90, 90, 90, 90, 90, 90, 90, 91,
			91, 90, 90, 90, 90, 90, 90, 90, 11, 11,
			11, 11, 91, 91, 91, 91, 91, 91, 91, 91,
			91, 91, 90, 90, 11, 11, 11, 11, 11, 11,
			11, 11, 11, 11, 11, 11, 11, 11, 90, 90,
			90, 90, 90, 11, 11, 11, 11, 11, 11, 11,
			91, 11, 90, 11, 11, 11, 11, 11, 11, 11,
			11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 93, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 23, 24, 23, 24, 91, 11, 23, 24,
			94, 94, 90, 40, 40, 40, 3, 95, 94, 94,
			94, 94, 11, 11, 96, 3, 97, 97, 97, 94,
			98, 94, 99, 99, 21, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 94, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 100, 101, 101, 101, 21, 13, 13, 13,
			13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
			13, 13, 13, 13, 102, 13, 13, 13, 13, 13,
			13, 13, 13, 13, 103, 104, 104, 105, 106, 107,
			25, 25, 25, 108, 109, 110, 23, 24, 23, 24,
			23, 24, 23, 24, 111, 112, 113, 114, 115, 116,
			7, 23, 24, 117, 23, 24, 21, 52, 52, 52,
			118, 118, 118, 118, 118, 118, 118, 118, 118, 118,
			118, 118, 118, 118, 118, 118, 119, 119, 119, 119,
			119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
			119, 119, 23, 24, 120, 92, 92, 92, 92, 92,
			121, 121, 23, 24, 23, 24, 23, 24, 122, 23,
			24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
			24, 23, 24, 123, 94, 124, 124, 124, 124, 124,
			124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
			124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
			124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
			124, 124, 124, 94, 94, 90, 125, 125, 125, 125,
			125, 125, 21, 126, 126, 126, 126, 126, 126, 126,
			126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
			126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
			126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
			126, 21, 21, 125, 8, 94, 94, 14, 14, 4,
			127, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			128, 92, 129, 92, 92, 129, 92, 92, 129, 92,
			127, 127, 127, 127, 127, 127, 127, 127, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 127, 127, 127, 127, 130,
			130, 130, 130, 129, 129, 127, 127, 127, 127, 127,
			127, 127, 127, 127, 127, 127, 17, 17, 17, 17,
			17, 17, 7, 7, 131, 3, 3, 132, 3, 129,
			14, 14, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 129, 133, 127, 129, 129, 134, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 92,
			92, 92, 92, 92, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 3, 3, 3, 129, 130, 130,
			92, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			129, 130, 92, 92, 92, 92, 92, 92, 92, 17,
			14, 92, 92, 92, 92, 92, 92, 134, 134, 92,
			92, 14, 92, 92, 92, 92, 130, 130, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 130, 130,
			130, 135, 135, 130, 129, 129, 129, 129, 129, 129,
			129, 129, 129, 129, 129, 129, 129, 129, 127, 133,
			130, 92, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 127, 127, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 130,
			127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
			127, 127, 127, 127, 136, 136, 136, 136, 136, 136,
			136, 136, 136, 136, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			134, 134, 14, 3, 3, 3, 134, 127, 127, 92,
			132, 132, 130, 130, 130, 130, 130, 130, 92, 92,
			92, 92, 134, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 134, 92, 92, 92, 134, 92, 92, 92,
			92, 92, 127, 127, 129, 129, 129, 129, 129, 129,
			129, 129, 129, 129, 129, 129, 129, 129, 129, 127,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 92,
			92, 92, 127, 127, 129, 127, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 127, 127, 127,
			127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
			127, 127, 127, 127, 127, 127, 127, 127, 130, 130,
			130, 130, 130, 127, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 127, 127, 127, 127, 127, 127, 127, 127,
			127, 127, 127, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 17, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 137, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 92, 137, 92, 15, 137, 137,
			137, 92, 92, 92, 92, 92, 92, 92, 92, 137,
			137, 137, 137, 92, 137, 137, 15, 92, 92, 92,
			92, 92, 92, 92, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 92, 92, 125, 125, 138, 138,
			138, 138, 138, 138, 138, 138, 138, 138, 125, 90,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 92, 137, 137, 94, 15,
			15, 15, 15, 15, 15, 15, 15, 94, 94, 15,
			15, 94, 94, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 94, 15, 15, 15, 15,
			15, 15, 15, 94, 15, 94, 94, 94, 15, 15,
			15, 15, 94, 94, 92, 15, 137, 137, 137, 92,
			92, 92, 92, 94, 94, 137, 137, 94, 94, 137,
			137, 92, 15, 94, 94, 94, 94, 94, 94, 94,
			94, 137, 94, 94, 94, 94, 15, 15, 94, 15,
			15, 15, 92, 92, 94, 94, 138, 138, 138, 138,
			138, 138, 138, 138, 138, 138, 15, 15, 4, 4,
			139, 139, 139, 139, 139, 139, 120, 4, 15, 125,
			92, 94, 94, 92, 92, 137, 94, 15, 15, 15,
			15, 15, 15, 94, 94, 94, 94, 15, 15, 94,
			15, 15, 94, 15, 15, 94, 15, 15, 94, 94,
			92, 94, 137, 137, 137, 92, 92, 94, 94, 94,
			94, 92, 92, 94, 94, 92, 92, 92, 94, 94,
			94, 92, 94, 94, 94, 94, 94, 94, 94, 15,
			15, 15, 15, 94, 15, 94, 94, 94, 94, 94,
			94, 94, 138, 138, 138, 138, 138, 138, 138, 138,
			138, 138, 92, 92, 15, 15, 15, 92, 125, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 92,
			92, 137, 94, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 94, 15, 15, 15, 94, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 94, 15, 15, 94, 15, 15, 15, 15, 15,
			94, 94, 92, 15, 137, 137, 137, 92, 92, 92,
			92, 92, 94, 92, 92, 137, 94, 137, 137, 92,
			94, 94, 15, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 125, 4,
			94, 94, 94, 94, 94, 94, 94, 15, 92, 92,
			92, 92, 92, 92, 94, 92, 137, 137, 94, 15,
			15, 15, 15, 15, 15, 15, 15, 94, 94, 15,
			15, 94, 15, 15, 94, 15, 15, 15, 15, 15,
			94, 94, 92, 15, 137, 92, 137, 92, 92, 92,
			92, 94, 94, 137, 137, 94, 94, 137, 137, 92,
			94, 94, 94, 94, 94, 94, 94, 92, 92, 137,
			94, 94, 94, 94, 15, 15, 94, 15, 120, 15,
			139, 139, 139, 139, 139, 139, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 92, 15, 94, 15,
			15, 15, 15, 15, 15, 94, 94, 94, 15, 15,
			15, 94, 15, 15, 15, 15, 94, 94, 94, 15,
			15, 94, 15, 94, 15, 15, 94, 94, 94, 15,
			15, 94, 94, 94, 15, 15, 15, 94, 94, 94,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 94, 94, 94, 94, 137, 137, 92, 137,
			137, 94, 94, 94, 137, 137, 137, 94, 137, 137,
			137, 92, 94, 94, 15, 94, 94, 94, 94, 94,
			94, 137, 94, 94, 94, 94, 94, 94, 94, 94,
			139, 139, 139, 14, 14, 14, 14, 14, 14, 4,
			14, 94, 94, 94, 94, 94, 92, 137, 137, 137,
			92, 15, 15, 15, 15, 15, 15, 15, 15, 94,
			15, 15, 15, 94, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 94, 94,
			94, 15, 92, 92, 92, 137, 137, 137, 137, 94,
			92, 92, 92, 94, 92, 92, 92, 92, 94, 94,
			94, 94, 94, 94, 94, 92, 92, 94, 15, 15,
			15, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 125, 18, 18, 18, 18, 18, 18,
			18, 120, 15, 92, 137, 137, 125, 15, 15, 15,
			15, 15, 15, 15, 15, 94, 15, 15, 15, 15,
			15, 15, 94, 15, 15, 15, 15, 15, 94, 94,
			92, 15, 137, 140, 137, 137, 137, 137, 137, 94,
			140, 137, 137, 94, 137, 137, 92, 92, 94, 94,
			94, 94, 94, 94, 94, 137, 137, 94, 94, 94,
			94, 94, 94, 94, 15, 94, 94, 15, 15, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 92, 92, 137, 137, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 94, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 92,
			92, 15, 137, 137, 137, 92, 92, 92, 92, 94,
			137, 137, 137, 94, 137, 137, 137, 92, 15, 120,
			94, 94, 94, 94, 15, 15, 15, 137, 139, 139,
			139, 139, 139, 139, 139, 15, 139, 139, 139, 139,
			139, 139, 139, 139, 139, 120, 15, 15, 15, 15,
			15, 15, 94, 92, 137, 137, 94, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 94, 94, 94, 15, 15,
			15, 15, 15, 15, 15, 15, 94, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 94, 15, 94, 94,
			15, 15, 15, 15, 15, 15, 15, 94, 94, 94,
			92, 94, 94, 94, 94, 137, 137, 137, 92, 92,
			92, 94, 92, 94, 137, 137, 137, 137, 137, 137,
			137, 137, 94, 94, 137, 137, 125, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 92, 15, 15, 92, 92,
			92, 92, 92, 92, 92, 94, 94, 94, 94, 4,
			15, 15, 15, 15, 15, 15, 90, 92, 92, 92,
			92, 92, 92, 92, 92, 125, 138, 138, 138, 138,
			138, 138, 138, 138, 138, 138, 125, 125, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 15,
			15, 94, 15, 94, 15, 15, 15, 15, 15, 94,
			15, 15, 15, 15, 15, 15, 15, 15, 94, 15,
			94, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 92, 15, 15, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 15, 94, 94, 15, 15, 15, 15,
			15, 94, 90, 94, 92, 92, 92, 92, 92, 92,
			94, 94, 138, 138, 138, 138, 138, 138, 138, 138,
			138, 138, 94, 94, 15, 15, 15, 15, 15, 120,
			120, 120, 125, 125, 125, 125, 125, 125, 125, 125,
			125, 125, 125, 125, 125, 125, 125, 120, 125, 120,
			120, 120, 92, 92, 120, 120, 120, 120, 120, 120,
			138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
			139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
			120, 92, 120, 92, 120, 92, 5, 6, 5, 6,
			137, 137, 15, 15, 15, 15, 15, 15, 15, 15,
			94, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 94, 94, 94, 94, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 137,
			92, 92, 92, 92, 92, 125, 92, 92, 15, 15,
			15, 15, 15, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 94, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 94, 120, 120, 120, 120,
			120, 120, 120, 120, 92, 120, 120, 120, 120, 120,
			120, 94, 120, 120, 125, 125, 125, 125, 125, 120,
			120, 120, 120, 125, 125, 94, 94, 94, 94, 94,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 137, 137, 92, 92, 92, 92, 137, 92, 92,
			92, 92, 92, 92, 137, 92, 92, 137, 137, 92,
			92, 15, 138, 138, 138, 138, 138, 138, 138, 138,
			138, 138, 125, 125, 125, 125, 125, 125, 15, 15,
			15, 15, 15, 15, 137, 137, 92, 92, 15, 15,
			15, 15, 92, 92, 92, 15, 137, 137, 137, 15,
			15, 137, 137, 137, 137, 137, 137, 137, 15, 15,
			15, 92, 92, 92, 92, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 92, 137,
			137, 92, 92, 137, 137, 137, 137, 137, 137, 92,
			15, 137, 138, 138, 138, 138, 138, 138, 138, 138,
			138, 138, 137, 137, 137, 92, 120, 120, 141, 141,
			141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
			141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
			94, 141, 94, 94, 94, 94, 94, 141, 94, 94,
			142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
			142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
			142, 142, 142, 142, 142, 142, 142, 125, 90, 142,
			142, 142, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 94, 15, 15, 15, 15, 94, 94, 15, 15,
			15, 15, 15, 15, 15, 94, 15, 94, 15, 15,
			15, 15, 94, 94, 15, 94, 15, 15, 15, 15,
			94, 94, 15, 15, 15, 15, 15, 15, 15, 94,
			15, 94, 15, 15, 15, 15, 94, 94, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 94, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 94, 94, 92, 92, 92, 125, 125,
			125, 125, 125, 125, 125, 125, 125, 139, 139, 139,
			139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
			139, 139, 139, 139, 139, 139, 139, 94, 94, 94,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			94, 94, 94, 94, 94, 94, 143, 143, 143, 143,
			143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
			143, 143, 144, 144, 144, 144, 144, 144, 94, 94,
			145, 145, 145, 145, 145, 145, 94, 94, 8, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 120, 125, 15,
			2, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 5, 6, 94,
			94, 94, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 125, 125, 125, 146, 146, 146, 15,
			15, 15, 15, 15, 15, 15, 15, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 94, 15, 15,
			15, 15, 92, 92, 92, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 15, 15, 92, 92,
			92, 125, 125, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 15, 15, 92, 92, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 15, 94,
			92, 92, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 92, 92,
			137, 92, 92, 92, 92, 92, 92, 92, 137, 137,
			137, 137, 137, 137, 137, 137, 92, 137, 137, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			125, 125, 125, 90, 125, 125, 125, 4, 15, 92,
			94, 94, 138, 138, 138, 138, 138, 138, 138, 138,
			138, 138, 94, 94, 94, 94, 94, 94, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 94, 94,
			94, 94, 94, 94, 3, 3, 3, 3, 3, 3,
			8, 3, 3, 3, 3, 92, 92, 92, 17, 94,
			15, 15, 15, 90, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 94, 94, 94, 94, 94,
			94, 94, 15, 15, 15, 15, 15, 92, 92, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 92, 15, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 94, 92, 92, 92, 137,
			137, 137, 137, 92, 92, 137, 137, 137, 94, 94,
			94, 94, 137, 137, 92, 137, 137, 137, 137, 137,
			137, 92, 92, 92, 94, 94, 94, 94, 14, 94,
			94, 94, 3, 3, 138, 138, 138, 138, 138, 138,
			138, 138, 138, 138, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 94, 94,
			15, 15, 15, 15, 15, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 94, 94,
			94, 94, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 94, 94, 94, 94, 94, 94, 138, 138,
			138, 138, 138, 138, 138, 138, 138, 138, 139, 94,
			94, 94, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			15, 15, 15, 15, 15, 15, 15, 92, 92, 137,
			137, 92, 94, 94, 125, 125, 15, 15, 15, 15,
			15, 137, 92, 137, 92, 92, 92, 92, 92, 92,
			92, 94, 92, 137, 92, 137, 137, 92, 92, 92,
			92, 92, 92, 92, 92, 137, 137, 137, 137, 137,
			137, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 94, 94, 92, 125, 125, 125, 125, 125, 125,
			125, 90, 125, 125, 125, 125, 125, 125, 94, 94,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 121, 92, 92, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 92, 92, 92, 92, 137, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 92, 137, 92, 92, 92, 92, 92, 137,
			92, 137, 137, 137, 137, 137, 92, 137, 137, 15,
			15, 15, 15, 15, 15, 15, 94, 94, 94, 94,
			125, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 94,
			94, 94, 92, 92, 137, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 137,
			92, 92, 92, 92, 137, 137, 92, 92, 137, 92,
			92, 92, 15, 15, 138, 138, 138, 138, 138, 138,
			138, 138, 138, 138, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 92, 137, 92, 92,
			137, 137, 137, 92, 137, 92, 92, 92, 137, 137,
			94, 94, 94, 94, 94, 94, 94, 94, 125, 125,
			125, 125, 15, 15, 15, 15, 137, 137, 137, 137,
			137, 137, 137, 137, 92, 92, 92, 92, 92, 92,
			92, 92, 137, 137, 92, 92, 94, 94, 94, 125,
			125, 125, 125, 125, 138, 138, 138, 138, 138, 138,
			138, 138, 138, 138, 94, 94, 94, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 90, 90,
			90, 90, 90, 90, 125, 125, 147, 148, 149, 150,
			150, 151, 152, 153, 154, 94, 94, 94, 94, 94,
			94, 94, 155, 155, 155, 155, 155, 155, 155, 155,
			155, 155, 155, 155, 155, 155, 155, 155, 155, 155,
			155, 155, 155, 155, 155, 155, 155, 155, 155, 94,
			94, 155, 155, 155, 125, 125, 125, 125, 125, 125,
			125, 125, 94, 94, 94, 94, 94, 94, 94, 94,
			92, 92, 92, 125, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 137, 92, 92,
			92, 92, 92, 92, 92, 15, 15, 15, 15, 92,
			15, 15, 15, 15, 15, 15, 92, 15, 15, 137,
			92, 92, 15, 94, 94, 94, 94, 94, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
			90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
			90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
			90, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 90, 156, 21, 21, 21, 157,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 158, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 90,
			90, 90, 90, 90, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 94, 92, 92, 92, 92, 92,
			23, 24, 23, 24, 23, 24, 21, 21, 21, 21,
			21, 159, 21, 21, 160, 21, 161, 161, 161, 161,
			161, 161, 161, 161, 162, 162, 162, 162, 162, 162,
			162, 162, 161, 161, 161, 161, 161, 161, 94, 94,
			162, 162, 162, 162, 162, 162, 94, 94, 21, 161,
			21, 161, 21, 161, 21, 161, 94, 162, 94, 162,
			94, 162, 94, 162, 163, 163, 164, 164, 164, 164,
			165, 165, 166, 166, 167, 167, 168, 168, 94, 94,
			161, 161, 161, 161, 161, 161, 161, 161, 169, 169,
			169, 169, 169, 169, 169, 169, 161, 161, 21, 170,
			21, 94, 21, 21, 162, 162, 171, 171, 172, 11,
			173, 11, 11, 11, 21, 170, 21, 94, 21, 21,
			174, 174, 174, 174, 172, 11, 11, 11, 161, 161,
			21, 21, 94, 94, 21, 21, 162, 162, 175, 175,
			94, 11, 11, 11, 161, 161, 21, 21, 21, 113,
			21, 21, 162, 162, 176, 176, 117, 11, 11, 11,
			94, 94, 21, 170, 21, 94, 21, 21, 177, 177,
			178, 178, 172, 11, 11, 94, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 17, 17, 17,
			179, 133, 8, 8, 8, 8, 8, 8, 3, 3,
			16, 20, 5, 16, 16, 20, 5, 16, 3, 3,
			3, 3, 3, 3, 3, 3, 180, 181, 17, 17,
			17, 17, 17, 2, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 16, 20, 3, 3, 3, 3, 12,
			12, 3, 3, 3, 7, 5, 6, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 7, 3,
			12, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 2, 17, 17, 17, 17, 17, 182, 17, 17,
			17, 17, 17, 17, 17, 17, 17, 17, 18, 90,
			94, 94, 18, 18, 18, 18, 18, 18, 7, 7,
			7, 5, 6, 90, 18, 18, 18, 18, 18, 18,
			18, 18, 18, 18, 7, 7, 7, 5, 6, 94,
			90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
			90, 90, 90, 94, 94, 94, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 182, 182, 182, 182, 182, 182, 182, 182,
			182, 182, 182, 182, 182, 182, 182, 182, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 121, 121, 121, 121, 92, 121, 121, 121, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			14, 14, 25, 14, 14, 14, 14, 25, 14, 14,
			21, 25, 25, 25, 21, 21, 25, 25, 25, 21,
			14, 25, 14, 14, 7, 25, 25, 25, 25, 25,
			14, 14, 14, 14, 14, 14, 25, 14, 183, 14,
			25, 14, 184, 185, 25, 25, 14, 21, 25, 25,
			186, 25, 21, 15, 15, 15, 15, 21, 14, 14,
			21, 21, 25, 25, 7, 7, 7, 7, 7, 25,
			21, 21, 21, 21, 14, 7, 14, 14, 187, 120,
			18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
			18, 18, 18, 18, 18, 18, 188, 188, 188, 188,
			188, 188, 188, 188, 188, 188, 188, 188, 188, 188,
			188, 188, 189, 189, 189, 189, 189, 189, 189, 189,
			189, 189, 189, 189, 189, 189, 189, 189, 146, 146,
			146, 23, 24, 146, 146, 146, 146, 18, 14, 14,
			94, 94, 94, 94, 7, 7, 7, 7, 7, 14,
			14, 14, 14, 14, 7, 7, 14, 14, 14, 14,
			7, 14, 14, 7, 14, 14, 7, 14, 14, 14,
			14, 14, 14, 14, 7, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			7, 7, 14, 14, 7, 14, 7, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			14, 14, 14, 14, 14, 14, 14, 14, 5, 6,
			5, 6, 14, 14, 14, 14, 7, 7, 14, 14,
			14, 14, 14, 14, 14, 5, 6, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 14, 7, 14, 14, 14,
			14, 14, 14, 14, 14, 120, 14, 14, 14, 14,
			14, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 7, 7, 7, 7, 7, 7,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 94, 94, 94, 94, 94, 18, 18, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 190, 190,
			190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
			190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
			190, 190, 190, 190, 191, 191, 191, 191, 191, 191,
			191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
			191, 191, 191, 191, 191, 191, 191, 191, 191, 191,
			18, 18, 18, 18, 18, 18, 14, 14, 14, 14,
			14, 14, 14, 7, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 7, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 7, 7, 7, 7,
			7, 7, 7, 7, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 7,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 120, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 5, 6, 5, 6, 5, 6,
			5, 6, 5, 6, 5, 6, 5, 6, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
			18, 18, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 7, 7, 7, 7, 7, 5,
			6, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 5, 6, 5, 6,
			5, 6, 5, 6, 5, 6, 7, 7, 7, 5,
			6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
			6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
			6, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 5, 6, 5, 6,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 5, 6, 7, 7,
			7, 7, 7, 7, 7, 14, 14, 7, 7, 7,
			7, 7, 7, 14, 14, 14, 14, 14, 14, 14,
			94, 94, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 94, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 124, 124,
			124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
			124, 124, 124, 94, 126, 126, 126, 126, 126, 126,
			126, 126, 126, 126, 126, 126, 126, 126, 126, 94,
			23, 24, 192, 193, 194, 195, 196, 23, 24, 23,
			24, 23, 24, 197, 198, 199, 200, 21, 23, 24,
			21, 23, 24, 21, 21, 21, 21, 21, 90, 90,
			201, 201, 23, 24, 23, 24, 21, 14, 14, 14,
			14, 14, 14, 23, 24, 23, 24, 92, 92, 92,
			23, 24, 94, 94, 94, 94, 94, 3, 3, 3,
			3, 18, 3, 3, 202, 202, 202, 202, 202, 202,
			202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
			202, 202, 202, 202, 202, 202, 94, 202, 94, 94,
			94, 94, 94, 202, 94, 94, 15, 15, 15, 15,
			15, 15, 15, 15, 94, 94, 94, 94, 94, 94,
			94, 90, 125, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 92, 15, 15,
			15, 15, 15, 15, 15, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			15, 94, 15, 15, 15, 15, 15, 15, 15, 94,
			3, 3, 16, 20, 16, 20, 3, 3, 3, 16,
			20, 3, 16, 20, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 8, 3, 3, 8, 3, 16, 20,
			3, 3, 16, 20, 5, 6, 5, 6, 5, 6,
			5, 6, 3, 3, 3, 3, 3, 91, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 8, 8,
			3, 3, 3, 3, 8, 3, 5, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			14, 14, 3, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 94, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 14, 14,
			14, 14, 14, 14, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 94, 94, 94, 94,
			2, 3, 3, 3, 14, 90, 15, 146, 5, 6,
			5, 6, 5, 6, 5, 6, 5, 6, 14, 14,
			5, 6, 5, 6, 5, 6, 5, 6, 8, 5,
			6, 6, 14, 146, 146, 146, 146, 146, 146, 146,
			146, 146, 92, 92, 92, 92, 137, 137, 8, 90,
			90, 90, 90, 90, 14, 14, 146, 146, 146, 90,
			15, 3, 14, 14, 15, 15, 15, 15, 15, 15,
			15, 94, 94, 92, 92, 11, 11, 90, 90, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 3, 90, 90, 90, 15, 94, 94, 94, 94,
			94, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 120, 120, 139, 139, 139, 139, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 14, 14, 94, 139, 139, 139, 139, 139, 139,
			139, 139, 139, 139, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 139, 139,
			139, 139, 139, 139, 139, 139, 14, 18, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
			18, 18, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 14, 14, 14, 120, 120, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
			18, 18, 18, 18, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 14, 14, 14, 14,
			120, 120, 120, 120, 120, 120, 120, 14, 14, 14,
			14, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			14, 14, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 14, 15, 15,
			15, 15, 15, 90, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 90, 3, 3, 3,
			138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
			15, 15, 94, 94, 94, 94, 23, 24, 23, 24,
			23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
			15, 92, 121, 121, 121, 3, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 3, 91, 23, 24,
			23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
			90, 90, 92, 92, 15, 15, 15, 15, 15, 15,
			146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
			92, 92, 125, 125, 125, 125, 125, 125, 94, 94,
			94, 94, 94, 94, 94, 94, 11, 11, 11, 11,
			11, 11, 11, 91, 91, 91, 91, 91, 91, 91,
			91, 91, 11, 11, 23, 24, 23, 24, 23, 24,
			23, 24, 23, 24, 23, 24, 23, 24, 21, 21,
			23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
			23, 24, 23, 24, 90, 21, 21, 21, 21, 21,
			21, 21, 21, 23, 24, 23, 24, 203, 23, 24,
			23, 24, 23, 24, 23, 24, 23, 24, 91, 204,
			204, 23, 24, 205, 21, 15, 23, 24, 23, 24,
			206, 21, 23, 24, 23, 24, 23, 24, 23, 24,
			23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
			23, 24, 207, 208, 209, 210, 207, 21, 211, 212,
			213, 214, 23, 24, 23, 24, 23, 24, 23, 24,
			23, 24, 23, 24, 94, 94, 23, 24, 215, 216,
			217, 23, 24, 23, 24, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 23, 24, 15, 90, 90,
			21, 15, 15, 15, 15, 15, 15, 15, 92, 15,
			15, 15, 92, 15, 15, 15, 15, 92, 15, 15,
			15, 15, 15, 15, 15, 137, 137, 92, 92, 137,
			14, 14, 14, 14, 92, 94, 94, 94, 139, 139,
			139, 139, 139, 139, 120, 120, 4, 14, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 3, 3,
			3, 3, 94, 94, 94, 94, 94, 94, 94, 94,
			137, 137, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
			137, 137, 137, 137, 137, 137, 92, 92, 94, 94,
			94, 94, 94, 94, 94, 94, 125, 125, 92, 92,
			15, 15, 15, 15, 15, 15, 125, 125, 125, 15,
			125, 15, 15, 92, 15, 15, 15, 15, 15, 15,
			92, 92, 92, 92, 92, 92, 92, 92, 125, 125,
			15, 15, 15, 15, 15, 15, 15, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 137, 137,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 125, 15, 15, 15, 92, 137, 137, 92, 92,
			92, 92, 137, 137, 92, 92, 137, 137, 137, 125,
			125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
			125, 125, 94, 90, 138, 138, 138, 138, 138, 138,
			138, 138, 138, 138, 94, 94, 94, 94, 125, 125,
			15, 15, 15, 15, 15, 92, 90, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 138, 138, 138, 138,
			138, 138, 138, 138, 138, 138, 15, 15, 15, 15,
			15, 94, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 92, 92, 92, 92, 92, 92, 137, 137, 92,
			92, 137, 137, 92, 92, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 92, 15, 15,
			15, 15, 15, 15, 15, 15, 92, 137, 94, 94,
			138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
			94, 94, 125, 125, 125, 125, 90, 15, 15, 15,
			15, 15, 15, 120, 120, 120, 15, 137, 92, 137,
			15, 15, 92, 15, 92, 92, 92, 15, 15, 92,
			92, 15, 15, 15, 15, 15, 92, 92, 15, 92,
			15, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 15, 15, 90, 125, 125,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 137, 92, 92, 137, 137, 125, 125, 15, 90,
			90, 137, 92, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 15, 15, 15, 15, 15, 15, 94,
			94, 15, 15, 15, 15, 15, 15, 94, 94, 15,
			15, 15, 15, 15, 15, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 21, 21, 21, 218, 21, 21,
			21, 21, 21, 21, 21, 204, 90, 90, 90, 90,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 90,
			11, 11, 94, 94, 94, 94, 219, 219, 219, 219,
			219, 219, 219, 219, 219, 219, 219, 219, 219, 219,
			219, 219, 15, 15, 15, 137, 137, 92, 137, 137,
			92, 137, 137, 125, 137, 92, 94, 94, 15, 15,
			15, 15, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			15, 94, 94, 94, 94, 15, 15, 15, 15, 15,
			220, 220, 220, 220, 220, 220, 220, 220, 220, 220,
			220, 220, 220, 220, 220, 220, 221, 221, 221, 221,
			221, 221, 221, 221, 221, 221, 221, 221, 221, 221,
			221, 221, 21, 21, 21, 21, 21, 21, 21, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 21, 21, 21, 21, 21, 94, 94, 94, 94,
			94, 130, 92, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 7, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 127, 130, 130,
			130, 130, 130, 127, 130, 127, 130, 130, 127, 130,
			130, 127, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 222, 222, 222, 222, 222, 222,
			222, 222, 222, 222, 222, 222, 222, 222, 222, 222,
			127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
			127, 127, 127, 127, 127, 127, 127, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 6, 5, 127, 127, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 132, 14, 127, 127, 3, 3,
			3, 3, 3, 3, 3, 5, 6, 3, 94, 94,
			94, 94, 94, 94, 3, 8, 8, 12, 12, 5,
			6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
			6, 5, 6, 5, 6, 3, 3, 5, 6, 3,
			3, 3, 3, 12, 12, 12, 3, 3, 3, 94,
			3, 3, 3, 3, 8, 5, 6, 5, 6, 5,
			6, 3, 3, 3, 7, 8, 7, 7, 7, 94,
			3, 4, 3, 3, 94, 94, 94, 94, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 127, 127, 17, 94, 3, 3, 3, 4, 3,
			3, 3, 5, 6, 3, 7, 3, 8, 3, 3,
			13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
			13, 5, 7, 6, 7, 5, 6, 3, 5, 6,
			3, 3, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 90, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 90, 90, 94, 94, 15, 15, 15, 15,
			15, 15, 94, 94, 15, 15, 15, 15, 15, 15,
			94, 94, 15, 15, 15, 15, 15, 15, 94, 94,
			15, 15, 15, 94, 94, 94, 4, 4, 7, 11,
			14, 4, 4, 94, 14, 7, 7, 7, 7, 14,
			14, 94, 182, 182, 182, 182, 182, 182, 182, 182,
			182, 17, 17, 17, 14, 14, 182, 182, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			94, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 94, 15, 15, 94, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 94, 94, 94, 94, 94, 125, 3, 125, 94,
			94, 94, 94, 139, 139, 139, 139, 139, 139, 139,
			139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
			139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
			139, 139, 94, 94, 94, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 223, 223, 223, 223, 223, 223,
			223, 223, 223, 223, 223, 223, 223, 223, 223, 223,
			223, 223, 223, 223, 223, 18, 18, 18, 18, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 18, 18, 14, 120,
			120, 94, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 94, 94, 94, 14, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 92, 94, 94,
			92, 18, 18, 18, 18, 18, 18, 18, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 94, 94,
			94, 94, 139, 139, 139, 139, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 15, 15, 15, 15, 146,
			15, 15, 15, 15, 15, 15, 15, 15, 146, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			92, 92, 92, 92, 92, 94, 94, 94, 94, 94,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 94, 125, 15, 15, 15, 15,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			15, 15, 125, 146, 146, 146, 146, 146, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 224, 224,
			224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
			224, 224, 224, 224, 224, 224, 224, 224, 224, 224,
			224, 224, 225, 225, 225, 225, 225, 225, 225, 225,
			225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
			225, 225, 225, 225, 225, 225, 224, 224, 224, 224,
			94, 94, 94, 94, 225, 225, 225, 225, 225, 225,
			225, 225, 225, 225, 225, 225, 225, 225, 225, 225,
			225, 225, 225, 225, 94, 94, 94, 94, 15, 15,
			15, 15, 15, 15, 15, 15, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 125,
			130, 130, 130, 130, 130, 130, 127, 127, 130, 127,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 127, 130, 130, 127, 127, 127, 130, 127,
			127, 130, 130, 130, 130, 130, 130, 130, 127, 129,
			226, 226, 226, 226, 226, 226, 226, 226, 130, 130,
			130, 130, 130, 130, 130, 135, 135, 226, 226, 226,
			226, 226, 226, 226, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 127,
			127, 127, 127, 127, 127, 127, 127, 226, 226, 226,
			226, 226, 226, 226, 226, 226, 130, 130, 130, 127,
			130, 130, 127, 127, 127, 127, 127, 226, 226, 226,
			226, 226, 130, 130, 130, 130, 130, 130, 226, 226,
			226, 226, 226, 226, 127, 127, 127, 3, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 127, 127,
			127, 127, 127, 129, 130, 130, 130, 130, 130, 130,
			130, 130, 127, 127, 127, 127, 226, 226, 130, 130,
			226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
			226, 226, 226, 226, 226, 226, 127, 127, 226, 226,
			226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
			226, 226, 130, 92, 92, 92, 127, 92, 92, 127,
			127, 127, 127, 127, 92, 92, 92, 92, 130, 130,
			130, 130, 127, 130, 130, 130, 127, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			127, 127, 92, 92, 92, 127, 127, 127, 127, 92,
			226, 226, 226, 226, 226, 226, 226, 226, 226, 127,
			127, 127, 127, 127, 127, 127, 129, 129, 129, 129,
			129, 129, 129, 129, 129, 127, 127, 127, 127, 127,
			127, 127, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 226, 226, 129, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 226, 226, 226, 130, 130, 130, 130, 130, 130,
			130, 130, 135, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 92, 92, 127, 127, 127,
			127, 226, 226, 226, 226, 226, 129, 129, 129, 129,
			129, 129, 129, 127, 127, 127, 127, 127, 127, 127,
			127, 127, 130, 130, 130, 130, 130, 130, 127, 127,
			127, 3, 3, 3, 3, 3, 3, 3, 130, 130,
			130, 130, 130, 130, 127, 127, 226, 226, 226, 226,
			226, 226, 226, 226, 130, 130, 130, 127, 127, 127,
			127, 127, 226, 226, 226, 226, 226, 226, 226, 226,
			130, 130, 127, 127, 127, 127, 127, 127, 127, 129,
			129, 129, 129, 127, 127, 127, 127, 127, 127, 127,
			127, 127, 127, 127, 127, 226, 226, 226, 226, 226,
			226, 226, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 127, 127, 127, 127, 127, 127, 127, 227, 227,
			227, 227, 227, 227, 227, 227, 227, 227, 227, 227,
			227, 227, 227, 227, 227, 227, 227, 127, 127, 127,
			127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
			228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
			228, 228, 228, 228, 228, 228, 228, 228, 228, 127,
			127, 127, 127, 127, 127, 127, 226, 226, 226, 226,
			226, 226, 130, 130, 130, 130, 92, 92, 92, 92,
			127, 127, 127, 127, 127, 127, 127, 127, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 127, 127,
			127, 127, 127, 127, 18, 18, 18, 18, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 18, 127,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			127, 92, 92, 128, 127, 127, 130, 130, 127, 127,
			127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
			127, 127, 226, 226, 226, 226, 226, 226, 226, 130,
			127, 127, 127, 127, 127, 127, 127, 127, 92, 226,
			226, 226, 226, 129, 129, 129, 129, 129, 127, 127,
			127, 127, 127, 127, 130, 130, 130, 130, 130, 226,
			226, 226, 226, 226, 226, 226, 127, 127, 127, 127,
			130, 130, 130, 130, 130, 130, 130, 127, 127, 127,
			127, 127, 127, 127, 127, 127, 137, 92, 137, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 125, 125, 125, 125, 125,
			125, 125, 94, 94, 94, 94, 18, 18, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
			18, 18, 18, 18, 18, 18, 138, 138, 138, 138,
			138, 138, 138, 138, 138, 138, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 92, 137, 137, 137, 92, 92, 92, 92, 137,
			137, 92, 92, 125, 125, 179, 125, 125, 125, 125,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 179, 94, 94, 92, 92, 92, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 92, 92, 92,
			92, 92, 137, 92, 92, 92, 92, 92, 92, 92,
			92, 94, 138, 138, 138, 138, 138, 138, 138, 138,
			138, 138, 125, 125, 125, 125, 15, 137, 137, 15,
			94, 94, 94, 94, 94, 94, 94, 94, 15, 15,
			15, 92, 125, 125, 15, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 137, 137, 137,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 137,
			137, 15, 15, 15, 15, 125, 125, 125, 125, 92,
			92, 92, 92, 125, 137, 92, 138, 138, 138, 138,
			138, 138, 138, 138, 138, 138, 15, 125, 15, 125,
			125, 125, 94, 139, 139, 139, 139, 139, 139, 139,
			139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
			139, 139, 139, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 137, 137, 137, 92,
			92, 92, 137, 137, 92, 137, 92, 92, 125, 125,
			125, 125, 125, 125, 92, 94, 15, 15, 15, 15,
			15, 15, 15, 94, 15, 94, 15, 15, 15, 15,
			94, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 94, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 125, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 92,
			137, 137, 137, 92, 92, 92, 92, 92, 92, 92,
			92, 94, 94, 94, 94, 94, 92, 92, 137, 137,
			94, 15, 15, 15, 15, 15, 15, 15, 15, 94,
			94, 15, 15, 94, 15, 15, 94, 15, 15, 15,
			15, 15, 94, 92, 92, 15, 137, 137, 92, 137,
			137, 137, 137, 94, 94, 137, 137, 94, 94, 137,
			137, 137, 94, 94, 15, 94, 94, 94, 94, 94,
			94, 137, 94, 94, 94, 94, 94, 15, 15, 15,
			15, 15, 137, 137, 94, 94, 92, 92, 92, 92,
			92, 92, 92, 94, 94, 94, 92, 92, 92, 92,
			92, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 15, 15, 15, 15, 15, 137, 137, 137,
			92, 92, 92, 92, 92, 92, 92, 92, 137, 137,
			92, 92, 92, 137, 92, 15, 15, 15, 15, 125,
			125, 125, 125, 125, 138, 138, 138, 138, 138, 138,
			138, 138, 138, 138, 125, 125, 94, 125, 92, 15,
			15, 15, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 137, 137, 137, 92,
			92, 92, 92, 92, 92, 137, 92, 137, 137, 137,
			137, 92, 92, 137, 92, 92, 15, 15, 125, 15,
			94, 94, 94, 94, 94, 94, 94, 94, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 137, 137, 137, 92, 92, 92, 92,
			94, 94, 137, 137, 137, 137, 92, 92, 137, 92,
			92, 125, 125, 125, 125, 125, 125, 125, 125, 125,
			125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
			125, 125, 125, 125, 15, 15, 15, 15, 92, 92,
			94, 94, 137, 137, 137, 92, 92, 92, 92, 92,
			92, 92, 92, 137, 137, 92, 137, 92, 92, 125,
			125, 125, 15, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 94, 94, 94,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 92, 137, 92, 137, 137, 92, 92, 92, 92,
			92, 92, 137, 92, 15, 94, 94, 94, 94, 94,
			94, 94, 137, 137, 92, 92, 92, 92, 137, 92,
			92, 92, 92, 92, 94, 94, 94, 94, 138, 138,
			138, 138, 138, 138, 138, 138, 138, 138, 139, 139,
			125, 125, 125, 120, 92, 92, 92, 92, 92, 92,
			92, 92, 137, 92, 92, 125, 94, 94, 94, 94,
			139, 139, 139, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 15, 15, 15, 15, 15,
			15, 15, 15, 94, 94, 15, 94, 94, 15, 15,
			15, 15, 15, 15, 15, 15, 94, 15, 15, 94,
			15, 15, 15, 15, 15, 15, 15, 15, 137, 137,
			137, 137, 137, 137, 94, 137, 137, 94, 94, 92,
			92, 137, 92, 15, 137, 15, 137, 92, 125, 125,
			125, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			15, 15, 15, 15, 15, 15, 15, 15, 94, 94,
			15, 15, 15, 15, 15, 15, 15, 137, 137, 137,
			92, 92, 92, 92, 94, 94, 92, 92, 137, 137,
			137, 137, 92, 15, 125, 15, 137, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 15, 92,
			92, 92, 92, 92, 92, 140, 140, 92, 92, 15,
			15, 15, 15, 15, 15, 15, 15, 92, 92, 92,
			92, 92, 92, 137, 15, 92, 92, 92, 92, 125,
			125, 125, 125, 125, 125, 125, 125, 92, 94, 94,
			94, 94, 94, 94, 94, 94, 15, 92, 92, 92,
			92, 92, 92, 137, 137, 92, 92, 92, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 137, 92, 92, 125, 125,
			125, 15, 125, 125, 125, 125, 125, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			92, 92, 92, 92, 92, 92, 92, 94, 92, 92,
			92, 92, 92, 92, 137, 140, 15, 125, 125, 125,
			125, 125, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 125, 125, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 94, 94,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 94, 137, 92, 92, 92, 92, 92, 92,
			92, 137, 92, 92, 137, 92, 92, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 15, 15, 15, 15,
			15, 15, 15, 94, 15, 15, 94, 15, 15, 15,
			15, 15, 15, 92, 92, 92, 92, 92, 92, 94,
			94, 94, 92, 94, 92, 92, 94, 92, 92, 92,
			92, 92, 92, 92, 15, 92, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 15, 15,
			94, 15, 15, 94, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			137, 137, 137, 137, 137, 94, 92, 92, 94, 137,
			137, 92, 137, 92, 15, 94, 94, 94, 94, 94,
			94, 94, 15, 15, 15, 92, 92, 137, 137, 125,
			125, 94, 94, 94, 94, 94, 94, 94, 139, 139,
			139, 139, 139, 14, 14, 14, 14, 14, 14, 14,
			14, 4, 4, 4, 4, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 125, 146, 146, 146, 146,
			146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
			146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
			146, 146, 146, 146, 146, 146, 146, 94, 125, 125,
			125, 125, 125, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 179, 179, 179, 179, 179, 179,
			179, 179, 179, 94, 94, 94, 94, 94, 94, 94,
			92, 92, 92, 92, 92, 125, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 92, 92, 92, 92,
			92, 92, 92, 125, 125, 125, 125, 125, 120, 120,
			120, 120, 90, 90, 90, 90, 125, 120, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 138, 138,
			138, 138, 138, 138, 138, 138, 138, 138, 94, 139,
			139, 139, 139, 139, 139, 139, 94, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 94, 94,
			94, 94, 94, 15, 15, 15, 139, 139, 139, 139,
			139, 139, 139, 125, 125, 125, 125, 94, 94, 94,
			94, 94, 15, 15, 15, 15, 15, 15, 15, 15,
			15, 15, 15, 94, 94, 94, 94, 92, 15, 137,
			137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
			137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
			137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
			137, 137, 137, 137, 137, 137, 137, 137, 94, 94,
			94, 94, 94, 94, 94, 92, 92, 92, 92, 90,
			90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
			90, 90, 90, 90, 3, 90, 92, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 137, 137,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 15, 15, 15, 15, 94, 94,
			94, 94, 94, 94, 94, 94, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 94, 94, 120, 92,
			92, 125, 17, 17, 17, 17, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 120, 120,
			120, 120, 120, 120, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 120, 120, 120, 120, 120, 120,
			120, 94, 94, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 137, 137, 92, 92, 92,
			120, 120, 120, 137, 137, 137, 137, 137, 137, 17,
			17, 17, 17, 17, 17, 17, 17, 92, 92, 92,
			92, 92, 92, 92, 92, 120, 120, 92, 92, 92,
			92, 92, 92, 92, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 92, 92,
			92, 92, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 94, 94, 94, 94, 94, 94, 94,
			14, 14, 92, 92, 92, 14, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 139, 139, 139, 139,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 139, 139, 139, 139, 139, 139, 139, 139,
			139, 94, 94, 94, 94, 94, 94, 94, 25, 25,
			25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
			25, 25, 25, 25, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 25, 25, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
			21, 21, 21, 21, 21, 21, 21, 94, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 25, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 25, 94, 25, 25, 94, 94, 25, 94,
			94, 25, 25, 94, 94, 25, 25, 25, 25, 94,
			25, 25, 25, 25, 25, 25, 25, 25, 21, 21,
			21, 21, 94, 21, 94, 21, 21, 21, 21, 21,
			21, 21, 94, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 25, 25,
			94, 25, 25, 25, 25, 94, 94, 25, 25, 25,
			25, 25, 25, 25, 25, 94, 25, 25, 25, 25,
			25, 25, 25, 94, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 25, 25, 94, 25, 25, 25,
			25, 94, 25, 25, 25, 25, 25, 94, 25, 94,
			94, 94, 25, 25, 25, 25, 25, 25, 25, 94,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 25, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 94, 94, 25, 25, 25, 25, 25, 25,
			25, 25, 25, 229, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 7,
			21, 21, 21, 21, 21, 21, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
			25, 229, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 7, 21, 21, 21, 21, 21, 21, 25, 25,
			25, 25, 25, 25, 25, 25, 25, 229, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 7, 21, 21, 21, 21, 21, 21,
			25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
			25, 25, 25, 25, 25, 229, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 7, 21, 21, 21, 21,
			21, 21, 25, 25, 25, 25, 25, 25, 25, 25,
			25, 229, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 7, 21, 21, 21, 21, 21, 21, 25, 21,
			94, 94, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			92, 92, 92, 92, 92, 92, 92, 120, 120, 120,
			120, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 120,
			120, 120, 120, 120, 120, 120, 120, 92, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 92, 120, 120, 125, 125, 125, 125, 125,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 92, 92, 92, 92, 92,
			94, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 94, 92, 92, 92, 92, 92, 92,
			92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
			92, 94, 94, 92, 92, 92, 92, 92, 92, 92,
			94, 92, 92, 94, 92, 92, 92, 92, 92, 94,
			94, 94, 94, 94, 92, 92, 92, 92, 92, 92,
			92, 90, 90, 90, 90, 90, 90, 90, 94, 94,
			138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
			94, 94, 94, 94, 15, 120, 15, 15, 15, 15,
			15, 15, 15, 15, 15, 15, 15, 15, 92, 92,
			92, 92, 138, 138, 138, 138, 138, 138, 138, 138,
			138, 138, 94, 94, 94, 94, 94, 4, 130, 130,
			130, 130, 130, 127, 127, 226, 226, 226, 226, 226,
			226, 226, 226, 226, 92, 92, 92, 92, 92, 92,
			92, 127, 127, 127, 127, 127, 127, 127, 127, 127,
			230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
			230, 230, 230, 230, 230, 230, 230, 230, 231, 231,
			231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
			231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
			231, 231, 231, 231, 231, 231, 231, 231, 231, 231,
			231, 231, 92, 92, 92, 92, 92, 92, 92, 134,
			127, 127, 127, 127, 136, 136, 136, 136, 136, 136,
			136, 136, 136, 136, 127, 127, 127, 127, 129, 129,
			127, 226, 226, 226, 226, 226, 226, 226, 226, 226,
			226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
			226, 226, 226, 226, 226, 226, 226, 226, 135, 226,
			226, 226, 132, 226, 226, 226, 226, 127, 127, 127,
			127, 127, 127, 127, 127, 127, 127, 127, 226, 226,
			226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
			226, 226, 135, 226, 226, 226, 226, 226, 226, 226,
			226, 226, 226, 226, 226, 226, 226, 226, 127, 127,
			130, 130, 130, 130, 127, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 127, 130, 130, 127,
			130, 127, 127, 130, 127, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 127, 130, 130, 130, 130,
			127, 130, 127, 130, 127, 127, 127, 127, 127, 127,
			130, 127, 127, 127, 127, 130, 127, 130, 127, 130,
			127, 130, 130, 130, 127, 130, 130, 127, 130, 127,
			127, 130, 127, 130, 127, 130, 127, 130, 127, 130,
			127, 130, 130, 127, 130, 127, 127, 130, 130, 130,
			130, 127, 130, 130, 130, 130, 130, 130, 130, 127,
			130, 130, 130, 130, 127, 130, 130, 130, 130, 127,
			130, 127, 130, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 127, 130, 130, 130, 130, 130, 130, 130,
			130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
			127, 127, 127, 127, 127, 130, 130, 130, 127, 130,
			130, 130, 130, 130, 127, 130, 130, 130, 130, 130,
			7, 7, 127, 127, 127, 127, 127, 127, 127, 127,
			127, 127, 127, 127, 127, 127, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 94, 94, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 18, 18,
			18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
			18, 14, 14, 14, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 14, 14, 14, 14, 14, 14,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 14, 94, 94, 94, 94, 94, 94,
			94, 94, 120, 120, 120, 120, 120, 120, 120, 120,
			120, 120, 120, 120, 120, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 120, 120,
			120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
			94, 94, 94, 94, 120, 120, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 11, 11, 11, 11, 11, 14, 14, 14, 14,
			14, 14, 14, 14, 94, 94, 94, 94, 94, 94,
			94, 94, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 94, 94, 94, 94, 94, 94, 94, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 94, 94, 14, 14, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 94,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 94, 14,
			14, 14, 14, 14, 14, 14, 14, 94, 94, 94,
			14, 14, 14, 94, 94, 94, 94, 94, 14, 14,
			14, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 14, 14, 14, 94, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
			182, 182, 182, 17, 182, 182, 182, 182, 182, 182,
			182, 182, 182, 182, 182, 182, 182, 182, 17, 17,
			17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
			17, 17, 17, 17, 221, 221, 221, 221, 221, 221,
			221, 221, 221, 221, 221, 221, 221, 221, 182, 182
		};

		private static ReadOnlySpan<byte> CategoriesValues => new byte[232]
		{
			14, 142, 139, 24, 26, 20, 21, 25, 19, 8,
			32, 27, 18, 33, 28, 36, 22, 15, 10, 33,
			23, 33, 33, 32, 33, 32, 32, 33, 32, 32,
			32, 32, 32, 32, 32, 33, 32, 32, 33, 32,
			33, 32, 32, 32, 32, 33, 32, 34, 33, 33,
			32, 32, 32, 32, 32, 32, 33, 32, 32, 32,
			33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
			33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
			33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
			35, 3, 5, 5, 61, 32, 32, 32, 32, 32,
			33, 33, 33, 33, 33, 32, 33, 33, 33, 33,
			33, 33, 33, 33, 33, 32, 33, 32, 32, 33,
			60, 7, 32, 33, 32, 56, 33, 93, 83, 88,
			68, 89, 90, 79, 67, 92, 72, 38, 40, 42,
			37, 32, 33, 32, 32, 33, 41, 33, 33, 33,
			33, 33, 33, 33, 33, 32, 33, 33, 33, 33,
			32, 33, 32, 33, 33, 33, 33, 33, 33, 34,
			33, 32, 34, 33, 32, 32, 32, 32, 32, 47,
			140, 141, 29, 32, 32, 32, 32, 33, 41, 41,
			60, 60, 32, 32, 32, 33, 33, 32, 32, 32,
			32, 32, 33, 32, 59, 32, 33, 32, 32, 32,
			32, 32, 32, 32, 32, 32, 32, 32, 33, 33,
			48, 49, 91, 9, 32, 33, 74, 64, 65, 57,
			64, 65
		};

		private static ReadOnlySpan<byte> UppercaseValues => new byte[464]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 224, 255, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 231, 2,
			0, 0, 0, 0, 121, 0, 0, 0, 255, 255,
			0, 0, 0, 0, 195, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			97, 0, 0, 0, 0, 0, 163, 0, 0, 0,
			130, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			56, 0, 0, 0, 255, 255, 254, 255, 177, 255,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 63, 42, 0, 0, 0, 0, 0, 0,
			31, 42, 28, 42, 30, 42, 46, 255, 50, 255,
			51, 255, 54, 255, 53, 255, 79, 165, 75, 165,
			49, 255, 40, 165, 68, 165, 47, 255, 45, 255,
			247, 41, 65, 165, 253, 41, 43, 255, 42, 255,
			231, 41, 38, 255, 67, 165, 42, 165, 187, 255,
			39, 255, 185, 255, 37, 255, 21, 165, 18, 165,
			0, 0, 0, 0, 0, 0, 84, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			218, 255, 219, 255, 225, 255, 192, 255, 193, 255,
			0, 0, 194, 255, 199, 255, 209, 255, 202, 255,
			248, 255, 170, 255, 176, 255, 7, 0, 140, 255,
			0, 0, 160, 255, 0, 0, 0, 0, 176, 255,
			0, 0, 0, 0, 0, 0, 241, 255, 0, 0,
			0, 0, 208, 255, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 192, 11, 0, 0, 0, 0,
			248, 255, 0, 0, 146, 231, 147, 231, 156, 231,
			158, 231, 157, 231, 164, 231, 219, 231, 194, 137,
			0, 0, 4, 138, 230, 14, 56, 138, 197, 255,
			0, 0, 8, 0, 0, 0, 74, 0, 86, 0,
			100, 0, 128, 0, 112, 0, 126, 0, 0, 0,
			9, 0, 0, 0, 0, 0, 219, 227, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 228, 255, 0, 0, 240, 255,
			0, 0, 230, 255, 0, 0, 0, 0, 0, 0,
			213, 213, 216, 213, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 160, 227, 0, 0, 0, 0,
			0, 0, 48, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 96, 252, 48, 104,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			216, 255, 0, 0, 0, 0, 192, 255, 0, 0,
			0, 0, 222, 255
		};

		private static ReadOnlySpan<byte> LowercaseValues => new byte[464]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			32, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
			0, 0, 135, 255, 0, 0, 210, 0, 206, 0,
			205, 0, 79, 0, 202, 0, 203, 0, 207, 0,
			0, 0, 211, 0, 209, 0, 0, 0, 213, 0,
			0, 0, 214, 0, 218, 0, 217, 0, 219, 0,
			0, 0, 2, 0, 1, 0, 0, 0, 0, 0,
			159, 255, 200, 255, 126, 255, 43, 42, 93, 255,
			40, 42, 0, 0, 61, 255, 69, 0, 71, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			116, 0, 38, 0, 37, 0, 64, 0, 63, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			8, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			196, 255, 0, 0, 249, 255, 80, 0, 0, 0,
			0, 0, 0, 0, 15, 0, 0, 0, 48, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 96, 28, 0, 0, 208, 151, 8, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			64, 244, 0, 0, 0, 0, 0, 0, 0, 0,
			65, 226, 0, 0, 248, 255, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 248, 255,
			0, 0, 182, 255, 247, 255, 0, 0, 170, 255,
			156, 255, 144, 255, 128, 255, 130, 255, 0, 0,
			0, 0, 0, 0, 0, 0, 163, 226, 65, 223,
			186, 223, 28, 0, 0, 0, 16, 0, 0, 0,
			26, 0, 0, 0, 9, 214, 26, 241, 25, 214,
			0, 0, 0, 0, 228, 213, 3, 214, 225, 213,
			226, 213, 193, 213, 0, 0, 252, 117, 0, 0,
			216, 90, 0, 0, 188, 90, 177, 90, 181, 90,
			191, 90, 238, 90, 214, 90, 235, 90, 160, 3,
			208, 255, 189, 90, 200, 117, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 40, 0,
			0, 0, 0, 0, 64, 0, 0, 0, 0, 0,
			34, 0, 0, 0
		};

		private static ReadOnlySpan<byte> NumericGraphemeLevel1Index => new byte[2176]
		{
			0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
			10, 11, 12, 13, 14, 10, 15, 16, 17, 18,
			19, 20, 21, 10, 22, 23, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 24, 25, 26, 27, 28, 29, 30,
			31, 32, 33, 27, 28, 29, 30, 31, 32, 33,
			27, 28, 29, 30, 31, 32, 33, 34, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 35, 36, 10, 37, 38, 39,
			40, 10, 41, 42, 43, 44, 45, 46, 47, 48,
			49, 50, 51, 52, 10, 10, 53, 10, 10, 10,
			10, 10, 10, 10, 54, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 55, 10, 56, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 57, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 58, 59, 10, 60, 10, 61, 10, 10,
			62, 63, 10, 10, 64, 10, 65, 10, 66, 67,
			68, 69, 70, 71, 72, 73, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			74, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 75, 76, 76, 76, 76, 76, 76, 76,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
			10, 10, 10, 10, 10, 10
		};

		private static ReadOnlySpan<byte> NumericGraphemeLevel2Index => new byte[4928]
		{
			0, 0, 1, 0, 2, 0, 3, 0, 2, 0,
			2, 0, 2, 0, 4, 0, 1, 0, 1, 0,
			5, 0, 6, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 7, 0, 7, 0,
			7, 0, 7, 0, 7, 0, 7, 0, 7, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 8, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 9, 0,
			7, 0, 10, 0, 11, 0, 2, 0, 2, 0,
			2, 0, 12, 0, 13, 0, 2, 0, 2, 0,
			14, 0, 7, 0, 3, 0, 15, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 16, 0,
			17, 0, 3, 0, 18, 0, 19, 0, 2, 0,
			7, 0, 20, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 21, 0, 15, 0, 3, 0,
			2, 0, 14, 0, 22, 0, 2, 0, 23, 0,
			24, 0, 2, 0, 2, 0, 25, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 26, 0, 27, 0, 7, 0, 28, 0,
			2, 0, 2, 0, 29, 0, 30, 0, 31, 0,
			32, 0, 2, 0, 33, 0, 2, 0, 2, 0,
			34, 0, 35, 0, 36, 0, 32, 0, 37, 0,
			38, 0, 2, 0, 2, 0, 39, 0, 40, 0,
			19, 0, 41, 0, 42, 0, 38, 0, 2, 0,
			2, 0, 39, 0, 43, 0, 2, 0, 32, 0,
			44, 0, 33, 0, 2, 0, 2, 0, 45, 0,
			35, 0, 46, 0, 32, 0, 47, 0, 48, 0,
			2, 0, 2, 0, 49, 0, 50, 0, 36, 0,
			41, 0, 51, 0, 52, 0, 2, 0, 2, 0,
			53, 0, 54, 0, 55, 0, 32, 0, 56, 0,
			33, 0, 2, 0, 2, 0, 57, 0, 58, 0,
			55, 0, 32, 0, 2, 0, 59, 0, 2, 0,
			2, 0, 60, 0, 61, 0, 62, 0, 32, 0,
			63, 0, 33, 0, 2, 0, 2, 0, 2, 0,
			64, 0, 65, 0, 41, 0, 66, 0, 2, 0,
			2, 0, 2, 0, 67, 0, 68, 0, 3, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			69, 0, 70, 0, 3, 0, 2, 0, 2, 0,
			2, 0, 71, 0, 72, 0, 73, 0, 2, 0,
			2, 0, 2, 0, 74, 0, 75, 0, 76, 0,
			7, 0, 77, 0, 78, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 79, 0, 80, 0,
			3, 0, 81, 0, 15, 0, 82, 0, 83, 0,
			84, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 85, 0, 85, 0, 85, 0,
			85, 0, 85, 0, 85, 0, 86, 0, 86, 0,
			86, 0, 86, 0, 87, 0, 88, 0, 88, 0,
			88, 0, 88, 0, 88, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 79, 0,
			89, 0, 90, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 91, 0, 92, 0, 2, 0, 93, 0,
			2, 0, 93, 0, 2, 0, 94, 0, 2, 0,
			94, 0, 2, 0, 2, 0, 2, 0, 95, 0,
			96, 0, 22, 0, 3, 0, 97, 0, 98, 0,
			3, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 55, 0, 2, 0, 99, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 100, 0, 101, 0, 41, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 102, 0, 2, 0,
			2, 0, 2, 0, 103, 0, 2, 0, 2, 0,
			2, 0, 104, 0, 105, 0, 106, 0, 3, 0,
			3, 0, 2, 0, 7, 0, 15, 0, 2, 0,
			2, 0, 2, 0, 107, 0, 2, 0, 2, 0,
			108, 0, 109, 0, 3, 0, 14, 0, 110, 0,
			111, 0, 2, 0, 112, 0, 3, 0, 2, 0,
			2, 0, 113, 0, 59, 0, 2, 0, 2, 0,
			114, 0, 115, 0, 3, 0, 3, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 116, 0, 117, 0, 118, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 7, 0, 7, 0, 7, 0, 119, 0,
			120, 0, 2, 0, 121, 0, 122, 0, 123, 0,
			2, 0, 1, 0, 124, 0, 125, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 7, 0, 7, 0,
			15, 0, 2, 0, 2, 0, 126, 0, 123, 0,
			2, 0, 127, 0, 128, 0, 128, 0, 129, 0,
			130, 0, 131, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 132, 0,
			133, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 133, 0, 2, 0, 2, 0, 2, 0,
			134, 0, 2, 0, 135, 0, 136, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			137, 0, 138, 0, 139, 0, 140, 0, 2, 0,
			2, 0, 126, 0, 2, 0, 141, 0, 142, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			132, 0, 143, 0, 144, 0, 2, 0, 2, 0,
			145, 0, 146, 0, 147, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 149, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 150, 0, 151, 0, 152, 0,
			153, 0, 154, 0, 155, 0, 156, 0, 157, 0,
			158, 0, 159, 0, 160, 0, 161, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 162, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 163, 0, 164, 0, 2, 0, 2, 0,
			2, 0, 165, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 166, 0, 167, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			166, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 7, 0, 7, 0, 168, 0,
			2, 0, 169, 0, 170, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 171, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 172, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 173, 0, 2, 0,
			174, 0, 175, 0, 2, 0, 2, 0, 173, 0,
			176, 0, 2, 0, 177, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			3, 0, 2, 0, 2, 0, 2, 0, 166, 0,
			178, 0, 2, 0, 53, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 179, 0, 180, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			181, 0, 2, 0, 182, 0, 183, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 184, 0, 2, 0,
			2, 0, 185, 0, 186, 0, 3, 0, 7, 0,
			187, 0, 3, 0, 2, 0, 188, 0, 2, 0,
			189, 0, 59, 0, 85, 0, 190, 0, 28, 0,
			2, 0, 2, 0, 191, 0, 192, 0, 3, 0,
			193, 0, 3, 0, 2, 0, 2, 0, 194, 0,
			195, 0, 196, 0, 3, 0, 2, 0, 197, 0,
			2, 0, 2, 0, 2, 0, 198, 0, 19, 0,
			2, 0, 199, 0, 200, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 201, 0, 3, 0, 202, 0,
			203, 0, 204, 0, 205, 0, 204, 0, 206, 0,
			204, 0, 202, 0, 203, 0, 204, 0, 205, 0,
			204, 0, 206, 0, 204, 0, 202, 0, 203, 0,
			204, 0, 205, 0, 204, 0, 206, 0, 204, 0,
			202, 0, 203, 0, 204, 0, 205, 0, 204, 0,
			206, 0, 204, 0, 202, 0, 203, 0, 204, 0,
			205, 0, 204, 0, 206, 0, 204, 0, 202, 0,
			203, 0, 204, 0, 205, 0, 204, 0, 206, 0,
			204, 0, 202, 0, 203, 0, 204, 0, 205, 0,
			204, 0, 206, 0, 204, 0, 202, 0, 203, 0,
			204, 0, 205, 0, 204, 0, 206, 0, 204, 0,
			202, 0, 203, 0, 204, 0, 205, 0, 204, 0,
			206, 0, 204, 0, 202, 0, 203, 0, 204, 0,
			205, 0, 204, 0, 206, 0, 204, 0, 202, 0,
			203, 0, 204, 0, 205, 0, 204, 0, 206, 0,
			204, 0, 202, 0, 203, 0, 204, 0, 205, 0,
			204, 0, 206, 0, 204, 0, 202, 0, 203, 0,
			204, 0, 205, 0, 204, 0, 206, 0, 204, 0,
			202, 0, 203, 0, 204, 0, 205, 0, 204, 0,
			206, 0, 204, 0, 202, 0, 203, 0, 204, 0,
			205, 0, 204, 0, 206, 0, 204, 0, 202, 0,
			203, 0, 204, 0, 205, 0, 204, 0, 206, 0,
			204, 0, 202, 0, 203, 0, 204, 0, 205, 0,
			204, 0, 206, 0, 204, 0, 202, 0, 203, 0,
			204, 0, 205, 0, 204, 0, 206, 0, 204, 0,
			202, 0, 203, 0, 204, 0, 205, 0, 204, 0,
			206, 0, 204, 0, 202, 0, 203, 0, 204, 0,
			205, 0, 204, 0, 206, 0, 204, 0, 202, 0,
			203, 0, 204, 0, 205, 0, 204, 0, 206, 0,
			204, 0, 202, 0, 203, 0, 204, 0, 205, 0,
			204, 0, 206, 0, 204, 0, 202, 0, 203, 0,
			204, 0, 205, 0, 204, 0, 206, 0, 204, 0,
			202, 0, 203, 0, 204, 0, 205, 0, 204, 0,
			206, 0, 204, 0, 202, 0, 203, 0, 204, 0,
			205, 0, 204, 0, 206, 0, 204, 0, 202, 0,
			203, 0, 204, 0, 205, 0, 204, 0, 206, 0,
			204, 0, 202, 0, 203, 0, 204, 0, 205, 0,
			204, 0, 206, 0, 204, 0, 202, 0, 203, 0,
			204, 0, 205, 0, 204, 0, 206, 0, 204, 0,
			202, 0, 203, 0, 204, 0, 205, 0, 204, 0,
			206, 0, 204, 0, 202, 0, 203, 0, 204, 0,
			205, 0, 204, 0, 206, 0, 204, 0, 202, 0,
			203, 0, 204, 0, 205, 0, 204, 0, 206, 0,
			204, 0, 202, 0, 203, 0, 204, 0, 205, 0,
			204, 0, 206, 0, 204, 0, 202, 0, 203, 0,
			204, 0, 205, 0, 204, 0, 206, 0, 204, 0,
			202, 0, 203, 0, 204, 0, 205, 0, 204, 0,
			206, 0, 204, 0, 202, 0, 203, 0, 204, 0,
			205, 0, 204, 0, 206, 0, 204, 0, 202, 0,
			203, 0, 204, 0, 205, 0, 204, 0, 207, 0,
			86, 0, 208, 0, 88, 0, 88, 0, 209, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 210, 0, 211, 0, 2, 0,
			2, 0, 2, 0, 212, 0, 2, 0, 213, 0,
			2, 0, 214, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 215, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 7, 0,
			2, 0, 7, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 4, 0,
			2, 0, 3, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 53, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			216, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 217, 0, 218, 0, 219, 0,
			220, 0, 221, 0, 222, 0, 223, 0, 224, 0,
			225, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 226, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 227, 0, 228, 0, 2, 0,
			2, 0, 229, 0, 2, 0, 230, 0, 2, 0,
			2, 0, 231, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 232, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			3, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 233, 0, 2, 0, 234, 0,
			2, 0, 2, 0, 235, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 236, 0, 2, 0, 237, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 238, 0,
			239, 0, 240, 0, 241, 0, 242, 0, 243, 0,
			2, 0, 2, 0, 244, 0, 245, 0, 2, 0,
			2, 0, 246, 0, 2, 0, 247, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 248, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			249, 0, 2, 0, 249, 0, 2, 0, 2, 0,
			250, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 251, 0, 2, 0, 2, 0, 252, 0,
			3, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 253, 0,
			254, 0, 2, 0, 2, 0, 255, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			0, 1, 1, 1, 2, 0, 21, 0, 2, 1,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 3, 1, 2, 0, 2, 0, 2, 0,
			4, 1, 2, 0, 2, 0, 5, 1, 6, 1,
			7, 1, 8, 1, 166, 0, 111, 0, 2, 0,
			2, 0, 9, 1, 10, 1, 2, 0, 2, 0,
			3, 0, 11, 1, 2, 0, 12, 1, 13, 1,
			14, 1, 2, 0, 2, 0, 15, 1, 111, 0,
			2, 0, 2, 0, 16, 1, 17, 1, 3, 0,
			18, 1, 19, 1, 2, 0, 2, 0, 20, 1,
			21, 1, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			166, 0, 22, 1, 3, 0, 59, 0, 2, 0,
			2, 0, 60, 0, 23, 1, 36, 0, 24, 1,
			25, 1, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 26, 1, 27, 1, 28, 1,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			29, 1, 30, 1, 3, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			166, 0, 31, 1, 15, 0, 32, 1, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 33, 1,
			15, 0, 3, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 34, 1, 35, 1, 3, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 79, 0, 36, 1,
			37, 1, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			20, 1, 38, 1, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 39, 1, 40, 1, 2, 0,
			2, 0, 2, 0, 41, 1, 42, 1, 3, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 43, 1, 44, 1, 2, 0,
			45, 1, 2, 0, 2, 0, 46, 1, 36, 0,
			47, 1, 2, 0, 2, 0, 48, 1, 49, 1,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 50, 1,
			51, 1, 2, 0, 52, 1, 53, 1, 2, 0,
			2, 0, 54, 1, 55, 1, 56, 1, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 57, 1, 58, 1, 3, 0, 2, 0,
			2, 0, 59, 1, 60, 1, 3, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 61, 1,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 62, 1, 63, 1, 2, 0,
			2, 0, 64, 1, 65, 1, 66, 1, 67, 1,
			68, 1, 69, 1, 70, 1, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 71, 1, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 3, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			25, 1, 2, 0, 2, 0, 2, 0, 6, 1,
			2, 0, 72, 1, 73, 1, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			74, 1, 75, 1, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 166, 0, 76, 1, 77, 1,
			77, 1, 78, 1, 11, 1, 2, 0, 2, 0,
			2, 0, 2, 0, 79, 1, 184, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 80, 1, 81, 1,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 82, 1, 83, 1,
			84, 1, 2, 0, 85, 1, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 93, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 74, 1, 86, 1, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			239, 0, 87, 1, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 88, 1, 89, 1,
			90, 1, 91, 1, 7, 0, 7, 0, 7, 0,
			92, 1, 7, 0, 7, 0, 77, 0, 193, 0,
			79, 1, 14, 0, 9, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 93, 1,
			94, 1, 95, 1, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 6, 1, 3, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			96, 1, 3, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			217, 0, 6, 1, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 97, 1, 3, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 18, 1, 98, 1, 99, 1,
			100, 1, 101, 1, 2, 0, 2, 0, 2, 0,
			2, 0, 18, 1, 98, 1, 102, 1, 103, 1,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 104, 1, 2, 0,
			134, 0, 2, 0, 2, 0, 2, 0, 105, 1,
			106, 1, 107, 1, 108, 1, 109, 1, 148, 0,
			148, 0, 148, 0, 110, 1, 111, 1, 112, 1,
			113, 1, 134, 0, 114, 1, 135, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			115, 1, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			116, 1, 117, 1, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 2, 0, 2, 0,
			2, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 118, 1, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 119, 1, 148, 0, 148, 0,
			105, 1, 2, 0, 2, 0, 2, 0, 120, 1,
			121, 1, 2, 0, 2, 0, 120, 1, 2, 0,
			122, 1, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 105, 1, 148, 0, 148, 0, 123, 1,
			146, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 3, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 148, 0, 148, 0, 148, 0,
			148, 0, 148, 0, 116, 1, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 124, 1, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			2, 0, 2, 0, 2, 0, 2, 0, 2, 0,
			1, 0, 1, 0, 7, 0, 7, 0, 7, 0,
			7, 0, 7, 0, 7, 0, 1, 0, 1, 0,
			1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
			1, 0, 7, 0, 7, 0, 7, 0, 7, 0,
			7, 0, 7, 0, 7, 0, 7, 0, 7, 0,
			7, 0, 7, 0, 7, 0, 7, 0, 7, 0,
			7, 0, 1, 0, 1, 0, 1, 0, 1, 0,
			1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
			1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
			1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
			1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
			1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
			1, 0, 1, 0, 1, 0, 1, 0
		};

		private static ReadOnlySpan<byte> NumericGraphemeLevel3Index => new byte[6096]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			1, 0, 0, 2, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 0,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 14,
			3, 3, 3, 0, 14, 3, 3, 3, 15, 16,
			3, 3, 3, 3, 3, 17, 3, 3, 18, 19,
			20, 3, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 3, 3,
			3, 21, 21, 21, 21, 21, 21, 21, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 3, 21, 3, 21, 21, 3,
			21, 21, 3, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 22, 22, 22, 22, 22, 22, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 3,
			0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 21, 21, 21,
			21, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 21, 21, 21, 21, 21, 21, 22,
			3, 21, 21, 21, 21, 21, 21, 3, 3, 21,
			21, 3, 21, 21, 21, 21, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 22, 3, 21, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 21, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 21, 21, 21, 3, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 3, 21,
			21, 21, 3, 21, 21, 21, 21, 21, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 21,
			21, 21, 3, 3, 3, 3, 3, 3, 3, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 22, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 23, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 23, 21, 3, 23, 23,
			23, 21, 21, 21, 21, 21, 21, 21, 21, 23,
			23, 23, 23, 21, 23, 23, 3, 21, 21, 21,
			21, 21, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 21, 3, 3, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 3, 21,
			23, 23, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 21, 3, 21, 23,
			23, 21, 21, 21, 21, 3, 3, 23, 23, 3,
			3, 23, 23, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 24, 25, 26, 18,
			20, 27, 3, 3, 3, 3, 21, 3, 3, 21,
			21, 23, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 21, 3, 23, 23,
			23, 21, 21, 3, 3, 3, 3, 21, 21, 3,
			3, 21, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 4, 5, 6, 7, 8, 9, 10, 11,
			12, 13, 21, 21, 3, 3, 3, 21, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 23, 21,
			21, 21, 21, 21, 3, 21, 21, 23, 3, 23,
			23, 21, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 21, 21, 21, 21, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 3, 21, 21, 3, 3, 3, 3,
			3, 21, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 18, 19, 20, 24, 25, 26,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			21, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 21, 23,
			21, 23, 23, 3, 3, 3, 23, 23, 23, 3,
			23, 23, 23, 21, 3, 3, 28, 29, 30, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 23, 23, 23, 21, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 21, 21, 23, 23, 23, 23, 3,
			21, 21, 21, 3, 21, 21, 21, 21, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 31, 32, 33, 34, 32, 33,
			34, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 3, 23, 21, 23, 23,
			21, 23, 23, 3, 21, 23, 23, 3, 23, 23,
			21, 21, 3, 3, 21, 21, 23, 23, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 21, 21, 3, 21, 23, 23, 21, 21, 21,
			21, 3, 23, 23, 23, 3, 23, 23, 23, 21,
			22, 3, 3, 3, 3, 3, 3, 3, 3, 21,
			35, 36, 37, 38, 39, 40, 41, 3, 28, 29,
			30, 18, 19, 20, 24, 25, 26, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 3, 3, 3, 3, 21,
			23, 23, 21, 21, 21, 3, 21, 3, 23, 23,
			23, 23, 23, 23, 23, 21, 3, 3, 23, 23,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 21, 3, 23, 21, 21, 21, 21,
			21, 21, 21, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 21, 21, 21,
			21, 21, 21, 3, 3, 21, 3, 23, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 21, 21,
			21, 21, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 21, 3, 3, 3, 3,
			3, 3, 4, 5, 6, 7, 8, 9, 10, 11,
			12, 13, 19, 42, 43, 44, 45, 46, 47, 48,
			49, 50, 3, 21, 3, 21, 3, 21, 3, 3,
			3, 3, 23, 23, 3, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 23,
			21, 21, 21, 21, 21, 3, 21, 21, 3, 3,
			3, 3, 3, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 3, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 21, 21, 21,
			21, 23, 21, 21, 21, 21, 21, 21, 3, 21,
			21, 23, 23, 21, 21, 3, 3, 3, 3, 3,
			3, 3, 23, 23, 21, 21, 3, 3, 3, 3,
			21, 21, 3, 21, 21, 21, 21, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			21, 3, 23, 21, 21, 3, 3, 3, 3, 3,
			3, 21, 3, 3, 4, 5, 6, 7, 8, 9,
			10, 11, 12, 13, 3, 3, 3, 21, 3, 3,
			51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
			51, 51, 51, 51, 51, 51, 52, 52, 52, 52,
			52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
			52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
			53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
			53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
			53, 53, 53, 53, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 17, 15, 16, 54, 55, 56, 57,
			58, 59, 28, 60, 61, 62, 63, 64, 65, 66,
			67, 29, 68, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			69, 70, 71, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			21, 21, 21, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 21, 21, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 21, 23, 21, 21, 21,
			21, 21, 21, 21, 23, 23, 23, 23, 23, 23,
			23, 23, 21, 23, 23, 21, 21, 21, 21, 21,
			21, 21, 31, 32, 33, 34, 72, 73, 74, 75,
			76, 77, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 21,
			21, 21, 0, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 21, 3, 3, 3, 3, 3, 3,
			21, 21, 21, 23, 23, 23, 23, 21, 21, 23,
			23, 23, 3, 3, 3, 3, 23, 23, 21, 23,
			23, 23, 23, 23, 23, 21, 21, 21, 3, 3,
			3, 3, 4, 5, 6, 7, 8, 9, 10, 11,
			12, 13, 17, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 23, 23, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 23,
			21, 23, 21, 21, 21, 21, 21, 21, 21, 3,
			21, 3, 21, 3, 3, 21, 21, 21, 21, 21,
			21, 21, 21, 23, 23, 23, 23, 23, 23, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 3,
			3, 21, 21, 21, 21, 21, 23, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 21, 21, 21, 21, 21, 21, 23,
			21, 23, 23, 23, 23, 23, 21, 23, 23, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			21, 21, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 21, 21, 23, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 23, 21, 21, 21, 21, 23, 23,
			21, 21, 23, 21, 21, 21, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 23, 21, 21, 23, 23,
			23, 21, 23, 21, 3, 3, 3, 3, 23, 23,
			23, 23, 23, 23, 23, 23, 21, 21, 21, 21,
			21, 21, 21, 21, 23, 23, 21, 21, 3, 3,
			3, 3, 3, 3, 3, 3, 21, 21, 21, 3,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 23, 21, 21, 21, 21, 21, 21,
			21, 3, 3, 3, 3, 21, 3, 3, 3, 3,
			3, 3, 21, 3, 3, 23, 21, 21, 3, 3,
			3, 3, 3, 3, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 3, 21, 21, 21, 21, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 0, 21, 78, 0, 0, 3, 3, 3, 3,
			3, 3, 3, 3, 0, 0, 0, 0, 0, 0,
			0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 14, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 14, 3, 3,
			3, 3, 3, 3, 79, 3, 3, 3, 54, 55,
			56, 57, 58, 59, 3, 3, 3, 3, 3, 3,
			79, 17, 15, 16, 54, 55, 56, 57, 58, 59,
			3, 3, 3, 3, 3, 3, 3, 3, 14, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 80, 81, 39, 82, 83, 41, 84, 85,
			86, 87, 88, 25, 89, 90, 91, 32, 32, 33,
			34, 72, 73, 74, 75, 76, 77, 28, 92, 93,
			63, 29, 94, 30, 30, 95, 68, 3, 3, 74,
			63, 96, 97, 31, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 14, 14, 14, 14, 14, 14,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 14, 14, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 14, 14, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 14, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 14,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			3, 3, 3, 3, 14, 14, 14, 3, 3, 3,
			3, 3, 17, 15, 16, 54, 55, 56, 57, 58,
			59, 28, 92, 93, 98, 99, 100, 27, 69, 70,
			71, 60, 17, 15, 16, 54, 55, 56, 57, 58,
			59, 28, 92, 93, 98, 99, 100, 27, 69, 70,
			71, 60, 17, 15, 16, 54, 55, 56, 57, 58,
			59, 28, 92, 93, 98, 99, 100, 27, 69, 70,
			71, 60, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 79, 92, 93, 98,
			99, 100, 27, 69, 70, 71, 60, 17, 15, 16,
			54, 55, 56, 57, 58, 59, 28, 79, 3, 3,
			3, 3, 3, 3, 14, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 14, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 14, 14, 14, 14, 3, 14, 14, 14, 14,
			14, 14, 3, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 3, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			14, 14, 14, 14, 14, 14, 3, 3, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 3,
			14, 3, 14, 3, 3, 3, 3, 3, 3, 14,
			3, 3, 3, 14, 3, 3, 3, 3, 3, 3,
			14, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 14, 14, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 14, 3,
			3, 14, 3, 3, 3, 3, 14, 3, 14, 3,
			3, 3, 3, 14, 14, 14, 3, 14, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 14,
			14, 14, 14, 14, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 17, 15,
			16, 54, 55, 56, 57, 58, 59, 28, 17, 15,
			16, 54, 55, 56, 57, 58, 59, 28, 17, 15,
			16, 54, 55, 56, 57, 58, 59, 28, 3, 14,
			14, 14, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 14, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 14, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 14, 3, 3, 3, 3, 14, 14, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 14, 14, 14, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 14, 14, 3, 3, 3,
			14, 3, 3, 3, 3, 14, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 21, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 19, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 31, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 32, 33, 34, 72, 73,
			74, 75, 76, 77, 21, 21, 21, 21, 21, 21,
			14, 3, 3, 3, 3, 3, 3, 3, 28, 60,
			61, 3, 3, 14, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 3, 3, 3,
			3, 3, 3, 3, 32, 33, 34, 72, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 32, 33,
			34, 72, 73, 74, 75, 76, 77, 28, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 28, 60, 61, 62, 63, 64, 65, 66,
			3, 101, 102, 103, 104, 105, 106, 107, 108, 109,
			61, 110, 111, 112, 113, 114, 3, 3, 3, 3,
			3, 3, 3, 14, 3, 14, 3, 3, 3, 3,
			3, 3, 3, 115, 116, 117, 118, 62, 119, 120,
			121, 122, 123, 124, 125, 126, 127, 63, 21, 21,
			21, 3, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 3, 3, 3, 3, 3, 3, 3, 3,
			32, 33, 34, 72, 73, 74, 75, 76, 77, 31,
			21, 21, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 21, 3,
			3, 3, 21, 3, 3, 3, 3, 21, 3, 3,
			3, 3, 3, 3, 3, 23, 23, 21, 21, 23,
			3, 3, 3, 3, 21, 3, 3, 3, 18, 19,
			20, 24, 25, 26, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 23, 23, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 23, 23, 23, 23, 23, 23,
			23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
			21, 21, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 21, 3, 3,
			3, 3, 3, 3, 21, 21, 21, 21, 21, 21,
			21, 21, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			51, 51, 51, 51, 51, 51, 51, 51, 51, 51,
			51, 51, 51, 3, 3, 3, 3, 3, 3, 21,
			23, 23, 21, 21, 21, 21, 23, 23, 21, 21,
			23, 23, 23, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 21, 21, 21, 21, 21, 21, 23,
			23, 21, 21, 23, 23, 21, 21, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 21, 23,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 3, 3, 3, 21, 3,
			21, 21, 21, 3, 3, 21, 21, 3, 3, 3,
			3, 3, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 23, 21, 21, 23, 23,
			3, 3, 3, 3, 3, 23, 21, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 23,
			23, 21, 23, 23, 21, 23, 23, 3, 23, 21,
			3, 3, 128, 129, 129, 129, 129, 129, 129, 129,
			129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
			129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
			128, 129, 129, 129, 129, 129, 129, 129, 129, 129,
			129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
			129, 129, 129, 129, 129, 129, 129, 129, 128, 129,
			129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
			128, 129, 129, 129, 129, 129, 129, 129, 129, 129,
			129, 129, 129, 129, 129, 129, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 52, 52,
			52, 52, 52, 52, 52, 3, 3, 3, 3, 53,
			53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
			53, 53, 53, 53, 53, 53, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 34, 3, 3, 3, 3, 3, 3, 3, 28,
			3, 3, 3, 3, 33, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 31, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 74,
			3, 74, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 28, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 3, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 32,
			33, 34, 72, 73, 74, 75, 76, 77, 28, 60,
			61, 62, 63, 64, 65, 66, 67, 29, 130, 131,
			132, 94, 133, 134, 135, 136, 30, 137, 138, 139,
			95, 140, 141, 142, 143, 68, 144, 145, 146, 96,
			147, 148, 149, 150, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 18, 19, 32, 73,
			63, 94, 95, 96, 73, 28, 63, 29, 94, 30,
			95, 73, 28, 63, 29, 94, 30, 68, 96, 28,
			32, 32, 32, 33, 33, 33, 33, 73, 28, 28,
			28, 28, 28, 61, 63, 63, 63, 63, 29, 131,
			94, 94, 94, 94, 94, 30, 95, 73, 63, 19,
			19, 83, 20, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			31, 18, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 21,
			3, 3, 21, 32, 33, 34, 72, 73, 74, 75,
			76, 77, 28, 60, 61, 62, 63, 64, 65, 66,
			67, 29, 130, 131, 132, 94, 133, 134, 135, 136,
			3, 3, 3, 3, 32, 73, 28, 63, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 67, 3, 3, 3, 3, 3, 3, 3, 3,
			136, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 21, 21, 21, 21, 3, 3, 3,
			3, 3, 3, 32, 33, 28, 60, 29, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 32, 33, 34, 28,
			60, 29, 30, 68, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 32, 33, 34, 72, 73, 28, 60,
			3, 3, 3, 3, 3, 3, 3, 32, 33, 34,
			72, 72, 73, 28, 60, 29, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 32, 73, 28,
			60, 29, 3, 3, 3, 3, 3, 3, 32, 28,
			60, 29, 33, 34, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			151, 19, 3, 3, 32, 33, 34, 72, 73, 74,
			75, 76, 77, 28, 60, 61, 62, 63, 64, 65,
			3, 3, 29, 130, 131, 132, 94, 133, 134, 135,
			136, 30, 137, 138, 139, 95, 140, 141, 142, 143,
			68, 144, 145, 146, 96, 147, 148, 149, 150, 97,
			152, 153, 154, 155, 156, 157, 158, 159, 160, 87,
			18, 82, 161, 19, 162, 83, 20, 88, 3, 21,
			21, 21, 3, 21, 21, 3, 3, 3, 3, 3,
			21, 21, 21, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 21, 21, 3, 3, 3, 3, 21,
			17, 15, 16, 54, 28, 60, 29, 30, 19, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 32,
			63, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 32, 28, 60, 3, 3,
			3, 3, 3, 21, 21, 3, 3, 3, 3, 32,
			73, 28, 60, 29, 3, 3, 3, 3, 3, 3,
			3, 3, 32, 33, 34, 72, 28, 60, 29, 30,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 32,
			33, 34, 72, 28, 60, 29, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 32, 73, 28, 63,
			29, 30, 3, 3, 3, 3, 21, 21, 21, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 17, 15,
			16, 54, 55, 56, 57, 58, 59, 28, 60, 61,
			62, 63, 64, 65, 66, 67, 29, 130, 131, 132,
			94, 133, 134, 135, 136, 19, 18, 82, 83, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 21, 21, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 32,
			33, 34, 72, 73, 28, 60, 61, 29, 19, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 21, 32,
			28, 60, 29, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 32,
			33, 34, 72, 28, 60, 29, 3, 3, 3, 3,
			23, 21, 23, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			17, 15, 16, 54, 55, 56, 57, 58, 59, 28,
			60, 61, 62, 63, 64, 65, 66, 67, 29, 30,
			4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
			23, 23, 23, 21, 21, 21, 21, 23, 23, 21,
			21, 3, 3, 22, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 22,
			3, 3, 21, 21, 21, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 21, 21, 21,
			23, 21, 21, 21, 21, 21, 21, 21, 21, 3,
			4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
			3, 3, 3, 3, 3, 23, 23, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 23, 23, 23, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 23, 23, 3,
			22, 22, 3, 3, 3, 3, 3, 21, 21, 21,
			21, 3, 23, 21, 3, 32, 33, 34, 72, 73,
			74, 75, 76, 77, 28, 60, 61, 62, 63, 64,
			65, 66, 67, 29, 30, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 23, 23,
			23, 21, 21, 21, 23, 23, 21, 23, 21, 21,
			3, 3, 3, 3, 3, 3, 21, 3, 23, 23,
			23, 21, 21, 21, 21, 21, 21, 21, 21, 3,
			3, 3, 3, 3, 21, 23, 23, 23, 23, 3,
			3, 23, 23, 3, 3, 23, 23, 23, 3, 3,
			3, 3, 23, 23, 3, 3, 21, 21, 21, 21,
			21, 21, 21, 3, 3, 3, 21, 21, 21, 21,
			21, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 23, 23, 23,
			21, 21, 21, 21, 21, 21, 21, 21, 23, 23,
			21, 21, 21, 23, 21, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 4, 5, 6, 7, 8, 9,
			10, 11, 12, 13, 3, 3, 3, 3, 21, 3,
			21, 23, 23, 21, 21, 21, 21, 21, 21, 23,
			21, 23, 23, 21, 23, 21, 21, 23, 21, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 23, 23, 21, 21, 21, 21, 3, 3,
			23, 23, 23, 23, 21, 21, 23, 21, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			21, 21, 3, 3, 23, 23, 23, 21, 21, 21,
			21, 21, 21, 21, 21, 23, 23, 21, 23, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 21, 23, 21, 23, 23, 21, 21, 21, 21,
			21, 21, 23, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 23, 23, 21, 21, 21, 21, 23, 21,
			21, 21, 21, 21, 3, 3, 3, 3, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 28, 60,
			3, 3, 3, 3, 21, 21, 21, 21, 21, 21,
			21, 21, 23, 21, 21, 3, 3, 3, 3, 3,
			4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
			28, 60, 61, 62, 63, 64, 65, 66, 67, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 21, 23, 23, 23, 23, 23, 3, 23,
			23, 3, 3, 21, 21, 23, 21, 22, 23, 22,
			23, 21, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 23, 23, 23, 21, 21,
			21, 21, 3, 3, 21, 21, 23, 23, 23, 23,
			21, 3, 3, 3, 23, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 3, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 21, 21, 21,
			21, 23, 22, 21, 21, 21, 21, 3, 3, 21,
			21, 21, 21, 21, 21, 23, 23, 21, 21, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 22, 22,
			22, 22, 22, 22, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 23, 21, 21,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 23, 21, 21, 21, 21, 21, 21, 21, 3,
			21, 21, 21, 21, 21, 21, 23, 21, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 32, 33,
			34, 72, 73, 74, 75, 76, 77, 28, 60, 61,
			62, 63, 64, 65, 66, 67, 29, 3, 3, 3,
			3, 3, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 3, 23, 21, 21, 21, 21,
			21, 21, 21, 23, 21, 21, 23, 21, 21, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 21,
			21, 21, 21, 21, 21, 3, 3, 3, 21, 3,
			21, 21, 3, 21, 21, 21, 21, 21, 21, 21,
			22, 21, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			23, 23, 23, 23, 23, 3, 21, 21, 3, 23,
			23, 21, 23, 21, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 21, 21, 23, 23, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 163, 35,
			164, 165, 36, 166, 37, 167, 38, 24, 24, 39,
			25, 40, 26, 41, 18, 19, 19, 20, 163, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			33, 34, 72, 73, 74, 75, 76, 77, 34, 72,
			73, 74, 75, 76, 77, 72, 73, 74, 75, 76,
			77, 32, 33, 34, 72, 73, 74, 75, 76, 77,
			32, 33, 34, 72, 73, 33, 34, 34, 72, 73,
			74, 75, 76, 77, 32, 33, 34, 34, 72, 73,
			168, 169, 32, 33, 34, 34, 72, 73, 34, 34,
			72, 72, 72, 72, 74, 75, 75, 75, 76, 76,
			77, 77, 77, 77, 33, 34, 72, 73, 74, 32,
			33, 34, 72, 72, 73, 73, 33, 34, 32, 33,
			82, 83, 88, 82, 83, 25, 18, 87, 18, 18,
			19, 82, 83, 62, 63, 72, 73, 74, 75, 76,
			77, 3, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 3, 3, 3, 3, 3, 3, 3, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 3, 28,
			29, 68, 170, 171, 172, 173, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			31, 32, 33, 34, 72, 73, 74, 75, 76, 77,
			28, 92, 93, 98, 99, 100, 27, 69, 70, 71,
			32, 33, 34, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 23, 23, 23, 23, 23, 23, 23,
			23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
			23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
			23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
			23, 23, 3, 3, 3, 3, 3, 3, 3, 21,
			3, 3, 3, 3, 21, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 21,
			21, 3, 0, 0, 0, 0, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 21, 23, 21, 21, 21, 3, 3,
			3, 23, 21, 21, 21, 21, 21, 0, 0, 0,
			0, 0, 0, 0, 0, 21, 21, 21, 21, 21,
			21, 21, 21, 3, 3, 21, 21, 21, 21, 21,
			21, 21, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 21, 21, 21, 21,
			3, 3, 27, 69, 70, 71, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 66, 67,
			32, 33, 34, 72, 73, 32, 73, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 4, 5,
			6, 7, 8, 9, 10, 11, 12, 13, 21, 21,
			21, 21, 21, 21, 21, 3, 3, 3, 3, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 3, 21, 21, 21, 21, 21, 21, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 3,
			3, 21, 21, 21, 21, 21, 21, 21, 3, 21,
			21, 3, 21, 21, 21, 21, 21, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 21, 21, 21, 21, 3, 3,
			3, 3, 21, 21, 21, 21, 21, 21, 21, 3,
			3, 3, 3, 3, 65, 66, 67, 29, 130, 131,
			132, 94, 133, 134, 135, 136, 30, 137, 138, 139,
			95, 140, 141, 142, 143, 68, 144, 145, 146, 96,
			147, 148, 149, 150, 97, 152, 97, 174, 175, 32,
			33, 34, 72, 73, 74, 75, 76, 77, 3, 18,
			19, 20, 3, 32, 33, 68, 97, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 95, 140,
			141, 142, 143, 68, 144, 145, 146, 96, 147, 148,
			149, 150, 3, 33, 34, 72, 73, 74, 75, 76,
			77, 28, 132, 133, 137, 68, 19, 87, 3, 3,
			79, 79, 17, 15, 16, 54, 55, 56, 57, 58,
			59, 31, 31, 14, 14, 14, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 14, 14,
			14, 14, 14, 14, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 14, 14, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 14, 3, 3, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 176, 176, 176, 176, 176, 176, 176, 176,
			176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
			176, 176, 176, 176, 176, 176, 176, 176, 3, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 14, 3, 3, 3, 3, 3,
			3, 3, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 3, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 21, 21, 21,
			21, 21, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 3, 3, 3, 3,
			3, 3, 3, 3, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 3, 3, 3, 3, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			3, 3, 3, 3, 3, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 3, 3, 3, 3,
			3, 3, 3, 3, 14, 14, 14, 14, 14, 14,
			14, 14, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 14, 14, 14, 14, 14, 14, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 3, 14, 14, 14, 14,
			77, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3
		};

		private static ReadOnlySpan<byte> DigitValues => new byte[177]
		{
			0, 0, 0, 0, 17, 34, 51, 68, 85, 102,
			119, 136, 153, 170, 0, 3, 4, 2, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 5, 6, 7, 8, 9, 10,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0
		};

		private static ReadOnlySpan<byte> NumericValues => new byte[1416]
		{
			0, 0, 0, 0, 0, 0, 240, 191, 0, 0,
			0, 0, 0, 0, 240, 191, 0, 0, 0, 0,
			0, 0, 240, 191, 0, 0, 0, 0, 0, 0,
			240, 191, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 240, 63, 0, 0,
			0, 0, 0, 0, 0, 64, 0, 0, 0, 0,
			0, 0, 8, 64, 0, 0, 0, 0, 0, 0,
			16, 64, 0, 0, 0, 0, 0, 0, 20, 64,
			0, 0, 0, 0, 0, 0, 24, 64, 0, 0,
			0, 0, 0, 0, 28, 64, 0, 0, 0, 0,
			0, 0, 32, 64, 0, 0, 0, 0, 0, 0,
			34, 64, 0, 0, 0, 0, 0, 0, 240, 191,
			0, 0, 0, 0, 0, 0, 0, 64, 0, 0,
			0, 0, 0, 0, 8, 64, 0, 0, 0, 0,
			0, 0, 240, 63, 0, 0, 0, 0, 0, 0,
			208, 63, 0, 0, 0, 0, 0, 0, 224, 63,
			0, 0, 0, 0, 0, 0, 232, 63, 0, 0,
			0, 0, 0, 0, 240, 191, 0, 0, 0, 0,
			0, 0, 240, 191, 0, 0, 0, 0, 0, 0,
			240, 191, 0, 0, 0, 0, 0, 0, 176, 63,
			0, 0, 0, 0, 0, 0, 192, 63, 0, 0,
			0, 0, 0, 0, 200, 63, 0, 0, 0, 0,
			0, 0, 48, 64, 0, 0, 0, 0, 0, 0,
			36, 64, 0, 0, 0, 0, 0, 0, 89, 64,
			0, 0, 0, 0, 0, 64, 143, 64, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 240, 63, 0, 0, 0, 0, 0, 0,
			0, 64, 0, 0, 0, 0, 0, 0, 8, 64,
			154, 153, 153, 153, 153, 153, 121, 63, 154, 153,
			153, 153, 153, 153, 153, 63, 51, 51, 51, 51,
			51, 51, 163, 63, 154, 153, 153, 153, 153, 153,
			169, 63, 154, 153, 153, 153, 153, 153, 185, 63,
			51, 51, 51, 51, 51, 51, 195, 63, 154, 153,
			153, 153, 153, 153, 201, 63, 0, 0, 0, 0,
			0, 0, 248, 63, 0, 0, 0, 0, 0, 0,
			4, 64, 0, 0, 0, 0, 0, 0, 12, 64,
			0, 0, 0, 0, 0, 0, 18, 64, 0, 0,
			0, 0, 0, 0, 22, 64, 0, 0, 0, 0,
			0, 0, 26, 64, 0, 0, 0, 0, 0, 0,
			30, 64, 0, 0, 0, 0, 0, 0, 33, 64,
			0, 0, 0, 0, 0, 0, 224, 191, 0, 0,
			0, 0, 0, 0, 240, 191, 0, 0, 0, 0,
			0, 0, 240, 191, 0, 0, 0, 0, 0, 0,
			240, 191, 0, 0, 0, 0, 0, 0, 16, 64,
			0, 0, 0, 0, 0, 0, 20, 64, 0, 0,
			0, 0, 0, 0, 24, 64, 0, 0, 0, 0,
			0, 0, 28, 64, 0, 0, 0, 0, 0, 0,
			32, 64, 0, 0, 0, 0, 0, 0, 34, 64,
			0, 0, 0, 0, 0, 0, 52, 64, 0, 0,
			0, 0, 0, 0, 62, 64, 0, 0, 0, 0,
			0, 0, 68, 64, 0, 0, 0, 0, 0, 0,
			73, 64, 0, 0, 0, 0, 0, 0, 78, 64,
			0, 0, 0, 0, 0, 128, 81, 64, 0, 0,
			0, 0, 0, 0, 84, 64, 0, 0, 0, 0,
			0, 128, 86, 64, 0, 0, 0, 0, 0, 136,
			195, 64, 0, 0, 0, 0, 0, 0, 49, 64,
			0, 0, 0, 0, 0, 0, 50, 64, 0, 0,
			0, 0, 0, 0, 51, 64, 0, 0, 0, 0,
			0, 0, 16, 64, 0, 0, 0, 0, 0, 0,
			20, 64, 0, 0, 0, 0, 0, 0, 24, 64,
			0, 0, 0, 0, 0, 0, 28, 64, 0, 0,
			0, 0, 0, 0, 32, 64, 0, 0, 0, 0,
			0, 0, 34, 64, 0, 0, 0, 0, 0, 0,
			240, 191, 0, 0, 0, 0, 0, 0, 0, 0,
			146, 36, 73, 146, 36, 73, 194, 63, 28, 199,
			113, 28, 199, 113, 188, 63, 85, 85, 85, 85,
			85, 85, 213, 63, 85, 85, 85, 85, 85, 85,
			229, 63, 154, 153, 153, 153, 153, 153, 217, 63,
			51, 51, 51, 51, 51, 51, 227, 63, 154, 153,
			153, 153, 153, 153, 233, 63, 85, 85, 85, 85,
			85, 85, 197, 63, 171, 170, 170, 170, 170, 170,
			234, 63, 0, 0, 0, 0, 0, 0, 216, 63,
			0, 0, 0, 0, 0, 0, 228, 63, 0, 0,
			0, 0, 0, 0, 236, 63, 0, 0, 0, 0,
			0, 0, 38, 64, 0, 0, 0, 0, 0, 0,
			40, 64, 0, 0, 0, 0, 0, 64, 127, 64,
			0, 0, 0, 0, 0, 136, 179, 64, 0, 0,
			0, 0, 0, 106, 232, 64, 0, 0, 0, 0,
			0, 106, 248, 64, 0, 0, 0, 0, 0, 0,
			42, 64, 0, 0, 0, 0, 0, 0, 44, 64,
			0, 0, 0, 0, 0, 0, 46, 64, 0, 0,
			0, 0, 0, 0, 53, 64, 0, 0, 0, 0,
			0, 0, 54, 64, 0, 0, 0, 0, 0, 0,
			55, 64, 0, 0, 0, 0, 0, 0, 56, 64,
			0, 0, 0, 0, 0, 0, 57, 64, 0, 0,
			0, 0, 0, 0, 58, 64, 0, 0, 0, 0,
			0, 0, 59, 64, 0, 0, 0, 0, 0, 0,
			60, 64, 0, 0, 0, 0, 0, 0, 61, 64,
			0, 0, 0, 0, 0, 0, 63, 64, 0, 0,
			0, 0, 0, 0, 64, 64, 0, 0, 0, 0,
			0, 128, 64, 64, 0, 0, 0, 0, 0, 0,
			65, 64, 0, 0, 0, 0, 0, 128, 65, 64,
			0, 0, 0, 0, 0, 0, 66, 64, 0, 0,
			0, 0, 0, 128, 66, 64, 0, 0, 0, 0,
			0, 0, 67, 64, 0, 0, 0, 0, 0, 128,
			67, 64, 0, 0, 0, 0, 0, 128, 68, 64,
			0, 0, 0, 0, 0, 0, 69, 64, 0, 0,
			0, 0, 0, 128, 69, 64, 0, 0, 0, 0,
			0, 0, 70, 64, 0, 0, 0, 0, 0, 128,
			70, 64, 0, 0, 0, 0, 0, 0, 71, 64,
			0, 0, 0, 0, 0, 128, 71, 64, 0, 0,
			0, 0, 0, 0, 72, 64, 0, 0, 0, 0,
			0, 128, 72, 64, 0, 0, 0, 0, 0, 0,
			240, 191, 0, 0, 0, 0, 0, 0, 240, 191,
			0, 0, 0, 0, 0, 0, 105, 64, 0, 0,
			0, 0, 0, 192, 114, 64, 0, 0, 0, 0,
			0, 0, 121, 64, 0, 0, 0, 0, 0, 192,
			130, 64, 0, 0, 0, 0, 0, 224, 133, 64,
			0, 0, 0, 0, 0, 0, 137, 64, 0, 0,
			0, 0, 0, 32, 140, 64, 0, 0, 0, 0,
			0, 64, 159, 64, 0, 0, 0, 0, 0, 112,
			167, 64, 0, 0, 0, 0, 0, 64, 175, 64,
			0, 0, 0, 0, 0, 112, 183, 64, 0, 0,
			0, 0, 0, 88, 187, 64, 0, 0, 0, 0,
			0, 64, 191, 64, 0, 0, 0, 0, 0, 148,
			193, 64, 0, 0, 0, 0, 0, 136, 211, 64,
			0, 0, 0, 0, 0, 76, 221, 64, 0, 0,
			0, 0, 0, 136, 227, 64, 0, 0, 0, 0,
			0, 76, 237, 64, 0, 0, 0, 0, 0, 23,
			241, 64, 0, 0, 0, 0, 0, 136, 243, 64,
			0, 0, 0, 0, 0, 249, 245, 64, 85, 85,
			85, 85, 85, 85, 237, 63, 0, 0, 0, 0,
			0, 106, 8, 65, 0, 0, 0, 0, 128, 79,
			18, 65, 0, 0, 0, 0, 0, 106, 24, 65,
			0, 0, 0, 0, 128, 132, 30, 65, 0, 0,
			0, 0, 128, 79, 34, 65, 0, 0, 0, 0,
			192, 92, 37, 65, 0, 0, 0, 0, 0, 106,
			40, 65, 0, 0, 0, 0, 64, 119, 43, 65,
			85, 85, 85, 85, 85, 85, 181, 63, 171, 170,
			170, 170, 170, 170, 218, 63, 171, 170, 170, 170,
			170, 170, 226, 63, 154, 153, 153, 153, 153, 153,
			105, 63, 154, 153, 153, 153, 153, 153, 137, 63,
			0, 0, 0, 0, 0, 0, 144, 63, 0, 0,
			0, 0, 0, 0, 160, 63, 0, 0, 0, 0,
			0, 0, 168, 63, 0, 0, 0, 0, 0, 94,
			10, 65, 0, 0, 0, 0, 0, 94, 26, 65,
			0, 0, 0, 0, 128, 132, 46, 65, 0, 0,
			0, 0, 132, 215, 151, 65, 0, 0, 0, 32,
			95, 160, 2, 66, 0, 0, 0, 162, 148, 26,
			109, 66, 0, 0, 0, 0, 208, 18, 99, 65,
			0, 0, 0, 0, 208, 18, 115, 65, 0, 0,
			0, 0, 0, 0, 240, 191
		};

		private static ReadOnlySpan<byte> GraphemeSegmentationValues => new byte[177]
		{
			3, 2, 1, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 14, 0, 0, 0, 0, 0,
			0, 4, 7, 8, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 9, 10, 11, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 5, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 12, 13,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 6
		};

		internal static StrongBidiCategory GetBidiCategory(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return GetBidiCategoryNoBoundsChecks((uint)GetCodePointFromString(s, index));
		}

		internal static StrongBidiCategory GetBidiCategory(StringBuilder s, int index)
		{
			int num = s[index];
			if (index < s.Length - 1)
			{
				int num2 = num - 55296;
				if ((uint)num2 <= 1023u)
				{
					int num3 = s[index + 1] - 56320;
					if ((uint)num3 <= 1023u)
					{
						num = (num2 << 10) + num3 + 65536;
					}
				}
			}
			return GetBidiCategoryNoBoundsChecks((uint)num);
		}

		private static StrongBidiCategory GetBidiCategoryNoBoundsChecks(uint codePoint)
		{
			nuint categoryCasingTableOffsetNoBoundsChecks = GetCategoryCasingTableOffsetNoBoundsChecks(codePoint);
			return (StrongBidiCategory)(Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoriesValues), categoryCasingTableOffsetNoBoundsChecks) & 0x60);
		}

		public static int GetDecimalDigitValue(char ch)
		{
			return GetDecimalDigitValueInternalNoBoundsCheck(ch);
		}

		public static int GetDecimalDigitValue(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return GetDecimalDigitValueInternalNoBoundsCheck((uint)GetCodePointFromString(s, index));
		}

		private static int GetDecimalDigitValueInternalNoBoundsCheck(uint codePoint)
		{
			nuint numericGraphemeTableOffsetNoBoundsChecks = GetNumericGraphemeTableOffsetNoBoundsChecks(codePoint);
			uint num = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(DigitValues), numericGraphemeTableOffsetNoBoundsChecks);
			return (int)((num >> 4) - 1);
		}

		public static int GetDigitValue(char ch)
		{
			return GetDigitValueInternalNoBoundsCheck(ch);
		}

		public static int GetDigitValue(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return GetDigitValueInternalNoBoundsCheck((uint)GetCodePointFromString(s, index));
		}

		private static int GetDigitValueInternalNoBoundsCheck(uint codePoint)
		{
			nuint numericGraphemeTableOffsetNoBoundsChecks = GetNumericGraphemeTableOffsetNoBoundsChecks(codePoint);
			int num = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(DigitValues), numericGraphemeTableOffsetNoBoundsChecks);
			return (num & 0xF) - 1;
		}

		internal static GraphemeClusterBreakType GetGraphemeClusterBreakType(Rune rune)
		{
			nuint numericGraphemeTableOffsetNoBoundsChecks = GetNumericGraphemeTableOffsetNoBoundsChecks((uint)rune.Value);
			return (GraphemeClusterBreakType)Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(GraphemeSegmentationValues), numericGraphemeTableOffsetNoBoundsChecks);
		}

		internal static bool GetIsWhiteSpace(char ch)
		{
			nuint categoryCasingTableOffsetNoBoundsChecks = GetCategoryCasingTableOffsetNoBoundsChecks(ch);
			return (sbyte)Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoriesValues), categoryCasingTableOffsetNoBoundsChecks) < 0;
		}

		public static double GetNumericValue(char ch)
		{
			return GetNumericValueNoBoundsCheck(ch);
		}

		internal static double GetNumericValue(int codePoint)
		{
			if (!UnicodeUtility.IsValidCodePoint((uint)codePoint))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.codePoint);
			}
			return GetNumericValueNoBoundsCheck((uint)codePoint);
		}

		public static double GetNumericValue(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return GetNumericValueInternal(s, index);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static double GetNumericValueInternal(string s, int index)
		{
			return GetNumericValueNoBoundsCheck((uint)GetCodePointFromString(s, index));
		}

		private static double GetNumericValueNoBoundsCheck(uint codePoint)
		{
			nuint numericGraphemeTableOffsetNoBoundsChecks = GetNumericGraphemeTableOffsetNoBoundsChecks(codePoint);
			ref byte source = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(NumericValues), numericGraphemeTableOffsetNoBoundsChecks * 8);
			_ = BitConverter.IsLittleEndian;
			return Unsafe.ReadUnaligned<double>(ref source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static char ToUpper(char codePoint)
		{
			nuint categoryCasingTableOffsetNoBoundsChecks = GetCategoryCasingTableOffsetNoBoundsChecks(codePoint);
			ref short reference = ref Unsafe.Add(ref Unsafe.As<byte, short>(ref MemoryMarshal.GetReference(UppercaseValues)), (nint)categoryCasingTableOffsetNoBoundsChecks);
			if (!BitConverter.IsLittleEndian)
			{
			}
			int num = reference;
			return (char)(num + codePoint);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ToUpper(uint codePoint)
		{
			if (!UnicodeUtility.IsValidCodePoint(codePoint))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.codePoint);
			}
			nuint categoryCasingTableOffsetNoBoundsChecks = GetCategoryCasingTableOffsetNoBoundsChecks(codePoint);
			ref short reference = ref Unsafe.Add(ref Unsafe.As<byte, short>(ref MemoryMarshal.GetReference(UppercaseValues)), (nint)categoryCasingTableOffsetNoBoundsChecks);
			if (!BitConverter.IsLittleEndian)
			{
			}
			int num = reference;
			return (uint)num + codePoint;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static char ToLower(char codePoint)
		{
			nuint categoryCasingTableOffsetNoBoundsChecks = GetCategoryCasingTableOffsetNoBoundsChecks(codePoint);
			ref short reference = ref Unsafe.Add(ref Unsafe.As<byte, short>(ref MemoryMarshal.GetReference(LowercaseValues)), (nint)categoryCasingTableOffsetNoBoundsChecks);
			if (!BitConverter.IsLittleEndian)
			{
			}
			int num = reference;
			return (char)(num + codePoint);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ToLower(uint codePoint)
		{
			if (!UnicodeUtility.IsValidCodePoint(codePoint))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.codePoint);
			}
			nuint categoryCasingTableOffsetNoBoundsChecks = GetCategoryCasingTableOffsetNoBoundsChecks(codePoint);
			ref short reference = ref Unsafe.Add(ref Unsafe.As<byte, short>(ref MemoryMarshal.GetReference(LowercaseValues)), (nint)categoryCasingTableOffsetNoBoundsChecks);
			if (!BitConverter.IsLittleEndian)
			{
			}
			int num = reference;
			return (uint)num + codePoint;
		}

		public static UnicodeCategory GetUnicodeCategory(char ch)
		{
			return GetUnicodeCategoryNoBoundsChecks(ch);
		}

		public static UnicodeCategory GetUnicodeCategory(int codePoint)
		{
			if (!UnicodeUtility.IsValidCodePoint((uint)codePoint))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.codePoint);
			}
			return GetUnicodeCategoryNoBoundsChecks((uint)codePoint);
		}

		public static UnicodeCategory GetUnicodeCategory(string s, int index)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			if ((uint)index >= (uint)s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return GetUnicodeCategoryInternal(s, index);
		}

		internal static UnicodeCategory GetUnicodeCategoryInternal(string value, int index)
		{
			return GetUnicodeCategoryNoBoundsChecks((uint)GetCodePointFromString(value, index));
		}

		internal static UnicodeCategory GetUnicodeCategoryInternal(string str, int index, out int charLength)
		{
			uint codePointFromString = (uint)GetCodePointFromString(str, index);
			charLength = ((codePointFromString < 65536) ? 1 : 2);
			return GetUnicodeCategoryNoBoundsChecks(codePointFromString);
		}

		private static UnicodeCategory GetUnicodeCategoryNoBoundsChecks(uint codePoint)
		{
			nuint categoryCasingTableOffsetNoBoundsChecks = GetCategoryCasingTableOffsetNoBoundsChecks(codePoint);
			return (UnicodeCategory)(Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoriesValues), categoryCasingTableOffsetNoBoundsChecks) & 0x1F);
		}

		private static int GetCodePointFromString(string s, int index)
		{
			int num = 0;
			if ((uint)index < (uint)s.Length)
			{
				num = s[index];
				int num2 = num - 55296;
				if ((uint)num2 <= 1023u)
				{
					index++;
					if ((uint)index < (uint)s.Length)
					{
						int num3 = s[index] - 56320;
						if ((uint)num3 <= 1023u)
						{
							num = (num2 << 10) + num3 + 65536;
						}
					}
				}
			}
			return num;
		}

		private static nuint GetCategoryCasingTableOffsetNoBoundsChecks(uint codePoint)
		{
			uint num = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoryCasingLevel1Index), codePoint >> 9);
			ref byte source = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoryCasingLevel2Index), (num << 6) + ((codePoint >> 3) & 0x3E));
			_ = BitConverter.IsLittleEndian;
			num = Unsafe.ReadUnaligned<ushort>(ref source);
			return Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoryCasingLevel3Index), (num << 4) + (codePoint & 0xF));
		}

		private static nuint GetNumericGraphemeTableOffsetNoBoundsChecks(uint codePoint)
		{
			uint num = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(NumericGraphemeLevel1Index), codePoint >> 9);
			ref byte source = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(NumericGraphemeLevel2Index), (num << 6) + ((codePoint >> 3) & 0x3E));
			_ = BitConverter.IsLittleEndian;
			num = Unsafe.ReadUnaligned<ushort>(ref source);
			return Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(NumericGraphemeLevel3Index), (num << 4) + (codePoint & 0xF));
		}
	}
	public class ChineseLunisolarCalendar : EastAsianLunisolarCalendar
	{
		public const int ChineseEra = 1;

		private static readonly DateTime s_minDate = new DateTime(1901, 2, 19);

		private static readonly DateTime s_maxDate = new DateTime(new DateTime(2101, 1, 28, 23, 59, 59, 999).Ticks + 9999);

		private static readonly int[,] s_yinfo = new int[200, 4]
		{
			{ 0, 2, 19, 19168 },
			{ 0, 2, 8, 42352 },
			{ 5, 1, 29, 21096 },
			{ 0, 2, 16, 53856 },
			{ 0, 2, 4, 55632 },
			{ 4, 1, 25, 27304 },
			{ 0, 2, 13, 22176 },
			{ 0, 2, 2, 39632 },
			{ 2, 1, 22, 19176 },
			{ 0, 2, 10, 19168 },
			{ 6, 1, 30, 42200 },
			{ 0, 2, 18, 42192 },
			{ 0, 2, 6, 53840 },
			{ 5, 1, 26, 54568 },
			{ 0, 2, 14, 46400 },
			{ 0, 2, 3, 54944 },
			{ 2, 1, 23, 38608 },
			{ 0, 2, 11, 38320 },
			{ 7, 2, 1, 18872 },
			{ 0, 2, 20, 18800 },
			{ 0, 2, 8, 42160 },
			{ 5, 1, 28, 45656 },
			{ 0, 2, 16, 27216 },
			{ 0, 2, 5, 27968 },
			{ 4, 1, 24, 44456 },
			{ 0, 2, 13, 11104 },
			{ 0, 2, 2, 38256 },
			{ 2, 1, 23, 18808 },
			{ 0, 2, 10, 18800 },
			{ 6, 1, 30, 25776 },
			{ 0, 2, 17, 54432 },
			{ 0, 2, 6, 59984 },
			{ 5, 1, 26, 27976 },
			{ 0, 2, 14, 23248 },
			{ 0, 2, 4, 11104 },
			{ 3, 1, 24, 37744 },
			{ 0, 2, 11, 37600 },
			{ 7, 1, 31, 51560 },
			{ 0, 2, 19, 51536 },
			{ 0, 2, 8, 54432 },
			{ 6, 1, 27, 55888 },
			{ 0, 2, 15, 46416 },
			{ 0, 2, 5, 22176 },
			{ 4, 1, 25, 43736 },
			{ 0, 2, 13, 9680 },
			{ 0, 2, 2, 37584 },
			{ 2, 1, 22, 51544 },
			{ 0, 2, 10, 43344 },
			{ 7, 1, 29, 46248 },
			{ 0, 2, 17, 27808 },
			{ 0, 2, 6, 46416 },
			{ 5, 1, 27, 21928 },
			{ 0, 2, 14, 19872 },
			{ 0, 2, 3, 42416 },
			{ 3, 1, 24, 21176 },
			{ 0, 2, 12, 21168 },
			{ 8, 1, 31, 43344 },
			{ 0, 2, 18, 59728 },
			{ 0, 2, 8, 27296 },
			{ 6, 1, 28, 44368 },
			{ 0, 2, 15, 43856 },
			{ 0, 2, 5, 19296 },
			{ 4, 1, 25, 42352 },
			{ 0, 2, 13, 42352 },
			{ 0, 2, 2, 21088 },
			{ 3, 1, 21, 59696 },
			{ 0, 2, 9, 55632 },
			{ 7, 1, 30, 23208 },
			{ 0, 2, 17, 22176 },
			{ 0, 2, 6, 38608 },
			{ 5, 1, 27, 19176 },
			{ 0, 2, 15, 19152 },
			{ 0, 2, 3, 42192 },
			{ 4, 1, 23, 53864 },
			{ 0, 2, 11, 53840 },
			{ 8, 1, 31, 54568 },
			{ 0, 2, 18, 46400 },
			{ 0, 2, 7, 46752 },
			{ 6, 1, 28, 38608 },
			{ 0, 2, 16, 38320 },
			{ 0, 2, 5, 18864 },
			{ 4, 1, 25, 42168 },
			{ 0, 2, 13, 42160 },
			{ 10, 2, 2, 45656 },
			{ 0, 2, 20, 27216 },
			{ 0, 2, 9, 27968 },
			{ 6, 1, 29, 44448 },
			{ 0, 2, 17, 43872 },
			{ 0, 2, 6, 38256 },
			{ 5, 1, 27, 18808 },
			{ 0, 2, 15, 18800 },
			{ 0, 2, 4, 25776 },
			{ 3, 1, 23, 27216 },
			{ 0, 2, 10, 59984 },
			{ 8, 1, 31, 27432 },
			{ 0, 2, 19, 23232 },
			{ 0, 2, 7, 43872 },
			{ 5, 1, 28, 37736 },
			{ 0, 2, 16, 37600 },
			{ 0, 2, 5, 51552 },
			{ 4, 1, 24, 54440 },
			{ 0, 2, 12, 54432 },
			{ 0, 2, 1, 55888 },
			{ 2, 1, 22, 23208 },
			{ 0, 2, 9, 22176 },
			{ 7, 1, 29, 43736 },
			{ 0, 2, 18, 9680 },
			{ 0, 2, 7, 37584 },
			{ 5, 1, 26, 51544 },
			{ 0, 2, 14, 43344 },
			{ 0, 2, 3, 46240 },
			{ 4, 1, 23, 46416 },
			{ 0, 2, 10, 44368 },
			{ 9, 1, 31, 21928 },
			{ 0, 2, 19, 19360 },
			{ 0, 2, 8, 42416 },
			{ 6, 1, 28, 21176 },
			{ 0, 2, 16, 21168 },
			{ 0, 2, 5, 43312 },
			{ 4, 1, 25, 29864 },
			{ 0, 2, 12, 27296 },
			{ 0, 2, 1, 44368 },
			{ 2, 1, 22, 19880 },
			{ 0, 2, 10, 19296 },
			{ 6, 1, 29, 42352 },
			{ 0, 2, 17, 42208 },
			{ 0, 2, 6, 53856 },
			{ 5, 1, 26, 59696 },
			{ 0, 2, 13, 54576 },
			{ 0, 2, 3, 23200 },
			{ 3, 1, 23, 27472 },
			{ 0, 2, 11, 38608 },
			{ 11, 1, 31, 19176 },
			{ 0, 2, 19, 19152 },
			{ 0, 2, 8, 42192 },
			{ 6, 1, 28, 53848 },
			{ 0, 2, 15, 53840 },
			{ 0, 2, 4, 54560 },
			{ 5, 1, 24, 55968 },
			{ 0, 2, 12, 46496 },
			{ 0, 2, 1, 22224 },
			{ 2, 1, 22, 19160 },
			{ 0, 2, 10, 18864 },
			{ 7, 1, 30, 42168 },
			{ 0, 2, 17, 42160 },
			{ 0, 2, 6, 43600 },
			{ 5, 1, 26, 46376 },
			{ 0, 2, 14, 27936 },
			{ 0, 2, 2, 44448 },
			{ 3, 1, 23, 21936 },
			{ 0, 2, 11, 37744 },
			{ 8, 2, 1, 18808 },
			{ 0, 2, 19, 18800 },
			{ 0, 2, 8, 25776 },
			{ 6, 1, 28, 27216 },
			{ 0, 2, 15, 59984 },
			{ 0, 2, 4, 27296 },
			{ 4, 1, 24, 43872 },
			{ 0, 2, 12, 43744 },
			{ 0, 2, 2, 37600 },
			{ 3, 1, 21, 51568 },
			{ 0, 2, 9, 51552 },
			{ 7, 1, 29, 54440 },
			{ 0, 2, 17, 54432 },
			{ 0, 2, 5, 55888 },
			{ 5, 1, 26, 23208 },
			{ 0, 2, 14, 22176 },
			{ 0, 2, 3, 42704 },
			{ 4, 1, 23, 21224 },
			{ 0, 2, 11, 21200 },
			{ 8, 1, 31, 43352 },
			{ 0, 2, 19, 43344 },
			{ 0, 2, 7, 46240 },
			{ 6, 1, 27, 46416 },
			{ 0, 2, 15, 44368 },
			{ 0, 2, 5, 21920 },
			{ 4, 1, 24, 42448 },
			{ 0, 2, 12, 42416 },
			{ 0, 2, 2, 21168 },
			{ 3, 1, 22, 43320 },
			{ 0, 2, 9, 26928 },
			{ 7, 1, 29, 29336 },
			{ 0, 2, 17, 27296 },
			{ 0, 2, 6, 44368 },
			{ 5, 1, 26, 19880 },
			{ 0, 2, 14, 19296 },
			{ 0, 2, 3, 42352 },
			{ 4, 1, 24, 21104 },
			{ 0, 2, 10, 53600 },
			{ 8, 1, 30, 59696 },
			{ 0, 2, 18, 54560 },
			{ 0, 2, 7, 55968 },
			{ 6, 1, 27, 27472 },
			{ 0, 2, 15, 22224 },
			{ 0, 2, 5, 19168 },
			{ 4, 1, 25, 42216 },
			{ 0, 2, 12, 41680 },
			{ 0, 2, 1, 53584 },
			{ 2, 1, 21, 55592 },
			{ 0, 2, 9, 54560 }
		};

		public override DateTime MinSupportedDateTime => s_minDate;

		public override DateTime MaxSupportedDateTime => s_maxDate;

		protected override int DaysInYearBeforeMinSupportedYear => 384;

		internal override int MinCalendarYear => 1901;

		internal override int MaxCalendarYear => 2100;

		internal override DateTime MinDate => s_minDate;

		internal override DateTime MaxDate => s_maxDate;

		internal override EraInfo[]? CalEraInfo => null;

		internal override CalendarId ID => CalendarId.CHINESELUNISOLAR;

		internal override CalendarId BaseCalendarID => CalendarId.GREGORIAN;

		public override int[] Eras => new int[1] { 1 };

		internal override int GetYearInfo(int lunarYear, int index)
		{
			if (lunarYear < 1901 || lunarYear > 2100)
			{
				throw new ArgumentOutOfRangeException("year", lunarYear, SR.Format(SR.ArgumentOutOfRange_Range, 1901, 2100));
			}
			return s_yinfo[lunarYear - 1901, index];
		}

		internal override int GetYear(int year, DateTime time)
		{
			return year;
		}

		internal override int GetGregorianYear(int year, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			if (year < 1901 || year > 2100)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1901, 2100));
			}
			return year;
		}

		public override int GetEra(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			return 1;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class CompareInfo : IDeserializationCallback
	{
		private static class SortHandleCache
		{
			private static readonly Dictionary<string, IntPtr> s_sortNameToSortHandleCache = new Dictionary<string, IntPtr>();

			internal static IntPtr GetCachedSortHandle(string sortName)
			{
				lock (s_sortNameToSortHandleCache)
				{
					if (!s_sortNameToSortHandleCache.TryGetValue(sortName, out var value))
					{
						switch (Interop.Globalization.GetSortHandle(sortName, out value))
						{
						case Interop.Globalization.ResultCode.OutOfMemory:
							throw new OutOfMemoryException();
						default:
							throw new ExternalException(SR.Arg_ExternalException);
						case Interop.Globalization.ResultCode.Success:
							break;
						}
						try
						{
							s_sortNameToSortHandleCache.Add(sortName, value);
						}
						catch
						{
							Interop.Globalization.CloseSortHandle(value);
							throw;
						}
					}
					return value;
				}
			}
		}

		internal static readonly CompareInfo Invariant = CultureInfo.InvariantCulture.CompareInfo;

		[OptionalField(VersionAdded = 2)]
		private string m_name;

		[NonSerialized]
		private IntPtr _sortHandle;

		[NonSerialized]
		private string _sortName;

		[OptionalField(VersionAdded = 3)]
		private SortVersion m_SortVersion;

		private int culture;

		[NonSerialized]
		private bool _isAsciiEqualityOrdinal;

		public string Name
		{
			get
			{
				if (m_name == "zh-CHT" || m_name == "zh-CHS")
				{
					return m_name;
				}
				return _sortName;
			}
		}

		public SortVersion Version
		{
			get
			{
				if (m_SortVersion == null)
				{
					if (GlobalizationMode.Invariant)
					{
						m_SortVersion = new SortVersion(0, 127, new Guid(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127));
					}
					else
					{
						m_SortVersion = (GlobalizationMode.UseNls ? NlsGetSortVersion() : IcuGetSortVersion());
					}
				}
				return m_SortVersion;
			}
		}

		public int LCID => CultureInfo.GetCultureInfo(Name).LCID;

		private static ReadOnlySpan<bool> HighCharTable => new bool[128]
		{
			true, true, true, true, true, true, true, true, true, false,
			true, false, false, true, true, true, true, true, true, true,
			true, true, true, true, true, true, true, true, true, true,
			true, true, false, false, false, false, false, false, false, true,
			false, false, false, false, false, true, false, false, false, false,
			false, false, false, false, false, false, false, false, false, false,
			false, false, false, false, false, false, false, false, false, false,
			false, false, false, false, false, false, false, false, false, false,
			false, false, false, false, false, false, false, false, false, false,
			false, false, false, false, false, false, false, false, false, false,
			false, false, false, false, false, false, false, false, false, false,
			false, false, false, false, false, false, false, false, false, false,
			false, false, false, false, false, false, false, true
		};

		internal CompareInfo(CultureInfo culture)
		{
			m_name = culture._name;
			InitSort(culture);
		}

		public static CompareInfo GetCompareInfo(int culture, Assembly assembly)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			if (assembly != typeof(object).Module.Assembly)
			{
				throw new ArgumentException(SR.Argument_OnlyMscorlib, "assembly");
			}
			return GetCompareInfo(culture);
		}

		public static CompareInfo GetCompareInfo(string name, Assembly assembly)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			if (assembly != typeof(object).Module.Assembly)
			{
				throw new ArgumentException(SR.Argument_OnlyMscorlib, "assembly");
			}
			return GetCompareInfo(name);
		}

		public static CompareInfo GetCompareInfo(int culture)
		{
			if (CultureData.IsCustomCultureId(culture))
			{
				throw new ArgumentException(SR.Argument_CustomCultureCannotBePassedByNumber, "culture");
			}
			return CultureInfo.GetCultureInfo(culture).CompareInfo;
		}

		public static CompareInfo GetCompareInfo(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			return CultureInfo.GetCultureInfo(name).CompareInfo;
		}

		public static bool IsSortable(char ch)
		{
			return IsSortable(MemoryMarshal.CreateReadOnlySpan(ref ch, 1));
		}

		public static bool IsSortable(string text)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			return IsSortable(text.AsSpan());
		}

		public static bool IsSortable(ReadOnlySpan<char> text)
		{
			if (text.Length == 0)
			{
				return false;
			}
			if (GlobalizationMode.Invariant)
			{
				return true;
			}
			if (!GlobalizationMode.UseNls)
			{
				return IcuIsSortable(text);
			}
			return NlsIsSortable(text);
		}

		public static bool IsSortable(Rune value)
		{
			Span<char> destination = stackalloc char[2];
			return IsSortable(destination[..value.EncodeToUtf16(destination)]);
		}

		[MemberNotNull("_sortName")]
		private void InitSort(CultureInfo culture)
		{
			_sortName = culture.SortName;
			if (GlobalizationMode.UseNls)
			{
				NlsInitSortHandle();
			}
			else
			{
				IcuInitSortHandle();
			}
		}

		[OnDeserializing]
		private void OnDeserializing(StreamingContext ctx)
		{
			m_name = null;
		}

		void IDeserializationCallback.OnDeserialization(object sender)
		{
			OnDeserialized();
		}

		[OnDeserialized]
		private void OnDeserialized(StreamingContext ctx)
		{
			OnDeserialized();
		}

		private void OnDeserialized()
		{
			if (m_name == null)
			{
				m_name = CultureInfo.GetCultureInfo(culture)._name;
			}
			else
			{
				InitSort(CultureInfo.GetCultureInfo(m_name));
			}
		}

		[OnSerializing]
		private void OnSerializing(StreamingContext ctx)
		{
			culture = CultureInfo.GetCultureInfo(Name).LCID;
		}

		public int Compare(string? string1, string? string2)
		{
			return Compare(string1, string2, CompareOptions.None);
		}

		public int Compare(string? string1, string? string2, CompareOptions options)
		{
			int result;
			if (string1 == null)
			{
				result = ((string2 != null) ? (-1) : 0);
			}
			else
			{
				if (string2 != null)
				{
					return Compare(string1.AsSpan(), string2.AsSpan(), options);
				}
				result = 1;
			}
			CheckCompareOptionsForCompare(options);
			return result;
		}

		internal int CompareOptionIgnoreCase(ReadOnlySpan<char> string1, ReadOnlySpan<char> string2)
		{
			if (!GlobalizationMode.Invariant)
			{
				return CompareStringCore(string1, string2, CompareOptions.IgnoreCase);
			}
			return InvariantModeCasing.CompareStringIgnoreCase(ref MemoryMarshal.GetReference(string1), string1.Length, ref MemoryMarshal.GetReference(string2), string2.Length);
		}

		public int Compare(string? string1, int offset1, int length1, string? string2, int offset2, int length2)
		{
			return Compare(string1, offset1, length1, string2, offset2, length2, CompareOptions.None);
		}

		public int Compare(string? string1, int offset1, string? string2, int offset2, CompareOptions options)
		{
			return Compare(string1, offset1, (string1 != null) ? (string1.Length - offset1) : 0, string2, offset2, (string2 != null) ? (string2.Length - offset2) : 0, options);
		}

		public int Compare(string? string1, int offset1, string? string2, int offset2)
		{
			return Compare(string1, offset1, string2, offset2, CompareOptions.None);
		}

		public int Compare(string? string1, int offset1, int length1, string? string2, int offset2, int length2, CompareOptions options)
		{
			ReadOnlySpan<char> slice = default(ReadOnlySpan<char>);
			ReadOnlySpan<char> slice2 = default(ReadOnlySpan<char>);
			if (string1 == null)
			{
				if (offset1 == 0 && length1 == 0)
				{
					goto IL_0027;
				}
			}
			else if (string1.TryGetSpan(offset1, length1, out slice))
			{
				goto IL_0027;
			}
			goto IL_006e;
			IL_0027:
			if (string2 == null)
			{
				if (offset2 == 0 && length2 == 0)
				{
					goto IL_0044;
				}
			}
			else if (string2.TryGetSpan(offset2, length2, out slice2))
			{
				goto IL_0044;
			}
			goto IL_006e;
			IL_006e:
			if (length1 < 0 || length2 < 0)
			{
				throw new ArgumentOutOfRangeException((length1 < 0) ? "length1" : "length2", SR.ArgumentOutOfRange_NeedPosNum);
			}
			if (offset1 < 0 || offset2 < 0)
			{
				throw new ArgumentOutOfRangeException((offset1 < 0) ? "offset1" : "offset2", SR.ArgumentOutOfRange_NeedPosNum);
			}
			if (offset1 > (string1?.Length ?? 0) - length1)
			{
				throw new ArgumentOutOfRangeException("string1", SR.ArgumentOutOfRange_OffsetLength);
			}
			throw new ArgumentOutOfRangeException("string2", SR.ArgumentOutOfRange_OffsetLength);
			IL_0044:
			int result;
			if (string1 == null)
			{
				result = ((string2 != null) ? (-1) : 0);
			}
			else
			{
				if (string2 != null)
				{
					return Compare(slice, slice2, options);
				}
				result = 1;
			}
			CheckCompareOptionsForCompare(options);
			return result;
		}

		public int Compare(ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, CompareOptions options = CompareOptions.None)
		{
			if (string1 == string2)
			{
				CheckCompareOptionsForCompare(options);
				return 0;
			}
			if ((options & ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth | CompareOptions.StringSort)) == 0)
			{
				if (!GlobalizationMode.Invariant)
				{
					return CompareStringCore(string1, string2, options);
				}
				if ((options & CompareOptions.IgnoreCase) == 0)
				{
					return string1.SequenceCompareTo(string2);
				}
				return Ordinal.CompareStringIgnoreCase(ref MemoryMarshal.GetReference(string1), string1.Length, ref MemoryMarshal.GetReference(string2), string2.Length);
			}
			switch (options)
			{
			case CompareOptions.Ordinal:
				return string1.SequenceCompareTo(string2);
			case CompareOptions.OrdinalIgnoreCase:
				return Ordinal.CompareStringIgnoreCase(ref MemoryMarshal.GetReference(string1), string1.Length, ref MemoryMarshal.GetReference(string2), string2.Length);
			default:
				ThrowCompareOptionsCheckFailed(options);
				return -1;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[StackTraceHidden]
		private static void CheckCompareOptionsForCompare(CompareOptions options)
		{
			if (((uint)options & 0xDFFFFFE0u) != 0 && options != CompareOptions.Ordinal && options != CompareOptions.OrdinalIgnoreCase)
			{
				ThrowCompareOptionsCheckFailed(options);
			}
		}

		[DoesNotReturn]
		[StackTraceHidden]
		private static void ThrowCompareOptionsCheckFailed(CompareOptions options)
		{
			throw new ArgumentException(((options & CompareOptions.Ordinal) != 0) ? SR.Argument_CompareOptionOrdinal : SR.Argument_InvalidFlag, "options");
		}

		private int CompareStringCore(ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, CompareOptions options)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuCompareString(string1, string2, options);
			}
			return NlsCompareString(string1, string2, options);
		}

		public bool IsPrefix(string source, string prefix, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			if (prefix == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.prefix);
			}
			return IsPrefix(source.AsSpan(), prefix.AsSpan(), options);
		}

		public unsafe bool IsPrefix(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options = CompareOptions.None)
		{
			if (prefix.IsEmpty)
			{
				return true;
			}
			if ((options & ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth)) == 0)
			{
				if (!GlobalizationMode.Invariant)
				{
					return StartsWithCore(source, prefix, options, null);
				}
				if ((options & CompareOptions.IgnoreCase) == 0)
				{
					return source.StartsWith(prefix);
				}
				return source.StartsWithOrdinalIgnoreCase(prefix);
			}
			switch (options)
			{
			case CompareOptions.Ordinal:
				return source.StartsWith(prefix);
			case CompareOptions.OrdinalIgnoreCase:
				return source.StartsWithOrdinalIgnoreCase(prefix);
			default:
				ThrowCompareOptionsCheckFailed(options);
				return false;
			}
		}

		public unsafe bool IsPrefix(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options, out int matchLength)
		{
			bool flag;
			if (GlobalizationMode.Invariant || prefix.IsEmpty || ((uint)options & 0xFFFFFFE0u) != 0)
			{
				flag = IsPrefix(source, prefix, options);
				matchLength = (flag ? prefix.Length : 0);
			}
			else
			{
				int num = 0;
				flag = StartsWithCore(source, prefix, options, &num);
				matchLength = num;
			}
			return flag;
		}

		private unsafe bool StartsWithCore(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options, int* matchLengthPtr)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuStartsWith(source, prefix, options, matchLengthPtr);
			}
			return NlsStartsWith(source, prefix, options, matchLengthPtr);
		}

		public bool IsPrefix(string source, string prefix)
		{
			return IsPrefix(source, prefix, CompareOptions.None);
		}

		public bool IsSuffix(string source, string suffix, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			if (suffix == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.suffix);
			}
			return IsSuffix(source.AsSpan(), suffix.AsSpan(), options);
		}

		public unsafe bool IsSuffix(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options = CompareOptions.None)
		{
			if (suffix.IsEmpty)
			{
				return true;
			}
			if ((options & ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth)) == 0)
			{
				if (!GlobalizationMode.Invariant)
				{
					return EndsWithCore(source, suffix, options, null);
				}
				if ((options & CompareOptions.IgnoreCase) == 0)
				{
					return source.EndsWith(suffix);
				}
				return source.EndsWithOrdinalIgnoreCase(suffix);
			}
			switch (options)
			{
			case CompareOptions.Ordinal:
				return source.EndsWith(suffix);
			case CompareOptions.OrdinalIgnoreCase:
				return source.EndsWithOrdinalIgnoreCase(suffix);
			default:
				ThrowCompareOptionsCheckFailed(options);
				return false;
			}
		}

		public unsafe bool IsSuffix(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options, out int matchLength)
		{
			bool flag;
			if (GlobalizationMode.Invariant || suffix.IsEmpty || ((uint)options & 0xFFFFFFE0u) != 0)
			{
				flag = IsSuffix(source, suffix, options);
				matchLength = (flag ? suffix.Length : 0);
			}
			else
			{
				int num = 0;
				flag = EndsWithCore(source, suffix, options, &num);
				matchLength = num;
			}
			return flag;
		}

		public bool IsSuffix(string source, string suffix)
		{
			return IsSuffix(source, suffix, CompareOptions.None);
		}

		private unsafe bool EndsWithCore(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options, int* matchLengthPtr)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuEndsWith(source, suffix, options, matchLengthPtr);
			}
			return NlsEndsWith(source, suffix, options, matchLengthPtr);
		}

		public int IndexOf(string source, char value)
		{
			return IndexOf(source, value, CompareOptions.None);
		}

		public int IndexOf(string source, string value)
		{
			return IndexOf(source, value, CompareOptions.None);
		}

		public int IndexOf(string source, char value, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			return IndexOf(source, MemoryMarshal.CreateReadOnlySpan(ref value, 1), options);
		}

		public int IndexOf(string source, string value, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			return IndexOf(source.AsSpan(), value.AsSpan(), options);
		}

		public int IndexOf(string source, char value, int startIndex)
		{
			return IndexOf(source, value, startIndex, CompareOptions.None);
		}

		public int IndexOf(string source, string value, int startIndex)
		{
			return IndexOf(source, value, startIndex, CompareOptions.None);
		}

		public int IndexOf(string source, char value, int startIndex, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			return IndexOf(source, value, startIndex, source.Length - startIndex, options);
		}

		public int IndexOf(string source, string value, int startIndex, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			return IndexOf(source, value, startIndex, source.Length - startIndex, options);
		}

		public int IndexOf(string source, char value, int startIndex, int count)
		{
			return IndexOf(source, value, startIndex, count, CompareOptions.None);
		}

		public int IndexOf(string source, string value, int startIndex, int count)
		{
			return IndexOf(source, value, startIndex, count, CompareOptions.None);
		}

		public int IndexOf(string source, char value, int startIndex, int count, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			if (!source.TryGetSpan(startIndex, count, out var slice))
			{
				if ((uint)startIndex > (uint)source.Length)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
				}
				else
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_Count);
				}
			}
			int num = IndexOf(slice, MemoryMarshal.CreateReadOnlySpan(ref value, 1), options);
			if (num >= 0)
			{
				num += startIndex;
			}
			return num;
		}

		public int IndexOf(string source, string value, int startIndex, int count, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			if (!source.TryGetSpan(startIndex, count, out var slice))
			{
				if ((uint)startIndex > (uint)source.Length)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
				}
				else
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_Count);
				}
			}
			int num = IndexOf(slice, value, options);
			if (num >= 0)
			{
				num += startIndex;
			}
			return num;
		}

		public unsafe int IndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value, CompareOptions options = CompareOptions.None)
		{
			if ((options & ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth)) == 0)
			{
				if (!GlobalizationMode.Invariant)
				{
					if (value.IsEmpty)
					{
						return 0;
					}
					return IndexOfCore(source, value, options, null, fromBeginning: true);
				}
				if ((options & CompareOptions.IgnoreCase) == 0)
				{
					return source.IndexOf(value);
				}
				return Ordinal.IndexOfOrdinalIgnoreCase(source, value);
			}
			switch (options)
			{
			case CompareOptions.Ordinal:
				return source.IndexOf(value);
			case CompareOptions.OrdinalIgnoreCase:
				return Ordinal.IndexOfOrdinalIgnoreCase(source, value);
			default:
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidFlag, ExceptionArgument.options);
				return -1;
			}
		}

		public unsafe int IndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value, CompareOptions options, out int matchLength)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out int num);
			int result = IndexOf(source, value, &num, options, fromBeginning: true);
			matchLength = num;
			return result;
		}

		public int IndexOf(ReadOnlySpan<char> source, Rune value, CompareOptions options = CompareOptions.None)
		{
			Span<char> destination = stackalloc char[2];
			return IndexOf(source, destination[..value.EncodeToUtf16(destination)], options);
		}

		private unsafe int IndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value, int* matchLengthPtr, CompareOptions options, bool fromBeginning)
		{
			*matchLengthPtr = 0;
			int num = 0;
			if ((options & ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth)) == 0)
			{
				if (!GlobalizationMode.Invariant)
				{
					if (value.IsEmpty)
					{
						if (!fromBeginning)
						{
							return source.Length;
						}
						return 0;
					}
					return IndexOfCore(source, value, options, matchLengthPtr, fromBeginning);
				}
				num = (((options & CompareOptions.IgnoreCase) != 0) ? (fromBeginning ? Ordinal.IndexOfOrdinalIgnoreCase(source, value) : Ordinal.LastIndexOfOrdinalIgnoreCase(source, value)) : (fromBeginning ? source.IndexOf(value) : source.LastIndexOf(value)));
			}
			else
			{
				switch (options)
				{
				case CompareOptions.Ordinal:
					num = (fromBeginning ? source.IndexOf(value) : source.LastIndexOf(value));
					break;
				case CompareOptions.OrdinalIgnoreCase:
					num = (fromBeginning ? Ordinal.IndexOfOrdinalIgnoreCase(source, value) : Ordinal.LastIndexOfOrdinalIgnoreCase(source, value));
					break;
				default:
					ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidFlag, ExceptionArgument.options);
					break;
				}
			}
			if (num >= 0)
			{
				*matchLengthPtr = value.Length;
			}
			return num;
		}

		private unsafe int IndexOfCore(ReadOnlySpan<char> source, ReadOnlySpan<char> target, CompareOptions options, int* matchLengthPtr, bool fromBeginning)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuIndexOfCore(source, target, options, matchLengthPtr, fromBeginning);
			}
			return NlsIndexOfCore(source, target, options, matchLengthPtr, fromBeginning);
		}

		public int LastIndexOf(string source, char value)
		{
			return LastIndexOf(source, value, CompareOptions.None);
		}

		public int LastIndexOf(string source, string value)
		{
			return LastIndexOf(source, value, CompareOptions.None);
		}

		public int LastIndexOf(string source, char value, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			return LastIndexOf(source, MemoryMarshal.CreateReadOnlySpan(ref value, 1), options);
		}

		public int LastIndexOf(string source, string value, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			return LastIndexOf(source.AsSpan(), value.AsSpan(), options);
		}

		public int LastIndexOf(string source, char value, int startIndex)
		{
			return LastIndexOf(source, value, startIndex, startIndex + 1, CompareOptions.None);
		}

		public int LastIndexOf(string source, string value, int startIndex)
		{
			return LastIndexOf(source, value, startIndex, startIndex + 1, CompareOptions.None);
		}

		public int LastIndexOf(string source, char value, int startIndex, CompareOptions options)
		{
			return LastIndexOf(source, value, startIndex, startIndex + 1, options);
		}

		public int LastIndexOf(string source, string value, int startIndex, CompareOptions options)
		{
			return LastIndexOf(source, value, startIndex, startIndex + 1, options);
		}

		public int LastIndexOf(string source, char value, int startIndex, int count)
		{
			return LastIndexOf(source, value, startIndex, count, CompareOptions.None);
		}

		public int LastIndexOf(string source, string value, int startIndex, int count)
		{
			return LastIndexOf(source, value, startIndex, count, CompareOptions.None);
		}

		public int LastIndexOf(string source, char value, int startIndex, int count, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			while ((uint)startIndex >= (uint)source.Length)
			{
				if (startIndex == -1 && source.Length == 0)
				{
					count = 0;
					break;
				}
				if (startIndex == source.Length)
				{
					startIndex--;
					if (count > 0)
					{
						count--;
					}
					continue;
				}
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
				break;
			}
			startIndex = startIndex - count + 1;
			if (!source.TryGetSpan(startIndex, count, out var slice))
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			int num = LastIndexOf(slice, MemoryMarshal.CreateReadOnlySpan(ref value, 1), options);
			if (num >= 0)
			{
				num += startIndex;
			}
			return num;
		}

		public int LastIndexOf(string source, string value, int startIndex, int count, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			while ((uint)startIndex >= (uint)source.Length)
			{
				if (startIndex == -1 && source.Length == 0)
				{
					count = 0;
					break;
				}
				if (startIndex == source.Length)
				{
					startIndex--;
					if (count > 0)
					{
						count--;
					}
					continue;
				}
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
				break;
			}
			startIndex = startIndex - count + 1;
			if (!source.TryGetSpan(startIndex, count, out var slice))
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			int num = LastIndexOf(slice, value, options);
			if (num >= 0)
			{
				num += startIndex;
			}
			return num;
		}

		public unsafe int LastIndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value, CompareOptions options = CompareOptions.None)
		{
			if ((options & ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth)) == 0)
			{
				if (!GlobalizationMode.Invariant)
				{
					if (value.IsEmpty)
					{
						return source.Length;
					}
					return IndexOfCore(source, value, options, null, fromBeginning: false);
				}
				if ((options & CompareOptions.IgnoreCase) == 0)
				{
					return source.LastIndexOf(value);
				}
				return Ordinal.LastIndexOfOrdinalIgnoreCase(source, value);
			}
			return options switch
			{
				CompareOptions.Ordinal => source.LastIndexOf(value), 
				CompareOptions.OrdinalIgnoreCase => Ordinal.LastIndexOfOrdinalIgnoreCase(source, value), 
				_ => throw new ArgumentException(SR.Argument_InvalidFlag, "options"), 
			};
		}

		public unsafe int LastIndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value, CompareOptions options, out int matchLength)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out int num);
			int result = IndexOf(source, value, &num, options, fromBeginning: false);
			matchLength = num;
			return result;
		}

		public int LastIndexOf(ReadOnlySpan<char> source, Rune value, CompareOptions options = CompareOptions.None)
		{
			Span<char> destination = stackalloc char[2];
			return LastIndexOf(source, destination[..value.EncodeToUtf16(destination)], options);
		}

		public SortKey GetSortKey(string source, CompareOptions options)
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantCreateSortKey(source, options);
			}
			return CreateSortKeyCore(source, options);
		}

		public SortKey GetSortKey(string source)
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantCreateSortKey(source, CompareOptions.None);
			}
			return CreateSortKeyCore(source, CompareOptions.None);
		}

		private SortKey CreateSortKeyCore(string source, CompareOptions options)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuCreateSortKey(source, options);
			}
			return NlsCreateSortKey(source, options);
		}

		public int GetSortKey(ReadOnlySpan<char> source, Span<byte> destination, CompareOptions options = CompareOptions.None)
		{
			if (((uint)options & 0xDFFFFFE0u) != 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidFlag, ExceptionArgument.options);
			}
			if (GlobalizationMode.Invariant)
			{
				return InvariantGetSortKey(source, destination, options);
			}
			return GetSortKeyCore(source, destination, options);
		}

		private int GetSortKeyCore(ReadOnlySpan<char> source, Span<byte> destination, CompareOptions options)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuGetSortKey(source, destination, options);
			}
			return NlsGetSortKey(source, destination, options);
		}

		public int GetSortKeyLength(ReadOnlySpan<char> source, CompareOptions options = CompareOptions.None)
		{
			if (((uint)options & 0xDFFFFFE0u) != 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidFlag, ExceptionArgument.options);
			}
			if (GlobalizationMode.Invariant)
			{
				return InvariantGetSortKeyLength(source, options);
			}
			return GetSortKeyLengthCore(source, options);
		}

		private int GetSortKeyLengthCore(ReadOnlySpan<char> source, CompareOptions options)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuGetSortKeyLength(source, options);
			}
			return NlsGetSortKeyLength(source, options);
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is CompareInfo compareInfo)
			{
				return Name == compareInfo.Name;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Name.GetHashCode();
		}

		public int GetHashCode(string source, CompareOptions options)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			return GetHashCode(source.AsSpan(), options);
		}

		public int GetHashCode(ReadOnlySpan<char> source, CompareOptions options)
		{
			if ((options & ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth | CompareOptions.StringSort)) == 0)
			{
				if (!GlobalizationMode.Invariant)
				{
					return GetHashCodeOfStringCore(source, options);
				}
				if ((options & CompareOptions.IgnoreCase) == 0)
				{
					return string.GetHashCode(source);
				}
				return string.GetHashCodeOrdinalIgnoreCase(source);
			}
			switch (options)
			{
			case CompareOptions.Ordinal:
				return string.GetHashCode(source);
			case CompareOptions.OrdinalIgnoreCase:
				return string.GetHashCodeOrdinalIgnoreCase(source);
			default:
				ThrowCompareOptionsCheckFailed(options);
				return -1;
			}
		}

		private int GetHashCodeOfStringCore(ReadOnlySpan<char> source, CompareOptions options)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuGetHashCodeOfString(source, options);
			}
			return NlsGetHashCodeOfString(source, options);
		}

		public override string ToString()
		{
			return "CompareInfo - " + Name;
		}

		private void IcuInitSortHandle()
		{
			if (GlobalizationMode.Invariant)
			{
				_isAsciiEqualityOrdinal = true;
				return;
			}
			_isAsciiEqualityOrdinal = _sortName.Length == 0 || (_sortName.Length >= 2 && _sortName[0] == 'e' && _sortName[1] == 'n' && (_sortName.Length == 2 || _sortName[2] == '-'));
			_sortHandle = SortHandleCache.GetCachedSortHandle(_sortName);
		}

		private unsafe int IcuCompareString(ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, CompareOptions options)
		{
			fixed (char* lpStr = &MemoryMarshal.GetReference(string1))
			{
				fixed (char* lpStr2 = &MemoryMarshal.GetReference(string2))
				{
					return Interop.Globalization.CompareString(_sortHandle, lpStr, string1.Length, lpStr2, string2.Length, options);
				}
			}
		}

		private unsafe int IcuIndexOfCore(ReadOnlySpan<char> source, ReadOnlySpan<char> target, CompareOptions options, int* matchLengthPtr, bool fromBeginning)
		{
			if (_isAsciiEqualityOrdinal && CanUseAsciiOrdinalForOptions(options))
			{
				if ((options & CompareOptions.IgnoreCase) != 0)
				{
					return IndexOfOrdinalIgnoreCaseHelper(source, target, options, matchLengthPtr, fromBeginning);
				}
				return IndexOfOrdinalHelper(source, target, options, matchLengthPtr, fromBeginning);
			}
			fixed (char* pSource = &MemoryMarshal.GetReference(source))
			{
				fixed (char* target2 = &MemoryMarshal.GetReference(target))
				{
					if (fromBeginning)
					{
						return Interop.Globalization.IndexOf(_sortHandle, target2, target.Length, pSource, source.Length, options, matchLengthPtr);
					}
					return Interop.Globalization.LastIndexOf(_sortHandle, target2, target.Length, pSource, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe int IndexOfOrdinalIgnoreCaseHelper(ReadOnlySpan<char> source, ReadOnlySpan<char> target, CompareOptions options, int* matchLengthPtr, bool fromBeginning)
		{
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(target))
				{
					char* ptr2 = ptr;
					char* ptr4 = ptr3;
					int num = 0;
					while (true)
					{
						if (num < target.Length)
						{
							char c = ptr4[num];
							if (c >= '\u0080' || HighCharTable[c])
							{
								break;
							}
							num++;
							continue;
						}
						if (target.Length > source.Length)
						{
							int num2 = 0;
							while (true)
							{
								if (num2 < source.Length)
								{
									char c2 = ptr2[num2];
									if (c2 >= '\u0080' || HighCharTable[c2])
									{
										break;
									}
									num2++;
									continue;
								}
								return -1;
							}
							break;
						}
						int num3;
						int num4;
						int num5;
						if (fromBeginning)
						{
							num3 = 0;
							num4 = source.Length - target.Length + 1;
							num5 = 1;
						}
						else
						{
							num3 = source.Length - target.Length;
							num4 = -1;
							num5 = -1;
						}
						int num6 = num3;
						while (true)
						{
							int num8;
							if (num6 != num4)
							{
								int num7 = 0;
								num8 = num6;
								while (true)
								{
									if (num7 < target.Length)
									{
										char c3 = ptr2[num8];
										char c4 = ptr4[num7];
										if (c3 >= '\u0080' || HighCharTable[c3])
										{
											break;
										}
										if (c3 == c4)
										{
											goto IL_0184;
										}
										if ((uint)(c3 - 97) <= 25u)
										{
											c3 = (char)(c3 - 32);
										}
										if ((uint)(c4 - 97) <= 25u)
										{
											c4 = (char)(c4 - 32);
										}
										if (c3 == c4)
										{
											goto IL_0184;
										}
										goto IL_0163;
									}
									if (num8 < source.Length && ptr2[num8] >= '\u0080')
									{
										break;
									}
									if (matchLengthPtr != null)
									{
										*matchLengthPtr = target.Length;
									}
									return num6;
									IL_0184:
									num7++;
									num8++;
								}
								break;
							}
							return -1;
							IL_0163:
							if (num8 < source.Length - 1 && (ptr2 + num8)[1] >= '\u0080')
							{
								break;
							}
							num6 += num5;
						}
						break;
					}
					if (fromBeginning)
					{
						return Interop.Globalization.IndexOf(_sortHandle, ptr4, target.Length, ptr2, source.Length, options, matchLengthPtr);
					}
					return Interop.Globalization.LastIndexOf(_sortHandle, ptr4, target.Length, ptr2, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe int IndexOfOrdinalHelper(ReadOnlySpan<char> source, ReadOnlySpan<char> target, CompareOptions options, int* matchLengthPtr, bool fromBeginning)
		{
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(target))
				{
					char* ptr2 = ptr;
					char* ptr4 = ptr3;
					int num = 0;
					while (true)
					{
						if (num < target.Length)
						{
							char c = ptr4[num];
							if (c >= '\u0080' || HighCharTable[c])
							{
								break;
							}
							num++;
							continue;
						}
						if (target.Length > source.Length)
						{
							int num2 = 0;
							while (true)
							{
								if (num2 < source.Length)
								{
									char c2 = ptr2[num2];
									if (c2 >= '\u0080' || HighCharTable[c2])
									{
										break;
									}
									num2++;
									continue;
								}
								return -1;
							}
							break;
						}
						int num3;
						int num4;
						int num5;
						if (fromBeginning)
						{
							num3 = 0;
							num4 = source.Length - target.Length + 1;
							num5 = 1;
						}
						else
						{
							num3 = source.Length - target.Length;
							num4 = -1;
							num5 = -1;
						}
						int num6 = num3;
						while (true)
						{
							int num8;
							if (num6 != num4)
							{
								int num7 = 0;
								num8 = num6;
								while (true)
								{
									if (num7 < target.Length)
									{
										char c3 = ptr2[num8];
										char c4 = ptr4[num7];
										if (c3 >= '\u0080' || HighCharTable[c3])
										{
											break;
										}
										if (c3 == c4)
										{
											num7++;
											num8++;
											continue;
										}
										goto IL_0135;
									}
									if (num8 < source.Length && ptr2[num8] >= '\u0080')
									{
										break;
									}
									if (matchLengthPtr != null)
									{
										*matchLengthPtr = target.Length;
									}
									return num6;
								}
								break;
							}
							return -1;
							IL_0135:
							if (num8 < source.Length - 1 && (ptr2 + num8)[1] >= '\u0080')
							{
								break;
							}
							num6 += num5;
						}
						break;
					}
					if (fromBeginning)
					{
						return Interop.Globalization.IndexOf(_sortHandle, ptr4, target.Length, ptr2, source.Length, options, matchLengthPtr);
					}
					return Interop.Globalization.LastIndexOf(_sortHandle, ptr4, target.Length, ptr2, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe bool IcuStartsWith(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options, int* matchLengthPtr)
		{
			if (_isAsciiEqualityOrdinal && CanUseAsciiOrdinalForOptions(options))
			{
				if ((options & CompareOptions.IgnoreCase) != 0)
				{
					return StartsWithOrdinalIgnoreCaseHelper(source, prefix, options, matchLengthPtr);
				}
				return StartsWithOrdinalHelper(source, prefix, options, matchLengthPtr);
			}
			fixed (char* source2 = &MemoryMarshal.GetReference(source))
			{
				fixed (char* target = &MemoryMarshal.GetReference(prefix))
				{
					return Interop.Globalization.StartsWith(_sortHandle, target, prefix.Length, source2, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe bool StartsWithOrdinalIgnoreCaseHelper(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options, int* matchLengthPtr)
		{
			int num = Math.Min(source.Length, prefix.Length);
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(prefix))
				{
					char* ptr2 = ptr;
					char* ptr4 = ptr3;
					while (true)
					{
						if (num != 0)
						{
							int num2 = *ptr2;
							int num3 = *ptr4;
							if (num2 >= 128 || num3 >= 128 || HighCharTable[num2] || HighCharTable[num3])
							{
								break;
							}
							if (num2 == num3)
							{
								ptr2++;
								ptr4++;
								num--;
								continue;
							}
							if ((uint)(num2 - 97) <= 25u)
							{
								num2 -= 32;
							}
							if ((uint)(num3 - 97) <= 25u)
							{
								num3 -= 32;
							}
							if (num2 == num3)
							{
								ptr2++;
								ptr4++;
								num--;
								continue;
							}
							if ((ptr2 < ptr + source.Length - 1 && ptr2[1] >= '\u0080') || (ptr4 < ptr3 + prefix.Length - 1 && ptr4[1] >= '\u0080'))
							{
								break;
							}
							return false;
						}
						if (source.Length < prefix.Length)
						{
							if (*ptr4 >= '\u0080')
							{
								break;
							}
							return false;
						}
						if (source.Length > prefix.Length && *ptr2 >= '\u0080')
						{
							break;
						}
						if (matchLengthPtr != null)
						{
							*matchLengthPtr = prefix.Length;
						}
						return true;
					}
					return Interop.Globalization.StartsWith(_sortHandle, ptr3, prefix.Length, ptr, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe bool StartsWithOrdinalHelper(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options, int* matchLengthPtr)
		{
			int num = Math.Min(source.Length, prefix.Length);
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(prefix))
				{
					char* ptr2 = ptr;
					char* ptr4 = ptr3;
					while (true)
					{
						if (num != 0)
						{
							int num2 = *ptr2;
							int num3 = *ptr4;
							if (num2 >= 128 || num3 >= 128 || HighCharTable[num2] || HighCharTable[num3])
							{
								break;
							}
							if (num2 == num3)
							{
								ptr2++;
								ptr4++;
								num--;
								continue;
							}
							if ((ptr2 < ptr + source.Length - 1 && ptr2[1] >= '\u0080') || (ptr4 < ptr3 + prefix.Length - 1 && ptr4[1] >= '\u0080'))
							{
								break;
							}
							return false;
						}
						if (source.Length < prefix.Length)
						{
							if (*ptr4 >= '\u0080')
							{
								break;
							}
							return false;
						}
						if (source.Length > prefix.Length && *ptr2 >= '\u0080')
						{
							break;
						}
						if (matchLengthPtr != null)
						{
							*matchLengthPtr = prefix.Length;
						}
						return true;
					}
					return Interop.Globalization.StartsWith(_sortHandle, ptr3, prefix.Length, ptr, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe bool IcuEndsWith(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options, int* matchLengthPtr)
		{
			if (_isAsciiEqualityOrdinal && CanUseAsciiOrdinalForOptions(options))
			{
				if ((options & CompareOptions.IgnoreCase) != 0)
				{
					return EndsWithOrdinalIgnoreCaseHelper(source, suffix, options, matchLengthPtr);
				}
				return EndsWithOrdinalHelper(source, suffix, options, matchLengthPtr);
			}
			fixed (char* source2 = &MemoryMarshal.GetReference(source))
			{
				fixed (char* target = &MemoryMarshal.GetReference(suffix))
				{
					return Interop.Globalization.EndsWith(_sortHandle, target, suffix.Length, source2, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe bool EndsWithOrdinalIgnoreCaseHelper(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options, int* matchLengthPtr)
		{
			int num = Math.Min(source.Length, suffix.Length);
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(suffix))
				{
					char* ptr2 = ptr + source.Length - 1;
					char* ptr4 = ptr3 + suffix.Length - 1;
					while (true)
					{
						if (num != 0)
						{
							int num2 = *ptr2;
							int num3 = *ptr4;
							if (num2 >= 128 || num3 >= 128 || HighCharTable[num2] || HighCharTable[num3])
							{
								break;
							}
							if (num2 == num3)
							{
								ptr2--;
								ptr4--;
								num--;
								continue;
							}
							if ((uint)(num2 - 97) <= 25u)
							{
								num2 -= 32;
							}
							if ((uint)(num3 - 97) <= 25u)
							{
								num3 -= 32;
							}
							if (num2 == num3)
							{
								ptr2--;
								ptr4--;
								num--;
								continue;
							}
							if ((ptr2 > ptr && *(ptr2 - 1) >= '\u0080') || (ptr4 > ptr3 && *(ptr4 - 1) >= '\u0080'))
							{
								break;
							}
							return false;
						}
						if (source.Length < suffix.Length)
						{
							if (*ptr4 >= '\u0080')
							{
								break;
							}
							return false;
						}
						if (source.Length > suffix.Length && *ptr2 >= '\u0080')
						{
							break;
						}
						if (matchLengthPtr != null)
						{
							*matchLengthPtr = suffix.Length;
						}
						return true;
					}
					return Interop.Globalization.EndsWith(_sortHandle, ptr3, suffix.Length, ptr, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe bool EndsWithOrdinalHelper(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options, int* matchLengthPtr)
		{
			int num = Math.Min(source.Length, suffix.Length);
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(suffix))
				{
					char* ptr2 = ptr + source.Length - 1;
					char* ptr4 = ptr3 + suffix.Length - 1;
					while (true)
					{
						if (num != 0)
						{
							int num2 = *ptr2;
							int num3 = *ptr4;
							if (num2 >= 128 || num3 >= 128 || HighCharTable[num2] || HighCharTable[num3])
							{
								break;
							}
							if (num2 == num3)
							{
								ptr2--;
								ptr4--;
								num--;
								continue;
							}
							if ((ptr2 > ptr && *(ptr2 - 1) >= '\u0080') || (ptr4 > ptr3 && *(ptr4 - 1) >= '\u0080'))
							{
								break;
							}
							return false;
						}
						if (source.Length < suffix.Length)
						{
							if (*ptr4 >= '\u0080')
							{
								break;
							}
							return false;
						}
						if (source.Length > suffix.Length && *ptr2 >= '\u0080')
						{
							break;
						}
						if (matchLengthPtr != null)
						{
							*matchLengthPtr = suffix.Length;
						}
						return true;
					}
					return Interop.Globalization.EndsWith(_sortHandle, ptr3, suffix.Length, ptr, source.Length, options, matchLengthPtr);
				}
			}
		}

		private unsafe SortKey IcuCreateSortKey(string source, CompareOptions options)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (((uint)options & 0xDFFFFFE0u) != 0)
			{
				throw new ArgumentException(SR.Argument_InvalidFlag, "options");
			}
			byte[] array;
			fixed (char* str = source)
			{
				int sortKey = Interop.Globalization.GetSortKey(_sortHandle, str, source.Length, null, 0, options);
				array = new byte[sortKey];
				fixed (byte[] array2 = array)
				{
					if (Interop.Globalization.GetSortKey(sortKey: (byte*)((array != null && array2.Length != 0) ? System.Runtime.CompilerServices.Unsafe.AsPointer(ref array2[0]) : null), sortHandle: _sortHandle, str: str, strLength: source.Length, sortKeyLength: sortKey, options: options) != sortKey)
					{
						throw new ArgumentException(SR.Arg_ExternalException);
					}
				}
				array2 = null;
			}
			return new SortKey(this, source, options, array);
		}

		private unsafe int IcuGetSortKey(ReadOnlySpan<char> source, Span<byte> destination, CompareOptions options)
		{
			int sortKey2;
			fixed (char* str = &MemoryMarshal.GetReference(source))
			{
				fixed (byte* sortKey = &MemoryMarshal.GetReference(destination))
				{
					sortKey2 = Interop.Globalization.GetSortKey(_sortHandle, str, source.Length, sortKey, destination.Length, options);
				}
			}
			if ((uint)sortKey2 > (uint)destination.Length)
			{
				if (sortKey2 <= destination.Length)
				{
					throw new ArgumentException(SR.Arg_ExternalException);
				}
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			return sortKey2;
		}

		private unsafe int IcuGetSortKeyLength(ReadOnlySpan<char> source, CompareOptions options)
		{
			fixed (char* str = &MemoryMarshal.GetReference(source))
			{
				return Interop.Globalization.GetSortKey(_sortHandle, str, source.Length, null, 0, options);
			}
		}

		private static bool IcuIsSortable(ReadOnlySpan<char> text)
		{
			do
			{
				if (Rune.DecodeFromUtf16(text, out var result, out var charsConsumed) != 0)
				{
					return false;
				}
				UnicodeCategory unicodeCategory = Rune.GetUnicodeCategory(result);
				if (unicodeCategory == UnicodeCategory.PrivateUse || unicodeCategory == UnicodeCategory.OtherNotAssigned)
				{
					return false;
				}
				text = text.Slice(charsConsumed);
			}
			while (!text.IsEmpty);
			return true;
		}

		private unsafe int IcuGetHashCodeOfString(ReadOnlySpan<char> source, CompareOptions options)
		{
			int num = ((source.Length <= 262144) ? (4 * source.Length) : 0);
			byte[] array = null;
			Span<byte> span = ((num > 1024) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(num))) : stackalloc byte[1024]);
			Span<byte> span2 = span;
			fixed (char* str = &MemoryMarshal.GetNonNullPinnableReference(source))
			{
				fixed (byte* sortKey = &MemoryMarshal.GetReference(span2))
				{
					num = Interop.Globalization.GetSortKey(_sortHandle, str, source.Length, sortKey, span2.Length, options);
				}
				if (num > span2.Length)
				{
					if (array != null)
					{
						ArrayPool<byte>.Shared.Return(array);
					}
					span2 = (array = ArrayPool<byte>.Shared.Rent(num));
					fixed (byte* sortKey2 = &MemoryMarshal.GetReference(span2))
					{
						num = Interop.Globalization.GetSortKey(_sortHandle, str, source.Length, sortKey2, span2.Length, options);
					}
				}
			}
			if (num == 0 || num > span2.Length)
			{
				throw new ArgumentException(SR.Arg_ExternalException);
			}
			int result = Marvin.ComputeHash32(span2.Slice(0, num), Marvin.DefaultSeed);
			if (array != null)
			{
				ArrayPool<byte>.Shared.Return(array);
			}
			return result;
		}

		private static bool CanUseAsciiOrdinalForOptions(CompareOptions options)
		{
			return (options & CompareOptions.IgnoreSymbols) == 0;
		}

		private SortVersion IcuGetSortVersion()
		{
			int sortVersion = Interop.Globalization.GetSortVersion(_sortHandle);
			return new SortVersion(sortVersion, LCID, new Guid(sortVersion, 0, 0, 0, 0, 0, 0, (byte)(LCID >> 24), (byte)((LCID & 0xFF0000) >> 16), (byte)((LCID & 0xFF00) >> 8), (byte)((uint)LCID & 0xFFu)));
		}

		private SortKey InvariantCreateSortKey(string source, CompareOptions options)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (((uint)options & 0xDFFFFFE0u) != 0)
			{
				throw new ArgumentException(SR.Argument_InvalidFlag, "options");
			}
			byte[] array;
			if (source.Length == 0)
			{
				array = Array.Empty<byte>();
			}
			else
			{
				array = new byte[source.Length * 2];
				if ((options & (CompareOptions.IgnoreCase | CompareOptions.OrdinalIgnoreCase)) != 0)
				{
					InvariantCreateSortKeyOrdinalIgnoreCase(source, array);
				}
				else
				{
					InvariantCreateSortKeyOrdinal(source, array);
				}
			}
			return new SortKey(this, source, options, array);
		}

		private static void InvariantCreateSortKeyOrdinal(ReadOnlySpan<char> source, Span<byte> sortKey)
		{
			for (int i = 0; i < source.Length; i++)
			{
				BinaryPrimitives.WriteUInt16BigEndian(sortKey, source[i]);
				sortKey = sortKey.Slice(2);
			}
		}

		private static void InvariantCreateSortKeyOrdinalIgnoreCase(ReadOnlySpan<char> source, Span<byte> sortKey)
		{
			for (int i = 0; i < source.Length; i++)
			{
				char c = source[i];
				if (char.IsHighSurrogate(c) && i < source.Length - 1)
				{
					char c2 = source[i + 1];
					if (char.IsLowSurrogate(c2))
					{
						SurrogateCasing.ToUpper(c, c2, out var hr, out var lr);
						BinaryPrimitives.WriteUInt16BigEndian(sortKey, hr);
						BinaryPrimitives.WriteUInt16BigEndian(sortKey, lr);
						i++;
						sortKey = sortKey.Slice(4);
						continue;
					}
				}
				BinaryPrimitives.WriteUInt16BigEndian(sortKey, InvariantModeCasing.ToUpper(c));
				sortKey = sortKey.Slice(2);
			}
		}

		private static int InvariantGetSortKey(ReadOnlySpan<char> source, Span<byte> destination, CompareOptions options)
		{
			if ((uint)destination.Length < (uint)(source.Length * 2))
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			if ((options & CompareOptions.IgnoreCase) == 0)
			{
				InvariantCreateSortKeyOrdinal(source, destination);
			}
			else
			{
				InvariantCreateSortKeyOrdinalIgnoreCase(source, destination);
			}
			return source.Length * 2;
		}

		private static int InvariantGetSortKeyLength(ReadOnlySpan<char> source, CompareOptions options)
		{
			int num = source.Length * 2;
			if (num < 0)
			{
				throw new ArgumentException(SR.ArgumentOutOfRange_GetByteCountOverflow, "source");
			}
			return num;
		}

		private void NlsInitSortHandle()
		{
			_sortHandle = NlsGetSortHandle(_sortName);
		}

		internal unsafe static IntPtr NlsGetSortHandle(string cultureName)
		{
			if (GlobalizationMode.Invariant)
			{
				return IntPtr.Zero;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out IntPtr intPtr);
			int num = Interop.Kernel32.LCMapStringEx(cultureName, 536870912u, null, 0, &intPtr, IntPtr.Size, null, null, IntPtr.Zero);
			if (num > 0)
			{
				int num2 = 0;
				char c = 'a';
				num = Interop.Kernel32.LCMapStringEx(null, 262144u, &c, 1, &num2, 4, null, null, intPtr);
				if (num > 1)
				{
					return intPtr;
				}
			}
			return IntPtr.Zero;
		}

		private unsafe static int FindStringOrdinal(uint dwFindStringOrdinalFlags, ReadOnlySpan<char> source, ReadOnlySpan<char> value, bool bIgnoreCase)
		{
			fixed (char* lpStringSource = &MemoryMarshal.GetReference(source))
			{
				fixed (char* lpStringValue = &MemoryMarshal.GetReference(value))
				{
					return Interop.Kernel32.FindStringOrdinal(dwFindStringOrdinalFlags, lpStringSource, source.Length, lpStringValue, value.Length, bIgnoreCase ? Interop.BOOL.TRUE : Interop.BOOL.FALSE);
				}
			}
		}

		internal static int NlsIndexOfOrdinalCore(ReadOnlySpan<char> source, ReadOnlySpan<char> value, bool ignoreCase, bool fromBeginning)
		{
			uint dwFindStringOrdinalFlags = (fromBeginning ? 4194304u : 8388608u);
			return FindStringOrdinal(dwFindStringOrdinalFlags, source, value, ignoreCase);
		}

		private unsafe int NlsGetHashCodeOfString(ReadOnlySpan<char> source, CompareOptions options)
		{
			if (!Environment.IsWindows8OrAbove)
			{
				source = source.ToString();
			}
			int num = source.Length;
			if (num == 0)
			{
				source = string.Empty;
				num = -1;
			}
			uint dwMapFlags = 0x400u | (uint)GetNativeCompareFlags(options);
			fixed (char* lpSrcStr = &MemoryMarshal.GetReference(source))
			{
				int num2 = Interop.Kernel32.LCMapStringEx((_sortHandle != IntPtr.Zero) ? null : _sortName, dwMapFlags, lpSrcStr, num, null, 0, null, null, _sortHandle);
				if (num2 == 0)
				{
					throw new ArgumentException(SR.Arg_ExternalException);
				}
				byte[] array = null;
				Span<byte> span = ((num2 > 512) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(num2))) : stackalloc byte[512]);
				Span<byte> span2 = span;
				fixed (byte* lpDestStr = &MemoryMarshal.GetReference(span2))
				{
					if (Interop.Kernel32.LCMapStringEx((_sortHandle != IntPtr.Zero) ? null : _sortName, dwMapFlags, lpSrcStr, num, lpDestStr, num2, null, null, _sortHandle) != num2)
					{
						throw new ArgumentException(SR.Arg_ExternalException);
					}
				}
				int result = Marvin.ComputeHash32(span2.Slice(0, num2), Marvin.DefaultSeed);
				if (array != null)
				{
					ArrayPool<byte>.Shared.Return(array);
				}
				return result;
			}
		}

		internal unsafe static int NlsCompareStringOrdinalIgnoreCase(ref char string1, int count1, ref char string2, int count2)
		{
			fixed (char* lpString = &string1)
			{
				fixed (char* lpString2 = &string2)
				{
					int num = Interop.Kernel32.CompareStringOrdinal(lpString, count1, lpString2, count2, bIgnoreCase: true);
					if (num == 0)
					{
						throw new ArgumentException(SR.Arg_ExternalException);
					}
					return num - 2;
				}
			}
		}

		private unsafe int NlsCompareString(ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, CompareOptions options)
		{
			string text = ((_sortHandle != IntPtr.Zero) ? null : _sortName);
			if (string1.IsEmpty)
			{
				string1 = string.Empty;
			}
			if (string2.IsEmpty)
			{
				string2 = string.Empty;
			}
			fixed (char* lpLocaleName = text)
			{
				fixed (char* lpString = &MemoryMarshal.GetReference(string1))
				{
					fixed (char* lpString2 = &MemoryMarshal.GetReference(string2))
					{
						int num = Interop.Kernel32.CompareStringEx(lpLocaleName, (uint)GetNativeCompareFlags(options), lpString, string1.Length, lpString2, string2.Length, null, null, _sortHandle);
						if (num == 0)
						{
							throw new ArgumentException(SR.Arg_ExternalException);
						}
						return num - 2;
					}
				}
			}
		}

		private unsafe int FindString(uint dwFindNLSStringFlags, ReadOnlySpan<char> lpStringSource, ReadOnlySpan<char> lpStringValue, int* pcchFound)
		{
			string text = ((_sortHandle != IntPtr.Zero) ? null : _sortName);
			int num = lpStringSource.Length;
			if (num == 0)
			{
				lpStringSource = string.Empty;
				num = -1;
			}
			fixed (char* lpLocaleName = text)
			{
				fixed (char* lpStringSource2 = &MemoryMarshal.GetReference(lpStringSource))
				{
					fixed (char* lpStringValue2 = &MemoryMarshal.GetReference(lpStringValue))
					{
						return Interop.Kernel32.FindNLSStringEx(lpLocaleName, dwFindNLSStringFlags, lpStringSource2, num, lpStringValue2, lpStringValue.Length, pcchFound, null, null, _sortHandle);
					}
				}
			}
		}

		private unsafe int NlsIndexOfCore(ReadOnlySpan<char> source, ReadOnlySpan<char> target, CompareOptions options, int* matchLengthPtr, bool fromBeginning)
		{
			uint num = (fromBeginning ? 4194304u : 8388608u);
			return FindString(num | (uint)GetNativeCompareFlags(options), source, target, matchLengthPtr);
		}

		private unsafe bool NlsStartsWith(ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options, int* matchLengthPtr)
		{
			int num = FindString(0x100000u | (uint)GetNativeCompareFlags(options), source, prefix, matchLengthPtr);
			if (num >= 0)
			{
				if (matchLengthPtr != null)
				{
					*matchLengthPtr += num;
				}
				return true;
			}
			return false;
		}

		private unsafe bool NlsEndsWith(ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options, int* matchLengthPtr)
		{
			int num = FindString(0x200000u | (uint)GetNativeCompareFlags(options), source, suffix, null);
			if (num >= 0)
			{
				if (matchLengthPtr != null)
				{
					*matchLengthPtr = source.Length - num;
				}
				return true;
			}
			return false;
		}

		private unsafe SortKey NlsCreateSortKey(string source, CompareOptions options)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (((uint)options & 0xDFFFFFE0u) != 0)
			{
				throw new ArgumentException(SR.Argument_InvalidFlag, "options");
			}
			uint dwMapFlags = 0x400u | (uint)GetNativeCompareFlags(options);
			int num = source.Length;
			if (num == 0)
			{
				num = -1;
			}
			byte[] array;
			fixed (char* lpSrcStr = source)
			{
				int num2 = Interop.Kernel32.LCMapStringEx((_sortHandle != IntPtr.Zero) ? null : _sortName, dwMapFlags, lpSrcStr, num, null, 0, null, null, _sortHandle);
				if (num2 == 0)
				{
					throw new ArgumentException(SR.Arg_ExternalException);
				}
				array = new byte[num2];
				fixed (byte* lpDestStr = array)
				{
					if (Interop.Kernel32.LCMapStringEx((_sortHandle != IntPtr.Zero) ? null : _sortName, dwMapFlags, lpSrcStr, num, lpDestStr, array.Length, null, null, _sortHandle) != num2)
					{
						throw new ArgumentException(SR.Arg_ExternalException);
					}
				}
			}
			return new SortKey(this, source, options, array);
		}

		private unsafe int NlsGetSortKey(ReadOnlySpan<char> source, Span<byte> destination, CompareOptions options)
		{
			if (destination.IsEmpty)
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			if (!Environment.IsWindows8OrAbove)
			{
				source = source.ToString();
			}
			uint dwMapFlags = 0x400u | (uint)GetNativeCompareFlags(options);
			int num = source.Length;
			if (num == 0)
			{
				source = string.Empty;
				num = -1;
			}
			int num3;
			fixed (char* lpSrcStr = &MemoryMarshal.GetReference(source))
			{
				fixed (byte* lpDestStr = &MemoryMarshal.GetReference(destination))
				{
					if (!Environment.IsWindows8OrAbove)
					{
						int num2 = Interop.Kernel32.LCMapStringEx((_sortHandle != IntPtr.Zero) ? null : _sortName, dwMapFlags, lpSrcStr, num, null, 0, null, null, _sortHandle);
						if (num2 > destination.Length)
						{
							ThrowHelper.ThrowArgumentException_DestinationTooShort();
						}
						if (num2 <= 0)
						{
							throw new ArgumentException(SR.Arg_ExternalException);
						}
					}
					num3 = Interop.Kernel32.LCMapStringEx((_sortHandle != IntPtr.Zero) ? null : _sortName, dwMapFlags, lpSrcStr, num, lpDestStr, destination.Length, null, null, _sortHandle);
				}
			}
			if (num3 <= 0)
			{
				if (Marshal.GetLastPInvokeError() != 122)
				{
					throw new ArgumentException(SR.Arg_ExternalException);
				}
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			return num3;
		}

		private unsafe int NlsGetSortKeyLength(ReadOnlySpan<char> source, CompareOptions options)
		{
			uint dwMapFlags = 0x400u | (uint)GetNativeCompareFlags(options);
			int num = source.Length;
			if (num == 0)
			{
				source = string.Empty;
				num = -1;
			}
			int num2;
			fixed (char* lpSrcStr = &MemoryMarshal.GetReference(source))
			{
				num2 = Interop.Kernel32.LCMapStringEx((_sortHandle != IntPtr.Zero) ? null : _sortName, dwMapFlags, lpSrcStr, num, null, 0, null, null, _sortHandle);
			}
			if (num2 <= 0)
			{
				throw new ArgumentException(SR.Arg_ExternalException);
			}
			return num2;
		}

		private unsafe static bool NlsIsSortable(ReadOnlySpan<char> text)
		{
			fixed (char* lpString = &MemoryMarshal.GetReference(text))
			{
				return Interop.Kernel32.IsNLSDefinedString(1, 0u, IntPtr.Zero, lpString, text.Length);
			}
		}

		private static int GetNativeCompareFlags(CompareOptions options)
		{
			int num = 134217728;
			if ((options & CompareOptions.IgnoreCase) != 0)
			{
				num |= 1;
			}
			if ((options & CompareOptions.IgnoreKanaType) != 0)
			{
				num |= 0x10000;
			}
			if ((options & CompareOptions.IgnoreNonSpace) != 0)
			{
				num |= 2;
			}
			if ((options & CompareOptions.IgnoreSymbols) != 0)
			{
				num |= 4;
			}
			if ((options & CompareOptions.IgnoreWidth) != 0)
			{
				num |= 0x20000;
			}
			if ((options & CompareOptions.StringSort) != 0)
			{
				num |= 0x1000;
			}
			if (options == CompareOptions.Ordinal)
			{
				num = 1073741824;
			}
			return num;
		}

		private unsafe SortVersion NlsGetSortVersion()
		{
			Interop.Kernel32.NlsVersionInfoEx nlsVersionInfoEx = default(Interop.Kernel32.NlsVersionInfoEx);
			nlsVersionInfoEx.dwNLSVersionInfoSize = sizeof(Interop.Kernel32.NlsVersionInfoEx);
			Interop.Kernel32.GetNLSVersionEx(1, _sortName, &nlsVersionInfoEx);
			return new SortVersion(nlsVersionInfoEx.dwNLSVersion, (nlsVersionInfoEx.dwEffectiveId == 0) ? LCID : nlsVersionInfoEx.dwEffectiveId, nlsVersionInfoEx.guidCustomVersion);
		}
	}
	[Flags]
	public enum CompareOptions
	{
		None = 0,
		IgnoreCase = 1,
		IgnoreNonSpace = 2,
		IgnoreSymbols = 4,
		IgnoreKanaType = 8,
		IgnoreWidth = 0x10,
		OrdinalIgnoreCase = 0x10000000,
		StringSort = 0x20000000,
		Ordinal = 0x40000000
	}
	internal sealed class CultureData
	{
		private enum LocaleStringData : uint
		{
			LocalizedDisplayName = 2u,
			EnglishDisplayName = 114u,
			NativeDisplayName = 115u,
			LocalizedLanguageName = 111u,
			EnglishLanguageName = 4097u,
			NativeLanguageName = 4u,
			LocalizedCountryName = 6u,
			EnglishCountryName = 4098u,
			NativeCountryName = 8u,
			AbbreviatedWindowsLanguageName = 3u,
			ListSeparator = 12u,
			DecimalSeparator = 14u,
			ThousandSeparator = 15u,
			Digits = 19u,
			MonetarySymbol = 20u,
			CurrencyEnglishName = 4103u,
			CurrencyNativeName = 4104u,
			Iso4217MonetarySymbol = 21u,
			MonetaryDecimalSeparator = 22u,
			MonetaryThousandSeparator = 23u,
			AMDesignator = 40u,
			PMDesignator = 41u,
			PositiveSign = 80u,
			NegativeSign = 81u,
			Iso639LanguageTwoLetterName = 89u,
			Iso639LanguageThreeLetterName = 103u,
			Iso639LanguageName = 89u,
			Iso3166CountryName = 90u,
			Iso3166CountryName2 = 104u,
			NaNSymbol = 105u,
			PositiveInfinitySymbol = 106u,
			NegativeInfinitySymbol = 107u,
			ParentName = 109u,
			ConsoleFallbackName = 110u,
			PercentSymbol = 118u,
			PerMilleSymbol = 119u
		}

		private enum LocaleGroupingData : uint
		{
			Digit = 16u,
			Monetary = 24u
		}

		private enum LocaleNumberData : uint
		{
			LanguageId = 1u,
			GeoId = 91u,
			DigitSubstitution = 4116u,
			MeasurementSystem = 13u,
			FractionalDigitsCount = 17u,
			NegativeNumberFormat = 4112u,
			MonetaryFractionalDigitsCount = 25u,
			PositiveMonetaryNumberFormat = 27u,
			NegativeMonetaryNumberFormat = 28u,
			CalendarType = 4105u,
			FirstDayOfWeek = 4108u,
			FirstWeekOfYear = 4109u,
			ReadingLayout = 112u,
			NegativePercentFormat = 116u,
			PositivePercentFormat = 117u,
			OemCodePage = 11u,
			AnsiCodePage = 4100u,
			MacCodePage = 4113u,
			EbcdicCodePage = 4114u
		}

		private struct EnumLocaleData
		{
			public string regionName;

			public string cultureName;
		}

		private struct EnumData
		{
			public List<string> strings;
		}

		private string _sRealName;

		private string _sWindowsName;

		private string _sName;

		private string _sParent;

		private string _sEnglishDisplayName;

		private string _sNativeDisplayName;

		private string _sSpecificCulture;

		private string _sISO639Language;

		private string _sISO639Language2;

		private string _sEnglishLanguage;

		private string _sNativeLanguage;

		private string _sAbbrevLang;

		private string _sConsoleFallbackName;

		private int _iInputLanguageHandle = -1;

		private string _sRegionName;

		private string _sLocalizedCountry;

		private string _sEnglishCountry;

		private string _sNativeCountry;

		private string _sISO3166CountryName;

		private string _sISO3166CountryName2;

		private int _iGeoId = -1;

		private string _sPositiveSign;

		private string _sNegativeSign;

		private int _iDigits;

		private int _iNegativeNumber;

		private int[] _waGrouping;

		private string _sDecimalSeparator;

		private string _sThousandSeparator;

		private string _sNaN;

		private string _sPositiveInfinity;

		private string _sNegativeInfinity;

		private int _iNegativePercent = -1;

		private int _iPositivePercent = -1;

		private string _sPercent;

		private string _sPerMille;

		private string _sCurrency;

		private string _sIntlMonetarySymbol;

		private string _sEnglishCurrency;

		private string _sNativeCurrency;

		private int _iCurrencyDigits;

		private int _iCurrency;

		private int _iNegativeCurrency;

		private int[] _waMonetaryGrouping;

		private string _sMonetaryDecimal;

		private string _sMonetaryThousand;

		private int _iMeasure = -1;

		private string _sListSeparator;

		private string _sAM1159;

		private string _sPM2359;

		private string _sTimeSeparator;

		private volatile string[] _saLongTimes;

		private volatile string[] _saShortTimes;

		private volatile string[] _saDurationFormats;

		private int _iFirstDayOfWeek = -1;

		private int _iFirstWeekOfYear = -1;

		private volatile CalendarId[] _waCalendars;

		private CalendarData[] _calendars;

		private int _iReadingLayout = -1;

		private int _iDefaultAnsiCodePage = -1;

		private int _iDefaultOemCodePage = -1;

		private int _iDefaultMacCodePage = -1;

		private int _iDefaultEbcdicCodePage = -1;

		private int _iLanguage;

		private bool _bUseOverrides;

		private bool _bUseOverridesUserSetting;

		private bool _bNeutral;

		private static volatile Dictionary<string, CultureData> s_cachedRegions;

		private static volatile Dictionary<string, string> s_regionNames;

		private static volatile CultureData s_Invariant;

		private static volatile Dictionary<string, CultureData> s_cachedCultures;

		private static readonly object s_lock = new object();

		private static Dictionary<string, string> RegionNames
		{
			get
			{
				object obj = s_regionNames;
				if (obj == null)
				{
					obj = new Dictionary<string, string>(257, StringComparer.OrdinalIgnoreCase)
					{
						{ "001", "en-001" },
						{ "029", "en-029" },
						{ "150", "en-150" },
						{ "419", "es-419" },
						{ "AD", "ca-AD" },
						{ "AE", "ar-AE" },
						{ "AF", "prs-AF" },
						{ "AG", "en-AG" },
						{ "AI", "en-AI" },
						{ "AL", "sq-AL" },
						{ "AM", "hy-AM" },
						{ "AO", "pt-AO" },
						{ "AQ", "en-A" },
						{ "AR", "es-AR" },
						{ "AS", "en-AS" },
						{ "AT", "de-AT" },
						{ "AU", "en-AU" },
						{ "AW", "nl-AW" },
						{ "AX", "sv-AX" },
						{ "AZ", "az-Cyrl-AZ" },
						{ "BA", "bs-Latn-BA" },
						{ "BB", "en-BB" },
						{ "BD", "bn-BD" },
						{ "BE", "nl-BE" },
						{ "BF", "fr-BF" },
						{ "BG", "bg-BG" },
						{ "BH", "ar-BH" },
						{ "BI", "rn-BI" },
						{ "BJ", "fr-BJ" },
						{ "BL", "fr-BL" },
						{ "BM", "en-BM" },
						{ "BN", "ms-BN" },
						{ "BO", "es-BO" },
						{ "BQ", "nl-BQ" },
						{ "BR", "pt-BR" },
						{ "BS", "en-BS" },
						{ "BT", "dz-BT" },
						{ "BV", "nb-B" },
						{ "BW", "en-BW" },
						{ "BY", "be-BY" },
						{ "BZ", "en-BZ" },
						{ "CA", "en-CA" },
						{ "CC", "en-CC" },
						{ "CD", "fr-CD" },
						{ "CF", "sg-CF" },
						{ "CG", "fr-CG" },
						{ "CH", "it-CH" },
						{ "CI", "fr-CI" },
						{ "CK", "en-CK" },
						{ "CL", "es-CL" },
						{ "CM", "fr-C" },
						{ "CN", "zh-CN" },
						{ "CO", "es-CO" },
						{ "CR", "es-CR" },
						{ "CS", "sr-Cyrl-CS" },
						{ "CU", "es-CU" },
						{ "CV", "pt-CV" },
						{ "CW", "nl-CW" },
						{ "CX", "en-CX" },
						{ "CY", "el-CY" },
						{ "CZ", "cs-CZ" },
						{ "DE", "de-DE" },
						{ "DJ", "fr-DJ" },
						{ "DK", "da-DK" },
						{ "DM", "en-DM" },
						{ "DO", "es-DO" },
						{ "DZ", "ar-DZ" },
						{ "EC", "es-EC" },
						{ "EE", "et-EE" },
						{ "EG", "ar-EG" },
						{ "ER", "tig-ER" },
						{ "ES", "es-ES" },
						{ "ET", "am-ET" },
						{ "FI", "fi-FI" },
						{ "FJ", "en-FJ" },
						{ "FK", "en-FK" },
						{ "FM", "en-FM" },
						{ "FO", "fo-FO" },
						{ "FR", "fr-FR" },
						{ "GA", "fr-GA" },
						{ "GB", "en-GB" },
						{ "GD", "en-GD" },
						{ "GE", "ka-GE" },
						{ "GF", "fr-GF" },
						{ "GG", "en-GG" },
						{ "GH", "en-GH" },
						{ "GI", "en-GI" },
						{ "GL", "kl-GL" },
						{ "GM", "en-GM" },
						{ "GN", "fr-GN" },
						{ "GP", "fr-GP" },
						{ "GQ", "es-GQ" },
						{ "GR", "el-GR" },
						{ "GS", "en-G" },
						{ "GT", "es-GT" },
						{ "GU", "en-GU" },
						{ "GW", "pt-GW" },
						{ "GY", "en-GY" },
						{ "HK", "zh-HK" },
						{ "HM", "en-H" },
						{ "HN", "es-HN" },
						{ "HR", "hr-HR" },
						{ "HT", "fr-HT" },
						{ "HU", "hu-HU" },
						{ "ID", "id-ID" },
						{ "IE", "en-IE" },
						{ "IL", "he-IL" },
						{ "IM", "gv-IM" },
						{ "IN", "hi-IN" },
						{ "IO", "en-IO" },
						{ "IQ", "ar-IQ" },
						{ "IR", "fa-IR" },
						{ "IS", "is-IS" },
						{ "IT", "it-IT" },
						{ "IV", "" },
						{ "JE", "en-JE" },
						{ "JM", "en-JM" },
						{ "JO", "ar-JO" },
						{ "JP", "ja-JP" },
						{ "KE", "sw-KE" },
						{ "KG", "ky-KG" },
						{ "KH", "km-KH" },
						{ "KI", "en-KI" },
						{ "KM", "ar-KM" },
						{ "KN", "en-KN" },
						{ "KP", "ko-KP" },
						{ "KR", "ko-KR" },
						{ "KW", "ar-KW" },
						{ "KY", "en-KY" },
						{ "KZ", "kk-KZ" },
						{ "LA", "lo-LA" },
						{ "LB", "ar-LB" },
						{ "LC", "en-LC" },
						{ "LI", "de-LI" },
						{ "LK", "si-LK" },
						{ "LR", "en-LR" },
						{ "LS", "st-LS" },
						{ "LT", "lt-LT" },
						{ "LU", "lb-LU" },
						{ "LV", "lv-LV" },
						{ "LY", "ar-LY" },
						{ "MA", "ar-MA" },
						{ "MC", "fr-MC" },
						{ "MD", "ro-MD" },
						{ "ME", "sr-Latn-ME" },
						{ "MF", "fr-MF" },
						{ "MG", "mg-MG" },
						{ "MH", "en-MH" },
						{ "MK", "mk-MK" },
						{ "ML", "fr-ML" },
						{ "MM", "my-MM" },
						{ "MN", "mn-MN" },
						{ "MO", "zh-MO" },
						{ "MP", "en-MP" },
						{ "MQ", "fr-MQ" },
						{ "MR", "ar-MR" },
						{ "MS", "en-MS" },
						{ "MT", "mt-MT" },
						{ "MU", "en-MU" },
						{ "MV", "dv-MV" },
						{ "MW", "en-MW" },
						{ "MX", "es-MX" },
						{ "MY", "ms-MY" },
						{ "MZ", "pt-MZ" },
						{ "NA", "en-NA" },
						{ "NC", "fr-NC" },
						{ "NE", "fr-NE" },
						{ "NF", "en-NF" },
						{ "NG", "ig-NG" },
						{ "NI", "es-NI" },
						{ "NL", "nl-NL" },
						{ "NO", "nn-NO" },
						{ "NP", "ne-NP" },
						{ "NR", "en-NR" },
						{ "NU", "en-NU" },
						{ "NZ", "en-NZ" },
						{ "OM", "ar-OM" },
						{ "PA", "es-PA" },
						{ "PE", "es-PE" },
						{ "PF", "fr-PF" },
						{ "PG", "en-PG" },
						{ "PH", "en-PH" },
						{ "PK", "ur-PK" },
						{ "PL", "pl-PL" },
						{ "PM", "fr-PM" },
						{ "PN", "en-PN" },
						{ "PR", "es-PR" },
						{ "PS", "ar-PS" },
						{ "PT", "pt-PT" },
						{ "PW", "en-PW" },
						{ "PY", "es-PY" },
						{ "QA", "ar-QA" },
						{ "RE", "fr-RE" },
						{ "RO", "ro-RO" },
						{ "RS", "sr-Latn-RS" },
						{ "RU", "ru-RU" },
						{ "RW", "rw-RW" },
						{ "SA", "ar-SA" },
						{ "SB", "en-SB" },
						{ "SC", "fr-SC" },
						{ "SD", "ar-SD" },
						{ "SE", "sv-SE" },
						{ "SG", "zh-SG" },
						{ "SH", "en-SH" },
						{ "SI", "sl-SI" },
						{ "SJ", "nb-SJ" },
						{ "SK", "sk-SK" },
						{ "SL", "en-SL" },
						{ "SM", "it-SM" },
						{ "SN", "wo-SN" },
						{ "SO", "so-SO" },
						{ "SR", "nl-SR" },
						{ "SS", "en-SS" },
						{ "ST", "pt-ST" },
						{ "SV", "es-SV" },
						{ "SX", "nl-SX" },
						{ "SY", "ar-SY" },
						{ "SZ", "ss-SZ" },
						{ "TC", "en-TC" },
						{ "TD", "fr-TD" },
						{ "TF", "fr-T" },
						{ "TG", "fr-TG" },
						{ "TH", "th-TH" },
						{ "TJ", "tg-Cyrl-TJ" },
						{ "TK", "en-TK" },
						{ "TL", "pt-TL" },
						{ "TM", "tk-TM" },
						{ "TN", "ar-TN" },
						{ "TO", "to-TO" },
						{ "TR", "tr-TR" },
						{ "TT", "en-TT" },
						{ "TV", "en-TV" },
						{ "TW", "zh-TW" },
						{ "TZ", "sw-TZ" },
						{ "UA", "uk-UA" },
						{ "UG", "sw-UG" },
						{ "UM", "en-UM" },
						{ "US", "en-US" },
						{ "UY", "es-UY" },
						{ "UZ", "uz-Cyrl-UZ" },
						{ "VA", "it-VA" },
						{ "VC", "en-VC" },
						{ "VE", "es-VE" },
						{ "VG", "en-VG" },
						{ "VI", "en-VI" },
						{ "VN", "vi-VN" },
						{ "VU", "fr-VU" },
						{ "WF", "fr-WF" },
						{ "WS", "en-WS" },
						{ "XK", "sq-XK" },
						{ "YE", "ar-YE" },
						{ "YT", "fr-YT" },
						{ "ZA", "af-ZA" },
						{ "ZM", "en-ZM" },
						{ "ZW", "en-ZW" }
					};
					s_regionNames = (Dictionary<string, string>)obj;
				}
				return (Dictionary<string, string>)obj;
			}
		}

		internal static CultureData Invariant => s_Invariant ?? (s_Invariant = CreateCultureWithInvariantData());

		internal string CultureName
		{
			get
			{
				string sName = _sName;
				if (sName == "zh-CHS" || sName == "zh-CHT")
				{
					return _sName;
				}
				return _sRealName;
			}
		}

		internal bool UseUserOverride => _bUseOverridesUserSetting;

		internal string Name => _sName ?? string.Empty;

		internal string ParentName => _sParent ?? (_sParent = GetLocaleInfoCore(_sRealName, LocaleStringData.ParentName));

		internal string DisplayName
		{
			get
			{
				string text = NativeName;
				if (!GlobalizationMode.Invariant && Name.Length > 0)
				{
					try
					{
						text = GetLanguageDisplayNameCore(Name.Equals("zh-CHT", StringComparison.OrdinalIgnoreCase) ? "zh-Hant" : (Name.Equals("zh-CHS", StringComparison.OrdinalIgnoreCase) ? "zh-Hans" : Name));
					}
					catch
					{
					}
					if (string.IsNullOrEmpty(text) && IsNeutralCulture)
					{
						text = LocalizedLanguageName;
					}
				}
				return text;
			}
		}

		internal string EnglishName
		{
			get
			{
				string text = _sEnglishDisplayName;
				if (text == null && !GlobalizationMode.Invariant)
				{
					if (IsNeutralCulture)
					{
						text = GetLocaleInfoCore(LocaleStringData.EnglishDisplayName);
						if (string.IsNullOrEmpty(text))
						{
							text = EnglishLanguageName;
						}
						string sName = _sName;
						if (sName == "zh-CHS" || sName == "zh-CHT")
						{
							text += " Legacy";
						}
					}
					else
					{
						text = GetLocaleInfoCore(LocaleStringData.EnglishDisplayName);
						if (string.IsNullOrEmpty(text))
						{
							text = ((EnglishLanguageName[^1] != ')') ? (EnglishLanguageName + " (" + EnglishCountryName + ")") : string.Concat(EnglishLanguageName.AsSpan(0, _sEnglishLanguage.Length - 1), ", ", EnglishCountryName, ")"));
						}
					}
					_sEnglishDisplayName = text;
				}
				return text;
			}
		}

		internal string NativeName
		{
			get
			{
				string text = _sNativeDisplayName;
				if (text == null && !GlobalizationMode.Invariant)
				{
					if (IsNeutralCulture)
					{
						text = GetLocaleInfoCore(LocaleStringData.NativeDisplayName);
						if (string.IsNullOrEmpty(text))
						{
							text = NativeLanguageName;
						}
						string sName = _sName;
						if (!(sName == "zh-CHS"))
						{
							if (sName == "zh-CHT")
							{
								text += " 舊版";
							}
						}
						else
						{
							text += " 旧版";
						}
					}
					else
					{
						text = GetLocaleInfoCore(LocaleStringData.NativeDisplayName);
						if (string.IsNullOrEmpty(text))
						{
							text = NativeLanguageName + " (" + NativeCountryName + ")";
						}
					}
					_sNativeDisplayName = text;
				}
				return text;
			}
		}

		internal string SpecificCultureName => _sSpecificCulture;

		internal string TwoLetterISOLanguageName => _sISO639Language ?? (_sISO639Language = GetLocaleInfoCore(LocaleStringData.Iso639LanguageTwoLetterName));

		internal string ThreeLetterISOLanguageName => _sISO639Language2 ?? (_sISO639Language2 = GetLocaleInfoCore(LocaleStringData.Iso639LanguageThreeLetterName));

		internal string ThreeLetterWindowsLanguageName => _sAbbrevLang ?? (_sAbbrevLang = (GlobalizationMode.UseNls ? NlsGetThreeLetterWindowsLanguageName(_sRealName) : IcuGetThreeLetterWindowsLanguageName(_sRealName)));

		private string LocalizedLanguageName
		{
			get
			{
				string result = NativeLanguageName;
				if (!GlobalizationMode.Invariant && Name.Length > 0 && (!GlobalizationMode.UseNls || CultureInfo.UserDefaultUICulture?.Name == CultureInfo.CurrentUICulture.Name))
				{
					result = GetLocaleInfoCore(LocaleStringData.LocalizedLanguageName, CultureInfo.CurrentUICulture.Name);
				}
				return result;
			}
		}

		private string EnglishLanguageName => _sEnglishLanguage ?? (_sEnglishLanguage = GetLocaleInfoCore(LocaleStringData.EnglishLanguageName));

		private string NativeLanguageName => _sNativeLanguage ?? (_sNativeLanguage = GetLocaleInfoCore(LocaleStringData.NativeLanguageName));

		internal string RegionName => _sRegionName ?? (_sRegionName = GetLocaleInfoCore(LocaleStringData.Iso3166CountryName));

		internal int GeoId
		{
			get
			{
				if (_iGeoId == -1 && !GlobalizationMode.Invariant)
				{
					_iGeoId = (GlobalizationMode.UseNls ? NlsGetLocaleInfo(LocaleNumberData.GeoId) : IcuGetGeoId(_sRealName));
				}
				return _iGeoId;
			}
		}

		internal string LocalizedCountryName
		{
			get
			{
				string text = _sLocalizedCountry;
				if (text == null && !GlobalizationMode.Invariant)
				{
					try
					{
						text = (GlobalizationMode.UseNls ? NlsGetRegionDisplayName() : IcuGetRegionDisplayName());
					}
					catch
					{
					}
					if (text == null)
					{
						text = NativeCountryName;
					}
					_sLocalizedCountry = text;
				}
				return text;
			}
		}

		internal string EnglishCountryName => _sEnglishCountry ?? (_sEnglishCountry = GetLocaleInfoCore(LocaleStringData.EnglishCountryName));

		internal string NativeCountryName => _sNativeCountry ?? (_sNativeCountry = GetLocaleInfoCore(LocaleStringData.NativeCountryName));

		internal string TwoLetterISOCountryName => _sISO3166CountryName ?? (_sISO3166CountryName = GetLocaleInfoCore(LocaleStringData.Iso3166CountryName));

		internal string ThreeLetterISOCountryName => _sISO3166CountryName2 ?? (_sISO3166CountryName2 = GetLocaleInfoCore(LocaleStringData.Iso3166CountryName2));

		internal int KeyboardLayoutId
		{
			get
			{
				if (_iInputLanguageHandle == -1)
				{
					if (IsSupplementalCustomCulture)
					{
						_iInputLanguageHandle = 1033;
					}
					else
					{
						_iInputLanguageHandle = LCID;
					}
				}
				return _iInputLanguageHandle;
			}
		}

		internal string SCONSOLEFALLBACKNAME => _sConsoleFallbackName ?? (_sConsoleFallbackName = (GlobalizationMode.UseNls ? NlsGetConsoleFallbackName(_sRealName) : IcuGetConsoleFallbackName(_sRealName)));

		internal int[] NumberGroupSizes => _waGrouping ?? (_waGrouping = GetLocaleInfoCoreUserOverride(LocaleGroupingData.Digit));

		private string NaNSymbol => _sNaN ?? (_sNaN = GetLocaleInfoCore(LocaleStringData.NaNSymbol));

		private string PositiveInfinitySymbol => _sPositiveInfinity ?? (_sPositiveInfinity = GetLocaleInfoCore(LocaleStringData.PositiveInfinitySymbol));

		private string NegativeInfinitySymbol => _sNegativeInfinity ?? (_sNegativeInfinity = GetLocaleInfoCore(LocaleStringData.NegativeInfinitySymbol));

		private int PercentNegativePattern
		{
			get
			{
				if (_iNegativePercent == -1)
				{
					_iNegativePercent = GetLocaleInfoCore(LocaleNumberData.NegativePercentFormat);
				}
				return _iNegativePercent;
			}
		}

		private int PercentPositivePattern
		{
			get
			{
				if (_iPositivePercent == -1)
				{
					_iPositivePercent = GetLocaleInfoCore(LocaleNumberData.PositivePercentFormat);
				}
				return _iPositivePercent;
			}
		}

		private string PercentSymbol => _sPercent ?? (_sPercent = GetLocaleInfoCore(LocaleStringData.PercentSymbol));

		private string PerMilleSymbol => _sPerMille ?? (_sPerMille = GetLocaleInfoCore(LocaleStringData.PerMilleSymbol));

		internal string CurrencySymbol => _sCurrency ?? (_sCurrency = GetLocaleInfoCoreUserOverride(LocaleStringData.MonetarySymbol));

		internal string ISOCurrencySymbol => _sIntlMonetarySymbol ?? (_sIntlMonetarySymbol = GetLocaleInfoCore(LocaleStringData.Iso4217MonetarySymbol));

		internal string CurrencyEnglishName => _sEnglishCurrency ?? (_sEnglishCurrency = GetLocaleInfoCore(LocaleStringData.CurrencyEnglishName));

		internal string CurrencyNativeName => _sNativeCurrency ?? (_sNativeCurrency = GetLocaleInfoCore(LocaleStringData.CurrencyNativeName));

		internal int[] CurrencyGroupSizes => _waMonetaryGrouping ?? (_waMonetaryGrouping = GetLocaleInfoCoreUserOverride(LocaleGroupingData.Monetary));

		internal int MeasurementSystem
		{
			get
			{
				if (_iMeasure == -1)
				{
					_iMeasure = GetLocaleInfoCoreUserOverride(LocaleNumberData.MeasurementSystem);
				}
				return _iMeasure;
			}
		}

		internal string ListSeparator => _sListSeparator ?? (_sListSeparator = (ShouldUseUserOverrideNlsData ? NlsGetLocaleInfo(LocaleStringData.ListSeparator) : IcuGetListSeparator(_sWindowsName)));

		internal string AMDesignator => _sAM1159 ?? (_sAM1159 = GetLocaleInfoCoreUserOverride(LocaleStringData.AMDesignator));

		internal string PMDesignator => _sPM2359 ?? (_sPM2359 = GetLocaleInfoCoreUserOverride(LocaleStringData.PMDesignator));

		internal string[] LongTimes
		{
			get
			{
				if (_saLongTimes == null && !GlobalizationMode.Invariant)
				{
					string[] timeFormatsCore = GetTimeFormatsCore(shortFormat: false);
					if (timeFormatsCore == null || timeFormatsCore.Length == 0)
					{
						_saLongTimes = Invariant._saLongTimes;
					}
					else
					{
						_saLongTimes = timeFormatsCore;
					}
				}
				return _saLongTimes;
			}
		}

		internal string[] ShortTimes
		{
			get
			{
				if (_saShortTimes == null && !GlobalizationMode.Invariant)
				{
					string[] array = GetTimeFormatsCore(shortFormat: true);
					if (array == null || array.Length == 0)
					{
						array = DeriveShortTimesFromLong();
					}
					_saShortTimes = array;
				}
				return _saShortTimes;
			}
		}

		internal int FirstDayOfWeek
		{
			get
			{
				if (_iFirstDayOfWeek == -1 && !GlobalizationMode.Invariant)
				{
					_iFirstDayOfWeek = (ShouldUseUserOverrideNlsData ? NlsGetFirstDayOfWeek() : IcuGetLocaleInfo(LocaleNumberData.FirstDayOfWeek));
				}
				return _iFirstDayOfWeek;
			}
		}

		internal int CalendarWeekRule
		{
			get
			{
				if (_iFirstWeekOfYear == -1)
				{
					_iFirstWeekOfYear = GetLocaleInfoCoreUserOverride(LocaleNumberData.FirstWeekOfYear);
				}
				return _iFirstWeekOfYear;
			}
		}

		internal CalendarId[] CalendarIds
		{
			get
			{
				if (_waCalendars == null && !GlobalizationMode.Invariant)
				{
					CalendarId[] array = new CalendarId[23];
					int num = CalendarData.GetCalendarsCore(_sWindowsName, _bUseOverrides, array);
					if (num == 0)
					{
						_waCalendars = Invariant._waCalendars;
					}
					else
					{
						if (_sWindowsName == "zh-TW")
						{
							bool flag = false;
							for (int i = 0; i < num; i++)
							{
								if (array[i] == CalendarId.TAIWAN)
								{
									flag = true;
									break;
								}
							}
							if (!flag)
							{
								num++;
								Array.Copy(array, 1, array, 2, 21);
								array[1] = CalendarId.TAIWAN;
							}
						}
						CalendarId[] array2 = new CalendarId[num];
						Array.Copy(array, array2, num);
						_waCalendars = array2;
					}
				}
				return _waCalendars;
			}
		}

		internal bool IsRightToLeft => ReadingLayout == 1;

		private int ReadingLayout
		{
			get
			{
				if (_iReadingLayout == -1 && !GlobalizationMode.Invariant)
				{
					_iReadingLayout = GetLocaleInfoCore(LocaleNumberData.ReadingLayout);
				}
				return _iReadingLayout;
			}
		}

		internal string TextInfoName => _sRealName;

		internal string SortName => _sRealName;

		internal bool IsSupplementalCustomCulture => IsCustomCultureId(LCID);

		internal int ANSICodePage
		{
			get
			{
				if (_iDefaultAnsiCodePage == -1 && !GlobalizationMode.Invariant)
				{
					_iDefaultAnsiCodePage = GetAnsiCodePage(_sRealName);
				}
				return _iDefaultAnsiCodePage;
			}
		}

		internal int OEMCodePage
		{
			get
			{
				if (_iDefaultOemCodePage == -1 && !GlobalizationMode.Invariant)
				{
					_iDefaultOemCodePage = GetOemCodePage(_sRealName);
				}
				return _iDefaultOemCodePage;
			}
		}

		internal int MacCodePage
		{
			get
			{
				if (_iDefaultMacCodePage == -1 && !GlobalizationMode.Invariant)
				{
					_iDefaultMacCodePage = GetMacCodePage(_sRealName);
				}
				return _iDefaultMacCodePage;
			}
		}

		internal int EBCDICCodePage
		{
			get
			{
				if (_iDefaultEbcdicCodePage == -1 && !GlobalizationMode.Invariant)
				{
					_iDefaultEbcdicCodePage = GetEbcdicCodePage(_sRealName);
				}
				return _iDefaultEbcdicCodePage;
			}
		}

		internal int LCID
		{
			get
			{
				if (_iLanguage == 0 && !GlobalizationMode.Invariant)
				{
					_iLanguage = (GlobalizationMode.UseNls ? NlsLocaleNameToLCID(_sRealName) : IcuLocaleNameToLCID(_sRealName));
				}
				return _iLanguage;
			}
		}

		internal bool IsNeutralCulture => _bNeutral;

		internal bool IsInvariantCulture => string.IsNullOrEmpty(Name);

		internal bool IsReplacementCulture
		{
			get
			{
				if (!GlobalizationMode.UseNls)
				{
					return false;
				}
				return NlsIsReplacementCulture;
			}
		}

		internal Calendar DefaultCalendar
		{
			get
			{
				if (GlobalizationMode.Invariant)
				{
					return new GregorianCalendar();
				}
				CalendarId calendarId = (CalendarId)GetLocaleInfoCore(LocaleNumberData.CalendarType);
				if (calendarId == CalendarId.UNINITIALIZED_VALUE)
				{
					calendarId = CalendarIds[0];
				}
				return CultureInfo.GetCalendarInstance(calendarId);
			}
		}

		internal string TimeSeparator
		{
			get
			{
				if (_sTimeSeparator == null && !GlobalizationMode.Invariant)
				{
					if (_sName == "fr-CA")
					{
						_sTimeSeparator = ":";
					}
					else
					{
						string text = (ShouldUseUserOverrideNlsData ? NlsGetTimeFormatString() : IcuGetTimeFormatString());
						if (string.IsNullOrEmpty(text))
						{
							text = LongTimes[0];
						}
						_sTimeSeparator = GetTimeSeparator(text);
					}
				}
				return _sTimeSeparator;
			}
		}

		internal unsafe bool NlsIsReplacementCulture
		{
			get
			{
				EnumData value = default(EnumData);
				value.strings = new List<string>();
				Interop.Kernel32.EnumSystemLocalesEx((delegate* unmanaged<char*, uint, void*, Interop.BOOL>)(delegate*<char*, uint, void*, Interop.BOOL>)(&EnumAllSystemLocalesProc), 8u, Unsafe.AsPointer(ref value), IntPtr.Zero);
				for (int i = 0; i < value.strings.Count; i++)
				{
					if (string.Equals(value.strings[i], _sRealName, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
				return false;
			}
		}

		internal static bool IsWin32Installed => true;

		private bool ShouldUseUserOverrideNlsData
		{
			get
			{
				if (!GlobalizationMode.UseNls)
				{
					return _bUseOverrides;
				}
				return true;
			}
		}

		internal static CultureData GetCultureDataForRegion(string cultureName, bool useUserOverride)
		{
			if (string.IsNullOrEmpty(cultureName))
			{
				return Invariant;
			}
			CultureData cultureData = null;
			cultureData = GetCultureData(cultureName, useUserOverride);
			if (cultureData != null && !cultureData.IsNeutralCulture)
			{
				return cultureData;
			}
			CultureData cultureData2 = cultureData;
			string key = AnsiToLower(useUserOverride ? cultureName : (cultureName + "*"));
			Dictionary<string, CultureData> dictionary = s_cachedRegions;
			if (dictionary == null)
			{
				dictionary = new Dictionary<string, CultureData>();
			}
			else
			{
				lock (s_lock)
				{
					dictionary.TryGetValue(key, out cultureData);
				}
				if (cultureData != null)
				{
					return cultureData;
				}
			}
			if ((cultureData == null || cultureData.IsNeutralCulture) && RegionNames.TryGetValue(cultureName, out var value))
			{
				cultureData = GetCultureData(value, useUserOverride);
			}
			if (!GlobalizationMode.Invariant && (cultureData == null || cultureData.IsNeutralCulture))
			{
				cultureData = (GlobalizationMode.UseNls ? NlsGetCultureDataFromRegionName(cultureName) : IcuGetCultureDataFromRegionName(cultureName));
			}
			if (cultureData != null && !cultureData.IsNeutralCulture)
			{
				lock (s_lock)
				{
					dictionary[key] = cultureData;
				}
				s_cachedRegions = dictionary;
			}
			else
			{
				cultureData = cultureData2;
			}
			return cultureData;
		}

		internal static void ClearCachedData()
		{
			s_cachedCultures = null;
			s_cachedRegions = null;
		}

		internal static CultureInfo[] GetCultures(CultureTypes types)
		{
			if (types <= (CultureTypes)0 || ((uint)types & 0xFFFFFF80u) != 0)
			{
				throw new ArgumentOutOfRangeException("types", SR.Format(SR.ArgumentOutOfRange_Range, CultureTypes.NeutralCultures, CultureTypes.FrameworkCultures));
			}
			if ((types & CultureTypes.WindowsOnlyCultures) != 0)
			{
				types &= ~CultureTypes.WindowsOnlyCultures;
			}
			if (GlobalizationMode.Invariant)
			{
				return new CultureInfo[1]
				{
					new CultureInfo("")
				};
			}
			if (!GlobalizationMode.UseNls)
			{
				return IcuEnumCultures(types);
			}
			return NlsEnumCultures(types);
		}

		private static CultureData CreateCultureWithInvariantData()
		{
			CultureData cultureData = new CultureData();
			cultureData._bUseOverrides = false;
			cultureData._bUseOverridesUserSetting = false;
			cultureData._sRealName = "";
			cultureData._sWindowsName = "";
			cultureData._sName = "";
			cultureData._sParent = "";
			cultureData._bNeutral = false;
			cultureData._sEnglishDisplayName = "Invariant Language (Invariant Country)";
			cultureData._sNativeDisplayName = "Invariant Language (Invariant Country)";
			cultureData._sSpecificCulture = "";
			cultureData._sISO639Language = "iv";
			cultureData._sISO639Language2 = "ivl";
			cultureData._sEnglishLanguage = "Invariant Language";
			cultureData._sNativeLanguage = "Invariant Language";
			cultureData._sAbbrevLang = "IVL";
			cultureData._sConsoleFallbackName = "";
			cultureData._iInputLanguageHandle = 127;
			cultureData._sRegionName = "IV";
			cultureData._sEnglishCountry = "Invariant Country";
			cultureData._sNativeCountry = "Invariant Country";
			cultureData._sISO3166CountryName = "IV";
			cultureData._sISO3166CountryName2 = "ivc";
			cultureData._iGeoId = 244;
			cultureData._sPositiveSign = "+";
			cultureData._sNegativeSign = "-";
			cultureData._iDigits = 2;
			cultureData._iNegativeNumber = 1;
			cultureData._waGrouping = new int[1] { 3 };
			cultureData._sDecimalSeparator = ".";
			cultureData._sThousandSeparator = ",";
			cultureData._sNaN = "NaN";
			cultureData._sPositiveInfinity = "Infinity";
			cultureData._sNegativeInfinity = "-Infinity";
			cultureData._iNegativePercent = 0;
			cultureData._iPositivePercent = 0;
			cultureData._sPercent = "%";
			cultureData._sPerMille = "‰";
			cultureData._sCurrency = "¤";
			cultureData._sIntlMonetarySymbol = "XDR";
			cultureData._sEnglishCurrency = "International Monetary Fund";
			cultureData._sNativeCurrency = "International Monetary Fund";
			cultureData._iCurrencyDigits = 2;
			cultureData._iCurrency = 0;
			cultureData._iNegativeCurrency = 0;
			cultureData._waMonetaryGrouping = new int[1] { 3 };
			cultureData._sMonetaryDecimal = ".";
			cultureData._sMonetaryThousand = ",";
			cultureData._iMeasure = 0;
			cultureData._sListSeparator = ",";
			cultureData._sTimeSeparator = ":";
			cultureData._sAM1159 = "AM";
			cultureData._sPM2359 = "PM";
			cultureData._saLongTimes = new string[1] { "HH:mm:ss" };
			cultureData._saShortTimes = new string[4] { "HH:mm", "hh:mm tt", "H:mm", "h:mm tt" };
			cultureData._saDurationFormats = new string[1] { "HH:mm:ss" };
			cultureData._iFirstDayOfWeek = 0;
			cultureData._iFirstWeekOfYear = 0;
			cultureData._waCalendars = new CalendarId[1] { CalendarId.GREGORIAN };
			if (!GlobalizationMode.Invariant)
			{
				cultureData._calendars = new CalendarData[23];
				cultureData._calendars[0] = CalendarData.Invariant;
			}
			cultureData._iReadingLayout = 0;
			cultureData._iLanguage = 127;
			cultureData._iDefaultAnsiCodePage = 1252;
			cultureData._iDefaultOemCodePage = 437;
			cultureData._iDefaultMacCodePage = 10000;
			cultureData._iDefaultEbcdicCodePage = 37;
			if (GlobalizationMode.Invariant)
			{
				cultureData._sLocalizedCountry = cultureData._sNativeCountry;
			}
			return cultureData;
		}

		internal static CultureData GetCultureData(string cultureName, bool useUserOverride)
		{
			if (string.IsNullOrEmpty(cultureName))
			{
				return Invariant;
			}
			if (GlobalizationMode.PredefinedCulturesOnly && (GlobalizationMode.Invariant || (GlobalizationMode.UseNls ? (!NlsIsEnsurePredefinedLocaleName(cultureName)) : (!IcuIsEnsurePredefinedLocaleName(cultureName)))))
			{
				return null;
			}
			string key = AnsiToLower(useUserOverride ? cultureName : (cultureName + "*"));
			Dictionary<string, CultureData> dictionary = s_cachedCultures;
			if (dictionary == null)
			{
				dictionary = new Dictionary<string, CultureData>();
			}
			else
			{
				bool flag;
				CultureData value;
				lock (s_lock)
				{
					flag = dictionary.TryGetValue(key, out value);
				}
				if (flag && value != null)
				{
					return value;
				}
			}
			CultureData cultureData = CreateCultureData(cultureName, useUserOverride);
			if (cultureData == null)
			{
				return null;
			}
			lock (s_lock)
			{
				dictionary[key] = cultureData;
			}
			s_cachedCultures = dictionary;
			return cultureData;
		}

		private static string NormalizeCultureName(string name, out bool isNeutralName)
		{
			isNeutralName = true;
			int i = 0;
			if (name.Length > 85)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidId, "name"));
			}
			Span<char> span = stackalloc char[name.Length];
			bool flag = false;
			for (; i < name.Length && name[i] != '-' && name[i] != '_'; i++)
			{
				if (name[i] >= 'A' && name[i] <= 'Z')
				{
					span[i] = (char)(name[i] + 32);
					flag = true;
				}
				else
				{
					span[i] = name[i];
				}
			}
			if (i < name.Length)
			{
				isNeutralName = false;
			}
			for (; i < name.Length; i++)
			{
				if (name[i] >= 'a' && name[i] <= 'z')
				{
					span[i] = (char)(name[i] - 32);
					flag = true;
				}
				else
				{
					span[i] = name[i];
				}
			}
			if (flag)
			{
				return new string(span);
			}
			return name;
		}

		private static CultureData CreateCultureData(string cultureName, bool useUserOverride)
		{
			if (GlobalizationMode.Invariant)
			{
				if (cultureName.Length > 85 || !CultureInfo.VerifyCultureName(cultureName, throwException: false))
				{
					return null;
				}
				CultureData cultureData = CreateCultureWithInvariantData();
				cultureData._sName = NormalizeCultureName(cultureName, out cultureData._bNeutral);
				cultureData._bUseOverridesUserSetting = useUserOverride;
				cultureData._sRealName = cultureData._sName;
				cultureData._sWindowsName = cultureData._sName;
				cultureData._iLanguage = 4096;
				return cultureData;
			}
			if (cultureName.Length == 1 && (cultureName[0] == 'C' || cultureName[0] == 'c'))
			{
				return Invariant;
			}
			CultureData cultureData2 = new CultureData();
			cultureData2._sRealName = cultureName;
			cultureData2._bUseOverridesUserSetting = useUserOverride;
			if (!cultureData2.InitCultureDataCore() && !cultureData2.InitCompatibilityCultureData())
			{
				return null;
			}
			cultureData2.InitUserOverride(useUserOverride);
			return cultureData2;
		}

		private bool InitCompatibilityCultureData()
		{
			string sRealName = _sRealName;
			string text = AnsiToLower(sRealName);
			string text2;
			string sName;
			if (!(text == "zh-chs"))
			{
				if (!(text == "zh-cht"))
				{
					return false;
				}
				text2 = "zh-Hant";
				sName = "zh-CHT";
			}
			else
			{
				text2 = "zh-Hans";
				sName = "zh-CHS";
			}
			_sRealName = text2;
			if (!InitCultureDataCore())
			{
				return false;
			}
			_sName = sName;
			_sParent = text2;
			return true;
		}

		internal static CultureData GetCultureData(int culture, bool bUseUserOverride)
		{
			string text = null;
			CultureData cultureData = null;
			if (culture == 127)
			{
				return Invariant;
			}
			if (GlobalizationMode.Invariant)
			{
				throw new CultureNotFoundException("culture", culture, SR.Argument_CultureNotSupportedInInvariantMode);
			}
			text = LCIDToLocaleName(culture);
			if (!string.IsNullOrEmpty(text))
			{
				cultureData = GetCultureData(text, bUseUserOverride);
			}
			if (cultureData == null)
			{
				throw new CultureNotFoundException("culture", culture, SR.Argument_CultureNotSupported);
			}
			return cultureData;
		}

		private string GetLanguageDisplayNameCore(string cultureName)
		{
			if (!GlobalizationMode.UseNls)
			{
				return IcuGetLanguageDisplayName(cultureName);
			}
			return NlsGetLanguageDisplayName(cultureName);
		}

		private string[] DeriveShortTimesFromLong()
		{
			string[] longTimes = LongTimes;
			string[] array = new string[longTimes.Length];
			for (int i = 0; i < longTimes.Length; i++)
			{
				array[i] = StripSecondsFromPattern(longTimes[i]);
			}
			return array;
		}

		private static string StripSecondsFromPattern(string time)
		{
			bool flag = false;
			int num = -1;
			for (int i = 0; i < time.Length; i++)
			{
				if (time[i] == '\'')
				{
					flag = !flag;
				}
				else if (time[i] == '\\')
				{
					i++;
				}
				else
				{
					if (flag)
					{
						continue;
					}
					switch (time[i])
					{
					case 's':
					{
						if (i - num <= 4 && i - num > 1 && time[num + 1] != '\'' && time[i - 1] != '\'' && num >= 0)
						{
							i = num + 1;
						}
						bool containsSpace;
						int indexOfNextTokenAfterSeconds = GetIndexOfNextTokenAfterSeconds(time, i, out containsSpace);
						time = string.Concat(str1: (!containsSpace) ? "" : " ", str0: time.AsSpan(0, i), str2: time.AsSpan(indexOfNextTokenAfterSeconds));
						break;
					}
					case 'H':
					case 'h':
					case 'm':
						num = i;
						break;
					}
				}
			}
			return time;
		}

		private static int GetIndexOfNextTokenAfterSeconds(string time, int index, out bool containsSpace)
		{
			bool flag = false;
			containsSpace = false;
			while (index < time.Length)
			{
				switch (time[index])
				{
				case '\'':
					flag = !flag;
					break;
				case '\\':
					index++;
					if (time[index] == ' ')
					{
						containsSpace = true;
					}
					break;
				case ' ':
					containsSpace = true;
					break;
				case 'H':
				case 'h':
				case 'm':
				case 't':
					if (!flag)
					{
						return index;
					}
					break;
				}
				index++;
			}
			containsSpace = false;
			return index;
		}

		internal string[] ShortDates(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saShortDates;
		}

		internal string[] LongDates(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saLongDates;
		}

		internal string[] YearMonths(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saYearMonths;
		}

		internal string[] DayNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saDayNames;
		}

		internal string[] AbbreviatedDayNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saAbbrevDayNames;
		}

		internal string[] SuperShortDayNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saSuperShortDayNames;
		}

		internal string[] MonthNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saMonthNames;
		}

		internal string[] GenitiveMonthNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saMonthGenitiveNames;
		}

		internal string[] AbbreviatedMonthNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saAbbrevMonthNames;
		}

		internal string[] AbbreviatedGenitiveMonthNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saAbbrevMonthGenitiveNames;
		}

		internal string[] LeapYearMonthNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saLeapYearMonthNames;
		}

		internal string MonthDay(CalendarId calendarId)
		{
			return GetCalendar(calendarId).sMonthDay;
		}

		internal string CalendarName(CalendarId calendarId)
		{
			return GetCalendar(calendarId).sNativeName;
		}

		internal CalendarData GetCalendar(CalendarId calendarId)
		{
			if (GlobalizationMode.Invariant)
			{
				return CalendarData.Invariant;
			}
			int num = (int)(calendarId - 1);
			if (_calendars == null)
			{
				_calendars = new CalendarData[23];
			}
			CalendarData calendarData = _calendars[num];
			if (calendarData == null)
			{
				calendarData = new CalendarData(_sWindowsName, calendarId, _bUseOverrides);
				_calendars[num] = calendarData;
			}
			return calendarData;
		}

		internal string[] EraNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saEraNames;
		}

		internal string[] AbbrevEraNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saAbbrevEraNames;
		}

		internal string[] AbbreviatedEnglishEraNames(CalendarId calendarId)
		{
			return GetCalendar(calendarId).saAbbrevEnglishEraNames;
		}

		internal string DateSeparator(CalendarId calendarId)
		{
			if (GlobalizationMode.Invariant)
			{
				return "/";
			}
			if (calendarId == CalendarId.JAPAN && !LocalAppContextSwitches.EnforceLegacyJapaneseDateParsing)
			{
				return "/";
			}
			return GetDateSeparator(ShortDates(calendarId)[0]);
		}

		private static string UnescapeNlsString(string str, int start, int end)
		{
			StringBuilder stringBuilder = null;
			for (int i = start; i < str.Length && i <= end; i++)
			{
				switch (str[i])
				{
				case '\'':
					if (stringBuilder == null)
					{
						stringBuilder = new StringBuilder(str, start, i - start, str.Length);
					}
					break;
				case '\\':
					if (stringBuilder == null)
					{
						stringBuilder = new StringBuilder(str, start, i - start, str.Length);
					}
					i++;
					if (i < str.Length)
					{
						stringBuilder.Append(str[i]);
					}
					break;
				default:
					stringBuilder?.Append(str[i]);
					break;
				}
			}
			if (stringBuilder == null)
			{
				return str.Substring(start, end - start + 1);
			}
			return stringBuilder.ToString();
		}

		private static string GetTimeSeparator(string format)
		{
			return GetSeparator(format, "Hhms");
		}

		private static string GetDateSeparator(string format)
		{
			return GetSeparator(format, "dyM");
		}

		private static string GetSeparator(string format, string timeParts)
		{
			int num = IndexOfTimePart(format, 0, timeParts);
			if (num != -1)
			{
				char c = format[num];
				do
				{
					num++;
				}
				while (num < format.Length && format[num] == c);
				int num2 = num;
				if (num2 < format.Length)
				{
					int num3 = IndexOfTimePart(format, num2, timeParts);
					if (num3 != -1)
					{
						return UnescapeNlsString(format, num2, num3 - 1);
					}
				}
			}
			return string.Empty;
		}

		private static int IndexOfTimePart(string format, int startIndex, string timeParts)
		{
			bool flag = false;
			for (int i = startIndex; i < format.Length; i++)
			{
				if (!flag && timeParts.Contains(format[i]))
				{
					return i;
				}
				switch (format[i])
				{
				case '\\':
					if (i + 1 < format.Length)
					{
						i++;
						char c = format[i];
						if (c != '\'' && c != '\\')
						{
							i--;
						}
					}
					break;
				case '\'':
					flag = !flag;
					break;
				}
			}
			return -1;
		}

		internal static bool IsCustomCultureId(int cultureId)
		{
			if (cultureId != 3072)
			{
				return cultureId == 4096;
			}
			return true;
		}

		internal void GetNFIValues(NumberFormatInfo nfi)
		{
			if (GlobalizationMode.Invariant || IsInvariantCulture)
			{
				nfi._positiveSign = _sPositiveSign;
				nfi._negativeSign = _sNegativeSign;
				nfi._numberGroupSeparator = _sThousandSeparator;
				nfi._numberDecimalSeparator = _sDecimalSeparator;
				nfi._numberDecimalDigits = _iDigits;
				nfi._numberNegativePattern = _iNegativeNumber;
				nfi._currencySymbol = _sCurrency;
				nfi._currencyGroupSeparator = _sMonetaryThousand;
				nfi._currencyDecimalSeparator = _sMonetaryDecimal;
				nfi._currencyDecimalDigits = _iCurrencyDigits;
				nfi._currencyNegativePattern = _iNegativeCurrency;
				nfi._currencyPositivePattern = _iCurrency;
			}
			else
			{
				nfi._positiveSign = GetLocaleInfoCoreUserOverride(LocaleStringData.PositiveSign);
				nfi._negativeSign = GetLocaleInfoCoreUserOverride(LocaleStringData.NegativeSign);
				nfi._numberDecimalSeparator = GetLocaleInfoCoreUserOverride(LocaleStringData.DecimalSeparator);
				nfi._numberGroupSeparator = GetLocaleInfoCoreUserOverride(LocaleStringData.ThousandSeparator);
				nfi._currencyGroupSeparator = GetLocaleInfoCoreUserOverride(LocaleStringData.MonetaryThousandSeparator);
				nfi._currencyDecimalSeparator = GetLocaleInfoCoreUserOverride(LocaleStringData.MonetaryDecimalSeparator);
				nfi._currencySymbol = GetLocaleInfoCoreUserOverride(LocaleStringData.MonetarySymbol);
				nfi._numberDecimalDigits = GetLocaleInfoCoreUserOverride(LocaleNumberData.FractionalDigitsCount);
				nfi._currencyDecimalDigits = GetLocaleInfoCoreUserOverride(LocaleNumberData.MonetaryFractionalDigitsCount);
				nfi._currencyPositivePattern = GetLocaleInfoCoreUserOverride(LocaleNumberData.PositiveMonetaryNumberFormat);
				nfi._currencyNegativePattern = GetLocaleInfoCoreUserOverride(LocaleNumberData.NegativeMonetaryNumberFormat);
				nfi._numberNegativePattern = GetLocaleInfoCoreUserOverride(LocaleNumberData.NegativeNumberFormat);
				string localeInfoCoreUserOverride = GetLocaleInfoCoreUserOverride(LocaleStringData.Digits);
				nfi._nativeDigits = new string[10];
				for (int i = 0; i < nfi._nativeDigits.Length; i++)
				{
					nfi._nativeDigits[i] = char.ToString(localeInfoCoreUserOverride[i]);
				}
				nfi._digitSubstitution = (ShouldUseUserOverrideNlsData ? NlsGetLocaleInfo(LocaleNumberData.DigitSubstitution) : IcuGetDigitSubstitution(_sRealName));
			}
			nfi._numberGroupSizes = NumberGroupSizes;
			nfi._currencyGroupSizes = CurrencyGroupSizes;
			nfi._percentNegativePattern = PercentNegativePattern;
			nfi._percentPositivePattern = PercentPositivePattern;
			nfi._percentSymbol = PercentSymbol;
			nfi._perMilleSymbol = PerMilleSymbol;
			nfi._negativeInfinitySymbol = NegativeInfinitySymbol;
			nfi._positiveInfinitySymbol = PositiveInfinitySymbol;
			nfi._nanSymbol = NaNSymbol;
			nfi._percentDecimalDigits = nfi._numberDecimalDigits;
			nfi._percentDecimalSeparator = nfi._numberDecimalSeparator;
			nfi._percentGroupSizes = nfi._numberGroupSizes;
			nfi._percentGroupSeparator = nfi._numberGroupSeparator;
			if (string.IsNullOrEmpty(nfi._positiveSign))
			{
				nfi._positiveSign = "+";
			}
			if (string.IsNullOrEmpty(nfi._currencyDecimalSeparator))
			{
				nfi._currencyDecimalSeparator = nfi._numberDecimalSeparator;
			}
		}

		internal static string AnsiToLower(string testString)
		{
			return TextInfo.ToLowerAsciiInvariant(testString);
		}

		private int GetLocaleInfoCore(LocaleNumberData type)
		{
			if (GlobalizationMode.Invariant)
			{
				return 0;
			}
			if (!GlobalizationMode.UseNls)
			{
				return IcuGetLocaleInfo(type);
			}
			return NlsGetLocaleInfo(type);
		}

		private int GetLocaleInfoCoreUserOverride(LocaleNumberData type)
		{
			if (GlobalizationMode.Invariant)
			{
				return 0;
			}
			if (!ShouldUseUserOverrideNlsData)
			{
				return IcuGetLocaleInfo(type);
			}
			return NlsGetLocaleInfo(type);
		}

		private string GetLocaleInfoCoreUserOverride(LocaleStringData type)
		{
			if (GlobalizationMode.Invariant)
			{
				return null;
			}
			if (!ShouldUseUserOverrideNlsData)
			{
				return IcuGetLocaleInfo(type);
			}
			return NlsGetLocaleInfo(type);
		}

		private string GetLocaleInfoCore(LocaleStringData type, string uiCultureName = null)
		{
			if (GlobalizationMode.Invariant)
			{
				return null;
			}
			if (!GlobalizationMode.UseNls)
			{
				return IcuGetLocaleInfo(type, uiCultureName);
			}
			return NlsGetLocaleInfo(type);
		}

		private string GetLocaleInfoCore(string localeName, LocaleStringData type, string uiCultureName = null)
		{
			if (GlobalizationMode.Invariant)
			{
				return null;
			}
			if (!GlobalizationMode.UseNls)
			{
				return IcuGetLocaleInfo(localeName, type, uiCultureName);
			}
			return NlsGetLocaleInfo(localeName, type);
		}

		private int[] GetLocaleInfoCoreUserOverride(LocaleGroupingData type)
		{
			if (GlobalizationMode.Invariant)
			{
				return null;
			}
			if (!ShouldUseUserOverrideNlsData)
			{
				return IcuGetLocaleInfo(type);
			}
			return NlsGetLocaleInfo(type);
		}

		private bool InitIcuCultureDataCore()
		{
			string text = _sRealName;
			if (!IsValidCultureName(text, out var indexOfUnderscore))
			{
				return false;
			}
			ReadOnlySpan<char> readOnlySpan = default(ReadOnlySpan<char>);
			if (indexOfUnderscore > 0)
			{
				readOnlySpan = text.AsSpan(indexOfUnderscore + 1);
				text = string.Concat(text.AsSpan(0, indexOfUnderscore), "@collation=", readOnlySpan);
			}
			if (!GetLocaleName(text, out _sWindowsName))
			{
				return false;
			}
			indexOfUnderscore = _sWindowsName.IndexOf("@collation=", StringComparison.Ordinal);
			if (indexOfUnderscore >= 0)
			{
				_sName = string.Concat(_sWindowsName.AsSpan(0, indexOfUnderscore), "_", readOnlySpan);
			}
			else
			{
				_sName = _sWindowsName;
			}
			_sRealName = _sName;
			_iLanguage = LCID;
			if (_iLanguage == 0)
			{
				_iLanguage = 4096;
			}
			_bNeutral = TwoLetterISOCountryName.Length == 0;
			_sSpecificCulture = (_bNeutral ? IcuLocaleData.GetSpecificCultureName(_sRealName) : _sRealName);
			if (indexOfUnderscore > 0 && !_bNeutral && !IsCustomCultureId(_iLanguage))
			{
				_sName = _sWindowsName.Substring(0, indexOfUnderscore);
			}
			return true;
		}

		internal unsafe static bool GetLocaleName(string localeName, out string windowsName)
		{
			char* value = stackalloc char[157];
			if (!Interop.Globalization.GetLocaleName(localeName, value, 157))
			{
				windowsName = null;
				return false;
			}
			windowsName = new string(value);
			return true;
		}

		private string IcuGetLocaleInfo(LocaleStringData type, string uiCultureName = null)
		{
			return IcuGetLocaleInfo(_sWindowsName, type, uiCultureName);
		}

		private unsafe string IcuGetLocaleInfo(string localeName, LocaleStringData type, string uiCultureName = null)
		{
			if (type == LocaleStringData.NegativeInfinitySymbol)
			{
				return IcuGetLocaleInfo(localeName, LocaleStringData.NegativeSign) + IcuGetLocaleInfo(localeName, LocaleStringData.PositiveInfinitySymbol);
			}
			char* value = stackalloc char[100];
			if (!Interop.Globalization.GetLocaleInfoString(localeName, (uint)type, value, 100, uiCultureName))
			{
				return string.Empty;
			}
			return new string(value);
		}

		private int IcuGetLocaleInfo(LocaleNumberData type)
		{
			if (type == LocaleNumberData.CalendarType)
			{
				return 0;
			}
			int value = 0;
			bool localeInfoInt = Interop.Globalization.GetLocaleInfoInt(_sWindowsName, (uint)type, ref value);
			return value;
		}

		private int[] IcuGetLocaleInfo(LocaleGroupingData type)
		{
			int primaryGroupSize = 0;
			int secondaryGroupSize = 0;
			bool localeInfoGroupingSizes = Interop.Globalization.GetLocaleInfoGroupingSizes(_sWindowsName, (uint)type, ref primaryGroupSize, ref secondaryGroupSize);
			if (secondaryGroupSize != 0)
			{
				return new int[2] { primaryGroupSize, secondaryGroupSize };
			}
			return new int[1] { primaryGroupSize };
		}

		private string IcuGetTimeFormatString()
		{
			return IcuGetTimeFormatString(shortFormat: false);
		}

		private unsafe string IcuGetTimeFormatString(bool shortFormat)
		{
			char* ptr = stackalloc char[100];
			if (!Interop.Globalization.GetLocaleTimeFormat(_sWindowsName, shortFormat, ptr, 100))
			{
				return string.Empty;
			}
			ReadOnlySpan<char> span = new ReadOnlySpan<char>(ptr, 100);
			return ConvertIcuTimeFormatString(span.Slice(0, span.IndexOf('\0')));
		}

		private static CultureData IcuGetCultureDataFromRegionName(string regionName)
		{
			return null;
		}

		private string IcuGetLanguageDisplayName(string cultureName)
		{
			return IcuGetLocaleInfo(cultureName, LocaleStringData.LocalizedDisplayName, CultureInfo.CurrentUICulture.Name);
		}

		private static string IcuGetRegionDisplayName()
		{
			return null;
		}

		internal static bool IcuIsEnsurePredefinedLocaleName(string name)
		{
			return Interop.Globalization.IsPredefinedLocale(name);
		}

		private static string ConvertIcuTimeFormatString(ReadOnlySpan<char> icuFormatString)
		{
			Span<char> span = stackalloc char[157];
			bool flag = false;
			int length = 0;
			for (int i = 0; i < icuFormatString.Length; i++)
			{
				switch (icuFormatString[i])
				{
				case '\'':
					span[length++] = icuFormatString[i++];
					for (; i < icuFormatString.Length; i++)
					{
						char c = icuFormatString[i];
						span[length++] = c;
						if (c == '\'')
						{
							break;
						}
					}
					break;
				case '.':
				case ':':
				case 'H':
				case 'h':
				case 'm':
				case 's':
					span[length++] = icuFormatString[i];
					break;
				case ' ':
				case '\u00a0':
					span[length++] = ' ';
					break;
				case 'a':
					if (!flag)
					{
						flag = true;
						span[length++] = 't';
						span[length++] = 't';
					}
					break;
				}
			}
			return span.Slice(0, length).ToString();
		}

		private static int IcuLocaleNameToLCID(string cultureName)
		{
			int localeDataNumericPart = IcuLocaleData.GetLocaleDataNumericPart(cultureName, IcuLocaleDataParts.Lcid);
			if (localeDataNumericPart != -1)
			{
				return localeDataNumericPart;
			}
			return 4096;
		}

		private static int IcuGetGeoId(string cultureName)
		{
			int localeDataNumericPart = IcuLocaleData.GetLocaleDataNumericPart(cultureName, IcuLocaleDataParts.GeoId);
			if (localeDataNumericPart != -1)
			{
				return localeDataNumericPart;
			}
			return Invariant.GeoId;
		}

		private static int IcuGetDigitSubstitution(string cultureName)
		{
			int localeDataNumericPart = IcuLocaleData.GetLocaleDataNumericPart(cultureName, IcuLocaleDataParts.DigitSubstitutionOrListSeparator);
			if (localeDataNumericPart != -1)
			{
				return (int)((long)localeDataNumericPart & 0xFFFFL);
			}
			return 1;
		}

		private static string IcuGetListSeparator(string cultureName)
		{
			int localeDataNumericPart = IcuLocaleData.GetLocaleDataNumericPart(cultureName, IcuLocaleDataParts.DigitSubstitutionOrListSeparator);
			if (localeDataNumericPart != -1)
			{
				switch (localeDataNumericPart & 0xFFFF0000u)
				{
				case 0L:
					return ",";
				case 65536L:
					return ";";
				case 131072L:
					return "،";
				case 196608L:
					return "؛";
				case 262144L:
					return ",,";
				}
			}
			return ",";
		}

		private static string IcuGetThreeLetterWindowsLanguageName(string cultureName)
		{
			return IcuLocaleData.GetThreeLetterWindowsLanguageName(cultureName) ?? "ZZZ";
		}

		private static CultureInfo[] IcuEnumCultures(CultureTypes types)
		{
			if ((types & (CultureTypes.NeutralCultures | CultureTypes.SpecificCultures)) == 0)
			{
				return Array.Empty<CultureInfo>();
			}
			int locales = Interop.Globalization.GetLocales(null, 0);
			if (locales <= 0)
			{
				return Array.Empty<CultureInfo>();
			}
			char[] array = new char[locales];
			locales = Interop.Globalization.GetLocales(array, locales);
			if (locales <= 0)
			{
				return Array.Empty<CultureInfo>();
			}
			bool flag = (types & CultureTypes.NeutralCultures) != 0;
			bool flag2 = (types & CultureTypes.SpecificCultures) != 0;
			List<CultureInfo> list = new List<CultureInfo>();
			if (flag)
			{
				list.Add(CultureInfo.InvariantCulture);
			}
			int num;
			for (int i = 0; i < locales; i += num)
			{
				num = array[i++];
				if (i + num <= locales)
				{
					CultureInfo cultureInfo = CultureInfo.GetCultureInfo(new string(array, i, num));
					if ((flag && cultureInfo.IsNeutralCulture) || (flag2 && !cultureInfo.IsNeutralCulture))
					{
						list.Add(cultureInfo);
					}
				}
			}
			return list.ToArray();
		}

		private static string IcuGetConsoleFallbackName(string cultureName)
		{
			return IcuLocaleData.GetConsoleUICulture(cultureName);
		}

		private static bool IsValidCultureName(string subject, out int indexOfUnderscore)
		{
			indexOfUnderscore = -1;
			if (subject.Length == 0)
			{
				return true;
			}
			if (subject.Length == 1 || subject.Length > 85)
			{
				return false;
			}
			bool flag = false;
			for (int i = 0; i < subject.Length; i++)
			{
				char c = subject[i];
				switch (c)
				{
				case '-':
				case '_':
					if (i == 0 || i == subject.Length - 1)
					{
						return false;
					}
					if (subject[i - 1] == '_' || subject[i - 1] == '-')
					{
						return false;
					}
					if (c == '_')
					{
						if (flag)
						{
							return false;
						}
						flag = true;
						indexOfUnderscore = i;
					}
					break;
				default:
					return false;
				case '\0':
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
				case 'G':
				case 'H':
				case 'I':
				case 'J':
				case 'K':
				case 'L':
				case 'M':
				case 'N':
				case 'O':
				case 'P':
				case 'Q':
				case 'R':
				case 'S':
				case 'T':
				case 'U':
				case 'V':
				case 'W':
				case 'X':
				case 'Y':
				case 'Z':
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
				case 'g':
				case 'h':
				case 'i':
				case 'j':
				case 'k':
				case 'l':
				case 'm':
				case 'n':
				case 'o':
				case 'p':
				case 'q':
				case 'r':
				case 's':
				case 't':
				case 'u':
				case 'v':
				case 'w':
				case 'x':
				case 'y':
				case 'z':
					break;
				}
			}
			return true;
		}

		internal unsafe static string GetLocaleInfoEx(string localeName, uint field)
		{
			char* ptr = stackalloc char[530];
			int localeInfoEx = GetLocaleInfoEx(localeName, field, ptr, 530);
			if (localeInfoEx > 0)
			{
				return new string(ptr);
			}
			return null;
		}

		internal unsafe static int GetLocaleInfoExInt(string localeName, uint field)
		{
			field |= 0x20000000u;
			int result = 0;
			GetLocaleInfoEx(localeName, field, (char*)(&result), 4);
			return result;
		}

		internal unsafe static int GetLocaleInfoEx(string lpLocaleName, uint lcType, char* lpLCData, int cchData)
		{
			return Interop.Kernel32.GetLocaleInfoEx(lpLocaleName, lcType, lpLCData, cchData);
		}

		private string NlsGetLocaleInfo(LocaleStringData type)
		{
			return NlsGetLocaleInfo(_sRealName, type);
		}

		private string NlsGetLocaleInfo(string localeName, LocaleStringData type)
		{
			return GetLocaleInfoFromLCType(localeName, (uint)type, _bUseOverrides);
		}

		private int NlsGetLocaleInfo(LocaleNumberData type)
		{
			uint num = (uint)type;
			if (!_bUseOverrides)
			{
				num |= 0x80000000u;
			}
			return GetLocaleInfoExInt(_sRealName, num);
		}

		private int[] NlsGetLocaleInfo(LocaleGroupingData type)
		{
			return ConvertWin32GroupString(GetLocaleInfoFromLCType(_sRealName, (uint)type, _bUseOverrides));
		}

		internal static bool NlsIsEnsurePredefinedLocaleName(string name)
		{
			return GetLocaleInfoExInt(name, 125u) != 1;
		}

		private string NlsGetTimeFormatString()
		{
			return ReescapeWin32String(GetLocaleInfoFromLCType(_sRealName, 4099u, _bUseOverrides));
		}

		private int NlsGetFirstDayOfWeek()
		{
			int localeInfoExInt = GetLocaleInfoExInt(_sRealName, 0x100Cu | ((!_bUseOverrides) ? 2147483648u : 0u));
			return ConvertFirstDayOfWeekMonToSun(localeInfoExInt);
		}

		private unsafe static CultureData NlsGetCultureDataFromRegionName(string regionName)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out EnumLocaleData value);
			value.cultureName = null;
			value.regionName = regionName;
			Interop.Kernel32.EnumSystemLocalesEx((delegate* unmanaged<char*, uint, void*, Interop.BOOL>)(delegate*<char*, uint, void*, Interop.BOOL>)(&EnumSystemLocalesProc), 34u, Unsafe.AsPointer(ref value), IntPtr.Zero);
			if (value.cultureName != null)
			{
				return GetCultureData(value.cultureName, useUserOverride: true);
			}
			return null;
		}

		private string NlsGetLanguageDisplayName(string cultureName)
		{
			CultureInfo userDefaultCulture;
			if (CultureInfo.DefaultThreadCurrentUICulture != null && (userDefaultCulture = CultureInfo.GetUserDefaultCulture()) != null && !CultureInfo.DefaultThreadCurrentUICulture.Name.Equals(userDefaultCulture.Name))
			{
				return NativeName;
			}
			return NlsGetLocaleInfo(cultureName, LocaleStringData.LocalizedDisplayName);
		}

		private string NlsGetRegionDisplayName()
		{
			if (CultureInfo.CurrentUICulture.Name.Equals(CultureInfo.UserDefaultUICulture.Name))
			{
				return NlsGetLocaleInfo(LocaleStringData.LocalizedCountryName);
			}
			return NativeCountryName;
		}

		private static string GetLocaleInfoFromLCType(string localeName, uint lctype, bool useUserOverride)
		{
			if (!useUserOverride)
			{
				lctype |= 0x80000000u;
			}
			return GetLocaleInfoEx(localeName, lctype) ?? string.Empty;
		}

		[return: NotNullIfNotNull("str")]
		internal static string ReescapeWin32String(string str)
		{
			if (str == null)
			{
				return null;
			}
			StringBuilder stringBuilder = null;
			bool flag = false;
			for (int i = 0; i < str.Length; i++)
			{
				if (str[i] == '\'')
				{
					if (flag)
					{
						if (i + 1 < str.Length && str[i + 1] == '\'')
						{
							if (stringBuilder == null)
							{
								stringBuilder = new StringBuilder(str, 0, i, str.Length * 2);
							}
							stringBuilder.Append("\\'");
							i++;
							continue;
						}
						flag = false;
					}
					else
					{
						flag = true;
					}
				}
				else if (str[i] == '\\')
				{
					if (stringBuilder == null)
					{
						stringBuilder = new StringBuilder(str, 0, i, str.Length * 2);
					}
					stringBuilder.Append("\\\\");
					continue;
				}
				stringBuilder?.Append(str[i]);
			}
			if (stringBuilder == null)
			{
				return str;
			}
			return stringBuilder.ToString();
		}

		[return: NotNullIfNotNull("array")]
		internal static string[] ReescapeWin32Strings(string[] array)
		{
			if (array != null)
			{
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = ReescapeWin32String(array[i]);
				}
			}
			return array;
		}

		private static int[] ConvertWin32GroupString(string win32Str)
		{
			if (string.IsNullOrEmpty(win32Str))
			{
				return new int[1] { 3 };
			}
			if (win32Str[0] == '0')
			{
				return new int[1];
			}
			int[] array;
			if (win32Str[^1] == '0')
			{
				array = new int[win32Str.Length / 2];
			}
			else
			{
				array = new int[win32Str.Length / 2 + 2];
				array[^1] = 0;
			}
			int num = 0;
			int num2 = 0;
			while (num < win32Str.Length && num2 < array.Length)
			{
				if (win32Str[num] < '1' || win32Str[num] > '9')
				{
					return new int[1] { 3 };
				}
				array[num2] = win32Str[num] - 48;
				num += 2;
				num2++;
			}
			return array;
		}

		private static int ConvertFirstDayOfWeekMonToSun(int iTemp)
		{
			iTemp++;
			if (iTemp > 6)
			{
				iTemp = 0;
			}
			return iTemp;
		}

		[UnmanagedCallersOnly]
		private unsafe static Interop.BOOL EnumSystemLocalesProc(char* lpLocaleString, uint flags, void* contextHandle)
		{
			ref EnumLocaleData reference = ref Unsafe.As<byte, EnumLocaleData>(ref *(byte*)contextHandle);
			try
			{
				string text = new string(lpLocaleString);
				string localeInfoEx = GetLocaleInfoEx(text, 90u);
				if (localeInfoEx != null && localeInfoEx.Equals(reference.regionName, StringComparison.OrdinalIgnoreCase))
				{
					reference.cultureName = text;
					return Interop.BOOL.FALSE;
				}
				return Interop.BOOL.TRUE;
			}
			catch (Exception)
			{
				return Interop.BOOL.FALSE;
			}
		}

		[UnmanagedCallersOnly]
		private unsafe static Interop.BOOL EnumAllSystemLocalesProc(char* lpLocaleString, uint flags, void* contextHandle)
		{
			ref EnumData reference = ref Unsafe.As<byte, EnumData>(ref *(byte*)contextHandle);
			try
			{
				reference.strings.Add(new string(lpLocaleString));
				return Interop.BOOL.TRUE;
			}
			catch (Exception)
			{
				return Interop.BOOL.FALSE;
			}
		}

		[UnmanagedCallersOnly]
		private unsafe static Interop.BOOL EnumTimeCallback(char* lpTimeFormatString, void* lParam)
		{
			ref EnumData reference = ref Unsafe.As<byte, EnumData>(ref *(byte*)lParam);
			try
			{
				reference.strings.Add(new string(lpTimeFormatString));
				return Interop.BOOL.TRUE;
			}
			catch (Exception)
			{
				return Interop.BOOL.FALSE;
			}
		}

		private unsafe static string[] nativeEnumTimeFormats(string localeName, uint dwFlags, bool useUserOverride)
		{
			EnumData value = default(EnumData);
			value.strings = new List<string>();
			Interop.Kernel32.EnumTimeFormatsEx((delegate* unmanaged<char*, void*, Interop.BOOL>)(delegate*<char*, void*, Interop.BOOL>)(&EnumTimeCallback), localeName, dwFlags, Unsafe.AsPointer(ref value));
			if (value.strings.Count > 0)
			{
				string[] array = value.strings.ToArray();
				if (!useUserOverride && value.strings.Count > 1)
				{
					uint lctype = ((dwFlags == 2) ? 121u : 4099u);
					string localeInfoFromLCType = GetLocaleInfoFromLCType(localeName, lctype, useUserOverride);
					if (localeInfoFromLCType != "")
					{
						string text = array[0];
						if (localeInfoFromLCType != text)
						{
							array[0] = array[1];
							array[1] = text;
						}
					}
				}
				return array;
			}
			return null;
		}

		private static int NlsLocaleNameToLCID(string cultureName)
		{
			return Interop.Kernel32.LocaleNameToLCID(cultureName, 134217728u);
		}

		private string NlsGetThreeLetterWindowsLanguageName(string cultureName)
		{
			return NlsGetLocaleInfo(cultureName, LocaleStringData.AbbreviatedWindowsLanguageName);
		}

		private unsafe static CultureInfo[] NlsEnumCultures(CultureTypes types)
		{
			uint num = 0u;
			if ((types & (CultureTypes.InstalledWin32Cultures | CultureTypes.ReplacementCultures | CultureTypes.FrameworkCultures)) != 0)
			{
				num |= 0x30u;
			}
			if ((types & CultureTypes.NeutralCultures) != 0)
			{
				num |= 0x10u;
			}
			if ((types & CultureTypes.SpecificCultures) != 0)
			{
				num |= 0x20u;
			}
			if ((types & CultureTypes.UserCustomCulture) != 0)
			{
				num |= 2u;
			}
			if ((types & CultureTypes.ReplacementCultures) != 0)
			{
				num |= 2u;
			}
			EnumData value = default(EnumData);
			value.strings = new List<string>();
			Interop.Kernel32.EnumSystemLocalesEx((delegate* unmanaged<char*, uint, void*, Interop.BOOL>)(delegate*<char*, uint, void*, Interop.BOOL>)(&EnumAllSystemLocalesProc), num, Unsafe.AsPointer(ref value), IntPtr.Zero);
			CultureInfo[] array = new CultureInfo[value.strings.Count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new CultureInfo(value.strings[i]);
			}
			return array;
		}

		private string NlsGetConsoleFallbackName(string cultureName)
		{
			return NlsGetLocaleInfo(cultureName, LocaleStringData.ConsoleFallbackName);
		}

		private unsafe bool InitCultureDataCore()
		{
			char* ptr = stackalloc char[85];
			if (!GlobalizationMode.UseNls)
			{
				if (InitIcuCultureDataCore())
				{
					return GetLocaleInfoEx(_sRealName, 92u, ptr, 85) != 0;
				}
				return false;
			}
			string sRealName = _sRealName;
			int localeInfoEx = GetLocaleInfoEx(sRealName, 92u, ptr, 85);
			if (localeInfoEx == 0)
			{
				return false;
			}
			_sRealName = new string(ptr, 0, localeInfoEx - 1);
			sRealName = _sRealName;
			if (GetLocaleInfoEx(sRealName, 536871025u, ptr, 2) == 0)
			{
				return false;
			}
			_bNeutral = *(uint*)ptr != 0;
			_sWindowsName = sRealName;
			if (_bNeutral)
			{
				_sName = sRealName;
				localeInfoEx = Interop.Kernel32.ResolveLocaleName(sRealName, ptr, 85);
				if (localeInfoEx < 1)
				{
					return false;
				}
				_sSpecificCulture = new string(ptr, 0, localeInfoEx - 1);
			}
			else
			{
				_sSpecificCulture = sRealName;
				_sName = sRealName;
				if (GetLocaleInfoEx(sRealName, 536870913u, ptr, 2) == 0)
				{
					return false;
				}
				_iLanguage = *(int*)ptr;
				if (!IsCustomCultureId(_iLanguage))
				{
					int num = sRealName.IndexOf('_');
					if (num > 0)
					{
						_sName = sRealName.Substring(0, num);
					}
				}
			}
			return true;
		}

		private void InitUserOverride(bool useUserOverride)
		{
			_bUseOverrides = useUserOverride && _sWindowsName == CultureInfo.UserDefaultLocaleName;
		}

		internal unsafe static CultureData GetCurrentRegionData()
		{
			Span<char> span = stackalloc char[10];
			int userGeoID = Interop.Kernel32.GetUserGeoID(16);
			if (userGeoID != -1)
			{
				int geoInfo;
				fixed (char* lpGeoData = span)
				{
					geoInfo = Interop.Kernel32.GetGeoInfo(userGeoID, 4, lpGeoData, span.Length, 0);
				}
				if (geoInfo != 0)
				{
					geoInfo -= ((span[geoInfo - 1] == '\0') ? 1 : 0);
					CultureData cultureDataForRegion = GetCultureDataForRegion(span.Slice(0, geoInfo).ToString(), useUserOverride: true);
					if (cultureDataForRegion != null)
					{
						return cultureDataForRegion;
					}
				}
			}
			return CultureInfo.CurrentCulture._cultureData;
		}

		private unsafe static string LCIDToLocaleName(int culture)
		{
			char* ptr = stackalloc char[86];
			int num = Interop.Kernel32.LCIDToLocaleName(culture, ptr, 86, 134217728u);
			if (num > 0)
			{
				return new string(ptr);
			}
			return null;
		}

		private string[] GetTimeFormatsCore(bool shortFormat)
		{
			if (GlobalizationMode.UseNls)
			{
				return ReescapeWin32Strings(nativeEnumTimeFormats(_sWindowsName, shortFormat ? 2u : 0u, _bUseOverrides));
			}
			string text = IcuGetTimeFormatString(shortFormat);
			if (_bUseOverrides)
			{
				string localeInfoFromLCType = GetLocaleInfoFromLCType(_sWindowsName, shortFormat ? 121u : 4099u, useUserOverride: true);
				if (localeInfoFromLCType != text)
				{
					return new string[2] { localeInfoFromLCType, text };
				}
				return new string[1] { localeInfoFromLCType };
			}
			return new string[1] { text };
		}

		private int GetAnsiCodePage(string cultureName)
		{
			return NlsGetLocaleInfo(LocaleNumberData.AnsiCodePage);
		}

		private int GetOemCodePage(string cultureName)
		{
			return NlsGetLocaleInfo(LocaleNumberData.OemCodePage);
		}

		private int GetMacCodePage(string cultureName)
		{
			return NlsGetLocaleInfo(LocaleNumberData.MacCodePage);
		}

		private int GetEbcdicCodePage(string cultureName)
		{
			return NlsGetLocaleInfo(LocaleNumberData.EbcdicCodePage);
		}
	}
	public class CultureInfo : IFormatProvider, ICloneable
	{
		private bool _isReadOnly;

		private CompareInfo _compareInfo;

		private TextInfo _textInfo;

		internal NumberFormatInfo _numInfo;

		internal DateTimeFormatInfo _dateTimeInfo;

		private Calendar _calendar;

		internal CultureData _cultureData;

		internal bool _isInherited;

		private CultureInfo _consoleFallbackCulture;

		internal string _name;

		private string _nonSortName;

		private string _sortName;

		private static volatile CultureInfo s_userDefaultCulture;

		private static volatile CultureInfo s_userDefaultUICulture;

		private static readonly CultureInfo s_InvariantCultureInfo = new CultureInfo(CultureData.Invariant, isReadOnly: true);

		private static volatile CultureInfo s_DefaultThreadCurrentUICulture;

		private static volatile CultureInfo s_DefaultThreadCurrentCulture;

		[ThreadStatic]
		private static CultureInfo s_currentThreadCulture;

		[ThreadStatic]
		private static CultureInfo s_currentThreadUICulture;

		private static AsyncLocal<CultureInfo> s_asyncLocalCurrentCulture;

		private static AsyncLocal<CultureInfo> s_asyncLocalCurrentUICulture;

		private static volatile Dictionary<string, CultureInfo> s_cachedCulturesByName;

		private static volatile Dictionary<int, CultureInfo> s_cachedCulturesByLcid;

		private CultureInfo _parent;

		internal const int LOCALE_NEUTRAL = 0;

		private const int LOCALE_USER_DEFAULT = 1024;

		private const int LOCALE_SYSTEM_DEFAULT = 2048;

		internal const int LOCALE_CUSTOM_UNSPECIFIED = 4096;

		internal const int LOCALE_CUSTOM_DEFAULT = 3072;

		internal const int LOCALE_INVARIANT = 127;

		public static CultureInfo CurrentCulture
		{
			get
			{
				return s_currentThreadCulture ?? s_DefaultThreadCurrentCulture ?? s_userDefaultCulture ?? InitializeUserDefaultCulture();
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (s_asyncLocalCurrentCulture == null)
				{
					Interlocked.CompareExchange(ref s_asyncLocalCurrentCulture, new AsyncLocal<CultureInfo>(AsyncLocalSetCurrentCulture), null);
				}
				s_asyncLocalCurrentCulture.Value = value;
			}
		}

		public static CultureInfo CurrentUICulture
		{
			get
			{
				return s_currentThreadUICulture ?? s_DefaultThreadCurrentUICulture ?? UserDefaultUICulture;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyCultureName(value, throwException: true);
				if (s_asyncLocalCurrentUICulture == null)
				{
					Interlocked.CompareExchange(ref s_asyncLocalCurrentUICulture, new AsyncLocal<CultureInfo>(AsyncLocalSetCurrentUICulture), null);
				}
				s_asyncLocalCurrentUICulture.Value = value;
			}
		}

		internal static CultureInfo UserDefaultUICulture => s_userDefaultUICulture ?? InitializeUserDefaultUICulture();

		public static CultureInfo InstalledUICulture => s_userDefaultCulture ?? InitializeUserDefaultCulture();

		public static CultureInfo? DefaultThreadCurrentCulture
		{
			get
			{
				return s_DefaultThreadCurrentCulture;
			}
			set
			{
				s_DefaultThreadCurrentCulture = value;
			}
		}

		public static CultureInfo? DefaultThreadCurrentUICulture
		{
			get
			{
				return s_DefaultThreadCurrentUICulture;
			}
			set
			{
				if (value != null)
				{
					VerifyCultureName(value, throwException: true);
				}
				s_DefaultThreadCurrentUICulture = value;
			}
		}

		public static CultureInfo InvariantCulture => s_InvariantCultureInfo;

		public virtual CultureInfo Parent
		{
			get
			{
				if (_parent == null)
				{
					string text = _cultureData.ParentName;
					if (text == "zh")
					{
						if (_name.Length == 5 && _name[2] == '-')
						{
							if ((_name[3] == 'C' && _name[4] == 'N') || (_name[3] == 'S' && _name[4] == 'G'))
							{
								text = "zh-Hans";
							}
							else if ((_name[3] == 'H' && _name[4] == 'K') || (_name[3] == 'M' && _name[4] == 'O') || (_name[3] == 'T' && _name[4] == 'W'))
							{
								text = "zh-Hant";
							}
						}
						else if (_name.Length > 8 && MemoryExtensions.Equals(_name.AsSpan(2, 4), "-Han", StringComparison.Ordinal) && _name[7] == '-')
						{
							if (_name[6] == 't')
							{
								text = "zh-Hant";
							}
							else if (_name[6] == 's')
							{
								text = "zh-Hans";
							}
						}
					}
					Interlocked.CompareExchange(value: (!string.IsNullOrEmpty(text)) ? (CreateCultureInfoNoThrow(text, _cultureData.UseUserOverride) ?? InvariantCulture) : InvariantCulture, location1: ref _parent, comparand: null);
				}
				return _parent;
			}
		}

		public virtual int LCID => _cultureData.LCID;

		public virtual int KeyboardLayoutId => _cultureData.KeyboardLayoutId;

		public virtual string Name
		{
			get
			{
				string text = _nonSortName;
				if (text == null)
				{
					string obj = _cultureData.Name ?? string.Empty;
					string text2 = obj;
					_nonSortName = obj;
					text = text2;
				}
				return text;
			}
		}

		internal string SortName => _sortName ?? (_sortName = _cultureData.SortName);

		public string IetfLanguageTag
		{
			get
			{
				string name = Name;
				if (!(name == "zh-CHT"))
				{
					if (name == "zh-CHS")
					{
						return "zh-Hans";
					}
					return Name;
				}
				return "zh-Hant";
			}
		}

		public virtual string DisplayName => _cultureData.DisplayName;

		public virtual string NativeName => _cultureData.NativeName;

		public virtual string EnglishName => _cultureData.EnglishName;

		public virtual string TwoLetterISOLanguageName => _cultureData.TwoLetterISOLanguageName;

		public virtual string ThreeLetterISOLanguageName => _cultureData.ThreeLetterISOLanguageName;

		public virtual string ThreeLetterWindowsLanguageName => _cultureData.ThreeLetterWindowsLanguageName;

		public virtual CompareInfo CompareInfo => _compareInfo ?? (_compareInfo = (UseUserOverride ? GetCultureInfo(_name).CompareInfo : new CompareInfo(this)));

		public virtual TextInfo TextInfo
		{
			get
			{
				if (_textInfo == null)
				{
					TextInfo textInfo = new TextInfo(_cultureData);
					textInfo.SetReadOnlyState(_isReadOnly);
					_textInfo = textInfo;
				}
				return _textInfo;
			}
		}

		public virtual bool IsNeutralCulture => _cultureData.IsNeutralCulture;

		public CultureTypes CultureTypes
		{
			get
			{
				CultureTypes cultureTypes = (_cultureData.IsNeutralCulture ? CultureTypes.NeutralCultures : CultureTypes.SpecificCultures);
				_ = CultureData.IsWin32Installed;
				cultureTypes |= CultureTypes.InstalledWin32Cultures;
				if (_cultureData.IsSupplementalCustomCulture)
				{
					cultureTypes |= CultureTypes.UserCustomCulture;
				}
				if (_cultureData.IsReplacementCulture)
				{
					cultureTypes |= CultureTypes.ReplacementCultures;
				}
				return cultureTypes;
			}
		}

		public virtual NumberFormatInfo NumberFormat
		{
			get
			{
				if (_numInfo == null)
				{
					NumberFormatInfo numberFormatInfo = new NumberFormatInfo(_cultureData);
					numberFormatInfo._isReadOnly = _isReadOnly;
					Interlocked.CompareExchange(ref _numInfo, numberFormatInfo, null);
				}
				return _numInfo;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_numInfo = value;
			}
		}

		public virtual DateTimeFormatInfo DateTimeFormat
		{
			get
			{
				if (_dateTimeInfo == null)
				{
					DateTimeFormatInfo dateTimeFormatInfo = new DateTimeFormatInfo(_cultureData, Calendar);
					dateTimeFormatInfo._isReadOnly = _isReadOnly;
					Interlocked.CompareExchange(ref _dateTimeInfo, dateTimeFormatInfo, null);
				}
				return _dateTimeInfo;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_dateTimeInfo = value;
			}
		}

		public virtual Calendar Calendar
		{
			get
			{
				if (_calendar == null)
				{
					Calendar defaultCalendar = _cultureData.DefaultCalendar;
					Interlocked.MemoryBarrier();
					defaultCalendar.SetReadOnlyState(_isReadOnly);
					_calendar = defaultCalendar;
				}
				return _calendar;
			}
		}

		public virtual Calendar[] OptionalCalendars
		{
			get
			{
				if (GlobalizationMode.Invariant)
				{
					return new GregorianCalendar[1]
					{
						new GregorianCalendar()
					};
				}
				CalendarId[] calendarIds = _cultureData.CalendarIds;
				Calendar[] array = new Calendar[calendarIds.Length];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = GetCalendarInstance(calendarIds[i]);
				}
				return array;
			}
		}

		public bool UseUserOverride => _cultureData.UseUserOverride;

		public bool IsReadOnly => _isReadOnly;

		internal bool HasInvariantCultureName => Name == InvariantCulture.Name;

		private static Dictionary<string, CultureInfo> CachedCulturesByName
		{
			get
			{
				Dictionary<string, CultureInfo> dictionary = s_cachedCulturesByName;
				if (dictionary == null)
				{
					dictionary = new Dictionary<string, CultureInfo>();
					dictionary = Interlocked.CompareExchange(ref s_cachedCulturesByName, dictionary, null) ?? dictionary;
				}
				return dictionary;
			}
		}

		private static Dictionary<int, CultureInfo> CachedCulturesByLcid
		{
			get
			{
				Dictionary<int, CultureInfo> dictionary = s_cachedCulturesByLcid;
				if (dictionary == null)
				{
					dictionary = new Dictionary<int, CultureInfo>();
					dictionary = Interlocked.CompareExchange(ref s_cachedCulturesByLcid, dictionary, null) ?? dictionary;
				}
				return dictionary;
			}
		}

		internal static string? UserDefaultLocaleName { get; set; } = GetUserDefaultLocaleName();


		private static void AsyncLocalSetCurrentCulture(AsyncLocalValueChangedArgs<CultureInfo> args)
		{
			s_currentThreadCulture = args.CurrentValue;
		}

		private static void AsyncLocalSetCurrentUICulture(AsyncLocalValueChangedArgs<CultureInfo> args)
		{
			s_currentThreadUICulture = args.CurrentValue;
		}

		private static CultureInfo InitializeUserDefaultCulture()
		{
			Interlocked.CompareExchange(ref s_userDefaultCulture, GetUserDefaultCulture(), null);
			return s_userDefaultCulture;
		}

		private static CultureInfo InitializeUserDefaultUICulture()
		{
			Interlocked.CompareExchange(ref s_userDefaultUICulture, GetUserDefaultUICulture(), null);
			return s_userDefaultUICulture;
		}

		private static string GetCultureNotSupportedExceptionMessage()
		{
			if (!GlobalizationMode.Invariant)
			{
				return SR.Argument_CultureNotSupported;
			}
			return SR.Argument_CultureNotSupportedInInvariantMode;
		}

		public CultureInfo(string name)
			: this(name, useUserOverride: true)
		{
		}

		public CultureInfo(string name, bool useUserOverride)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			CultureData cultureData = CultureData.GetCultureData(name, useUserOverride);
			if (cultureData == null)
			{
				throw new CultureNotFoundException("name", name, GetCultureNotSupportedExceptionMessage());
			}
			_cultureData = cultureData;
			_name = _cultureData.CultureName;
			_isInherited = GetType() != typeof(CultureInfo);
		}

		private CultureInfo(CultureData cultureData, bool isReadOnly = false)
		{
			_cultureData = cultureData;
			_name = cultureData.CultureName;
			_isReadOnly = isReadOnly;
		}

		private static CultureInfo CreateCultureInfoNoThrow(string name, bool useUserOverride)
		{
			CultureData cultureData = CultureData.GetCultureData(name, useUserOverride);
			if (cultureData == null)
			{
				return null;
			}
			return new CultureInfo(cultureData);
		}

		public CultureInfo(int culture)
			: this(culture, useUserOverride: true)
		{
		}

		public CultureInfo(int culture, bool useUserOverride)
		{
			if (culture < 0)
			{
				throw new ArgumentOutOfRangeException("culture", SR.ArgumentOutOfRange_NeedPosNum);
			}
			switch (culture)
			{
			case 0:
			case 1024:
			case 2048:
			case 3072:
			case 4096:
				throw new CultureNotFoundException("culture", culture, SR.Argument_CultureNotSupported);
			}
			_cultureData = CultureData.GetCultureData(culture, useUserOverride);
			_isInherited = GetType() != typeof(CultureInfo);
			_name = _cultureData.CultureName;
		}

		internal CultureInfo(string cultureName, string textAndCompareCultureName)
		{
			if (cultureName == null)
			{
				throw new ArgumentNullException("cultureName", SR.ArgumentNull_String);
			}
			CultureData cultureData = CultureData.GetCultureData(cultureName, useUserOverride: false) ?? throw new CultureNotFoundException("cultureName", cultureName, GetCultureNotSupportedExceptionMessage());
			_cultureData = cultureData;
			_name = _cultureData.CultureName;
			CultureInfo cultureInfo = GetCultureInfo(textAndCompareCultureName);
			_compareInfo = cultureInfo.CompareInfo;
			_textInfo = cultureInfo.TextInfo;
		}

		private static CultureInfo GetCultureByName(string name)
		{
			try
			{
				return new CultureInfo(name)
				{
					_isReadOnly = true
				};
			}
			catch (ArgumentException)
			{
				return InvariantCulture;
			}
		}

		public static CultureInfo CreateSpecificCulture(string name)
		{
			CultureInfo cultureInfo;
			try
			{
				cultureInfo = new CultureInfo(name);
			}
			catch (ArgumentException)
			{
				cultureInfo = null;
				for (int i = 0; i < name.Length; i++)
				{
					if ('-' == name[i])
					{
						try
						{
							cultureInfo = new CultureInfo(name.Substring(0, i));
						}
						catch (ArgumentException)
						{
							throw;
						}
						break;
					}
				}
				if (cultureInfo == null)
				{
					throw;
				}
			}
			if (!cultureInfo.IsNeutralCulture)
			{
				return cultureInfo;
			}
			return new CultureInfo(cultureInfo._cultureData.SpecificCultureName);
		}

		internal static bool VerifyCultureName(string cultureName, bool throwException)
		{
			foreach (char c in cultureName)
			{
				if (!char.IsLetterOrDigit(c) && c != '-' && c != '_')
				{
					if (throwException)
					{
						throw new ArgumentException(SR.Format(SR.Argument_InvalidResourceCultureName, cultureName));
					}
					return false;
				}
			}
			return true;
		}

		internal static bool VerifyCultureName(CultureInfo culture, bool throwException)
		{
			if (!culture._isInherited)
			{
				return true;
			}
			return VerifyCultureName(culture.Name, throwException);
		}

		public static CultureInfo[] GetCultures(CultureTypes types)
		{
			if ((types & CultureTypes.UserCustomCulture) == CultureTypes.UserCustomCulture)
			{
				types |= CultureTypes.ReplacementCultures;
			}
			return CultureData.GetCultures(types);
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (this == value)
			{
				return true;
			}
			if (value is CultureInfo cultureInfo)
			{
				if (Name.Equals(cultureInfo.Name))
				{
					return CompareInfo.Equals(cultureInfo.CompareInfo);
				}
				return false;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Name.GetHashCode() + CompareInfo.GetHashCode();
		}

		public override string ToString()
		{
			return _name;
		}

		public virtual object? GetFormat(Type? formatType)
		{
			if (formatType == typeof(NumberFormatInfo))
			{
				return NumberFormat;
			}
			if (formatType == typeof(DateTimeFormatInfo))
			{
				return DateTimeFormat;
			}
			return null;
		}

		public void ClearCachedData()
		{
			UserDefaultLocaleName = GetUserDefaultLocaleName();
			s_userDefaultCulture = GetUserDefaultCulture();
			s_userDefaultUICulture = GetUserDefaultUICulture();
			RegionInfo.s_currentRegionInfo = null;
			TimeZone.ResetTimeZone();
			TimeZoneInfo.ClearCachedData();
			s_cachedCulturesByLcid = null;
			s_cachedCulturesByName = null;
			CultureData.ClearCachedData();
		}

		internal static Calendar GetCalendarInstance(CalendarId calType)
		{
			if (calType == CalendarId.GREGORIAN)
			{
				return new GregorianCalendar();
			}
			return GetCalendarInstanceRare(calType);
		}

		internal static Calendar GetCalendarInstanceRare(CalendarId calType)
		{
			switch (calType)
			{
			case CalendarId.GREGORIAN_US:
			case CalendarId.GREGORIAN_ME_FRENCH:
			case CalendarId.GREGORIAN_ARABIC:
			case CalendarId.GREGORIAN_XLIT_ENGLISH:
			case CalendarId.GREGORIAN_XLIT_FRENCH:
				return new GregorianCalendar((GregorianCalendarTypes)calType);
			case CalendarId.TAIWAN:
				return new TaiwanCalendar();
			case CalendarId.JAPAN:
				return new JapaneseCalendar();
			case CalendarId.KOREA:
				return new KoreanCalendar();
			case CalendarId.THAI:
				return new ThaiBuddhistCalendar();
			case CalendarId.HIJRI:
				return new HijriCalendar();
			case CalendarId.HEBREW:
				return new HebrewCalendar();
			case CalendarId.UMALQURA:
				return new UmAlQuraCalendar();
			case CalendarId.PERSIAN:
				return new PersianCalendar();
			default:
				return new GregorianCalendar();
			}
		}

		public CultureInfo GetConsoleFallbackUICulture()
		{
			CultureInfo cultureInfo = _consoleFallbackCulture;
			if (cultureInfo == null)
			{
				cultureInfo = CreateSpecificCulture(_cultureData.SCONSOLEFALLBACKNAME);
				cultureInfo._isReadOnly = true;
				_consoleFallbackCulture = cultureInfo;
			}
			return cultureInfo;
		}

		public virtual object Clone()
		{
			CultureInfo cultureInfo = (CultureInfo)MemberwiseClone();
			cultureInfo._isReadOnly = false;
			if (!_isInherited)
			{
				if (_dateTimeInfo != null)
				{
					cultureInfo._dateTimeInfo = (DateTimeFormatInfo)_dateTimeInfo.Clone();
				}
				if (_numInfo != null)
				{
					cultureInfo._numInfo = (NumberFormatInfo)_numInfo.Clone();
				}
			}
			else
			{
				cultureInfo.DateTimeFormat = (DateTimeFormatInfo)DateTimeFormat.Clone();
				cultureInfo.NumberFormat = (NumberFormatInfo)NumberFormat.Clone();
			}
			if (_textInfo != null)
			{
				cultureInfo._textInfo = (TextInfo)_textInfo.Clone();
			}
			if (_dateTimeInfo != null && _dateTimeInfo.Calendar == _calendar)
			{
				cultureInfo._calendar = cultureInfo.DateTimeFormat.Calendar;
			}
			else if (_calendar != null)
			{
				cultureInfo._calendar = (Calendar)_calendar.Clone();
			}
			return cultureInfo;
		}

		public static CultureInfo ReadOnly(CultureInfo ci)
		{
			if (ci == null)
			{
				throw new ArgumentNullException("ci");
			}
			if (ci.IsReadOnly)
			{
				return ci;
			}
			CultureInfo cultureInfo = (CultureInfo)ci.MemberwiseClone();
			if (!ci.IsNeutralCulture)
			{
				if (!ci._isInherited)
				{
					if (ci._dateTimeInfo != null)
					{
						cultureInfo._dateTimeInfo = DateTimeFormatInfo.ReadOnly(ci._dateTimeInfo);
					}
					if (ci._numInfo != null)
					{
						cultureInfo._numInfo = NumberFormatInfo.ReadOnly(ci._numInfo);
					}
				}
				else
				{
					cultureInfo.DateTimeFormat = DateTimeFormatInfo.ReadOnly(ci.DateTimeFormat);
					cultureInfo.NumberFormat = NumberFormatInfo.ReadOnly(ci.NumberFormat);
				}
			}
			if (ci._textInfo != null)
			{
				cultureInfo._textInfo = System.Globalization.TextInfo.ReadOnly(ci._textInfo);
			}
			if (ci._calendar != null)
			{
				cultureInfo._calendar = System.Globalization.Calendar.ReadOnly(ci._calendar);
			}
			cultureInfo._isReadOnly = true;
			return cultureInfo;
		}

		private void VerifyWritable()
		{
			if (_isReadOnly)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
			}
		}

		public static CultureInfo GetCultureInfo(int culture)
		{
			if (culture <= 0)
			{
				throw new ArgumentOutOfRangeException("culture", SR.ArgumentOutOfRange_NeedPosNum);
			}
			Dictionary<int, CultureInfo> cachedCulturesByLcid = CachedCulturesByLcid;
			CultureInfo value;
			lock (cachedCulturesByLcid)
			{
				if (cachedCulturesByLcid.TryGetValue(culture, out value))
				{
					return value;
				}
			}
			try
			{
				value = new CultureInfo(culture, useUserOverride: false)
				{
					_isReadOnly = true
				};
			}
			catch (ArgumentException)
			{
				throw new CultureNotFoundException("culture", culture, GetCultureNotSupportedExceptionMessage());
			}
			lock (cachedCulturesByLcid)
			{
				cachedCulturesByLcid[culture] = value;
				return value;
			}
		}

		public static CultureInfo GetCultureInfo(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			name = CultureData.AnsiToLower(name);
			Dictionary<string, CultureInfo> cachedCulturesByName = CachedCulturesByName;
			CultureInfo value;
			lock (cachedCulturesByName)
			{
				if (cachedCulturesByName.TryGetValue(name, out value))
				{
					return value;
				}
			}
			value = CreateCultureInfoNoThrow(name, useUserOverride: false) ?? throw new CultureNotFoundException("name", name, GetCultureNotSupportedExceptionMessage());
			value._isReadOnly = true;
			name = CultureData.AnsiToLower(value._name);
			lock (cachedCulturesByName)
			{
				cachedCulturesByName[name] = value;
				return value;
			}
		}

		public static CultureInfo GetCultureInfo(string name, string altName)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (altName == null)
			{
				throw new ArgumentNullException("altName");
			}
			name = CultureData.AnsiToLower(name);
			altName = CultureData.AnsiToLower(altName);
			string key = name + "\ufffd" + altName;
			Dictionary<string, CultureInfo> cachedCulturesByName = CachedCulturesByName;
			CultureInfo value;
			lock (cachedCulturesByName)
			{
				if (cachedCulturesByName.TryGetValue(key, out value))
				{
					return value;
				}
			}
			try
			{
				value = new CultureInfo(name, altName)
				{
					_isReadOnly = true
				};
				value.TextInfo.SetReadOnlyState(readOnly: true);
			}
			catch (ArgumentException)
			{
				throw new CultureNotFoundException("name/altName", SR.Format(SR.Argument_OneOfCulturesNotSupported, name, altName));
			}
			lock (cachedCulturesByName)
			{
				cachedCulturesByName[key] = value;
				return value;
			}
		}

		public static CultureInfo GetCultureInfo(string name, bool predefinedOnly)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (predefinedOnly && !GlobalizationMode.Invariant && (GlobalizationMode.UseNls ? (!CultureData.NlsIsEnsurePredefinedLocaleName(name)) : (!CultureData.IcuIsEnsurePredefinedLocaleName(name))))
			{
				throw new CultureNotFoundException("name", name, SR.Format(SR.Argument_InvalidPredefinedCultureName, name));
			}
			return GetCultureInfo(name);
		}

		public static CultureInfo GetCultureInfoByIetfLanguageTag(string name)
		{
			if (name == "zh-CHT" || name == "zh-CHS")
			{
				throw new CultureNotFoundException("name", SR.Format(SR.Argument_CultureIetfNotSupported, name));
			}
			CultureInfo cultureInfo = GetCultureInfo(name);
			if (cultureInfo.LCID > 65535 || cultureInfo.LCID == 1034)
			{
				throw new CultureNotFoundException("name", SR.Format(SR.Argument_CultureIetfNotSupported, name));
			}
			return cultureInfo;
		}

		internal static CultureInfo GetUserDefaultCulture()
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantCulture;
			}
			string userDefaultLocaleName = UserDefaultLocaleName;
			if (userDefaultLocaleName == null)
			{
				return InvariantCulture;
			}
			return GetCultureByName(userDefaultLocaleName);
		}

		private unsafe static CultureInfo GetUserDefaultUICulture()
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantCulture;
			}
			uint num = 0u;
			uint num2 = 0u;
			if (Interop.Kernel32.GetUserPreferredUILanguages(8u, &num, null, &num2) != 0)
			{
				Span<char> span = ((num2 > 256) ? ((Span<char>)new char[num2]) : stackalloc char[(int)num2]);
				Span<char> span2 = span;
				fixed (char* pwszLanguagesBuffer = span2)
				{
					if (Interop.Kernel32.GetUserPreferredUILanguages(8u, &num, pwszLanguagesBuffer, &num2) != 0)
					{
						return GetCultureByName(span2.ToString());
					}
				}
			}
			return InitializeUserDefaultCulture();
		}

		private static string GetUserDefaultLocaleName()
		{
			string text;
			if (!GlobalizationMode.Invariant)
			{
				text = CultureData.GetLocaleInfoEx(null, 92u);
				if (text == null)
				{
					return CultureData.GetLocaleInfoEx("!x-sys-default-locale", 92u);
				}
			}
			else
			{
				text = InvariantCulture.Name;
			}
			return text;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class CultureNotFoundException : ArgumentException
	{
		private readonly string _invalidCultureName;

		private readonly int? _invalidCultureId;

		public virtual int? InvalidCultureId => _invalidCultureId;

		public virtual string? InvalidCultureName => _invalidCultureName;

		private static string DefaultMessage => SR.Argument_CultureNotSupported;

		private string? FormattedInvalidCultureId
		{
			get
			{
				if (!InvalidCultureId.HasValue)
				{
					return InvalidCultureName;
				}
				return string.Format(CultureInfo.InvariantCulture, "{0} (0x{0:x4})", InvalidCultureId.Value);
			}
		}

		public override string Message
		{
			get
			{
				string message = base.Message;
				if (_invalidCultureId.HasValue || _invalidCultureName != null)
				{
					string text = SR.Format(SR.Argument_CultureInvalidIdentifier, FormattedInvalidCultureId);
					if (message == null)
					{
						return text;
					}
					return message + "\r\n" + text;
				}
				return message;
			}
		}

		public CultureNotFoundException()
			: base(DefaultMessage)
		{
		}

		public CultureNotFoundException(string? message)
			: base(message)
		{
		}

		public CultureNotFoundException(string? paramName, string? message)
			: base(message, paramName)
		{
		}

		public CultureNotFoundException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		public CultureNotFoundException(string? paramName, string? invalidCultureName, string? message)
			: base(message, paramName)
		{
			_invalidCultureName = invalidCultureName;
		}

		public CultureNotFoundException(string? message, string? invalidCultureName, Exception? innerException)
			: base(message, innerException)
		{
			_invalidCultureName = invalidCultureName;
		}

		public CultureNotFoundException(string? message, int invalidCultureId, Exception? innerException)
			: base(message, innerException)
		{
			_invalidCultureId = invalidCultureId;
		}

		public CultureNotFoundException(string? paramName, int invalidCultureId, string? message)
			: base(message, paramName)
		{
			_invalidCultureId = invalidCultureId;
		}

		protected CultureNotFoundException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_invalidCultureId = (int?)info.GetValue("InvalidCultureId", typeof(int?));
			_invalidCultureName = (string)info.GetValue("InvalidCultureName", typeof(string));
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("InvalidCultureId", _invalidCultureId, typeof(int?));
			info.AddValue("InvalidCultureName", _invalidCultureName, typeof(string));
		}
	}
	[Flags]
	public enum CultureTypes
	{
		NeutralCultures = 1,
		SpecificCultures = 2,
		InstalledWin32Cultures = 4,
		AllCultures = 7,
		UserCustomCulture = 8,
		ReplacementCultures = 0x10,
		[Obsolete("CultureTypes.WindowsOnlyCultures has been deprecated. Use other values in CultureTypes instead.")]
		WindowsOnlyCultures = 0x20,
		[Obsolete("CultureTypes.FrameworkCultures has been deprecated. Use other values in CultureTypes instead.")]
		FrameworkCultures = 0x40
	}
	[Flags]
	internal enum MonthNameStyles
	{
		Regular = 0,
		Genitive = 1,
		LeapYear = 2
	}
	[Flags]
	internal enum DateTimeFormatFlags
	{
		None = 0,
		UseGenitiveMonth = 1,
		UseLeapYearMonth = 2,
		UseSpacesInMonthNames = 4,
		UseHebrewRule = 8,
		UseSpacesInDayNames = 0x10,
		UseDigitPrefixInTokens = 0x20,
		NotInitialized = -1
	}
	public sealed class DateTimeFormatInfo : IFormatProvider, ICloneable
	{
		internal sealed class TokenHashValue
		{
			internal string tokenString;

			internal TokenType tokenType;

			internal int tokenValue;

			internal TokenHashValue(string tokenString, TokenType tokenType, int tokenValue)
			{
				this.tokenString = tokenString;
				this.tokenType = tokenType;
				this.tokenValue = tokenValue;
			}
		}

		private static volatile DateTimeFormatInfo s_invariantInfo;

		private readonly CultureData _cultureData;

		private string _name;

		private string _langName;

		private CompareInfo _compareInfo;

		private CultureInfo _cultureInfo;

		private string amDesignator;

		private string pmDesignator;

		private string dateSeparator;

		private string generalShortTimePattern;

		private string generalLongTimePattern;

		private string timeSeparator;

		private string monthDayPattern;

		private string dateTimeOffsetPattern;

		private Calendar calendar;

		private int firstDayOfWeek = -1;

		private int calendarWeekRule = -1;

		private string fullDateTimePattern;

		private string[] abbreviatedDayNames;

		private string[] m_superShortDayNames;

		private string[] dayNames;

		private string[] abbreviatedMonthNames;

		private string[] monthNames;

		private string[] genitiveMonthNames;

		private string[] m_genitiveAbbreviatedMonthNames;

		private string[] leapYearMonthNames;

		private string longDatePattern;

		private string shortDatePattern;

		private string yearMonthPattern;

		private string longTimePattern;

		private string shortTimePattern;

		private string[] allYearMonthPatterns;

		private string[] allShortDatePatterns;

		private string[] allLongDatePatterns;

		private string[] allShortTimePatterns;

		private string[] allLongTimePatterns;

		private string[] m_eraNames;

		private string[] m_abbrevEraNames;

		private string[] m_abbrevEnglishEraNames;

		private CalendarId[] optionalCalendars;

		internal bool _isReadOnly;

		private DateTimeFormatFlags formatFlags = DateTimeFormatFlags.NotInitialized;

		private string _decimalSeparator;

		private string _fullTimeSpanPositivePattern;

		private string _fullTimeSpanNegativePattern;

		private TokenHashValue[] _dtfiTokenHash;

		private static volatile DateTimeFormatInfo s_jajpDTFI;

		private static volatile DateTimeFormatInfo s_zhtwDTFI;

		private string CultureName => _name ?? (_name = _cultureData.CultureName);

		private CultureInfo Culture => _cultureInfo ?? (_cultureInfo = CultureInfo.GetCultureInfo(CultureName));

		private string LanguageName => _langName ?? (_langName = _cultureData.TwoLetterISOLanguageName);

		public static DateTimeFormatInfo InvariantInfo
		{
			get
			{
				if (s_invariantInfo == null)
				{
					DateTimeFormatInfo dateTimeFormatInfo = new DateTimeFormatInfo();
					dateTimeFormatInfo.Calendar.SetReadOnlyState(readOnly: true);
					dateTimeFormatInfo._isReadOnly = true;
					s_invariantInfo = dateTimeFormatInfo;
				}
				return s_invariantInfo;
			}
		}

		public static DateTimeFormatInfo CurrentInfo
		{
			get
			{
				CultureInfo currentCulture = CultureInfo.CurrentCulture;
				if (!currentCulture._isInherited)
				{
					DateTimeFormatInfo dateTimeInfo = currentCulture._dateTimeInfo;
					if (dateTimeInfo != null)
					{
						return dateTimeInfo;
					}
				}
				return (DateTimeFormatInfo)currentCulture.GetFormat(typeof(DateTimeFormatInfo));
			}
		}

		public string AMDesignator
		{
			get
			{
				if (amDesignator == null)
				{
					amDesignator = _cultureData.AMDesignator;
				}
				return amDesignator;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				ClearTokenHashTable();
				amDesignator = value;
			}
		}

		public Calendar Calendar
		{
			get
			{
				return calendar;
			}
			[MemberNotNull("calendar")]
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value == calendar)
				{
					return;
				}
				for (int i = 0; i < OptionalCalendars.Length; i++)
				{
					if (OptionalCalendars[i] == value.ID)
					{
						if (calendar != null)
						{
							m_eraNames = null;
							m_abbrevEraNames = null;
							m_abbrevEnglishEraNames = null;
							monthDayPattern = null;
							dayNames = null;
							abbreviatedDayNames = null;
							m_superShortDayNames = null;
							monthNames = null;
							abbreviatedMonthNames = null;
							genitiveMonthNames = null;
							m_genitiveAbbreviatedMonthNames = null;
							leapYearMonthNames = null;
							formatFlags = DateTimeFormatFlags.NotInitialized;
							allShortDatePatterns = null;
							allLongDatePatterns = null;
							allYearMonthPatterns = null;
							dateTimeOffsetPattern = null;
							longDatePattern = null;
							shortDatePattern = null;
							yearMonthPattern = null;
							fullDateTimePattern = null;
							generalShortTimePattern = null;
							generalLongTimePattern = null;
							dateSeparator = null;
							ClearTokenHashTable();
						}
						calendar = value;
						InitializeOverridableProperties(_cultureData, calendar.ID);
						return;
					}
				}
				throw new ArgumentOutOfRangeException("value", value, SR.Argument_InvalidCalendar);
			}
		}

		private CalendarId[] OptionalCalendars => optionalCalendars ?? (optionalCalendars = _cultureData.CalendarIds);

		internal string[] EraNames => m_eraNames ?? (m_eraNames = _cultureData.EraNames(Calendar.ID));

		internal string[] AbbreviatedEraNames => m_abbrevEraNames ?? (m_abbrevEraNames = _cultureData.AbbrevEraNames(Calendar.ID));

		internal string[] AbbreviatedEnglishEraNames
		{
			get
			{
				if (m_abbrevEnglishEraNames == null)
				{
					m_abbrevEnglishEraNames = _cultureData.AbbreviatedEnglishEraNames(Calendar.ID);
				}
				return m_abbrevEnglishEraNames;
			}
		}

		public string DateSeparator
		{
			get
			{
				if (dateSeparator == null)
				{
					dateSeparator = _cultureData.DateSeparator(Calendar.ID);
				}
				return dateSeparator;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				ClearTokenHashTable();
				dateSeparator = value;
			}
		}

		public DayOfWeek FirstDayOfWeek
		{
			get
			{
				if (firstDayOfWeek == -1)
				{
					firstDayOfWeek = _cultureData.FirstDayOfWeek;
				}
				return (DayOfWeek)firstDayOfWeek;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value < DayOfWeek.Sunday || value > DayOfWeek.Saturday)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, DayOfWeek.Sunday, DayOfWeek.Saturday));
				}
				firstDayOfWeek = (int)value;
			}
		}

		public CalendarWeekRule CalendarWeekRule
		{
			get
			{
				if (calendarWeekRule == -1)
				{
					calendarWeekRule = _cultureData.CalendarWeekRule;
				}
				return (CalendarWeekRule)calendarWeekRule;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value < CalendarWeekRule.FirstDay || value > CalendarWeekRule.FirstFourDayWeek)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, CalendarWeekRule.FirstDay, CalendarWeekRule.FirstFourDayWeek));
				}
				calendarWeekRule = (int)value;
			}
		}

		public string FullDateTimePattern
		{
			get
			{
				return fullDateTimePattern ?? (fullDateTimePattern = LongDatePattern + " " + LongTimePattern);
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				fullDateTimePattern = value;
			}
		}

		public string LongDatePattern
		{
			get
			{
				return longDatePattern ?? (longDatePattern = UnclonedLongDatePatterns[0]);
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				longDatePattern = value;
				OnLongDatePatternChanged();
			}
		}

		public string LongTimePattern
		{
			get
			{
				return longTimePattern ?? (longTimePattern = UnclonedLongTimePatterns[0]);
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				longTimePattern = value;
				OnLongTimePatternChanged();
			}
		}

		public string MonthDayPattern
		{
			get
			{
				if (monthDayPattern == null)
				{
					monthDayPattern = _cultureData.MonthDay(Calendar.ID);
				}
				return monthDayPattern;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				monthDayPattern = value;
			}
		}

		public string PMDesignator
		{
			get
			{
				if (pmDesignator == null)
				{
					pmDesignator = _cultureData.PMDesignator;
				}
				return pmDesignator;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				ClearTokenHashTable();
				pmDesignator = value;
			}
		}

		public string RFC1123Pattern => "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'";

		public string ShortDatePattern
		{
			get
			{
				return shortDatePattern ?? (shortDatePattern = UnclonedShortDatePatterns[0]);
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				shortDatePattern = value;
				OnShortDatePatternChanged();
			}
		}

		public string ShortTimePattern
		{
			get
			{
				return shortTimePattern ?? (shortTimePattern = UnclonedShortTimePatterns[0]);
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				shortTimePattern = value;
				OnShortTimePatternChanged();
			}
		}

		public string SortableDateTimePattern => "yyyy'-'MM'-'dd'T'HH':'mm':'ss";

		internal string GeneralShortTimePattern => generalShortTimePattern ?? (generalShortTimePattern = ShortDatePattern + " " + ShortTimePattern);

		internal string GeneralLongTimePattern => generalLongTimePattern ?? (generalLongTimePattern = ShortDatePattern + " " + LongTimePattern);

		internal string DateTimeOffsetPattern
		{
			get
			{
				if (dateTimeOffsetPattern == null)
				{
					bool flag = false;
					bool flag2 = false;
					char c = '\'';
					int num = 0;
					while (!flag && num < LongTimePattern.Length)
					{
						switch (LongTimePattern[num])
						{
						case 'z':
							flag = !flag2;
							break;
						case '"':
						case '\'':
							if (flag2 && c == LongTimePattern[num])
							{
								flag2 = false;
							}
							else if (!flag2)
							{
								c = LongTimePattern[num];
								flag2 = true;
							}
							break;
						case '%':
						case '\\':
							num++;
							break;
						}
						num++;
					}
					dateTimeOffsetPattern = (flag ? (ShortDatePattern + " " + LongTimePattern) : (ShortDatePattern + " " + LongTimePattern + " zzz"));
				}
				return dateTimeOffsetPattern;
			}
		}

		public string TimeSeparator
		{
			get
			{
				if (timeSeparator == null)
				{
					timeSeparator = _cultureData.TimeSeparator;
				}
				return timeSeparator;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				ClearTokenHashTable();
				timeSeparator = value;
			}
		}

		public string UniversalSortableDateTimePattern => "yyyy'-'MM'-'dd HH':'mm':'ss'Z'";

		public string YearMonthPattern
		{
			get
			{
				return yearMonthPattern ?? (yearMonthPattern = UnclonedYearMonthPatterns[0]);
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				yearMonthPattern = value;
				OnYearMonthPatternChanged();
			}
		}

		public string[] AbbreviatedDayNames
		{
			get
			{
				return (string[])InternalGetAbbreviatedDayOfWeekNames().Clone();
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value.Length != 7)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidArrayLength, 7), "value");
				}
				CheckNullValue(value, value.Length);
				ClearTokenHashTable();
				abbreviatedDayNames = value;
			}
		}

		public string[] ShortestDayNames
		{
			get
			{
				return (string[])InternalGetSuperShortDayNames().Clone();
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value.Length != 7)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidArrayLength, 7), "value");
				}
				CheckNullValue(value, value.Length);
				m_superShortDayNames = value;
			}
		}

		public string[] DayNames
		{
			get
			{
				return (string[])InternalGetDayOfWeekNames().Clone();
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value.Length != 7)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidArrayLength, 7), "value");
				}
				CheckNullValue(value, value.Length);
				ClearTokenHashTable();
				dayNames = value;
			}
		}

		public string[] AbbreviatedMonthNames
		{
			get
			{
				return (string[])InternalGetAbbreviatedMonthNames().Clone();
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value.Length != 13)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidArrayLength, 13), "value");
				}
				CheckNullValue(value, value.Length - 1);
				ClearTokenHashTable();
				abbreviatedMonthNames = value;
			}
		}

		public string[] MonthNames
		{
			get
			{
				return (string[])InternalGetMonthNames().Clone();
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value.Length != 13)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidArrayLength, 13), "value");
				}
				CheckNullValue(value, value.Length - 1);
				monthNames = value;
				ClearTokenHashTable();
			}
		}

		internal bool HasSpacesInMonthNames => (FormatFlags & DateTimeFormatFlags.UseSpacesInMonthNames) != 0;

		internal bool HasSpacesInDayNames => (FormatFlags & DateTimeFormatFlags.UseSpacesInDayNames) != 0;

		private string[] AllYearMonthPatterns => GetMergedPatterns(UnclonedYearMonthPatterns, YearMonthPattern);

		private string[] AllShortDatePatterns => GetMergedPatterns(UnclonedShortDatePatterns, ShortDatePattern);

		private string[] AllShortTimePatterns => GetMergedPatterns(UnclonedShortTimePatterns, ShortTimePattern);

		private string[] AllLongDatePatterns => GetMergedPatterns(UnclonedLongDatePatterns, LongDatePattern);

		private string[] AllLongTimePatterns => GetMergedPatterns(UnclonedLongTimePatterns, LongTimePattern);

		private string[] UnclonedYearMonthPatterns
		{
			get
			{
				if (allYearMonthPatterns == null)
				{
					allYearMonthPatterns = _cultureData.YearMonths(Calendar.ID);
				}
				return allYearMonthPatterns;
			}
		}

		private string[] UnclonedShortDatePatterns
		{
			get
			{
				if (allShortDatePatterns == null)
				{
					allShortDatePatterns = _cultureData.ShortDates(Calendar.ID);
				}
				return allShortDatePatterns;
			}
		}

		private string[] UnclonedLongDatePatterns
		{
			get
			{
				if (allLongDatePatterns == null)
				{
					allLongDatePatterns = _cultureData.LongDates(Calendar.ID);
				}
				return allLongDatePatterns;
			}
		}

		private string[] UnclonedShortTimePatterns
		{
			get
			{
				if (allShortTimePatterns == null)
				{
					allShortTimePatterns = _cultureData.ShortTimes;
				}
				return allShortTimePatterns;
			}
		}

		private string[] UnclonedLongTimePatterns
		{
			get
			{
				if (allLongTimePatterns == null)
				{
					allLongTimePatterns = _cultureData.LongTimes;
				}
				return allLongTimePatterns;
			}
		}

		public bool IsReadOnly => _isReadOnly;

		public string NativeCalendarName => _cultureData.CalendarName(Calendar.ID);

		public string[] AbbreviatedMonthGenitiveNames
		{
			get
			{
				return (string[])InternalGetGenitiveMonthNames(abbreviated: true).Clone();
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value.Length != 13)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidArrayLength, 13), "value");
				}
				CheckNullValue(value, value.Length - 1);
				ClearTokenHashTable();
				m_genitiveAbbreviatedMonthNames = value;
			}
		}

		public string[] MonthGenitiveNames
		{
			get
			{
				return (string[])InternalGetGenitiveMonthNames(abbreviated: false).Clone();
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (value.Length != 13)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidArrayLength, 13), "value");
				}
				CheckNullValue(value, value.Length - 1);
				genitiveMonthNames = value;
				ClearTokenHashTable();
			}
		}

		internal string DecimalSeparator => _decimalSeparator ?? (_decimalSeparator = new NumberFormatInfo(_cultureData.UseUserOverride ? CultureData.GetCultureData(_cultureData.CultureName, useUserOverride: false) : _cultureData).NumberDecimalSeparator);

		internal string FullTimeSpanPositivePattern => _fullTimeSpanPositivePattern ?? (_fullTimeSpanPositivePattern = "d':'h':'mm':'ss'" + DecimalSeparator + "'FFFFFFF");

		internal string FullTimeSpanNegativePattern => _fullTimeSpanNegativePattern ?? (_fullTimeSpanNegativePattern = "'-'" + FullTimeSpanPositivePattern);

		internal CompareInfo CompareInfo => _compareInfo ?? (_compareInfo = System.Globalization.CompareInfo.GetCompareInfo(_cultureData.SortName));

		internal DateTimeFormatFlags FormatFlags
		{
			get
			{
				if (formatFlags == DateTimeFormatFlags.NotInitialized)
				{
					return InitializeFormatFlags();
				}
				return formatFlags;
			}
		}

		internal bool HasForceTwoDigitYears
		{
			get
			{
				CalendarId iD = calendar.ID;
				if (iD - 3 <= CalendarId.GREGORIAN)
				{
					return true;
				}
				return false;
			}
		}

		internal bool HasYearMonthAdjustment => (FormatFlags & DateTimeFormatFlags.UseHebrewRule) != 0;

		private string[] InternalGetAbbreviatedDayOfWeekNames()
		{
			return abbreviatedDayNames ?? InternalGetAbbreviatedDayOfWeekNamesCore();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private string[] InternalGetAbbreviatedDayOfWeekNamesCore()
		{
			abbreviatedDayNames = _cultureData.AbbreviatedDayNames(Calendar.ID);
			return abbreviatedDayNames;
		}

		private string[] InternalGetSuperShortDayNames()
		{
			return m_superShortDayNames ?? InternalGetSuperShortDayNamesCore();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private string[] InternalGetSuperShortDayNamesCore()
		{
			m_superShortDayNames = _cultureData.SuperShortDayNames(Calendar.ID);
			return m_superShortDayNames;
		}

		private string[] InternalGetDayOfWeekNames()
		{
			return dayNames ?? InternalGetDayOfWeekNamesCore();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private string[] InternalGetDayOfWeekNamesCore()
		{
			dayNames = _cultureData.DayNames(Calendar.ID);
			return dayNames;
		}

		private string[] InternalGetAbbreviatedMonthNames()
		{
			return abbreviatedMonthNames ?? InternalGetAbbreviatedMonthNamesCore();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private string[] InternalGetAbbreviatedMonthNamesCore()
		{
			abbreviatedMonthNames = _cultureData.AbbreviatedMonthNames(Calendar.ID);
			return abbreviatedMonthNames;
		}

		private string[] InternalGetMonthNames()
		{
			return monthNames ?? internalGetMonthNamesCore();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private string[] internalGetMonthNamesCore()
		{
			monthNames = _cultureData.MonthNames(Calendar.ID);
			return monthNames;
		}

		public DateTimeFormatInfo()
			: this(CultureInfo.InvariantCulture._cultureData, GregorianCalendar.GetDefaultInstance())
		{
		}

		internal DateTimeFormatInfo(CultureData cultureData, Calendar cal)
		{
			_cultureData = cultureData;
			calendar = cal;
			InitializeOverridableProperties(cultureData, calendar.ID);
		}

		private void InitializeOverridableProperties(CultureData cultureData, CalendarId calendarId)
		{
			if (firstDayOfWeek == -1)
			{
				firstDayOfWeek = cultureData.FirstDayOfWeek;
			}
			if (calendarWeekRule == -1)
			{
				calendarWeekRule = cultureData.CalendarWeekRule;
			}
			if (amDesignator == null)
			{
				amDesignator = cultureData.AMDesignator;
			}
			if (pmDesignator == null)
			{
				pmDesignator = cultureData.PMDesignator;
			}
			if (timeSeparator == null)
			{
				timeSeparator = cultureData.TimeSeparator;
			}
			if (dateSeparator == null)
			{
				dateSeparator = cultureData.DateSeparator(calendarId);
			}
			allLongTimePatterns = _cultureData.LongTimes;
			allShortTimePatterns = _cultureData.ShortTimes;
			allLongDatePatterns = cultureData.LongDates(calendarId);
			allShortDatePatterns = cultureData.ShortDates(calendarId);
			allYearMonthPatterns = cultureData.YearMonths(calendarId);
		}

		public static DateTimeFormatInfo GetInstance(IFormatProvider? provider)
		{
			if (provider != null)
			{
				if (!(provider is CultureInfo cultureInfo) || cultureInfo._isInherited)
				{
					if (!(provider is DateTimeFormatInfo result))
					{
						if (!(provider.GetFormat(typeof(DateTimeFormatInfo)) is DateTimeFormatInfo result2))
						{
							return CurrentInfo;
						}
						return result2;
					}
					return result;
				}
				return cultureInfo.DateTimeFormat;
			}
			return CurrentInfo;
		}

		public object? GetFormat(Type? formatType)
		{
			if (!(formatType == typeof(DateTimeFormatInfo)))
			{
				return null;
			}
			return this;
		}

		public object Clone()
		{
			DateTimeFormatInfo dateTimeFormatInfo = (DateTimeFormatInfo)MemberwiseClone();
			dateTimeFormatInfo.calendar = (Calendar)Calendar.Clone();
			dateTimeFormatInfo._isReadOnly = false;
			return dateTimeFormatInfo;
		}

		public int GetEra(string eraName)
		{
			if (eraName == null)
			{
				throw new ArgumentNullException("eraName");
			}
			if (eraName.Length == 0)
			{
				return -1;
			}
			for (int i = 0; i < EraNames.Length; i++)
			{
				if (m_eraNames[i].Length > 0 && Culture.CompareInfo.Compare(eraName, m_eraNames[i], CompareOptions.IgnoreCase) == 0)
				{
					return i + 1;
				}
			}
			for (int j = 0; j < AbbreviatedEraNames.Length; j++)
			{
				if (Culture.CompareInfo.Compare(eraName, m_abbrevEraNames[j], CompareOptions.IgnoreCase) == 0)
				{
					return j + 1;
				}
			}
			for (int k = 0; k < AbbreviatedEnglishEraNames.Length; k++)
			{
				if (System.Globalization.CompareInfo.Invariant.Compare(eraName, m_abbrevEnglishEraNames[k], CompareOptions.IgnoreCase) == 0)
				{
					return k + 1;
				}
			}
			return -1;
		}

		public string GetEraName(int era)
		{
			if (era == 0)
			{
				era = Calendar.CurrentEraValue;
			}
			if (--era < EraNames.Length && era >= 0)
			{
				return m_eraNames[era];
			}
			throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
		}

		public string GetAbbreviatedEraName(int era)
		{
			if (AbbreviatedEraNames.Length == 0)
			{
				return GetEraName(era);
			}
			if (era == 0)
			{
				era = Calendar.CurrentEraValue;
			}
			if (--era < m_abbrevEraNames.Length && era >= 0)
			{
				return m_abbrevEraNames[era];
			}
			throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
		}

		private void OnLongDatePatternChanged()
		{
			ClearTokenHashTable();
			fullDateTimePattern = null;
		}

		private void OnLongTimePatternChanged()
		{
			ClearTokenHashTable();
			fullDateTimePattern = null;
			generalLongTimePattern = null;
			dateTimeOffsetPattern = null;
		}

		private void OnShortDatePatternChanged()
		{
			ClearTokenHashTable();
			generalLongTimePattern = null;
			generalShortTimePattern = null;
			dateTimeOffsetPattern = null;
		}

		private void OnShortTimePatternChanged()
		{
			ClearTokenHashTable();
			generalShortTimePattern = null;
		}

		private void OnYearMonthPatternChanged()
		{
			ClearTokenHashTable();
		}

		private static void CheckNullValue(string[] values, int length)
		{
			for (int i = 0; i < length; i++)
			{
				if (values[i] == null)
				{
					throw new ArgumentNullException("value", SR.ArgumentNull_ArrayValue);
				}
			}
		}

		internal string InternalGetMonthName(int month, MonthNameStyles style, bool abbreviated)
		{
			string[] array = style switch
			{
				MonthNameStyles.Genitive => InternalGetGenitiveMonthNames(abbreviated), 
				MonthNameStyles.LeapYear => InternalGetLeapYearMonthNames(), 
				_ => abbreviated ? InternalGetAbbreviatedMonthNames() : InternalGetMonthNames(), 
			};
			if (month < 1 || month > array.Length)
			{
				throw new ArgumentOutOfRangeException("month", month, SR.Format(SR.ArgumentOutOfRange_Range, 1, array.Length));
			}
			return array[month - 1];
		}

		private string[] InternalGetGenitiveMonthNames(bool abbreviated)
		{
			if (abbreviated)
			{
				if (m_genitiveAbbreviatedMonthNames == null)
				{
					m_genitiveAbbreviatedMonthNames = _cultureData.AbbreviatedGenitiveMonthNames(Calendar.ID);
				}
				return m_genitiveAbbreviatedMonthNames;
			}
			if (genitiveMonthNames == null)
			{
				genitiveMonthNames = _cultureData.GenitiveMonthNames(Calendar.ID);
			}
			return genitiveMonthNames;
		}

		internal string[] InternalGetLeapYearMonthNames()
		{
			if (leapYearMonthNames == null)
			{
				leapYearMonthNames = _cultureData.LeapYearMonthNames(Calendar.ID);
			}
			return leapYearMonthNames;
		}

		public string GetAbbreviatedDayName(DayOfWeek dayofweek)
		{
			if (dayofweek < DayOfWeek.Sunday || dayofweek > DayOfWeek.Saturday)
			{
				throw new ArgumentOutOfRangeException("dayofweek", dayofweek, SR.Format(SR.ArgumentOutOfRange_Range, DayOfWeek.Sunday, DayOfWeek.Saturday));
			}
			return InternalGetAbbreviatedDayOfWeekNames()[(int)dayofweek];
		}

		public string GetShortestDayName(DayOfWeek dayOfWeek)
		{
			if (dayOfWeek < DayOfWeek.Sunday || dayOfWeek > DayOfWeek.Saturday)
			{
				throw new ArgumentOutOfRangeException("dayOfWeek", dayOfWeek, SR.Format(SR.ArgumentOutOfRange_Range, DayOfWeek.Sunday, DayOfWeek.Saturday));
			}
			return InternalGetSuperShortDayNames()[(int)dayOfWeek];
		}

		private static string[] GetCombinedPatterns(string[] patterns1, string[] patterns2, string connectString)
		{
			string[] array = new string[patterns1.Length * patterns2.Length];
			int num = 0;
			for (int i = 0; i < patterns1.Length; i++)
			{
				for (int j = 0; j < patterns2.Length; j++)
				{
					array[num++] = patterns1[i] + connectString + patterns2[j];
				}
			}
			return array;
		}

		public string[] GetAllDateTimePatterns()
		{
			List<string> list = new List<string>(132);
			for (int i = 0; i < DateTimeFormat.allStandardFormats.Length; i++)
			{
				string[] allDateTimePatterns = GetAllDateTimePatterns(DateTimeFormat.allStandardFormats[i]);
				for (int j = 0; j < allDateTimePatterns.Length; j++)
				{
					list.Add(allDateTimePatterns[j]);
				}
			}
			return list.ToArray();
		}

		public string[] GetAllDateTimePatterns(char format)
		{
			switch (format)
			{
			case 'd':
				return AllShortDatePatterns;
			case 'D':
				return AllLongDatePatterns;
			case 'f':
				return GetCombinedPatterns(AllLongDatePatterns, AllShortTimePatterns, " ");
			case 'F':
			case 'U':
				return GetCombinedPatterns(AllLongDatePatterns, AllLongTimePatterns, " ");
			case 'g':
				return GetCombinedPatterns(AllShortDatePatterns, AllShortTimePatterns, " ");
			case 'G':
				return GetCombinedPatterns(AllShortDatePatterns, AllLongTimePatterns, " ");
			case 'M':
			case 'm':
				return new string[1] { MonthDayPattern };
			case 'O':
			case 'o':
				return new string[1] { "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffffffK" };
			case 'R':
			case 'r':
				return new string[1] { "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'" };
			case 's':
				return new string[1] { "yyyy'-'MM'-'dd'T'HH':'mm':'ss" };
			case 't':
				return AllShortTimePatterns;
			case 'T':
				return AllLongTimePatterns;
			case 'u':
				return new string[1] { UniversalSortableDateTimePattern };
			case 'Y':
			case 'y':
				return AllYearMonthPatterns;
			default:
				throw new ArgumentException(SR.Format(SR.Format_BadFormatSpecifier, format), "format");
			}
		}

		public string GetDayName(DayOfWeek dayofweek)
		{
			if (dayofweek < DayOfWeek.Sunday || dayofweek > DayOfWeek.Saturday)
			{
				throw new ArgumentOutOfRangeException("dayofweek", dayofweek, SR.Format(SR.ArgumentOutOfRange_Range, DayOfWeek.Sunday, DayOfWeek.Saturday));
			}
			return InternalGetDayOfWeekNames()[(int)dayofweek];
		}

		public string GetAbbreviatedMonthName(int month)
		{
			if (month < 1 || month > 13)
			{
				throw new ArgumentOutOfRangeException("month", month, SR.Format(SR.ArgumentOutOfRange_Range, 1, 13));
			}
			return InternalGetAbbreviatedMonthNames()[month - 1];
		}

		public string GetMonthName(int month)
		{
			if (month < 1 || month > 13)
			{
				throw new ArgumentOutOfRangeException("month", month, SR.Format(SR.ArgumentOutOfRange_Range, 1, 13));
			}
			return InternalGetMonthNames()[month - 1];
		}

		private static string[] GetMergedPatterns(string[] patterns, string defaultPattern)
		{
			if (defaultPattern == patterns[0])
			{
				return (string[])patterns.Clone();
			}
			int i;
			for (i = 0; i < patterns.Length && !(defaultPattern == patterns[i]); i++)
			{
			}
			string[] array;
			if (i < patterns.Length)
			{
				array = (string[])patterns.Clone();
				array[i] = array[0];
			}
			else
			{
				array = new string[patterns.Length + 1];
				Array.Copy(patterns, 0, array, 1, patterns.Length);
			}
			array[0] = defaultPattern;
			return array;
		}

		public static DateTimeFormatInfo ReadOnly(DateTimeFormatInfo dtfi)
		{
			if (dtfi == null)
			{
				throw new ArgumentNullException("dtfi");
			}
			if (dtfi.IsReadOnly)
			{
				return dtfi;
			}
			DateTimeFormatInfo dateTimeFormatInfo = (DateTimeFormatInfo)dtfi.MemberwiseClone();
			dateTimeFormatInfo.calendar = System.Globalization.Calendar.ReadOnly(dtfi.Calendar);
			dateTimeFormatInfo._isReadOnly = true;
			return dateTimeFormatInfo;
		}

		public void SetAllDateTimePatterns(string[] patterns, char format)
		{
			if (IsReadOnly)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
			}
			if (patterns == null)
			{
				throw new ArgumentNullException("patterns");
			}
			if (patterns.Length == 0)
			{
				throw new ArgumentException(SR.Arg_ArrayZeroError, "patterns");
			}
			for (int i = 0; i < patterns.Length; i++)
			{
				if (patterns[i] == null)
				{
					throw new ArgumentNullException("patterns[" + i + "]", SR.ArgumentNull_ArrayValue);
				}
			}
			switch (format)
			{
			case 'd':
				allShortDatePatterns = patterns;
				shortDatePattern = allShortDatePatterns[0];
				OnShortDatePatternChanged();
				break;
			case 'D':
				allLongDatePatterns = patterns;
				longDatePattern = allLongDatePatterns[0];
				OnLongDatePatternChanged();
				break;
			case 't':
				allShortTimePatterns = patterns;
				shortTimePattern = allShortTimePatterns[0];
				OnShortTimePatternChanged();
				break;
			case 'T':
				allLongTimePatterns = patterns;
				longTimePattern = allLongTimePatterns[0];
				OnLongTimePatternChanged();
				break;
			case 'Y':
			case 'y':
				allYearMonthPatterns = patterns;
				yearMonthPattern = allYearMonthPatterns[0];
				OnYearMonthPatternChanged();
				break;
			default:
				throw new ArgumentException(SR.Format(SR.Format_BadFormatSpecifier, format), "format");
			}
		}

		internal static void ValidateStyles(DateTimeStyles style, bool styles = false)
		{
			if (((uint)style & 0xFFFFFF00u) != 0 || (style & (DateTimeStyles.AssumeLocal | DateTimeStyles.AssumeUniversal)) == (DateTimeStyles.AssumeLocal | DateTimeStyles.AssumeUniversal) || (style & (DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal | DateTimeStyles.AssumeUniversal | DateTimeStyles.RoundtripKind)) > DateTimeStyles.RoundtripKind)
			{
				ThrowInvalid(style, styles);
			}
			static void ThrowInvalid(DateTimeStyles style, bool styles)
			{
				string message = ((((uint)style & 0xFFFFFF00u) != 0) ? SR.Argument_InvalidDateTimeStyles : (((style & (DateTimeStyles.AssumeLocal | DateTimeStyles.AssumeUniversal)) == (DateTimeStyles.AssumeLocal | DateTimeStyles.AssumeUniversal)) ? SR.Argument_ConflictingDateTimeStyles : SR.Argument_ConflictingDateTimeRoundtripStyles));
				throw new ArgumentException(message, styles ? "styles" : "style");
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private DateTimeFormatFlags InitializeFormatFlags()
		{
			formatFlags = (DateTimeFormatFlags)(DateTimeFormatInfoScanner.GetFormatFlagGenitiveMonth(MonthNames, InternalGetGenitiveMonthNames(abbreviated: false), AbbreviatedMonthNames, InternalGetGenitiveMonthNames(abbreviated: true)) | DateTimeFormatInfoScanner.GetFormatFlagUseSpaceInMonthNames(MonthNames, InternalGetGenitiveMonthNames(abbreviated: false), AbbreviatedMonthNames, InternalGetGenitiveMonthNames(abbreviated: true)) | DateTimeFormatInfoScanner.GetFormatFlagUseSpaceInDayNames(DayNames, AbbreviatedDayNames) | DateTimeFormatInfoScanner.GetFormatFlagUseHebrewCalendar((int)Calendar.ID));
			return formatFlags;
		}

		internal bool YearMonthAdjustment(ref int year, ref int month, bool parsedMonthName)
		{
			if ((FormatFlags & DateTimeFormatFlags.UseHebrewRule) != 0)
			{
				if (year < 1000)
				{
					year += 5000;
				}
				if (year < Calendar.GetYear(Calendar.MinSupportedDateTime) || year > Calendar.GetYear(Calendar.MaxSupportedDateTime))
				{
					return false;
				}
				if (parsedMonthName && !Calendar.IsLeapYear(year))
				{
					if (month >= 8)
					{
						month--;
					}
					else if (month == 7)
					{
						return false;
					}
				}
			}
			return true;
		}

		internal static DateTimeFormatInfo GetJapaneseCalendarDTFI()
		{
			DateTimeFormatInfo dateTimeFormat = s_jajpDTFI;
			if (dateTimeFormat == null)
			{
				dateTimeFormat = new CultureInfo("ja-JP", useUserOverride: false).DateTimeFormat;
				dateTimeFormat.Calendar = JapaneseCalendar.GetDefaultInstance();
				s_jajpDTFI = dateTimeFormat;
			}
			return dateTimeFormat;
		}

		internal static DateTimeFormatInfo GetTaiwanCalendarDTFI()
		{
			DateTimeFormatInfo dateTimeFormat = s_zhtwDTFI;
			if (dateTimeFormat == null)
			{
				dateTimeFormat = new CultureInfo("zh-TW", useUserOverride: false).DateTimeFormat;
				dateTimeFormat.Calendar = TaiwanCalendar.GetDefaultInstance();
				s_zhtwDTFI = dateTimeFormat;
			}
			return dateTimeFormat;
		}

		private void ClearTokenHashTable()
		{
			_dtfiTokenHash = null;
			formatFlags = DateTimeFormatFlags.NotInitialized;
		}

		internal TokenHashValue[] CreateTokenHashTable()
		{
			TokenHashValue[] array = _dtfiTokenHash;
			if (array == null)
			{
				array = new TokenHashValue[199];
				string text = TimeSeparator.Trim();
				if ("," != text)
				{
					InsertHash(array, ",", TokenType.IgnorableSymbol, 0);
				}
				if ("." != text)
				{
					InsertHash(array, ".", TokenType.IgnorableSymbol, 0);
				}
				if ("시" != text && "時" != text && "时" != text)
				{
					InsertHash(array, TimeSeparator, TokenType.SEP_Time, 0);
				}
				if (_name == "fr-CA")
				{
					InsertHash(array, " h", TokenType.SEP_HourSuff, 0);
					InsertHash(array, " h ", TokenType.SEP_HourSuff, 0);
					InsertHash(array, " min", TokenType.SEP_MinuteSuff, 0);
					InsertHash(array, " min ", TokenType.SEP_MinuteSuff, 0);
					InsertHash(array, " s", TokenType.SEP_SecondSuff, 0);
					InsertHash(array, " s ", TokenType.SEP_SecondSuff, 0);
				}
				InsertHash(array, AMDesignator, (TokenType)1027, 0);
				InsertHash(array, PMDesignator, (TokenType)1284, 1);
				if (LanguageName.Equals("sq"))
				{
					InsertHash(array, "." + AMDesignator, (TokenType)1027, 0);
					InsertHash(array, "." + PMDesignator, (TokenType)1284, 1);
				}
				InsertHash(array, "年", TokenType.SEP_YearSuff, 0);
				InsertHash(array, "년", TokenType.SEP_YearSuff, 0);
				InsertHash(array, "月", TokenType.SEP_MonthSuff, 0);
				InsertHash(array, "월", TokenType.SEP_MonthSuff, 0);
				InsertHash(array, "日", TokenType.SEP_DaySuff, 0);
				InsertHash(array, "일", TokenType.SEP_DaySuff, 0);
				InsertHash(array, "時", TokenType.SEP_HourSuff, 0);
				InsertHash(array, "时", TokenType.SEP_HourSuff, 0);
				InsertHash(array, "分", TokenType.SEP_MinuteSuff, 0);
				InsertHash(array, "秒", TokenType.SEP_SecondSuff, 0);
				if (!LocalAppContextSwitches.EnforceLegacyJapaneseDateParsing && Calendar.ID == CalendarId.JAPAN)
				{
					InsertHash(array, "元", TokenType.YearNumberToken, 1);
					InsertHash(array, "(", TokenType.IgnorableSymbol, 0);
					InsertHash(array, ")", TokenType.IgnorableSymbol, 0);
				}
				if (LanguageName.Equals("ko"))
				{
					InsertHash(array, "시", TokenType.SEP_HourSuff, 0);
					InsertHash(array, "분", TokenType.SEP_MinuteSuff, 0);
					InsertHash(array, "초", TokenType.SEP_SecondSuff, 0);
				}
				if (LanguageName.Equals("ky"))
				{
					InsertHash(array, "-", TokenType.IgnorableSymbol, 0);
				}
				else
				{
					InsertHash(array, "-", TokenType.SEP_DateOrOffset, 0);
				}
				DateTimeFormatInfoScanner dateTimeFormatInfoScanner = new DateTimeFormatInfoScanner();
				string[] dateWordsOfDTFI = dateTimeFormatInfoScanner.GetDateWordsOfDTFI(this);
				_ = FormatFlags;
				bool flag = false;
				if (dateWordsOfDTFI != null)
				{
					for (int i = 0; i < dateWordsOfDTFI.Length; i++)
					{
						switch (dateWordsOfDTFI[i][0])
						{
						case '\ue000':
						{
							ReadOnlySpan<char> monthPostfix = dateWordsOfDTFI[i].AsSpan(1);
							AddMonthNames(array, monthPostfix);
							break;
						}
						case '\ue001':
						{
							string text2 = dateWordsOfDTFI[i].Substring(1);
							InsertHash(array, text2, TokenType.IgnorableSymbol, 0);
							if (DateSeparator.Trim().Equals(text2))
							{
								flag = true;
							}
							break;
						}
						default:
							InsertHash(array, dateWordsOfDTFI[i], TokenType.DateWordToken, 0);
							if (LanguageName.Equals("eu"))
							{
								InsertHash(array, "." + dateWordsOfDTFI[i], TokenType.DateWordToken, 0);
							}
							break;
						}
					}
				}
				if (!flag)
				{
					InsertHash(array, DateSeparator, TokenType.SEP_Date, 0);
				}
				AddMonthNames(array);
				for (int j = 1; j <= 13; j++)
				{
					InsertHash(array, GetAbbreviatedMonthName(j), TokenType.MonthToken, j);
				}
				if ((FormatFlags & DateTimeFormatFlags.UseGenitiveMonth) != 0)
				{
					string[] array2 = InternalGetGenitiveMonthNames(abbreviated: false);
					string[] array3 = InternalGetGenitiveMonthNames(abbreviated: true);
					for (int k = 1; k <= 13; k++)
					{
						InsertHash(array, array2[k - 1], TokenType.MonthToken, k);
						InsertHash(array, array3[k - 1], TokenType.MonthToken, k);
					}
				}
				if ((FormatFlags & DateTimeFormatFlags.UseLeapYearMonth) != 0)
				{
					for (int l = 1; l <= 13; l++)
					{
						string str = InternalGetMonthName(l, MonthNameStyles.LeapYear, abbreviated: false);
						InsertHash(array, str, TokenType.MonthToken, l);
					}
				}
				for (int m = 0; m < 7; m++)
				{
					string dayName = GetDayName((DayOfWeek)m);
					InsertHash(array, dayName, TokenType.DayOfWeekToken, m);
					dayName = GetAbbreviatedDayName((DayOfWeek)m);
					InsertHash(array, dayName, TokenType.DayOfWeekToken, m);
				}
				int[] eras = calendar.Eras;
				for (int n = 1; n <= eras.Length; n++)
				{
					InsertHash(array, GetEraName(n), TokenType.EraToken, n);
					InsertHash(array, GetAbbreviatedEraName(n), TokenType.EraToken, n);
				}
				if (!GlobalizationMode.Invariant)
				{
					if (LanguageName.Equals("ja"))
					{
						for (int num = 0; num < 7; num++)
						{
							string str2 = "(" + GetAbbreviatedDayName((DayOfWeek)num) + ")";
							InsertHash(array, str2, TokenType.DayOfWeekToken, num);
						}
						if (Calendar.GetType() != typeof(JapaneseCalendar))
						{
							DateTimeFormatInfo japaneseCalendarDTFI = GetJapaneseCalendarDTFI();
							for (int num2 = 1; num2 <= japaneseCalendarDTFI.Calendar.Eras.Length; num2++)
							{
								InsertHash(array, japaneseCalendarDTFI.GetEraName(num2), TokenType.JapaneseEraToken, num2);
								InsertHash(array, japaneseCalendarDTFI.GetAbbreviatedEraName(num2), TokenType.JapaneseEraToken, num2);
								InsertHash(array, japaneseCalendarDTFI.AbbreviatedEnglishEraNames[num2 - 1], TokenType.JapaneseEraToken, num2);
							}
						}
					}
					else if (CultureName.Equals("zh-TW"))
					{
						DateTimeFormatInfo taiwanCalendarDTFI = GetTaiwanCalendarDTFI();
						for (int num3 = 1; num3 <= taiwanCalendarDTFI.Calendar.Eras.Length; num3++)
						{
							if (taiwanCalendarDTFI.GetEraName(num3).Length > 0)
							{
								InsertHash(array, taiwanCalendarDTFI.GetEraName(num3), TokenType.TEraToken, num3);
							}
						}
					}
				}
				InsertHash(array, InvariantInfo.AMDesignator, (TokenType)1027, 0);
				InsertHash(array, InvariantInfo.PMDesignator, (TokenType)1284, 1);
				for (int num4 = 1; num4 <= 12; num4++)
				{
					string monthName = InvariantInfo.GetMonthName(num4);
					InsertHash(array, monthName, TokenType.MonthToken, num4);
					monthName = InvariantInfo.GetAbbreviatedMonthName(num4);
					InsertHash(array, monthName, TokenType.MonthToken, num4);
				}
				for (int num5 = 0; num5 < 7; num5++)
				{
					string dayName2 = InvariantInfo.GetDayName((DayOfWeek)num5);
					InsertHash(array, dayName2, TokenType.DayOfWeekToken, num5);
					dayName2 = InvariantInfo.GetAbbreviatedDayName((DayOfWeek)num5);
					InsertHash(array, dayName2, TokenType.DayOfWeekToken, num5);
				}
				for (int num6 = 0; num6 < AbbreviatedEnglishEraNames.Length; num6++)
				{
					InsertHash(array, AbbreviatedEnglishEraNames[num6], TokenType.EraToken, num6 + 1);
				}
				InsertHash(array, "T", TokenType.SEP_LocalTimeMark, 0);
				InsertHash(array, "GMT", TokenType.TimeZoneToken, 0);
				InsertHash(array, "Z", TokenType.TimeZoneToken, 0);
				InsertHash(array, "/", TokenType.SEP_Date, 0);
				InsertHash(array, ":", TokenType.SEP_Time, 0);
				_dtfiTokenHash = array;
			}
			return array;
		}

		private void AddMonthNames(TokenHashValue[] temp, ReadOnlySpan<char> monthPostfix = default(ReadOnlySpan<char>))
		{
			for (int i = 1; i <= 13; i++)
			{
				string monthName = GetMonthName(i);
				if (monthName.Length > 0)
				{
					if (!monthPostfix.IsEmpty)
					{
						InsertHash(temp, monthName + monthPostfix, TokenType.MonthToken, i);
					}
					else
					{
						InsertHash(temp, monthName, TokenType.MonthToken, i);
					}
				}
				monthName = GetAbbreviatedMonthName(i);
				InsertHash(temp, monthName, TokenType.MonthToken, i);
			}
		}

		private static bool TryParseHebrewNumber(ref __DTString str, out bool badFormat, out int number)
		{
			number = -1;
			badFormat = false;
			int index = str.Index;
			if (!HebrewNumber.IsDigit(str.Value[index]))
			{
				return false;
			}
			HebrewNumberParsingContext context = new HebrewNumberParsingContext(0);
			HebrewNumberParsingState hebrewNumberParsingState;
			do
			{
				hebrewNumberParsingState = HebrewNumber.ParseByChar(str.Value[index++], ref context);
				if ((uint)hebrewNumberParsingState <= 1u)
				{
					return false;
				}
			}
			while (index < str.Value.Length && hebrewNumberParsingState != HebrewNumberParsingState.FoundEndOfHebrewNumber);
			if (hebrewNumberParsingState != HebrewNumberParsingState.FoundEndOfHebrewNumber)
			{
				return false;
			}
			str.Advance(index - str.Index);
			number = context.result;
			return true;
		}

		private static bool IsHebrewChar(char ch)
		{
			if (ch >= '\u0590')
			{
				return ch <= '\u05ff';
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool IsAllowedJapaneseTokenFollowedByNonSpaceLetter(string tokenString, char nextCh)
		{
			if (!LocalAppContextSwitches.EnforceLegacyJapaneseDateParsing && Calendar.ID == CalendarId.JAPAN && (nextCh == "元"[0] || (tokenString == "元" && nextCh == "年"[0])))
			{
				return true;
			}
			return false;
		}

		internal bool Tokenize(TokenType TokenMask, out TokenType tokenType, out int tokenValue, ref __DTString str)
		{
			tokenType = TokenType.UnknownToken;
			tokenValue = 0;
			char c = str.m_current;
			bool flag = char.IsLetter(c);
			if (flag)
			{
				c = Culture.TextInfo.ToLower(c);
				if (!GlobalizationMode.Invariant && IsHebrewChar(c) && TokenMask == TokenType.RegularTokenMask && TryParseHebrewNumber(ref str, out var badFormat, out tokenValue))
				{
					if (badFormat)
					{
						tokenType = TokenType.UnknownToken;
						return false;
					}
					tokenType = TokenType.HebrewNumber;
					return true;
				}
			}
			int num = c % 199;
			int num2 = 1 + c % 197;
			int num3 = str.Length - str.Index;
			int num4 = 0;
			TokenHashValue[] array = _dtfiTokenHash ?? CreateTokenHashTable();
			do
			{
				TokenHashValue tokenHashValue = array[num];
				if (tokenHashValue == null)
				{
					break;
				}
				if ((tokenHashValue.tokenType & TokenMask) > (TokenType)0 && tokenHashValue.tokenString.Length <= num3)
				{
					bool flag2 = true;
					if (flag)
					{
						int num5 = str.Index + tokenHashValue.tokenString.Length;
						if (num5 > str.Length)
						{
							flag2 = false;
						}
						else if (num5 < str.Length)
						{
							char c2 = str.Value[num5];
							flag2 = !char.IsLetter(c2) || IsAllowedJapaneseTokenFollowedByNonSpaceLetter(tokenHashValue.tokenString, c2);
						}
					}
					if (flag2 && ((tokenHashValue.tokenString.Length == 1 && str.Value[str.Index] == tokenHashValue.tokenString[0]) || Culture.CompareInfo.Compare(str.Value.Slice(str.Index, tokenHashValue.tokenString.Length), tokenHashValue.tokenString, CompareOptions.IgnoreCase) == 0))
					{
						tokenType = tokenHashValue.tokenType & TokenMask;
						tokenValue = tokenHashValue.tokenValue;
						str.Advance(tokenHashValue.tokenString.Length);
						return true;
					}
					if ((tokenHashValue.tokenType == TokenType.MonthToken && HasSpacesInMonthNames) || (tokenHashValue.tokenType == TokenType.DayOfWeekToken && HasSpacesInDayNames))
					{
						int matchLength = 0;
						if (str.MatchSpecifiedWords(tokenHashValue.tokenString, checkWordBoundary: true, ref matchLength))
						{
							tokenType = tokenHashValue.tokenType & TokenMask;
							tokenValue = tokenHashValue.tokenValue;
							str.Advance(matchLength);
							return true;
						}
					}
				}
				num4++;
				num += num2;
				if (num >= 199)
				{
					num -= 199;
				}
			}
			while (num4 < 199);
			return false;
		}

		private void InsertAtCurrentHashNode(TokenHashValue[] hashTable, string str, char ch, TokenType tokenType, int tokenValue, int pos, int hashcode, int hashProbe)
		{
			TokenHashValue tokenHashValue = hashTable[hashcode];
			hashTable[hashcode] = new TokenHashValue(str, tokenType, tokenValue);
			while (++pos < 199)
			{
				hashcode += hashProbe;
				if (hashcode >= 199)
				{
					hashcode -= 199;
				}
				TokenHashValue tokenHashValue2 = hashTable[hashcode];
				if (tokenHashValue2 == null || Culture.TextInfo.ToLower(tokenHashValue2.tokenString[0]) == ch)
				{
					hashTable[hashcode] = tokenHashValue;
					if (tokenHashValue2 == null)
					{
						break;
					}
					tokenHashValue = tokenHashValue2;
				}
			}
		}

		private void InsertHash(TokenHashValue[] hashTable, string str, TokenType tokenType, int tokenValue)
		{
			if (string.IsNullOrEmpty(str))
			{
				return;
			}
			int num = 0;
			if (char.IsWhiteSpace(str[0]) || char.IsWhiteSpace(str[^1]))
			{
				str = str.Trim();
				if (str.Length == 0)
				{
					return;
				}
			}
			char c = Culture.TextInfo.ToLower(str[0]);
			int num2 = c % 199;
			int num3 = 1 + c % 197;
			do
			{
				TokenHashValue tokenHashValue = hashTable[num2];
				if (tokenHashValue == null)
				{
					hashTable[num2] = new TokenHashValue(str, tokenType, tokenValue);
					break;
				}
				if (str.Length >= tokenHashValue.tokenString.Length && CompareStringIgnoreCaseOptimized(str, 0, tokenHashValue.tokenString.Length, tokenHashValue.tokenString, 0, tokenHashValue.tokenString.Length))
				{
					if (str.Length > tokenHashValue.tokenString.Length)
					{
						InsertAtCurrentHashNode(hashTable, str, c, tokenType, tokenValue, num, num2, num3);
						break;
					}
					int tokenType2 = (int)tokenHashValue.tokenType;
					if (((tokenType2 & 0xFF) == 0 && (tokenType & TokenType.RegularTokenMask) != 0) || ((tokenType2 & 0xFF00) == 0 && (tokenType & TokenType.SeparatorTokenMask) != 0))
					{
						tokenHashValue.tokenType |= tokenType;
						if (tokenValue != 0)
						{
							tokenHashValue.tokenValue = tokenValue;
						}
					}
					break;
				}
				num++;
				num2 += num3;
				if (num2 >= 199)
				{
					num2 -= 199;
				}
			}
			while (num < 199);
		}

		private bool CompareStringIgnoreCaseOptimized(string string1, int offset1, int length1, string string2, int offset2, int length2)
		{
			if (length1 == 1 && length2 == 1 && string1[offset1] == string2[offset2])
			{
				return true;
			}
			return Culture.CompareInfo.Compare(string1, offset1, length1, string2, offset2, length2, CompareOptions.IgnoreCase) == 0;
		}
	}
	internal enum FORMATFLAGS
	{
		None = 0,
		UseGenitiveMonth = 1,
		UseLeapYearMonth = 2,
		UseSpacesInMonthNames = 4,
		UseHebrewParsing = 8,
		UseSpacesInDayNames = 0x10,
		UseDigitPrefixInTokens = 0x20
	}
	internal enum CalendarId : ushort
	{
		UNINITIALIZED_VALUE = 0,
		GREGORIAN = 1,
		GREGORIAN_US = 2,
		JAPAN = 3,
		TAIWAN = 4,
		KOREA = 5,
		HIJRI = 6,
		THAI = 7,
		HEBREW = 8,
		GREGORIAN_ME_FRENCH = 9,
		GREGORIAN_ARABIC = 10,
		GREGORIAN_XLIT_ENGLISH = 11,
		GREGORIAN_XLIT_FRENCH = 12,
		JULIAN = 13,
		JAPANESELUNISOLAR = 14,
		CHINESELUNISOLAR = 15,
		SAKA = 16,
		LUNAR_ETO_CHN = 17,
		LUNAR_ETO_KOR = 18,
		LUNAR_ETO_ROKUYOU = 19,
		KOREANLUNISOLAR = 20,
		TAIWANLUNISOLAR = 21,
		PERSIAN = 22,
		UMALQURA = 23,
		LAST_CALENDAR = 23
	}
	internal sealed class DateTimeFormatInfoScanner
	{
		private enum FoundDatePattern
		{
			None = 0,
			FoundYearPatternFlag = 1,
			FoundMonthPatternFlag = 2,
			FoundDayPatternFlag = 4,
			FoundYMDPatternFlag = 7
		}

		internal List<string> m_dateWords = new List<string>();

		private FoundDatePattern _ymdFlags;

		internal static int SkipWhiteSpacesAndNonLetter(string pattern, int currentIndex)
		{
			while (currentIndex < pattern.Length)
			{
				char c = pattern[currentIndex];
				if (c == '\\')
				{
					currentIndex++;
					if (currentIndex >= pattern.Length)
					{
						break;
					}
					c = pattern[currentIndex];
					if (c == '\'')
					{
						continue;
					}
				}
				if (char.IsLetter(c) || c == '\'' || c == '.')
				{
					break;
				}
				currentIndex++;
			}
			return currentIndex;
		}

		internal void AddDateWordOrPostfix(string formatPostfix, string str)
		{
			if (str.Length == 0)
			{
				return;
			}
			if (str.Length == 1)
			{
				switch (str[0])
				{
				case '.':
					AddIgnorableSymbols(".");
					return;
				case '-':
				case '/':
				case '分':
				case '年':
				case '日':
				case '时':
				case '時':
				case '月':
				case '秒':
				case '년':
				case '분':
				case '시':
				case '월':
				case '일':
				case '초':
					return;
				}
			}
			if (m_dateWords == null)
			{
				m_dateWords = new List<string>();
			}
			if (formatPostfix == "MMMM")
			{
				string item = "\ue000" + str;
				if (!m_dateWords.Contains(item))
				{
					m_dateWords.Add(item);
				}
				return;
			}
			if (!m_dateWords.Contains(str))
			{
				m_dateWords.Add(str);
			}
			if (str[^1] == '.')
			{
				string item2 = str[0..^1];
				if (!m_dateWords.Contains(item2))
				{
					m_dateWords.Add(item2);
				}
			}
		}

		internal int AddDateWords(string pattern, int index, string formatPostfix)
		{
			int num = SkipWhiteSpacesAndNonLetter(pattern, index);
			if (num != index && formatPostfix != null)
			{
				formatPostfix = null;
			}
			index = num;
			StringBuilder stringBuilder = new StringBuilder();
			while (index < pattern.Length)
			{
				char c = pattern[index];
				switch (c)
				{
				case '\'':
					break;
				case '\\':
					index++;
					if (index < pattern.Length)
					{
						stringBuilder.Append(pattern[index]);
						index++;
					}
					continue;
				default:
					if (char.IsWhiteSpace(c))
					{
						AddDateWordOrPostfix(formatPostfix, stringBuilder.ToString());
						if (formatPostfix != null)
						{
							formatPostfix = null;
						}
						stringBuilder.Length = 0;
						index++;
					}
					else
					{
						stringBuilder.Append(c);
						index++;
					}
					continue;
				}
				AddDateWordOrPostfix(formatPostfix, stringBuilder.ToString());
				index++;
				break;
			}
			return index;
		}

		internal static int ScanRepeatChar(string pattern, char ch, int index, out int count)
		{
			count = 1;
			while (++index < pattern.Length && pattern[index] == ch)
			{
				count++;
			}
			return index;
		}

		internal void AddIgnorableSymbols(string text)
		{
			if (m_dateWords == null)
			{
				m_dateWords = new List<string>();
			}
			string item = "\ue001" + text;
			if (!m_dateWords.Contains(item))
			{
				m_dateWords.Add(item);
			}
		}

		internal void ScanDateWord(string pattern)
		{
			_ymdFlags = FoundDatePattern.None;
			int num = 0;
			while (num < pattern.Length)
			{
				char c = pattern[num];
				int count;
				switch (c)
				{
				case '\'':
					num = AddDateWords(pattern, num + 1, null);
					break;
				case 'M':
					num = ScanRepeatChar(pattern, 'M', num, out count);
					if (count >= 4 && num < pattern.Length && pattern[num] == '\'')
					{
						num = AddDateWords(pattern, num + 1, "MMMM");
					}
					_ymdFlags |= FoundDatePattern.FoundMonthPatternFlag;
					break;
				case 'y':
				{
					num = ScanRepeatChar(pattern, 'y', num, out var _);
					_ymdFlags |= FoundDatePattern.FoundYearPatternFlag;
					break;
				}
				case 'd':
					num = ScanRepeatChar(pattern, 'd', num, out count);
					if (count <= 2)
					{
						_ymdFlags |= FoundDatePattern.FoundDayPatternFlag;
					}
					break;
				case '\\':
					num += 2;
					break;
				case '.':
					if (_ymdFlags == FoundDatePattern.FoundYMDPatternFlag)
					{
						AddIgnorableSymbols(".");
						_ymdFlags = FoundDatePattern.None;
					}
					num++;
					break;
				default:
					if (_ymdFlags == FoundDatePattern.FoundYMDPatternFlag && !char.IsWhiteSpace(c))
					{
						_ymdFlags = FoundDatePattern.None;
					}
					num++;
					break;
				}
			}
		}

		internal string[] GetDateWordsOfDTFI(DateTimeFormatInfo dtfi)
		{
			string[] allDateTimePatterns = dtfi.GetAllDateTimePatterns('D');
			for (int i = 0; i < allDateTimePatterns.Length; i++)
			{
				ScanDateWord(allDateTimePatterns[i]);
			}
			allDateTimePatterns = dtfi.GetAllDateTimePatterns('d');
			for (int i = 0; i < allDateTimePatterns.Length; i++)
			{
				ScanDateWord(allDateTimePatterns[i]);
			}
			allDateTimePatterns = dtfi.GetAllDateTimePatterns('y');
			for (int i = 0; i < allDateTimePatterns.Length; i++)
			{
				ScanDateWord(allDateTimePatterns[i]);
			}
			ScanDateWord(dtfi.MonthDayPattern);
			allDateTimePatterns = dtfi.GetAllDateTimePatterns('T');
			for (int i = 0; i < allDateTimePatterns.Length; i++)
			{
				ScanDateWord(allDateTimePatterns[i]);
			}
			allDateTimePatterns = dtfi.GetAllDateTimePatterns('t');
			for (int i = 0; i < allDateTimePatterns.Length; i++)
			{
				ScanDateWord(allDateTimePatterns[i]);
			}
			string[] array = null;
			if (m_dateWords != null && m_dateWords.Count > 0)
			{
				array = new string[m_dateWords.Count];
				for (int i = 0; i < m_dateWords.Count; i++)
				{
					array[i] = m_dateWords[i];
				}
			}
			return array;
		}

		internal static FORMATFLAGS GetFormatFlagGenitiveMonth(string[] monthNames, string[] genitveMonthNames, string[] abbrevMonthNames, string[] genetiveAbbrevMonthNames)
		{
			if (EqualStringArrays(monthNames, genitveMonthNames) && EqualStringArrays(abbrevMonthNames, genetiveAbbrevMonthNames))
			{
				return FORMATFLAGS.None;
			}
			return FORMATFLAGS.UseGenitiveMonth;
		}

		internal static FORMATFLAGS GetFormatFlagUseSpaceInMonthNames(string[] monthNames, string[] genitveMonthNames, string[] abbrevMonthNames, string[] genetiveAbbrevMonthNames)
		{
			FORMATFLAGS fORMATFLAGS = FORMATFLAGS.None;
			fORMATFLAGS |= ((ArrayElementsBeginWithDigit(monthNames) || ArrayElementsBeginWithDigit(genitveMonthNames) || ArrayElementsBeginWithDigit(abbrevMonthNames) || ArrayElementsBeginWithDigit(genetiveAbbrevMonthNames)) ? FORMATFLAGS.UseDigitPrefixInTokens : FORMATFLAGS.None);
			return fORMATFLAGS | ((ArrayElementsHaveSpace(monthNames) || ArrayElementsHaveSpace(genitveMonthNames) || ArrayElementsHaveSpace(abbrevMonthNames) || ArrayElementsHaveSpace(genetiveAbbrevMonthNames)) ? FORMATFLAGS.UseSpacesInMonthNames : FORMATFLAGS.None);
		}

		internal static FORMATFLAGS GetFormatFlagUseSpaceInDayNames(string[] dayNames, string[] abbrevDayNames)
		{
			if (!ArrayElementsHaveSpace(dayNames) && !ArrayElementsHaveSpace(abbrevDayNames))
			{
				return FORMATFLAGS.None;
			}
			return FORMATFLAGS.UseSpacesInDayNames;
		}

		internal static FORMATFLAGS GetFormatFlagUseHebrewCalendar(int calID)
		{
			if (calID != 8)
			{
				return FORMATFLAGS.None;
			}
			return (FORMATFLAGS)10;
		}

		private static bool EqualStringArrays(string[] array1, string[] array2)
		{
			if (array1 == array2)
			{
				return true;
			}
			if (array1.Length != array2.Length)
			{
				return false;
			}
			for (int i = 0; i < array1.Length; i++)
			{
				if (array1[i] != array2[i])
				{
					return false;
				}
			}
			return true;
		}

		private static bool ArrayElementsHaveSpace(string[] array)
		{
			for (int i = 0; i < array.Length; i++)
			{
				for (int j = 0; j < array[i].Length; j++)
				{
					if (char.IsWhiteSpace(array[i][j]))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool ArrayElementsBeginWithDigit(string[] array)
		{
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].Length <= 0 || array[i][0] < '0' || array[i][0] > '9')
				{
					continue;
				}
				int j;
				for (j = 1; j < array[i].Length && array[i][j] >= '0' && array[i][j] <= '9'; j++)
				{
				}
				if (j == array[i].Length)
				{
					return false;
				}
				if (j == array[i].Length - 1)
				{
					char c = array[i][j];
					if (c == '月' || c == '월')
					{
						return false;
					}
				}
				if (j == array[i].Length - 4 && array[i][j] == '\'' && array[i][j + 1] == ' ' && array[i][j + 2] == '月' && array[i][j + 3] == '\'')
				{
					return false;
				}
				return true;
			}
			return false;
		}
	}
	[Flags]
	public enum DateTimeStyles
	{
		None = 0,
		AllowLeadingWhite = 1,
		AllowTrailingWhite = 2,
		AllowInnerWhite = 4,
		AllowWhiteSpaces = 7,
		NoCurrentDateDefault = 8,
		AdjustToUniversal = 0x10,
		AssumeLocal = 0x20,
		AssumeUniversal = 0x40,
		RoundtripKind = 0x80
	}
	public class DaylightTime
	{
		private readonly DateTime _start;

		private readonly DateTime _end;

		private readonly TimeSpan _delta;

		public DateTime Start => _start;

		public DateTime End => _end;

		public TimeSpan Delta => _delta;

		public DaylightTime(DateTime start, DateTime end, TimeSpan delta)
		{
			_start = start;
			_end = end;
			_delta = delta;
		}
	}
	internal readonly struct DaylightTimeStruct
	{
		public readonly DateTime Start;

		public readonly DateTime End;

		public readonly TimeSpan Delta;

		public DaylightTimeStruct(DateTime start, DateTime end, TimeSpan delta)
		{
			Start = start;
			End = end;
			Delta = delta;
		}
	}
	public enum DigitShapes
	{
		Context,
		None,
		NativeNational
	}
	public abstract class EastAsianLunisolarCalendar : Calendar
	{
		private static readonly int[] s_daysToMonth365 = new int[12]
		{
			0, 31, 59, 90, 120, 151, 181, 212, 243, 273,
			304, 334
		};

		private static readonly int[] s_daysToMonth366 = new int[12]
		{
			0, 31, 60, 91, 121, 152, 182, 213, 244, 274,
			305, 335
		};

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.LunisolarCalendar;

		internal abstract int MinCalendarYear { get; }

		internal abstract int MaxCalendarYear { get; }

		internal abstract EraInfo[]? CalEraInfo { get; }

		internal abstract DateTime MinDate { get; }

		internal abstract DateTime MaxDate { get; }

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(BaseCalendarID, GetYear(new DateTime(2029, 1, 1)));
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > MaxCalendarYear)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, MaxCalendarYear));
				}
				_twoDigitYearMax = value;
			}
		}

		public virtual int GetSexagenaryYear(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			TimeToLunar(time, out var year, out var _, out var _);
			return (year - 4) % 60 + 1;
		}

		public int GetCelestialStem(int sexagenaryYear)
		{
			if (sexagenaryYear < 1 || sexagenaryYear > 60)
			{
				throw new ArgumentOutOfRangeException("sexagenaryYear", sexagenaryYear, SR.Format(SR.ArgumentOutOfRange_Range, 1, 60));
			}
			return (sexagenaryYear - 1) % 10 + 1;
		}

		public int GetTerrestrialBranch(int sexagenaryYear)
		{
			if (sexagenaryYear < 1 || sexagenaryYear > 60)
			{
				throw new ArgumentOutOfRangeException("sexagenaryYear", sexagenaryYear, SR.Format(SR.ArgumentOutOfRange_Range, 1, 60));
			}
			return (sexagenaryYear - 1) % 12 + 1;
		}

		internal abstract int GetYearInfo(int LunarYear, int Index);

		internal abstract int GetYear(int year, DateTime time);

		internal abstract int GetGregorianYear(int year, int era);

		internal int MinEraCalendarYear(int era)
		{
			EraInfo[] calEraInfo = CalEraInfo;
			if (calEraInfo == null)
			{
				return MinCalendarYear;
			}
			if (era == 0)
			{
				era = CurrentEraValue;
			}
			if (era == GetEra(MinDate))
			{
				return GetYear(MinCalendarYear, MinDate);
			}
			for (int i = 0; i < calEraInfo.Length; i++)
			{
				if (era == calEraInfo[i].era)
				{
					return calEraInfo[i].minEraYear;
				}
			}
			throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
		}

		internal int MaxEraCalendarYear(int era)
		{
			EraInfo[] calEraInfo = CalEraInfo;
			if (calEraInfo == null)
			{
				return MaxCalendarYear;
			}
			if (era == 0)
			{
				era = CurrentEraValue;
			}
			if (era == GetEra(MaxDate))
			{
				return GetYear(MaxCalendarYear, MaxDate);
			}
			for (int i = 0; i < calEraInfo.Length; i++)
			{
				if (era == calEraInfo[i].era)
				{
					return calEraInfo[i].maxEraYear;
				}
			}
			throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
		}

		internal EastAsianLunisolarCalendar()
		{
		}

		internal void CheckTicksRange(long ticks)
		{
			if (ticks < MinSupportedDateTime.Ticks || ticks > MaxSupportedDateTime.Ticks)
			{
				throw new ArgumentOutOfRangeException("time", ticks, SR.Format(CultureInfo.InvariantCulture, SR.ArgumentOutOfRange_CalendarRange, MinSupportedDateTime, MaxSupportedDateTime));
			}
		}

		internal void CheckEraRange(int era)
		{
			if (era == 0)
			{
				era = CurrentEraValue;
			}
			if (era < GetEra(MinDate) || era > GetEra(MaxDate))
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
		}

		internal int CheckYearRange(int year, int era)
		{
			CheckEraRange(era);
			year = GetGregorianYear(year, era);
			if (year < MinCalendarYear || year > MaxCalendarYear)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, MinEraCalendarYear(era), MaxEraCalendarYear(era)));
			}
			return year;
		}

		internal int CheckYearMonthRange(int year, int month, int era)
		{
			year = CheckYearRange(year, era);
			if (month == 13 && GetYearInfo(year, 0) == 0)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
			if (month < 1 || month > 13)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
			return year;
		}

		internal int InternalGetDaysInMonth(int year, int month)
		{
			int num = 32768;
			num >>= month - 1;
			if ((GetYearInfo(year, 3) & num) == 0)
			{
				return 29;
			}
			return 30;
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			year = CheckYearMonthRange(year, month, era);
			return InternalGetDaysInMonth(year, month);
		}

		private static bool GregorianIsLeapYear(int y)
		{
			if (y % 4 != 0)
			{
				return false;
			}
			if (y % 100 != 0)
			{
				return true;
			}
			return y % 400 == 0;
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			year = CheckYearMonthRange(year, month, era);
			int num = InternalGetDaysInMonth(year, month);
			if (day < 1 || day > num)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Day, num, month));
			}
			if (!LunarToGregorian(year, month, day, out var solarYear, out var solarMonth, out var solarDay))
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
			}
			return new DateTime(solarYear, solarMonth, solarDay, hour, minute, second, millisecond);
		}

		private void GregorianToLunar(int solarYear, int solarMonth, int solarDate, out int lunarYear, out int lunarMonth, out int lunarDate)
		{
			int num = (GregorianIsLeapYear(solarYear) ? s_daysToMonth366[solarMonth - 1] : s_daysToMonth365[solarMonth - 1]);
			num += solarDate;
			int num2 = num;
			lunarYear = solarYear;
			int yearInfo;
			int yearInfo2;
			if (lunarYear == MaxCalendarYear + 1)
			{
				lunarYear--;
				num2 += (GregorianIsLeapYear(lunarYear) ? 366 : 365);
				yearInfo = GetYearInfo(lunarYear, 1);
				yearInfo2 = GetYearInfo(lunarYear, 2);
			}
			else
			{
				yearInfo = GetYearInfo(lunarYear, 1);
				yearInfo2 = GetYearInfo(lunarYear, 2);
				if (solarMonth < yearInfo || (solarMonth == yearInfo && solarDate < yearInfo2))
				{
					lunarYear--;
					num2 += (GregorianIsLeapYear(lunarYear) ? 366 : 365);
					yearInfo = GetYearInfo(lunarYear, 1);
					yearInfo2 = GetYearInfo(lunarYear, 2);
				}
			}
			num2 -= s_daysToMonth365[yearInfo - 1];
			num2 -= yearInfo2 - 1;
			int num3 = 32768;
			int yearInfo3 = GetYearInfo(lunarYear, 3);
			int num4 = (((yearInfo3 & num3) != 0) ? 30 : 29);
			lunarMonth = 1;
			while (num2 > num4)
			{
				num2 -= num4;
				lunarMonth++;
				num3 >>= 1;
				num4 = (((yearInfo3 & num3) != 0) ? 30 : 29);
			}
			lunarDate = num2;
		}

		private bool LunarToGregorian(int lunarYear, int lunarMonth, int lunarDate, out int solarYear, out int solarMonth, out int solarDay)
		{
			if (lunarDate < 1 || lunarDate > 30)
			{
				solarYear = 0;
				solarMonth = 0;
				solarDay = 0;
				return false;
			}
			int num = lunarDate - 1;
			for (int i = 1; i < lunarMonth; i++)
			{
				num += InternalGetDaysInMonth(lunarYear, i);
			}
			int yearInfo = GetYearInfo(lunarYear, 1);
			int yearInfo2 = GetYearInfo(lunarYear, 2);
			bool flag = GregorianIsLeapYear(lunarYear);
			int[] array = (flag ? s_daysToMonth366 : s_daysToMonth365);
			solarDay = yearInfo2;
			if (yearInfo > 1)
			{
				solarDay += array[yearInfo - 1];
			}
			solarDay += num;
			if (solarDay > 365 + (flag ? 1 : 0))
			{
				solarYear = lunarYear + 1;
				solarDay -= 365 + (flag ? 1 : 0);
			}
			else
			{
				solarYear = lunarYear;
			}
			solarMonth = 1;
			while (solarMonth < 12 && array[solarMonth] < solarDay)
			{
				solarMonth++;
			}
			solarDay -= array[solarMonth - 1];
			return true;
		}

		private DateTime LunarToTime(DateTime time, int year, int month, int day)
		{
			LunarToGregorian(year, month, day, out var solarYear, out var solarMonth, out var solarDay);
			time.GetTime(out var hour, out var minute, out var second, out var millisecond);
			return GregorianCalendar.GetDefaultInstance().ToDateTime(solarYear, solarMonth, solarDay, hour, minute, second, millisecond);
		}

		private void TimeToLunar(DateTime time, out int year, out int month, out int day)
		{
			Calendar defaultInstance = GregorianCalendar.GetDefaultInstance();
			int year2 = defaultInstance.GetYear(time);
			int month2 = defaultInstance.GetMonth(time);
			int dayOfMonth = defaultInstance.GetDayOfMonth(time);
			GregorianToLunar(year2, month2, dayOfMonth, out year, out month, out day);
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			if (months < -120000 || months > 120000)
			{
				throw new ArgumentOutOfRangeException("months", months, SR.Format(SR.ArgumentOutOfRange_Range, -120000, 120000));
			}
			CheckTicksRange(time.Ticks);
			TimeToLunar(time, out var year, out var month, out var day);
			int num = month + months;
			if (num > 0)
			{
				int num2 = (InternalIsLeapYear(year) ? 13 : 12);
				while (num - num2 > 0)
				{
					num -= num2;
					year++;
					num2 = (InternalIsLeapYear(year) ? 13 : 12);
				}
				month = num;
			}
			else
			{
				while (num <= 0)
				{
					int num3 = (InternalIsLeapYear(year - 1) ? 13 : 12);
					num += num3;
					year--;
				}
				month = num;
			}
			int num4 = InternalGetDaysInMonth(year, month);
			if (day > num4)
			{
				day = num4;
			}
			DateTime result = LunarToTime(time, year, month, day);
			Calendar.CheckAddResult(result.Ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return result;
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			CheckTicksRange(time.Ticks);
			TimeToLunar(time, out var year, out var month, out var day);
			year += years;
			if (month == 13 && !InternalIsLeapYear(year))
			{
				month = 12;
				day = InternalGetDaysInMonth(year, month);
			}
			int num = InternalGetDaysInMonth(year, month);
			if (day > num)
			{
				day = num;
			}
			DateTime result = LunarToTime(time, year, month, day);
			Calendar.CheckAddResult(result.Ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return result;
		}

		public override int GetDayOfYear(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			TimeToLunar(time, out var year, out var month, out var day);
			for (int i = 1; i < month; i++)
			{
				day += InternalGetDaysInMonth(year, i);
			}
			return day;
		}

		public override int GetDayOfMonth(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			TimeToLunar(time, out var _, out var _, out var day);
			return day;
		}

		public override int GetDaysInYear(int year, int era)
		{
			year = CheckYearRange(year, era);
			int num = 0;
			int num2 = (InternalIsLeapYear(year) ? 13 : 12);
			while (num2 != 0)
			{
				num += InternalGetDaysInMonth(year, num2--);
			}
			return num;
		}

		public override int GetMonth(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			TimeToLunar(time, out var _, out var month, out var _);
			return month;
		}

		public override int GetYear(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			TimeToLunar(time, out var year, out var _, out var _);
			return GetYear(year, time);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			return (DayOfWeek)((int)(time.Ticks / 864000000000L + 1) % 7);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			year = CheckYearRange(year, era);
			if (!InternalIsLeapYear(year))
			{
				return 12;
			}
			return 13;
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			year = CheckYearMonthRange(year, month, era);
			int num = InternalGetDaysInMonth(year, month);
			if (day < 1 || day > num)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Day, num, month));
			}
			int yearInfo = GetYearInfo(year, 0);
			if (yearInfo != 0)
			{
				return month == yearInfo + 1;
			}
			return false;
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			year = CheckYearMonthRange(year, month, era);
			int yearInfo = GetYearInfo(year, 0);
			if (yearInfo != 0)
			{
				return month == yearInfo + 1;
			}
			return false;
		}

		public override int GetLeapMonth(int year, int era)
		{
			year = CheckYearRange(year, era);
			int yearInfo = GetYearInfo(year, 0);
			if (yearInfo <= 0)
			{
				return 0;
			}
			return yearInfo + 1;
		}

		internal bool InternalIsLeapYear(int year)
		{
			return GetYearInfo(year, 0) != 0;
		}

		public override bool IsLeapYear(int year, int era)
		{
			year = CheckYearRange(year, era);
			return InternalIsLeapYear(year);
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			year = base.ToFourDigitYear(year);
			CheckYearRange(year, 0);
			return year;
		}
	}
	public static class GlobalizationExtensions
	{
		public static StringComparer GetStringComparer(this CompareInfo compareInfo, CompareOptions options)
		{
			if (compareInfo == null)
			{
				throw new ArgumentNullException("compareInfo");
			}
			return options switch
			{
				CompareOptions.Ordinal => StringComparer.Ordinal, 
				CompareOptions.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase, 
				_ => new CultureAwareComparer(compareInfo, options), 
			};
		}
	}
	internal static class GlobalizationMode
	{
		private static class Settings
		{
			internal static bool Invariant { get; } = AppContextConfigHelper.GetBooleanConfig("System.Globalization.Invariant", "DOTNET_SYSTEM_GLOBALIZATION_INVARIANT");


			internal static bool PredefinedCulturesOnly { get; } = AppContextConfigHelper.GetBooleanConfig("System.Globalization.PredefinedCulturesOnly", "DOTNET_SYSTEM_GLOBALIZATION_PREDEFINED_CULTURES_ONLY", GlobalizationMode.Invariant);

		}

		internal static bool Invariant => Settings.Invariant;

		internal static bool PredefinedCulturesOnly => Settings.PredefinedCulturesOnly;

		internal static bool UseNls { get; } = !Invariant && (AppContextConfigHelper.GetBooleanConfig("System.Globalization.UseNls", "DOTNET_SYSTEM_GLOBALIZATION_USENLS") || !LoadIcu());


		private static bool TryGetAppLocalIcuSwitchValue([NotNullWhen(true)] out string value)
		{
			return TryGetStringValue("System.Globalization.AppLocalIcu", "DOTNET_SYSTEM_GLOBALIZATION_APPLOCALICU", out value);
		}

		private static bool TryGetStringValue(string switchName, string envVariable, [NotNullWhen(true)] out string value)
		{
			value = AppContext.GetData(switchName) as string;
			if (string.IsNullOrEmpty(value))
			{
				value = Environment.GetEnvironmentVariable(envVariable);
				if (string.IsNullOrEmpty(value))
				{
					return false;
				}
			}
			return true;
		}

		private static void LoadAppLocalIcu(string icuSuffixAndVersion)
		{
			ReadOnlySpan<char> suffix = default(ReadOnlySpan<char>);
			int num = icuSuffixAndVersion.IndexOf(':');
			ReadOnlySpan<char> version;
			if (num >= 0)
			{
				suffix = icuSuffixAndVersion.AsSpan(0, num);
				version = icuSuffixAndVersion.AsSpan(suffix.Length + 1);
			}
			else
			{
				version = icuSuffixAndVersion;
			}
			LoadAppLocalIcuCore(version, suffix);
		}

		private static string CreateLibraryName(ReadOnlySpan<char> baseName, ReadOnlySpan<char> suffix, ReadOnlySpan<char> extension, ReadOnlySpan<char> version, bool versionAtEnd = false)
		{
			if (!versionAtEnd)
			{
				return string.Concat(baseName, suffix, version, extension);
			}
			return string.Concat(baseName, suffix, extension, version);
		}

		private static IntPtr LoadLibrary(string library, bool failOnLoadFailure)
		{
			if (!NativeLibrary.TryLoad(library, typeof(object).Assembly, DllImportSearchPath.ApplicationDirectory | DllImportSearchPath.System32, out var handle) && failOnLoadFailure)
			{
				Environment.FailFast("Failed to load app-local ICU: " + library);
			}
			return handle;
		}

		private static bool LoadIcu()
		{
			if (!TryGetAppLocalIcuSwitchValue(out var value))
			{
				return Interop.Globalization.LoadICU() != 0;
			}
			LoadAppLocalIcu(value);
			return true;
		}

		private static void LoadAppLocalIcuCore(ReadOnlySpan<char> version, ReadOnlySpan<char> suffix)
		{
			IntPtr intPtr = IntPtr.Zero;
			IntPtr intPtr2 = IntPtr.Zero;
			int num = version.IndexOf('.');
			if (num > 0)
			{
				ReadOnlySpan<char> version2 = version.Slice(0, num);
				intPtr = LoadLibrary(CreateLibraryName("icuuc", suffix, ".dll", version2), failOnLoadFailure: false);
				if (intPtr != IntPtr.Zero)
				{
					intPtr2 = LoadLibrary(CreateLibraryName("icuin", suffix, ".dll", version2), failOnLoadFailure: false);
				}
			}
			if (intPtr == IntPtr.Zero)
			{
				intPtr = LoadLibrary(CreateLibraryName("icuuc", suffix, ".dll", version), failOnLoadFailure: true);
			}
			if (intPtr2 == IntPtr.Zero)
			{
				intPtr2 = LoadLibrary(CreateLibraryName("icuin", suffix, ".dll", version), failOnLoadFailure: true);
			}
			Interop.Globalization.InitICUFunctions(intPtr, intPtr2, version, suffix);
		}
	}
	public class GregorianCalendar : Calendar
	{
		public const int ADEra = 1;

		private GregorianCalendarTypes _type;

		private static readonly int[] DaysToMonth365 = new int[13]
		{
			0, 31, 59, 90, 120, 151, 181, 212, 243, 273,
			304, 334, 365
		};

		private static readonly int[] DaysToMonth366 = new int[13]
		{
			0, 31, 60, 91, 121, 152, 182, 213, 244, 274,
			305, 335, 366
		};

		private static volatile Calendar s_defaultInstance;

		public override DateTime MinSupportedDateTime => DateTime.MinValue;

		public override DateTime MaxSupportedDateTime => DateTime.MaxValue;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.SolarCalendar;

		public virtual GregorianCalendarTypes CalendarType
		{
			get
			{
				return _type;
			}
			set
			{
				VerifyWritable();
				if (value < GregorianCalendarTypes.Localized || value > GregorianCalendarTypes.TransliteratedFrench)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, GregorianCalendarTypes.Localized, GregorianCalendarTypes.TransliteratedFrench));
				}
				_type = value;
			}
		}

		internal override CalendarId ID => (CalendarId)_type;

		public override int[] Eras => new int[1] { 1 };

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 2029);
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > 9999)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, 9999));
				}
				_twoDigitYearMax = value;
			}
		}

		internal static Calendar GetDefaultInstance()
		{
			return s_defaultInstance ?? (s_defaultInstance = new GregorianCalendar());
		}

		public GregorianCalendar()
			: this(GregorianCalendarTypes.Localized)
		{
		}

		public GregorianCalendar(GregorianCalendarTypes type)
		{
			if (type < GregorianCalendarTypes.Localized || type > GregorianCalendarTypes.TransliteratedFrench)
			{
				throw new ArgumentOutOfRangeException("type", type, SR.Format(SR.ArgumentOutOfRange_Range, GregorianCalendarTypes.Localized, GregorianCalendarTypes.TransliteratedFrench));
			}
			_type = type;
		}

		internal static long GetAbsoluteDate(int year, int month, int day)
		{
			if (year >= 1 && year <= 9999 && month >= 1 && month <= 12)
			{
				int[] array = ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? DaysToMonth366 : DaysToMonth365);
				if (day >= 1 && day <= array[month] - array[month - 1])
				{
					int num = year - 1;
					return num * 365 + num / 4 - num / 100 + num / 400 + array[month - 1] + day - 1;
				}
			}
			throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
		}

		internal virtual long DateToTicks(int year, int month, int day)
		{
			return GetAbsoluteDate(year, month, day) * 864000000000L;
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			if (months < -120000 || months > 120000)
			{
				throw new ArgumentOutOfRangeException("months", months, SR.Format(SR.ArgumentOutOfRange_Range, -120000, 120000));
			}
			time.GetDate(out var year, out var month, out var day);
			int num = month - 1 + months;
			if (num >= 0)
			{
				month = num % 12 + 1;
				year += num / 12;
			}
			else
			{
				month = 12 + (num + 1) % 12;
				year += (num - 11) / 12;
			}
			int[] array = ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? DaysToMonth366 : DaysToMonth365);
			int num2 = array[month] - array[month - 1];
			if (day > num2)
			{
				day = num2;
			}
			long ticks = DateToTicks(year, month, day) + time.Ticks % 864000000000L;
			Calendar.CheckAddResult(ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return new DateTime(ticks);
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return AddMonths(time, years * 12);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return time.Day;
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return time.DayOfWeek;
		}

		public override int GetDayOfYear(DateTime time)
		{
			return time.DayOfYear;
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			return DateTime.DaysInMonth(year, month);
		}

		public override int GetDaysInYear(int year, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			if (!DateTime.IsLeapYear(year))
			{
				return 365;
			}
			return 366;
		}

		public override int GetEra(DateTime time)
		{
			return 1;
		}

		public override int GetMonth(DateTime time)
		{
			return time.Month;
		}

		public override int GetMonthsInYear(int year, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			if (year < 1 || year > 9999)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, 9999));
			}
			return 12;
		}

		public override int GetYear(DateTime time)
		{
			return time.Year;
		}

		internal override bool IsValidYear(int year, int era)
		{
			if (year >= 1)
			{
				return year <= 9999;
			}
			return false;
		}

		internal override bool IsValidDay(int year, int month, int day, int era)
		{
			if ((era != 0 && era != 1) || year < 1 || year > 9999 || month < 1 || month > 12 || day < 1)
			{
				return false;
			}
			int[] array = ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? DaysToMonth366 : DaysToMonth365);
			return day <= array[month] - array[month - 1];
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			if (month < 1 || month > 12)
			{
				throw new ArgumentOutOfRangeException("month", month, SR.Format(SR.ArgumentOutOfRange_Range, 1, 12));
			}
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			if (year < 1 || year > 9999)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, 9999));
			}
			if (day < 1 || day > GetDaysInMonth(year, month))
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Range, 1, GetDaysInMonth(year, month)));
			}
			if (IsLeapYear(year) && month == 2)
			{
				return day == 29;
			}
			return false;
		}

		public override int GetLeapMonth(int year, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			if (year < 1 || year > 9999)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, 9999));
			}
			return 0;
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			if (year < 1 || year > 9999)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, 9999));
			}
			if (month < 1 || month > 12)
			{
				throw new ArgumentOutOfRangeException("month", month, SR.Format(SR.ArgumentOutOfRange_Range, 1, 12));
			}
			return false;
		}

		public override bool IsLeapYear(int year, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			return DateTime.IsLeapYear(year);
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			return new DateTime(year, month, day, hour, minute, second, millisecond);
		}

		internal override bool TryToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era, out DateTime result)
		{
			if (era != 0 && era != 1)
			{
				result = DateTime.MinValue;
				return false;
			}
			return DateTime.TryCreate(year, month, day, hour, minute, second, millisecond, out result);
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (year > 9999)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, 9999));
			}
			return base.ToFourDigitYear(year);
		}
	}
	internal sealed class EraInfo
	{
		internal int era;

		internal long ticks;

		internal int yearOffset;

		internal int minEraYear;

		internal int maxEraYear;

		internal string eraName;

		internal string abbrevEraName;

		internal string englishEraName;

		internal EraInfo(int era, int startYear, int startMonth, int startDay, int yearOffset, int minEraYear, int maxEraYear)
		{
			this.era = era;
			this.yearOffset = yearOffset;
			this.minEraYear = minEraYear;
			this.maxEraYear = maxEraYear;
			ticks = new DateTime(startYear, startMonth, startDay).Ticks;
		}

		internal EraInfo(int era, int startYear, int startMonth, int startDay, int yearOffset, int minEraYear, int maxEraYear, string eraName, string abbrevEraName, string englishEraName)
		{
			this.era = era;
			this.yearOffset = yearOffset;
			this.minEraYear = minEraYear;
			this.maxEraYear = maxEraYear;
			ticks = new DateTime(startYear, startMonth, startDay).Ticks;
			this.eraName = eraName;
			this.abbrevEraName = abbrevEraName;
			this.englishEraName = englishEraName;
		}
	}
	internal sealed class GregorianCalendarHelper
	{
		internal static readonly int[] DaysToMonth365 = new int[13]
		{
			0, 31, 59, 90, 120, 151, 181, 212, 243, 273,
			304, 334, 365
		};

		internal static readonly int[] DaysToMonth366 = new int[13]
		{
			0, 31, 60, 91, 121, 152, 182, 213, 244, 274,
			305, 335, 366
		};

		internal int m_maxYear;

		internal int m_minYear;

		internal Calendar m_Cal;

		internal EraInfo[] m_EraInfo;

		internal int[] m_eras;

		internal int MaxYear => m_maxYear;

		public int[] Eras
		{
			get
			{
				if (m_eras == null)
				{
					m_eras = new int[m_EraInfo.Length];
					for (int i = 0; i < m_EraInfo.Length; i++)
					{
						m_eras[i] = m_EraInfo[i].era;
					}
				}
				return (int[])m_eras.Clone();
			}
		}

		internal GregorianCalendarHelper(Calendar cal, EraInfo[] eraInfo)
		{
			m_Cal = cal;
			m_EraInfo = eraInfo;
			m_maxYear = m_EraInfo[0].maxEraYear;
			m_minYear = m_EraInfo[0].minEraYear;
		}

		private int GetYearOffset(int year, int era, bool throwOnError)
		{
			if (year < 0)
			{
				if (throwOnError)
				{
					throw new ArgumentOutOfRangeException("year", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				return -1;
			}
			if (era == 0)
			{
				era = m_Cal.CurrentEraValue;
			}
			for (int i = 0; i < m_EraInfo.Length; i++)
			{
				if (era != m_EraInfo[i].era)
				{
					continue;
				}
				if (year >= m_EraInfo[i].minEraYear)
				{
					if (year <= m_EraInfo[i].maxEraYear)
					{
						return m_EraInfo[i].yearOffset;
					}
					if (!LocalAppContextSwitches.EnforceJapaneseEraYearRanges)
					{
						int num = year - m_EraInfo[i].maxEraYear;
						for (int num2 = i - 1; num2 >= 0; num2--)
						{
							if (num <= m_EraInfo[num2].maxEraYear)
							{
								return m_EraInfo[i].yearOffset;
							}
							num -= m_EraInfo[num2].maxEraYear;
						}
					}
				}
				if (!throwOnError)
				{
					break;
				}
				throw new ArgumentOutOfRangeException("year", SR.Format(SR.ArgumentOutOfRange_Range, m_EraInfo[i].minEraYear, m_EraInfo[i].maxEraYear));
			}
			if (throwOnError)
			{
				throw new ArgumentOutOfRangeException("era", SR.ArgumentOutOfRange_InvalidEraValue);
			}
			return -1;
		}

		internal int GetGregorianYear(int year, int era)
		{
			return GetYearOffset(year, era, throwOnError: true) + year;
		}

		internal bool IsValidYear(int year, int era)
		{
			return GetYearOffset(year, era, throwOnError: false) >= 0;
		}

		internal int GetDatePart(long ticks, int part)
		{
			CheckTicksRange(ticks);
			int num = (int)(ticks / 864000000000L);
			int num2 = num / 146097;
			num -= num2 * 146097;
			int num3 = num / 36524;
			if (num3 == 4)
			{
				num3 = 3;
			}
			num -= num3 * 36524;
			int num4 = num / 1461;
			num -= num4 * 1461;
			int num5 = num / 365;
			if (num5 == 4)
			{
				num5 = 3;
			}
			if (part == 0)
			{
				return num2 * 400 + num3 * 100 + num4 * 4 + num5 + 1;
			}
			num -= num5 * 365;
			if (part == 1)
			{
				return num + 1;
			}
			int[] array = ((num5 == 3 && (num4 != 24 || num3 == 3)) ? DaysToMonth366 : DaysToMonth365);
			int i;
			for (i = (num >> 5) + 1; num >= array[i]; i++)
			{
			}
			if (part == 2)
			{
				return i;
			}
			return num - array[i - 1] + 1;
		}

		internal static long GetAbsoluteDate(int year, int month, int day)
		{
			if (year >= 1 && year <= 9999 && month >= 1 && month <= 12)
			{
				int[] array = ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? DaysToMonth366 : DaysToMonth365);
				if (day >= 1 && day <= array[month] - array[month - 1])
				{
					int num = year - 1;
					int num2 = num * 365 + num / 4 - num / 100 + num / 400 + array[month - 1] + day - 1;
					return num2;
				}
			}
			throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
		}

		internal static long DateToTicks(int year, int month, int day)
		{
			return GetAbsoluteDate(year, month, day) * 864000000000L;
		}

		internal static long TimeToTicks(int hour, int minute, int second, int millisecond)
		{
			if (hour >= 0 && hour < 24 && minute >= 0 && minute < 60 && second >= 0 && second < 60)
			{
				if (millisecond < 0 || millisecond >= 1000)
				{
					throw new ArgumentOutOfRangeException("millisecond", SR.Format(SR.ArgumentOutOfRange_Range, 0, 999));
				}
				return InternalGlobalizationHelper.TimeToTicks(hour, minute, second) + (long)millisecond * 10000L;
			}
			throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadHourMinuteSecond);
		}

		internal void CheckTicksRange(long ticks)
		{
			if (ticks < m_Cal.MinSupportedDateTime.Ticks || ticks > m_Cal.MaxSupportedDateTime.Ticks)
			{
				throw new ArgumentOutOfRangeException("time", SR.Format(CultureInfo.InvariantCulture, SR.ArgumentOutOfRange_CalendarRange, m_Cal.MinSupportedDateTime, m_Cal.MaxSupportedDateTime));
			}
		}

		public DateTime AddMonths(DateTime time, int months)
		{
			if (months < -120000 || months > 120000)
			{
				throw new ArgumentOutOfRangeException("months", SR.Format(SR.ArgumentOutOfRange_Range, -120000, 120000));
			}
			CheckTicksRange(time.Ticks);
			int datePart = GetDatePart(time.Ticks, 0);
			int datePart2 = GetDatePart(time.Ticks, 2);
			int num = GetDatePart(time.Ticks, 3);
			int num2 = datePart2 - 1 + months;
			if (num2 >= 0)
			{
				datePart2 = num2 % 12 + 1;
				datePart += num2 / 12;
			}
			else
			{
				datePart2 = 12 + (num2 + 1) % 12;
				datePart += (num2 - 11) / 12;
			}
			int[] array = ((datePart % 4 == 0 && (datePart % 100 != 0 || datePart % 400 == 0)) ? DaysToMonth366 : DaysToMonth365);
			int num3 = array[datePart2] - array[datePart2 - 1];
			if (num > num3)
			{
				num = num3;
			}
			long ticks = DateToTicks(datePart, datePart2, num) + time.Ticks % 864000000000L;
			Calendar.CheckAddResult(ticks, m_Cal.MinSupportedDateTime, m_Cal.MaxSupportedDateTime);
			return new DateTime(ticks);
		}

		public DateTime AddYears(DateTime time, int years)
		{
			return AddMonths(time, years * 12);
		}

		public int GetDayOfMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 3);
		}

		public DayOfWeek GetDayOfWeek(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			return (DayOfWeek)((time.Ticks / 864000000000L + 1) % 7);
		}

		public int GetDayOfYear(DateTime time)
		{
			return GetDatePart(time.Ticks, 1);
		}

		public int GetDaysInMonth(int year, int month, int era)
		{
			year = GetGregorianYear(year, era);
			if (month < 1 || month > 12)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
			int[] array = ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? DaysToMonth366 : DaysToMonth365);
			return array[month] - array[month - 1];
		}

		public int GetDaysInYear(int year, int era)
		{
			year = GetGregorianYear(year, era);
			if (year % 4 != 0 || (year % 100 == 0 && year % 400 != 0))
			{
				return 365;
			}
			return 366;
		}

		public int GetEra(DateTime time)
		{
			long ticks = time.Ticks;
			for (int i = 0; i < m_EraInfo.Length; i++)
			{
				if (ticks >= m_EraInfo[i].ticks)
				{
					return m_EraInfo[i].era;
				}
			}
			throw new ArgumentOutOfRangeException("time", SR.ArgumentOutOfRange_Era);
		}

		public int GetMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 2);
		}

		public int GetMonthsInYear(int year, int era)
		{
			ValidateYearInEra(year, era);
			return 12;
		}

		public int GetYear(DateTime time)
		{
			long ticks = time.Ticks;
			int datePart = GetDatePart(ticks, 0);
			for (int i = 0; i < m_EraInfo.Length; i++)
			{
				if (ticks >= m_EraInfo[i].ticks)
				{
					return datePart - m_EraInfo[i].yearOffset;
				}
			}
			throw new ArgumentException(SR.Argument_NoEra);
		}

		public int GetYear(int year, DateTime time)
		{
			long ticks = time.Ticks;
			for (int i = 0; i < m_EraInfo.Length; i++)
			{
				if (ticks >= m_EraInfo[i].ticks && year > m_EraInfo[i].yearOffset)
				{
					return year - m_EraInfo[i].yearOffset;
				}
			}
			throw new ArgumentException(SR.Argument_NoEra);
		}

		public bool IsLeapDay(int year, int month, int day, int era)
		{
			if (day < 1 || day > GetDaysInMonth(year, month, era))
			{
				throw new ArgumentOutOfRangeException("day", SR.Format(SR.ArgumentOutOfRange_Range, 1, GetDaysInMonth(year, month, era)));
			}
			if (!IsLeapYear(year, era))
			{
				return false;
			}
			if (month == 2 && day == 29)
			{
				return true;
			}
			return false;
		}

		public void ValidateYearInEra(int year, int era)
		{
			GetYearOffset(year, era, throwOnError: true);
		}

		public int GetLeapMonth(int year, int era)
		{
			ValidateYearInEra(year, era);
			return 0;
		}

		public bool IsLeapMonth(int year, int month, int era)
		{
			ValidateYearInEra(year, era);
			if (month < 1 || month > 12)
			{
				throw new ArgumentOutOfRangeException("month", SR.Format(SR.ArgumentOutOfRange_Range, 1, 12));
			}
			return false;
		}

		public bool IsLeapYear(int year, int era)
		{
			year = GetGregorianYear(year, era);
			if (year % 4 == 0)
			{
				if (year % 100 == 0)
				{
					return year % 400 == 0;
				}
				return true;
			}
			return false;
		}

		public DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			year = GetGregorianYear(year, era);
			long ticks = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second, millisecond);
			CheckTicksRange(ticks);
			return new DateTime(ticks);
		}

		public int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
		{
			CheckTicksRange(time.Ticks);
			return GregorianCalendar.GetDefaultInstance().GetWeekOfYear(time, rule, firstDayOfWeek);
		}

		public int ToFourDigitYear(int year, int twoDigitYearMax)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", SR.ArgumentOutOfRange_NeedPosNum);
			}
			if (year < 100)
			{
				int num = year % 100;
				return (twoDigitYearMax / 100 - ((num > twoDigitYearMax % 100) ? 1 : 0)) * 100 + num;
			}
			if (year < m_minYear || year > m_maxYear)
			{
				throw new ArgumentOutOfRangeException("year", SR.Format(SR.ArgumentOutOfRange_Range, m_minYear, m_maxYear));
			}
			return year;
		}
	}
	public enum GregorianCalendarTypes
	{
		Localized = 1,
		USEnglish = 2,
		MiddleEastFrench = 9,
		Arabic = 10,
		TransliteratedEnglish = 11,
		TransliteratedFrench = 12
	}
	public class HebrewCalendar : Calendar
	{
		internal sealed class DateBuffer
		{
			internal int year;

			internal int month;

			internal int day;
		}

		public static readonly int HebrewEra = 1;

		private static readonly DateTime s_calendarMinValue = new DateTime(1583, 1, 1);

		private static readonly DateTime s_calendarMaxValue = new DateTime(new DateTime(2239, 9, 29, 23, 59, 59, 999).Ticks + 9999);

		private static ReadOnlySpan<byte> HebrewTable => new byte[1316]
		{
			7, 3, 17, 3, 0, 4, 11, 2, 21, 6,
			1, 3, 13, 2, 25, 4, 5, 3, 16, 2,
			27, 6, 9, 1, 20, 2, 0, 6, 11, 3,
			23, 4, 4, 2, 14, 3, 27, 4, 8, 2,
			18, 3, 28, 6, 11, 1, 22, 5, 2, 3,
			12, 3, 25, 4, 6, 2, 16, 3, 26, 6,
			8, 2, 20, 1, 0, 6, 11, 2, 24, 4,
			4, 3, 15, 2, 25, 6, 8, 1, 19, 2,
			29, 6, 9, 3, 22, 4, 3, 2, 13, 3,
			25, 4, 6, 3, 17, 2, 27, 6, 7, 3,
			19, 2, 31, 4, 11, 3, 23, 4, 5, 2,
			15, 3, 25, 6, 6, 2, 19, 1, 29, 6,
			10, 2, 22, 4, 3, 3, 14, 2, 24, 6,
			6, 1, 17, 3, 28, 5, 8, 3, 20, 1,
			32, 5, 12, 3, 22, 6, 4, 1, 16, 2,
			26, 6, 6, 3, 17, 2, 0, 4, 10, 3,
			22, 4, 3, 2, 14, 3, 24, 6, 5, 2,
			17, 1, 28, 6, 9, 2, 19, 3, 31, 4,
			13, 2, 23, 6, 3, 3, 15, 1, 27, 5,
			7, 3, 17, 3, 29, 4, 11, 2, 21, 6,
			3, 1, 14, 2, 25, 6, 5, 3, 16, 2,
			28, 4, 9, 3, 20, 2, 0, 6, 12, 1,
			23, 6, 4, 2, 14, 3, 26, 4, 8, 2,
			18, 3, 0, 4, 10, 3, 21, 5, 1, 3,
			13, 1, 24, 5, 5, 3, 15, 3, 27, 4,
			8, 2, 19, 3, 29, 6, 10, 2, 22, 4,
			3, 3, 14, 2, 26, 4, 6, 3, 18, 2,
			28, 6, 10, 1, 20, 6, 2, 2, 12, 3,
			24, 4, 5, 2, 16, 3, 28, 4, 8, 3,
			19, 2, 0, 6, 12, 1, 23, 5, 3, 3,
			14, 3, 26, 4, 7, 2, 17, 3, 28, 6,
			9, 2, 21, 4, 1, 3, 13, 2, 25, 4,
			5, 3, 16, 2, 27, 6, 9, 1, 19, 3,
			0, 5, 11, 3, 23, 4, 4, 2, 14, 3,
			25, 6, 7, 1, 18, 2, 28, 6, 9, 3,
			21, 4, 2, 2, 12, 3, 25, 4, 6, 2,
			16, 3, 26, 6, 8, 2, 20, 1, 0, 6,
			11, 2, 22, 6, 4, 1, 15, 2, 25, 6,
			6, 3, 18, 1, 29, 5, 9, 3, 22, 4,
			2, 3, 13, 2, 23, 6, 4, 3, 15, 2,
			27, 4, 7, 3, 19, 2, 31, 4, 11, 3,
			21, 6, 3, 2, 15, 1, 25, 6, 6, 2,
			17, 3, 29, 4, 10, 2, 20, 6, 3, 1,
			13, 3, 24, 5, 4, 3, 16, 1, 27, 5,
			7, 3, 17, 3, 0, 4, 11, 2, 21, 6,
			1, 3, 13, 2, 25, 4, 5, 3, 16, 2,
			29, 4, 9, 3, 19, 6, 30, 2, 13, 1,
			23, 6, 4, 2, 14, 3, 27, 4, 8, 2,
			18, 3, 0, 4, 11, 3, 22, 5, 2, 3,
			14, 1, 26, 5, 6, 3, 16, 3, 28, 4,
			10, 2, 20, 6, 30, 3, 11, 2, 24, 4,
			4, 3, 15, 2, 25, 6, 8, 1, 19, 2,
			29, 6, 9, 3, 22, 4, 3, 2, 13, 3,
			25, 4, 7, 2, 17, 3, 27, 6, 9, 1,
			21, 5, 1, 3, 11, 3, 23, 4, 5, 2,
			15, 3, 25, 6, 6, 2, 19, 1, 29, 6,
			10, 2, 22, 4, 3, 3, 14, 2, 24, 6,
			6, 1, 18, 2, 28, 6, 8, 3, 20, 4,
			2, 2, 12, 3, 24, 4, 4, 3, 16, 2,
			26, 6, 6, 3, 17, 2, 0, 4, 10, 3,
			22, 4, 3, 2, 14, 3, 24, 6, 5, 2,
			17, 1, 28, 6, 9, 2, 21, 4, 1, 3,
			13, 2, 23, 6, 5, 1, 15, 3, 27, 5,
			7, 3, 19, 1, 0, 5, 10, 3, 22, 4,
			2, 3, 13, 2, 24, 6, 4, 3, 15, 2,
			27, 4, 8, 3, 20, 4, 1, 2, 11, 3,
			22, 6, 3, 2, 15, 1, 25, 6, 7, 2,
			17, 3, 29, 4, 10, 2, 21, 6, 1, 3,
			13, 1, 24, 5, 5, 3, 15, 3, 27, 4,
			8, 2, 19, 6, 1, 1, 12, 2, 22, 6,
			3, 3, 14, 2, 26, 4, 6, 3, 18, 2,
			28, 6, 10, 1, 20, 6, 2, 2, 12, 3,
			24, 4, 5, 2, 16, 3, 28, 4, 9, 2,
			19, 6, 30, 3, 12, 1, 23, 5, 3, 3,
			14, 3, 26, 4, 7, 2, 17, 3, 28, 6,
			9, 2, 21, 4, 1, 3, 13, 2, 25, 4,
			5, 3, 16, 2, 27, 6, 9, 1, 19, 6,
			30, 2, 11, 3, 23, 4, 4, 2, 14, 3,
			27, 4, 7, 3, 18, 2, 28, 6, 11, 1,
			22, 5, 2, 3, 12, 3, 25, 4, 6, 2,
			16, 3, 26, 6, 8, 2, 20, 4, 30, 3,
			11, 2, 24, 4, 4, 3, 15, 2, 25, 6,
			8, 1, 18, 3, 29, 5, 9, 3, 22, 4,
			3, 2, 13, 3, 23, 6, 6, 1, 17, 2,
			27, 6, 7, 3, 20, 4, 1, 2, 11, 3,
			23, 4, 5, 2, 15, 3, 25, 6, 6, 2,
			19, 1, 29, 6, 10, 2, 20, 6, 3, 1,
			14, 2, 24, 6, 4, 3, 17, 1, 28, 5,
			8, 3, 20, 4, 1, 3, 12, 2, 22, 6,
			2, 3, 14, 2, 26, 4, 6, 3, 17, 2,
			0, 4, 10, 3, 20, 6, 1, 2, 14, 1,
			24, 6, 5, 2, 15, 3, 28, 4, 9, 2,
			19, 6, 1, 1, 12, 3, 23, 5, 3, 3,
			15, 1, 27, 5, 7, 3, 17, 3, 29, 4,
			11, 2, 21, 6, 1, 3, 12, 2, 25, 4,
			5, 3, 16, 2, 28, 4, 9, 3, 19, 6,
			30, 2, 12, 1, 23, 6, 4, 2, 14, 3,
			26, 4, 8, 2, 18, 3, 0, 4, 10, 3,
			22, 5, 2, 3, 14, 1, 25, 5, 6, 3,
			16, 3, 28, 4, 9, 2, 20, 6, 30, 3,
			11, 2, 23, 4, 4, 3, 15, 2, 27, 4,
			7, 3, 19, 2, 29, 6, 11, 1, 21, 6,
			3, 2, 13, 3, 25, 4, 6, 2, 17, 3,
			27, 6, 9, 1, 20, 5, 30, 3, 10, 3,
			22, 4, 3, 2, 14, 3, 24, 6, 5, 2,
			17, 1, 28, 6, 9, 2, 21, 4, 1, 3,
			13, 2, 23, 6, 5, 1, 16, 2, 27, 6,
			7, 3, 19, 4, 30, 2, 11, 3, 23, 4,
			3, 3, 14, 2, 25, 6, 5, 3, 16, 2,
			28, 4, 9, 3, 21, 4, 2, 2, 12, 3,
			23, 6, 4, 2, 16, 1, 26, 6, 8, 2,
			20, 4, 30, 3, 11, 2, 22, 6, 4, 1,
			14, 3, 25, 5, 6, 3, 18, 1, 29, 5,
			9, 3, 22, 4, 2, 3, 13, 2, 23, 6,
			4, 3, 15, 2, 27, 4, 7, 3, 20, 4,
			1, 2, 11, 3, 21, 6, 3, 2, 15, 1,
			25, 6, 6, 2, 17, 3, 29, 4, 10, 2,
			20, 6, 3, 1, 13, 3, 24, 5, 4, 3,
			17, 1, 28, 5, 8, 3, 18, 6, 1, 1,
			12, 2, 22, 6, 2, 3, 14, 2, 26, 4,
			6, 3, 17, 2, 28, 6, 10, 1, 20, 6,
			1, 2, 12, 3, 24, 4, 5, 2, 15, 3,
			28, 4, 9, 2, 19, 6, 33, 3, 12, 1,
			23, 5, 3, 3, 13, 3, 25, 4, 6, 2,
			16, 3, 26, 6, 8, 2, 20, 4, 30, 3,
			11, 2, 24, 4, 4, 3, 15, 2, 25, 6,
			8, 1, 18, 6, 33, 2, 9, 3, 22, 4,
			3, 2, 13, 3, 25, 4, 6, 3, 17, 2,
			27, 6, 9, 1, 21, 5, 1, 3, 11, 3,
			23, 4, 5, 2, 15, 3, 25, 6, 6, 2,
			19, 4, 33, 3, 10, 2, 22, 4, 3, 3,
			14, 2, 24, 6, 6, 1
		};

		private static ReadOnlySpan<byte> LunarMonthLen => new byte[98]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 30, 29, 29, 29, 30,
			29, 30, 29, 30, 29, 30, 29, 0, 0, 30,
			29, 30, 29, 30, 29, 30, 29, 30, 29, 30,
			29, 0, 0, 30, 30, 30, 29, 30, 29, 30,
			29, 30, 29, 30, 29, 0, 0, 30, 29, 29,
			29, 30, 30, 29, 30, 29, 30, 29, 30, 29,
			0, 30, 29, 30, 29, 30, 30, 29, 30, 29,
			30, 29, 30, 29, 0, 30, 30, 30, 29, 30,
			30, 29, 30, 29, 30, 29, 30, 29
		};

		public override DateTime MinSupportedDateTime => s_calendarMinValue;

		public override DateTime MaxSupportedDateTime => s_calendarMaxValue;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.LunisolarCalendar;

		internal override CalendarId ID => CalendarId.HEBREW;

		public override int[] Eras => new int[1] { HebrewEra };

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 5790);
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value != 99)
				{
					CheckHebrewYearValue(value, HebrewEra, "value");
				}
				_twoDigitYearMax = value;
			}
		}

		private static void CheckHebrewYearValue(int y, int era, string varName)
		{
			CheckEraRange(era);
			if (y > 5999 || y < 5343)
			{
				throw new ArgumentOutOfRangeException(varName, y, SR.Format(SR.ArgumentOutOfRange_Range, 5343, 5999));
			}
		}

		private void CheckHebrewMonthValue(int year, int month, int era)
		{
			int monthsInYear = GetMonthsInYear(year, era);
			if (month < 1 || month > monthsInYear)
			{
				throw new ArgumentOutOfRangeException("month", month, SR.Format(SR.ArgumentOutOfRange_Range, 1, monthsInYear));
			}
		}

		private void CheckHebrewDayValue(int year, int month, int day, int era)
		{
			int daysInMonth = GetDaysInMonth(year, month, era);
			if (day < 1 || day > daysInMonth)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Range, 1, daysInMonth));
			}
		}

		private static void CheckEraRange(int era)
		{
			if (era != 0 && era != HebrewEra)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
		}

		private static void CheckTicksRange(long ticks)
		{
			if (ticks < s_calendarMinValue.Ticks || ticks > s_calendarMaxValue.Ticks)
			{
				throw new ArgumentOutOfRangeException("time", ticks, SR.Format(CultureInfo.InvariantCulture, SR.ArgumentOutOfRange_CalendarRange, s_calendarMinValue, s_calendarMaxValue));
			}
		}

		private static int GetResult(DateBuffer result, int part)
		{
			return part switch
			{
				0 => result.year, 
				2 => result.month, 
				3 => result.day, 
				_ => throw new InvalidOperationException(SR.InvalidOperation_DateTimeParsing), 
			};
		}

		internal static int GetLunarMonthDay(int gregorianYear, DateBuffer lunarDate)
		{
			int num = gregorianYear - 1583;
			if (num < 0 || num > 656)
			{
				throw new ArgumentOutOfRangeException("gregorianYear");
			}
			num *= 2;
			lunarDate.day = HebrewTable[num];
			int result = HebrewTable[num + 1];
			switch (lunarDate.day)
			{
			case 0:
				lunarDate.month = 5;
				lunarDate.day = 1;
				break;
			case 30:
				lunarDate.month = 3;
				break;
			case 31:
				lunarDate.month = 5;
				lunarDate.day = 2;
				break;
			case 32:
				lunarDate.month = 5;
				lunarDate.day = 3;
				break;
			case 33:
				lunarDate.month = 3;
				lunarDate.day = 29;
				break;
			default:
				lunarDate.month = 4;
				break;
			}
			return result;
		}

		internal virtual int GetDatePart(long ticks, int part)
		{
			CheckTicksRange(ticks);
			new DateTime(ticks).GetDate(out var year, out var month, out var day);
			DateBuffer dateBuffer = new DateBuffer();
			dateBuffer.year = year + 3760;
			int num = GetLunarMonthDay(year, dateBuffer);
			DateBuffer dateBuffer2 = new DateBuffer();
			dateBuffer2.year = dateBuffer.year;
			dateBuffer2.month = dateBuffer.month;
			dateBuffer2.day = dateBuffer.day;
			long absoluteDate = GregorianCalendar.GetAbsoluteDate(year, month, day);
			if (month == 1 && day == 1)
			{
				return GetResult(dateBuffer2, part);
			}
			long num2 = absoluteDate - GregorianCalendar.GetAbsoluteDate(year, 1, 1);
			if (num2 + dateBuffer.day <= LunarMonthLen[num * 14 + dateBuffer.month])
			{
				dateBuffer2.day += (int)num2;
				return GetResult(dateBuffer2, part);
			}
			dateBuffer2.month++;
			dateBuffer2.day = 1;
			num2 -= LunarMonthLen[num * 14 + dateBuffer.month] - dateBuffer.day;
			if (num2 > 1)
			{
				while (num2 > LunarMonthLen[num * 14 + dateBuffer2.month])
				{
					num2 -= LunarMonthLen[num * 14 + dateBuffer2.month++];
					if (dateBuffer2.month > 13 || LunarMonthLen[num * 14 + dateBuffer2.month] == 0)
					{
						dateBuffer2.year++;
						num = HebrewTable[(year + 1 - 1583) * 2 + 1];
						dateBuffer2.month = 1;
					}
				}
				dateBuffer2.day += (int)(num2 - 1);
			}
			return GetResult(dateBuffer2, part);
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			try
			{
				int num = GetDatePart(time.Ticks, 0);
				int datePart = GetDatePart(time.Ticks, 2);
				int num2 = GetDatePart(time.Ticks, 3);
				int num3;
				if (months >= 0)
				{
					int monthsInYear;
					for (num3 = datePart + months; num3 > (monthsInYear = GetMonthsInYear(num, 0)); num3 -= monthsInYear)
					{
						num++;
					}
				}
				else if ((num3 = datePart + months) <= 0)
				{
					months = -months;
					months -= datePart;
					num--;
					int monthsInYear;
					while (months > (monthsInYear = GetMonthsInYear(num, 0)))
					{
						num--;
						months -= monthsInYear;
					}
					monthsInYear = GetMonthsInYear(num, 0);
					num3 = monthsInYear - months;
				}
				int daysInMonth = GetDaysInMonth(num, num3);
				if (num2 > daysInMonth)
				{
					num2 = daysInMonth;
				}
				return new DateTime(ToDateTime(num, num3, num2, 0, 0, 0, 0).Ticks + time.Ticks % 864000000000L);
			}
			catch (ArgumentException)
			{
				throw new ArgumentOutOfRangeException("months", months, SR.ArgumentOutOfRange_AddValue);
			}
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			int datePart = GetDatePart(time.Ticks, 0);
			int num = GetDatePart(time.Ticks, 2);
			int num2 = GetDatePart(time.Ticks, 3);
			datePart += years;
			CheckHebrewYearValue(datePart, 0, "years");
			int monthsInYear = GetMonthsInYear(datePart, 0);
			if (num > monthsInYear)
			{
				num = monthsInYear;
			}
			int daysInMonth = GetDaysInMonth(datePart, num);
			if (num2 > daysInMonth)
			{
				num2 = daysInMonth;
			}
			long ticks = ToDateTime(datePart, num, num2, 0, 0, 0, 0).Ticks + time.Ticks % 864000000000L;
			Calendar.CheckAddResult(ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return new DateTime(ticks);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 3);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return (DayOfWeek)((int)(time.Ticks / 864000000000L + 1) % 7);
		}

		internal static int GetHebrewYearType(int year, int era)
		{
			CheckHebrewYearValue(year, era, "year");
			return HebrewTable[(year - 3760 - 1583) * 2 + 1];
		}

		public override int GetDayOfYear(DateTime time)
		{
			int year = GetYear(time);
			DateTime dateTime = ((year != 5343) ? ToDateTime(year, 1, 1, 0, 0, 0, 0, 0) : new DateTime(1582, 9, 27));
			return (int)((time.Ticks - dateTime.Ticks) / 864000000000L) + 1;
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			CheckEraRange(era);
			int hebrewYearType = GetHebrewYearType(year, era);
			CheckHebrewMonthValue(year, month, era);
			int num = LunarMonthLen[hebrewYearType * 14 + month];
			if (num == 0)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
			return num;
		}

		public override int GetDaysInYear(int year, int era)
		{
			CheckEraRange(era);
			int hebrewYearType = GetHebrewYearType(year, era);
			if (hebrewYearType < 4)
			{
				return 352 + hebrewYearType;
			}
			return 382 + (hebrewYearType - 3);
		}

		public override int GetEra(DateTime time)
		{
			return HebrewEra;
		}

		public override int GetMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 2);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			if (!IsLeapYear(year, era))
			{
				return 12;
			}
			return 13;
		}

		public override int GetYear(DateTime time)
		{
			return GetDatePart(time.Ticks, 0);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			if (IsLeapMonth(year, month, era))
			{
				CheckHebrewDayValue(year, month, day, era);
				return true;
			}
			if (IsLeapYear(year, 0) && month == 6 && day == 30)
			{
				return true;
			}
			CheckHebrewDayValue(year, month, day, era);
			return false;
		}

		public override int GetLeapMonth(int year, int era)
		{
			if (IsLeapYear(year, era))
			{
				return 7;
			}
			return 0;
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			bool flag = IsLeapYear(year, era);
			CheckHebrewMonthValue(year, month, era);
			if (flag)
			{
				return month == 7;
			}
			return false;
		}

		public override bool IsLeapYear(int year, int era)
		{
			CheckHebrewYearValue(year, era, "year");
			return (7L * (long)year + 1) % 19 < 7;
		}

		private static int GetDayDifference(int lunarYearType, int month1, int day1, int month2, int day2)
		{
			if (month1 == month2)
			{
				return day1 - day2;
			}
			bool flag = month1 > month2;
			if (flag)
			{
				int num = month1;
				int num2 = day1;
				month1 = month2;
				day1 = day2;
				month2 = num;
				day2 = num2;
			}
			int num3 = LunarMonthLen[lunarYearType * 14 + month1] - day1;
			month1++;
			while (month1 < month2)
			{
				num3 += LunarMonthLen[lunarYearType * 14 + month1++];
			}
			num3 += day2;
			if (!flag)
			{
				return -num3;
			}
			return num3;
		}

		private static DateTime HebrewToGregorian(int hebrewYear, int hebrewMonth, int hebrewDay, int hour, int minute, int second, int millisecond)
		{
			int num = hebrewYear - 3760;
			DateBuffer dateBuffer = new DateBuffer();
			int lunarMonthDay = GetLunarMonthDay(num, dateBuffer);
			if (hebrewMonth == dateBuffer.month && hebrewDay == dateBuffer.day)
			{
				return new DateTime(num, 1, 1, hour, minute, second, millisecond);
			}
			int dayDifference = GetDayDifference(lunarMonthDay, hebrewMonth, hebrewDay, dateBuffer.month, dateBuffer.day);
			return new DateTime(new DateTime(num, 1, 1).Ticks + dayDifference * 864000000000L + Calendar.TimeToTicks(hour, minute, second, millisecond));
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			CheckHebrewYearValue(year, era, "year");
			CheckHebrewMonthValue(year, month, era);
			CheckHebrewDayValue(year, month, day, era);
			DateTime result = HebrewToGregorian(year, month, day, hour, minute, second, millisecond);
			CheckTicksRange(result.Ticks);
			return result;
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (year < 100)
			{
				return base.ToFourDigitYear(year);
			}
			if (year > 5999 || year < 5343)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 5343, 5999));
			}
			return year;
		}
	}
	internal struct HebrewNumberParsingContext
	{
		internal HebrewNumber.HS state;

		internal int result;

		public HebrewNumberParsingContext(int result)
		{
			state = HebrewNumber.HS.Start;
			this.result = result;
		}
	}
	internal enum HebrewNumberParsingState
	{
		InvalidHebrewNumber,
		NotHebrewDigit,
		FoundEndOfHebrewNumber,
		ContinueParsing
	}
	internal static class HebrewNumber
	{
		private enum HebrewToken : short
		{
			Invalid = -1,
			Digit400,
			Digit200_300,
			Digit100,
			Digit10,
			Digit1,
			Digit6_7,
			Digit7,
			Digit9,
			SingleQuote,
			DoubleQuote
		}

		private struct HebrewValue
		{
			internal HebrewToken token;

			internal short value;

			internal HebrewValue(HebrewToken token, short value)
			{
				this.token = token;
				this.value = value;
			}
		}

		internal enum HS : sbyte
		{
			_err = -1,
			Start = 0,
			S400 = 1,
			S400_400 = 2,
			S400_X00 = 3,
			S400_X0 = 4,
			X00_DQ = 5,
			S400_X00_X0 = 6,
			X0_DQ = 7,
			X = 8,
			X0 = 9,
			X00 = 10,
			S400_DQ = 11,
			S400_400_DQ = 12,
			S400_400_100 = 13,
			S9 = 14,
			X00_S9 = 15,
			S9_DQ = 16,
			END = 100
		}

		private static readonly HebrewValue[] s_hebrewValues = new HebrewValue[27]
		{
			new HebrewValue(HebrewToken.Digit1, 1),
			new HebrewValue(HebrewToken.Digit1, 2),
			new HebrewValue(HebrewToken.Digit1, 3),
			new HebrewValue(HebrewToken.Digit1, 4),
			new HebrewValue(HebrewToken.Digit1, 5),
			new HebrewValue(HebrewToken.Digit6_7, 6),
			new HebrewValue(HebrewToken.Digit6_7, 7),
			new HebrewValue(HebrewToken.Digit1, 8),
			new HebrewValue(HebrewToken.Digit9, 9),
			new HebrewValue(HebrewToken.Digit10, 10),
			new HebrewValue(HebrewToken.Invalid, -1),
			new HebrewValue(HebrewToken.Digit10, 20),
			new HebrewValue(HebrewToken.Digit10, 30),
			new HebrewValue(HebrewToken.Invalid, -1),
			new HebrewValue(HebrewToken.Digit10, 40),
			new HebrewValue(HebrewToken.Invalid, -1),
			new HebrewValue(HebrewToken.Digit10, 50),
			new HebrewValue(HebrewToken.Digit10, 60),
			new HebrewValue(HebrewToken.Digit10, 70),
			new HebrewValue(HebrewToken.Invalid, -1),
			new HebrewValue(HebrewToken.Digit10, 80),
			new HebrewValue(HebrewToken.Invalid, -1),
			new HebrewValue(HebrewToken.Digit10, 90),
			new HebrewValue(HebrewToken.Digit100, 100),
			new HebrewValue(HebrewToken.Digit200_300, 200),
			new HebrewValue(HebrewToken.Digit200_300, 300),
			new HebrewValue(HebrewToken.Digit400, 400)
		};

		private static readonly char s_maxHebrewNumberCh = (char)(1488 + s_hebrewValues.Length - 1);

		private static readonly HS[] s_numberPasingState = new HS[170]
		{
			HS.S400,
			HS.X00,
			HS.X00,
			HS.X0,
			HS.X,
			HS.X,
			HS.X,
			HS.S9,
			HS._err,
			HS._err,
			HS.S400_400,
			HS.S400_X00,
			HS.S400_X00,
			HS.S400_X0,
			HS._err,
			HS._err,
			HS._err,
			HS.X00_S9,
			HS.END,
			HS.S400_DQ,
			HS._err,
			HS._err,
			HS.S400_400_100,
			HS.S400_X0,
			HS._err,
			HS._err,
			HS._err,
			HS.X00_S9,
			HS._err,
			HS.S400_400_DQ,
			HS._err,
			HS._err,
			HS._err,
			HS.S400_X00_X0,
			HS._err,
			HS._err,
			HS._err,
			HS.X00_S9,
			HS._err,
			HS.X00_DQ,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.X0_DQ,
			HS._err,
			HS._err,
			HS._err,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.X0_DQ,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.END,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.END,
			HS.X0_DQ,
			HS._err,
			HS._err,
			HS._err,
			HS.S400_X0,
			HS._err,
			HS._err,
			HS._err,
			HS.X00_S9,
			HS.END,
			HS.X00_DQ,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS.END,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.S400_X00_X0,
			HS._err,
			HS._err,
			HS._err,
			HS.X00_S9,
			HS._err,
			HS.X00_DQ,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.END,
			HS.S9_DQ,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.S9_DQ,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS._err,
			HS.END,
			HS.END,
			HS._err,
			HS._err,
			HS._err
		};

		internal static void Append(StringBuilder outputBuffer, int Number)
		{
			int length = outputBuffer.Length;
			char c = '\0';
			if (Number > 5000)
			{
				Number -= 5000;
			}
			int num = Number / 100;
			if (num > 0)
			{
				Number -= num * 100;
				for (int i = 0; i < num / 4; i++)
				{
					outputBuffer.Append('ת');
				}
				int num2 = num % 4;
				if (num2 > 0)
				{
					outputBuffer.Append((char)(1510 + num2));
				}
			}
			int num3 = Number / 10;
			Number %= 10;
			switch (num3)
			{
			case 0:
				c = '\0';
				break;
			case 1:
				c = 'י';
				break;
			case 2:
				c = 'כ';
				break;
			case 3:
				c = 'ל';
				break;
			case 4:
				c = 'מ';
				break;
			case 5:
				c = 'נ';
				break;
			case 6:
				c = 'ס';
				break;
			case 7:
				c = 'ע';
				break;
			case 8:
				c = 'פ';
				break;
			case 9:
				c = 'צ';
				break;
			}
			char c2 = (char)((Number > 0) ? ((uint)(1488 + Number - 1)) : 0u);
			if (c2 == 'ה' && c == 'י')
			{
				c2 = 'ו';
				c = 'ט';
			}
			if (c2 == 'ו' && c == 'י')
			{
				c2 = 'ז';
				c = 'ט';
			}
			if (c != 0)
			{
				outputBuffer.Append(c);
			}
			if (c2 != 0)
			{
				outputBuffer.Append(c2);
			}
			if (outputBuffer.Length - length > 1)
			{
				outputBuffer.Insert(outputBuffer.Length - 1, '"');
			}
			else
			{
				outputBuffer.Append('\'');
			}
		}

		internal static HebrewNumberParsingState ParseByChar(char ch, ref HebrewNumberParsingContext context)
		{
			HebrewToken hebrewToken;
			switch (ch)
			{
			case '\'':
				hebrewToken = HebrewToken.SingleQuote;
				break;
			case '"':
				hebrewToken = HebrewToken.DoubleQuote;
				break;
			default:
			{
				int num = ch - 1488;
				if (num >= 0 && num < s_hebrewValues.Length)
				{
					hebrewToken = s_hebrewValues[num].token;
					if (hebrewToken == HebrewToken.Invalid)
					{
						return HebrewNumberParsingState.NotHebrewDigit;
					}
					context.result += s_hebrewValues[num].value;
					break;
				}
				return HebrewNumberParsingState.NotHebrewDigit;
			}
			}
			context.state = s_numberPasingState[(int)context.state * 10 + (int)hebrewToken];
			if (context.state == HS._err)
			{
				return HebrewNumberParsingState.InvalidHebrewNumber;
			}
			if (context.state == HS.END)
			{
				return HebrewNumberParsingState.FoundEndOfHebrewNumber;
			}
			return HebrewNumberParsingState.ContinueParsing;
		}

		internal static bool IsDigit(char ch)
		{
			if (ch >= 'א' && ch <= s_maxHebrewNumberCh)
			{
				return s_hebrewValues[ch - 1488].value >= 0;
			}
			if (ch != '\'')
			{
				return ch == '"';
			}
			return true;
		}
	}
	public class HijriCalendar : Calendar
	{
		public static readonly int HijriEra = 1;

		private static readonly int[] s_hijriMonthDays = new int[13]
		{
			0, 30, 59, 89, 118, 148, 177, 207, 236, 266,
			295, 325, 355
		};

		private int _hijriAdvance = int.MinValue;

		private static readonly DateTime s_calendarMinValue = new DateTime(622, 7, 18);

		private static readonly DateTime s_calendarMaxValue = DateTime.MaxValue;

		public override DateTime MinSupportedDateTime => s_calendarMinValue;

		public override DateTime MaxSupportedDateTime => s_calendarMaxValue;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.LunarCalendar;

		internal override CalendarId ID => CalendarId.HIJRI;

		protected override int DaysInYearBeforeMinSupportedYear => 354;

		public int HijriAdjustment
		{
			get
			{
				if (_hijriAdvance == int.MinValue)
				{
					_hijriAdvance = GetHijriDateAdjustment();
				}
				return _hijriAdvance;
			}
			set
			{
				if (value < -2 || value > 2)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Bounds_Lower_Upper, -2, 2));
				}
				VerifyWritable();
				_hijriAdvance = value;
			}
		}

		public override int[] Eras => new int[1] { HijriEra };

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 1451);
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > 9666)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, 9666));
				}
				_twoDigitYearMax = value;
			}
		}

		private long GetAbsoluteDateHijri(int y, int m, int d)
		{
			return DaysUpToHijriYear(y) + s_hijriMonthDays[m - 1] + d - 1 - HijriAdjustment;
		}

		private long DaysUpToHijriYear(int HijriYear)
		{
			int num = (HijriYear - 1) / 30 * 30;
			int num2 = HijriYear - num - 1;
			long num3 = (long)num * 10631L / 30 + 227013;
			while (num2 > 0)
			{
				num3 += 354 + (IsLeapYear(num2, 0) ? 1 : 0);
				num2--;
			}
			return num3;
		}

		internal static void CheckTicksRange(long ticks)
		{
			if (ticks < s_calendarMinValue.Ticks || ticks > s_calendarMaxValue.Ticks)
			{
				throw new ArgumentOutOfRangeException("time", ticks, SR.Format(CultureInfo.InvariantCulture, SR.ArgumentOutOfRange_CalendarRange, s_calendarMinValue, s_calendarMaxValue));
			}
		}

		internal static void CheckEraRange(int era)
		{
			if (era != 0 && era != HijriEra)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
		}

		internal static void CheckYearRange(int year, int era)
		{
			CheckEraRange(era);
			if (year < 1 || year > 9666)
			{
				throw new ArgumentOutOfRangeException("year", SR.Format(SR.ArgumentOutOfRange_Range, 1, 9666));
			}
		}

		internal static void CheckYearMonthRange(int year, int month, int era)
		{
			CheckYearRange(year, era);
			if (year == 9666 && month > 4)
			{
				throw new ArgumentOutOfRangeException("month", month, SR.Format(SR.ArgumentOutOfRange_Range, 1, 4));
			}
			if (month < 1 || month > 12)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
		}

		internal virtual int GetDatePart(long ticks, int part)
		{
			CheckTicksRange(ticks);
			long num = ticks / 864000000000L + 1;
			num += HijriAdjustment;
			int num2 = (int)((num - 227013) * 30 / 10631) + 1;
			long num3 = DaysUpToHijriYear(num2);
			long num4 = GetDaysInYear(num2, 0);
			if (num < num3)
			{
				num3 -= num4;
				num2--;
			}
			else if (num == num3)
			{
				num2--;
				num3 -= GetDaysInYear(num2, 0);
			}
			else if (num > num3 + num4)
			{
				num3 += num4;
				num2++;
			}
			if (part == 0)
			{
				return num2;
			}
			int i = 1;
			num -= num3;
			if (part == 1)
			{
				return (int)num;
			}
			for (; i <= 12 && num > s_hijriMonthDays[i - 1]; i++)
			{
			}
			i--;
			if (part == 2)
			{
				return i;
			}
			int result = (int)(num - s_hijriMonthDays[i - 1]);
			if (part == 3)
			{
				return result;
			}
			throw new InvalidOperationException(SR.InvalidOperation_DateTimeParsing);
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			if (months < -120000 || months > 120000)
			{
				throw new ArgumentOutOfRangeException("months", months, SR.Format(SR.ArgumentOutOfRange_Range, -120000, 120000));
			}
			int datePart = GetDatePart(time.Ticks, 0);
			int datePart2 = GetDatePart(time.Ticks, 2);
			int num = GetDatePart(time.Ticks, 3);
			int num2 = datePart2 - 1 + months;
			if (num2 >= 0)
			{
				datePart2 = num2 % 12 + 1;
				datePart += num2 / 12;
			}
			else
			{
				datePart2 = 12 + (num2 + 1) % 12;
				datePart += (num2 - 11) / 12;
			}
			int daysInMonth = GetDaysInMonth(datePart, datePart2);
			if (num > daysInMonth)
			{
				num = daysInMonth;
			}
			long ticks = GetAbsoluteDateHijri(datePart, datePart2, num) * 864000000000L + time.Ticks % 864000000000L;
			Calendar.CheckAddResult(ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return new DateTime(ticks);
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return AddMonths(time, years * 12);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 3);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return (DayOfWeek)((int)(time.Ticks / 864000000000L + 1) % 7);
		}

		public override int GetDayOfYear(DateTime time)
		{
			return GetDatePart(time.Ticks, 1);
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			CheckYearMonthRange(year, month, era);
			if (month == 12)
			{
				if (!IsLeapYear(year, 0))
				{
					return 29;
				}
				return 30;
			}
			if (month % 2 != 1)
			{
				return 29;
			}
			return 30;
		}

		public override int GetDaysInYear(int year, int era)
		{
			CheckYearRange(year, era);
			if (!IsLeapYear(year, 0))
			{
				return 354;
			}
			return 355;
		}

		public override int GetEra(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			return HijriEra;
		}

		public override int GetMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 2);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			CheckYearRange(year, era);
			return 12;
		}

		public override int GetYear(DateTime time)
		{
			return GetDatePart(time.Ticks, 0);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			int daysInMonth = GetDaysInMonth(year, month, era);
			if (day < 1 || day > daysInMonth)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Day, daysInMonth, month));
			}
			if (IsLeapYear(year, era) && month == 12)
			{
				return day == 30;
			}
			return false;
		}

		public override int GetLeapMonth(int year, int era)
		{
			CheckYearRange(year, era);
			return 0;
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			CheckYearMonthRange(year, month, era);
			return false;
		}

		public override bool IsLeapYear(int year, int era)
		{
			CheckYearRange(year, era);
			return (year * 11 + 14) % 30 < 11;
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			int daysInMonth = GetDaysInMonth(year, month, era);
			if (day < 1 || day > daysInMonth)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Day, daysInMonth, month));
			}
			long absoluteDateHijri = GetAbsoluteDateHijri(year, month, day);
			if (absoluteDateHijri < 0)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
			}
			return new DateTime(absoluteDateHijri * 864000000000L + Calendar.TimeToTicks(hour, minute, second, millisecond));
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (year < 100)
			{
				return base.ToFourDigitYear(year);
			}
			if (year > 9666)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, 9666));
			}
			return year;
		}

		private int GetHijriDateAdjustment()
		{
			if (_hijriAdvance == int.MinValue)
			{
				_hijriAdvance = GetAdvanceHijriDate();
			}
			return _hijriAdvance;
		}

		private static int GetAdvanceHijriDate()
		{
			using RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Control Panel\\International");
			if (registryKey == null)
			{
				return 0;
			}
			object value = registryKey.GetValue("AddHijriDate");
			if (value == null)
			{
				return 0;
			}
			int result = 0;
			string text = value.ToString();
			if (string.Compare(text, 0, "AddHijriDate", 0, "AddHijriDate".Length, StringComparison.OrdinalIgnoreCase) == 0)
			{
				if (text.Length == "AddHijriDate".Length)
				{
					result = -1;
				}
				else
				{
					try
					{
						int num = int.Parse(text.AsSpan("AddHijriDate".Length), NumberStyles.Integer, CultureInfo.InvariantCulture);
						if (num >= -2 && num <= 2)
						{
							result = num;
						}
					}
					catch (ArgumentException)
					{
					}
					catch (FormatException)
					{
					}
					catch (OverflowException)
					{
					}
				}
			}
			return result;
		}
	}
	internal enum IcuLocaleDataParts
	{
		Lcid,
		AnsiCodePage,
		OemCodePage,
		MacCodePage,
		EbcdicCodePage,
		GeoId,
		DigitSubstitutionOrListSeparator,
		SpecificLocaleIndex,
		ConsoleLocaleIndex
	}
	internal static class IcuLocaleData
	{
		private static ReadOnlySpan<byte> CultureNames => "aa-djaa-eraa-etaf-naaf-zaagq-cmak-gham-etar-001ar-aear-bhar-djar-dzar-egar-erar-ilar-iqar-joar-kmar-kwar-lbar-lyar-maar-mrar-omar-psar-qaar-saar-sdar-soar-ssar-syar-tdar-tnar-yearn-clas-inasa-tzast-esaz-cyrl-azaz-latn-azba-rubas-cmbe-bybem-zmbez-tzbg-bgbin-ngbm-latn-mlbn-bdbn-inbo-cnbo-inbr-frbrx-inbs-cyrl-babs-latn-babyn-erca-adca-es-valenciaca-frca-itce-rucgg-ugchr-cher-usco-frcs-czcu-rucy-gbda-dkda-gldav-kede-atde-bede-chde-de_phonebde-itde-lide-ludje-nedsb-dedua-cmdv-mvdyo-sndz-btebu-keee-ghee-tgel-cyel-gren-001en-029en-150en-agen-aien-asen-aten-auen-bben-been-bien-bmen-bsen-bwen-bzen-caen-ccen-chen-cken-cmen-cxen-cyen-deen-dken-dmen-eren-fien-fjen-fken-fmen-gben-gden-ggen-ghen-gien-gmen-guen-gyen-hken-iden-ieen-ilen-imen-inen-ioen-jeen-jmen-keen-kien-knen-kyen-lcen-lren-lsen-mgen-mhen-moen-mpen-msen-mten-muen-mwen-myen-naen-nfen-ngen-nlen-nren-nuen-nzen-pgen-phen-pken-pnen-pren-pwen-rwen-sben-scen-sden-seen-sgen-shen-sien-slen-ssen-sxen-szen-tcen-tken-toen-tten-tven-tzen-ugen-umen-usen-vcen-vgen-vien-vuen-wsen-zaen-zmen-zweo-001es-419es-ares-boes-bres-cles-coes-cres-cues-does-eces-es_tradnles-gqes-gtes-hnes-mxes-nies-paes-pees-phes-pres-pyes-sves-uses-uyes-veet-eeeu-esewo-cmfa-irff-cmff-gnff-latn-snff-mrff-ngfi-fifil-phfo-dkfo-fofr-029fr-befr-bffr-bifr-bjfr-blfr-cafr-cdfr-cffr-cgfr-chfr-cifr-cmfr-djfr-dzfr-frfr-gafr-gffr-gnfr-gpfr-gqfr-htfr-kmfr-lufr-mafr-mcfr-mffr-mgfr-mlfr-mqfr-mrfr-mufr-ncfr-nefr-pffr-pmfr-refr-rwfr-scfr-snfr-syfr-tdfr-tgfr-tnfr-vufr-wffr-ytfur-itfy-nlga-iegd-gbgl-esgn-pygsw-chgsw-frgsw-ligu-inguz-kegv-imha-latn-ghha-latn-neha-latn-nghaw-ushe-ilhi-inhr-bahr-hrhsb-dehu-hu_technlhy-amia-001ia-fribb-ngid-idig-ngii-cnis-isit-chit-itit-smiu-cans-caiu-latn-caja-jp_radstrjgo-cmjmc-tzjv-java-idjv-latn-idka-ge_modernkab-dzkam-kekde-tzkea-cvkhq-mlki-kekk-kzkkj-cmkl-glkln-kekm-khkn-inko-kpko-krkok-inkr-ngks-arab-inks-deva-inksb-tzksf-cmksh-deku-arab-iqku-arab-irkw-gbky-kgla-001lag-tzlb-lulg-uglkt-usln-aoln-cdln-cfln-cglo-lalrc-iqlrc-irlt-ltlu-cdluo-keluy-kelv-lvmas-kemas-tzmer-kemfe-mumg-mgmgh-mzmgo-cmmi-nzmk-mkml-inmn-cyrlmn-mnmn-mong-cnmn-mong-mnmni-inmoh-camr-inms-bnms-myms-sgmt-mtmua-cmmy-mmmzn-irnaq-nanb-nonb-sjnd-zwnds-dends-nlne-inne-npnl-awnl-benl-bqnl-cwnl-nlnl-srnl-sxnmg-cmnn-nonnh-cmnonqo-gnnr-zanso-zanus-ssnyn-ugoc-from-etom-keor-inos-geos-rupa-arab-pkpa-inpap-029pl-plprg-001prs-afps-afpt-aopt-brpt-chpt-cvpt-gqpt-gwpt-lupt-mopt-mzpt-ptpt-stpt-tlqps-latn-x-shqps-plocaqps-plocmquc-latn-gtquz-boquz-ecquz-perm-chrn-biro-mdro-rorof-tzru-byru-kgru-kzru-mdru-ruru-uarw-rwrwk-tzsa-insah-rusaq-kesbp-tzsd-arab-pksd-deva-inse-fise-nose-seseh-mzses-mlsg-cfshi-latn-mashi-tfng-masi-lksk-sksl-sisma-nosma-sesmj-nosmj-sesmn-fisms-fisn-latn-zwso-djso-etso-keso-sosq-alsq-mksq-xksr-cyrl-basr-cyrl-cssr-cyrl-mesr-cyrl-rssr-cyrl-xksr-latn-basr-latn-cssr-latn-mesr-latn-rssr-latn-xkss-szss-zassy-erst-lsst-zasv-axsv-fisv-sesw-cdsw-kesw-tzsw-ugswc-cdsyr-syta-inta-lkta-myta-sgte-inteo-keteo-ugtg-cyrl-tjth-thti-erti-ettig-ertk-tmtn-bwtn-zato-totr-cytr-trts-zatt-rutwq-netzm-arab-matzm-latn-dztzm-latn-matzm-tfng-maug-cnuk-uaur-inur-pkuz-arab-afuz-cyrl-uzuz-latn-uzvai-latn-lrvai-vaii-lrve-zavi-vnvo-001vun-tzwae-chwal-etwo-snx-iv_mathanxh-zaxog-ugyav-cmyi-001yo-bjyo-ngyue-hkzgh-tfng-mazh-chszh-chtzh-cn_phonebzh-cn_strokezh-hans-hkzh-hans-mozh-hantzh-hk_radstrzh-mo_radstrzh-mo_strokezh-sg_phonebzh-sg_strokezh-tw_pronunzh-tw_radstrzu-za"u8;

		private static ReadOnlySpan<byte> LocalesNamesIndexes => new byte[1728]
		{
			0, 2, 0, 5, 0, 85, 0, 165, 0, 242,
			0, 245, 1, 69, 1, 147, 1, 150, 1, 242,
			1, 245, 2, 66, 2, 69, 2, 146, 2, 150,
			2, 245, 3, 69, 3, 149, 3, 229, 4, 53,
			4, 133, 4, 213, 5, 37, 5, 117, 5, 197,
			6, 21, 6, 101, 6, 181, 7, 5, 7, 85,
			7, 165, 7, 245, 8, 69, 8, 149, 8, 229,
			9, 53, 9, 133, 9, 213, 10, 37, 10, 117,
			10, 197, 11, 19, 11, 22, 11, 114, 11, 117,
			11, 195, 11, 198, 12, 35, 12, 38, 12, 130,
			12, 135, 12, 138, 13, 39, 13, 42, 13, 194,
			13, 197, 14, 19, 14, 22, 14, 114, 14, 117,
			14, 195, 14, 198, 15, 35, 15, 38, 15, 130,
			15, 133, 15, 211, 15, 214, 16, 50, 16, 55,
			16, 58, 16, 210, 16, 213, 17, 37, 17, 114,
			17, 117, 17, 197, 18, 18, 18, 21, 18, 99,
			18, 102, 18, 194, 18, 199, 18, 202, 19, 103,
			19, 106, 20, 3, 20, 6, 20, 98, 20, 101,
			20, 181, 20, 190, 21, 149, 21, 229, 22, 50,
			22, 53, 22, 131, 22, 134, 22, 227, 22, 232,
			22, 235, 23, 146, 23, 149, 23, 226, 23, 229,
			24, 50, 24, 53, 24, 130, 24, 133, 24, 210,
			24, 213, 25, 37, 25, 115, 25, 118, 25, 210,
			25, 213, 26, 37, 26, 117, 26, 197, 26, 204,
			27, 133, 27, 213, 28, 37, 28, 115, 28, 118,
			28, 211, 28, 214, 29, 51, 29, 54, 29, 146,
			29, 149, 29, 227, 29, 230, 30, 66, 30, 69,
			30, 147, 30, 150, 30, 242, 30, 245, 31, 69,
			31, 146, 31, 149, 31, 229, 32, 50, 32, 54,
			32, 150, 32, 246, 33, 85, 33, 165, 33, 245,
			34, 69, 34, 149, 34, 229, 35, 53, 35, 133,
			35, 213, 36, 37, 36, 117, 36, 197, 37, 21,
			37, 101, 37, 181, 38, 5, 38, 85, 38, 165,
			38, 245, 39, 69, 39, 149, 39, 229, 40, 53,
			40, 133, 40, 213, 41, 37, 41, 117, 41, 197,
			42, 21, 42, 101, 42, 181, 43, 5, 43, 85,
			43, 165, 43, 245, 44, 69, 44, 149, 44, 229,
			45, 53, 45, 133, 45, 213, 46, 37, 46, 117,
			46, 197, 47, 21, 47, 101, 47, 181, 48, 5,
			48, 85, 48, 165, 48, 245, 49, 69, 49, 149,
			49, 229, 50, 53, 50, 133, 50, 213, 51, 37,
			51, 117, 51, 197, 52, 21, 52, 101, 52, 181,
			53, 5, 53, 85, 53, 165, 53, 245, 54, 69,
			54, 149, 54, 229, 55, 53, 55, 133, 55, 213,
			56, 37, 56, 117, 56, 197, 57, 21, 57, 101,
			57, 181, 58, 5, 58, 85, 58, 165, 58, 245,
			59, 69, 59, 149, 59, 229, 60, 53, 60, 133,
			60, 213, 61, 37, 61, 117, 61, 197, 62, 21,
			62, 101, 62, 181, 63, 5, 63, 85, 63, 165,
			63, 245, 64, 69, 64, 149, 64, 229, 65, 50,
			65, 54, 65, 146, 65, 150, 65, 245, 66, 69,
			66, 149, 66, 229, 67, 53, 67, 133, 67, 213,
			68, 37, 68, 117, 68, 197, 68, 204, 69, 133,
			69, 213, 70, 37, 70, 117, 70, 197, 71, 21,
			71, 101, 71, 181, 72, 5, 72, 85, 72, 165,
			72, 245, 73, 69, 73, 149, 73, 226, 73, 229,
			74, 50, 74, 53, 74, 131, 74, 134, 74, 226,
			74, 229, 75, 50, 75, 53, 75, 133, 75, 215,
			75, 218, 76, 117, 76, 197, 77, 18, 77, 21,
			77, 99, 77, 102, 77, 194, 77, 197, 78, 21,
			78, 98, 78, 102, 78, 197, 79, 21, 79, 101,
			79, 181, 80, 5, 80, 85, 80, 165, 80, 245,
			81, 69, 81, 149, 81, 229, 82, 53, 82, 133,
			82, 213, 83, 37, 83, 117, 83, 197, 84, 21,
			84, 101, 84, 181, 85, 5, 85, 85, 85, 165,
			85, 245, 86, 69, 86, 149, 86, 229, 87, 53,
			87, 133, 87, 213, 88, 37, 88, 117, 88, 197,
			89, 21, 89, 101, 89, 181, 90, 5, 90, 85,
			90, 165, 90, 245, 91, 69, 91, 149, 91, 229,
			92, 53, 92, 133, 92, 213, 93, 35, 93, 38,
			93, 130, 93, 133, 93, 210, 93, 213, 94, 34,
			94, 37, 94, 114, 94, 117, 94, 194, 94, 197,
			95, 19, 95, 22, 95, 118, 95, 214, 96, 50,
			96, 53, 96, 131, 96, 134, 96, 226, 96, 229,
			97, 50, 97, 55, 97, 58, 97, 218, 98, 122,
			99, 19, 99, 22, 99, 114, 99, 117, 99, 194,
			99, 197, 100, 18, 100, 21, 100, 101, 100, 179,
			100, 182, 101, 18, 101, 21, 101, 28, 101, 210,
			101, 213, 102, 34, 102, 38, 102, 133, 102, 211,
			102, 214, 103, 50, 103, 53, 103, 130, 103, 133,
			103, 210, 103, 213, 104, 34, 104, 37, 104, 114,
			104, 117, 104, 197, 105, 21, 105, 98, 105, 103,
			105, 106, 106, 7, 106, 10, 106, 162, 106, 165,
			106, 172, 107, 99, 107, 102, 107, 195, 107, 198,
			108, 34, 108, 39, 108, 42, 108, 199, 108, 202,
			109, 98, 109, 101, 109, 108, 110, 35, 110, 38,
			110, 131, 110, 134, 110, 227, 110, 230, 111, 67,
			111, 70, 111, 163, 111, 166, 112, 2, 112, 5,
			112, 82, 112, 85, 112, 163, 112, 166, 113, 2,
			113, 5, 113, 83, 113, 86, 113, 178, 113, 181,
			114, 2, 114, 5, 114, 82, 114, 85, 114, 165,
			114, 243, 114, 246, 115, 82, 115, 85, 115, 162,
			115, 167, 115, 170, 116, 71, 116, 74, 116, 227,
			116, 230, 117, 67, 117, 70, 117, 163, 117, 166,
			118, 2, 118, 7, 118, 10, 118, 170, 119, 66,
			119, 69, 119, 146, 119, 149, 119, 226, 119, 230,
			120, 67, 120, 70, 120, 162, 120, 165, 120, 242,
			120, 245, 121, 67, 121, 70, 121, 162, 121, 165,
			121, 245, 122, 69, 122, 149, 122, 226, 122, 229,
			123, 51, 123, 54, 123, 150, 123, 242, 123, 245,
			124, 66, 124, 69, 124, 147, 124, 150, 124, 243,
			124, 246, 125, 82, 125, 85, 125, 163, 125, 166,
			126, 6, 126, 99, 126, 102, 126, 195, 126, 198,
			127, 34, 127, 37, 127, 115, 127, 118, 127, 211,
			127, 214, 128, 50, 128, 53, 128, 130, 128, 133,
			128, 210, 128, 213, 129, 34, 129, 39, 129, 149,
			129, 231, 129, 234, 130, 138, 131, 35, 131, 38,
			131, 131, 131, 134, 131, 226, 131, 229, 132, 50,
			132, 53, 132, 133, 132, 213, 133, 34, 133, 37,
			133, 115, 133, 118, 133, 210, 133, 213, 134, 35,
			134, 38, 134, 131, 134, 134, 134, 226, 134, 229,
			135, 53, 135, 130, 135, 133, 135, 211, 135, 214,
			136, 54, 136, 146, 136, 149, 136, 229, 137, 50,
			137, 53, 137, 133, 137, 213, 138, 37, 138, 117,
			138, 197, 139, 21, 139, 99, 139, 102, 139, 194,
			139, 197, 140, 19, 140, 22, 140, 114, 140, 147,
			140, 150, 140, 242, 140, 245, 141, 67, 141, 70,
			141, 163, 141, 166, 142, 3, 142, 6, 142, 98,
			142, 101, 142, 178, 142, 181, 143, 5, 143, 82,
			143, 85, 143, 162, 143, 165, 143, 245, 144, 66,
			144, 71, 144, 74, 144, 229, 145, 51, 145, 55,
			145, 162, 145, 165, 145, 243, 145, 247, 146, 99,
			146, 102, 146, 194, 146, 197, 147, 18, 147, 21,
			147, 101, 147, 181, 148, 5, 148, 85, 148, 165,
			148, 245, 149, 69, 149, 149, 149, 229, 150, 53,
			150, 133, 150, 221, 151, 168, 151, 169, 152, 57,
			152, 195, 152, 200, 152, 203, 153, 115, 153, 118,
			153, 214, 154, 54, 154, 146, 154, 149, 154, 226,
			154, 229, 155, 50, 155, 53, 155, 133, 155, 211,
			155, 214, 156, 50, 156, 53, 156, 133, 156, 213,
			157, 37, 157, 117, 157, 197, 158, 18, 158, 21,
			158, 99, 158, 102, 158, 194, 158, 197, 159, 19,
			159, 22, 159, 115, 159, 118, 159, 211, 159, 214,
			160, 50, 160, 55, 160, 58, 160, 215, 160, 218,
			161, 114, 161, 117, 161, 197, 162, 21, 162, 99,
			162, 102, 162, 195, 162, 198, 163, 34, 163, 37,
			163, 115, 163, 120, 163, 123, 164, 40, 164, 43,
			164, 210, 164, 213, 165, 34, 165, 37, 165, 114,
			165, 117, 165, 195, 165, 198, 166, 38, 166, 131,
			166, 134, 166, 230, 167, 67, 167, 70, 167, 163,
			167, 166, 168, 2, 168, 7, 168, 10, 168, 162,
			168, 165, 168, 245, 169, 69, 169, 149, 169, 226,
			169, 229, 170, 53, 170, 133, 170, 210, 170, 215,
			170, 218, 171, 122, 172, 26, 172, 186, 173, 90,
			173, 247, 173, 250, 174, 154, 175, 58, 175, 218,
			176, 122, 177, 18, 177, 21, 177, 101, 177, 179,
			177, 182, 178, 18, 178, 21, 178, 101, 178, 178,
			178, 181, 179, 5, 179, 85, 179, 162, 179, 165,
			179, 245, 180, 69, 180, 149, 180, 227, 180, 230,
			181, 67, 181, 70, 181, 162, 181, 165, 181, 245,
			182, 69, 182, 149, 182, 226, 182, 229, 183, 51,
			183, 54, 183, 150, 183, 242, 183, 247, 183, 250,
			184, 146, 184, 149, 184, 226, 184, 229, 185, 53,
			185, 131, 185, 134, 185, 226, 185, 229, 186, 50,
			186, 53, 186, 133, 186, 210, 186, 213, 187, 34,
			187, 37, 187, 117, 187, 194, 187, 197, 188, 18,
			188, 21, 188, 99, 188, 102, 188, 195, 188, 200,
			188, 203, 189, 120, 189, 123, 190, 43, 190, 216,
			190, 219, 191, 130, 191, 133, 191, 210, 191, 213,
			192, 34, 192, 37, 192, 117, 192, 194, 192, 199,
			192, 202, 193, 103, 193, 106, 194, 7, 194, 10,
			194, 163, 194, 168, 194, 171, 195, 88, 195, 91,
			196, 2, 196, 5, 196, 82, 196, 85, 196, 162,
			196, 166, 197, 3, 197, 6, 197, 99, 197, 102,
			197, 195, 197, 198, 198, 34, 198, 37, 198, 123,
			199, 34, 199, 37, 199, 115, 199, 118, 199, 211,
			199, 214, 200, 50, 200, 54, 200, 146, 200, 149,
			200, 229, 201, 51, 201, 54, 201, 147, 201, 152,
			201, 155, 202, 66, 202, 70, 202, 166, 203, 5,
			203, 12, 203, 204, 204, 135, 204, 138, 205, 42,
			205, 199, 206, 53, 206, 60, 206, 245, 206, 252,
			207, 188, 208, 117, 208, 124, 209, 60, 209, 245,
			209, 252, 210, 188, 211, 114, 211, 117
		};

		private static ReadOnlySpan<byte> ThreeLetterWindowsLanguageName => "ZZZZZZZZZZZZAFKZZZAFKZZZZZZZZZZZZAMHAMHARAZZZARUARHZZZARGAREZZZZZZARIARJZZZARKARBARLARMZZZAROZZZARQARAZZZZZZZZZARSZZZARTARYMPDMPDASMASMZZZZZZZZZZZZAZEAZCAZCAZEAZEBASBASZZZZZZBELBELZZZZZZZZZZZZBGRBGRZZZZZZZZZZZZZZZBNBBNBBNGBOBBOBZZZBREBREZZZZZZBSBBSCBSCBSBBSBZZZZZZCATZZZCATVALZZZZZZZZZZZZZZZZZZCRECRECRECOSCOSCSYCSYZZZZZZCYMCYMDANDANZZZZZZZZZDEUDEAZZZDESDEUDEUZZZDECDELZZZZZZDSBDSBZZZZZZDIVDIVZZZZZZZZZZZZZZZZZZZZZZZZZZZELLZZZELLENUZZZENBZZZZZZZZZZZZZZZENAZZZZZZZZZZZZZZZZZZENLENCZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZENGZZZZZZZZZZZZZZZZZZZZZENHZZZENIZZZZZZENNZZZZZZENJZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZENMZZZZZZZZZZZZZZZZZZENZZZZENPZZZZZZZZZZZZZZZZZZZZZZZZZZZENEZZZZZZZZZZZZZZZZZZZZZZZZZZZENTZZZZZZZZZZZZENUZZZZZZZZZZZZZZZENSZZZENWZZZZZZESPESJESSESBZZZESLESOESCESKESDESFESNESPZZZESGESHESMESIESAESRZZZESUESZESEESTESYESVETIETIEUQEUQZZZZZZFARFARFULZZZZZZFULFULZZZZZZFINFINFPOFPOFOSZZZFOSFRAZZZFRBZZZZZZZZZZZZFRCFRDZZZZZZFRSFRIFREZZZZZZFRAZZZZZZZZZZZZZZZFRHZZZFRLFROFRMZZZZZZFRFZZZZZZZZZZZZZZZZZZZZZFRRZZZZZZFRNZZZZZZZZZZZZZZZZZZZZZZZZZZZFYNFYNIREIREGLAGLAGLCGLCGRNGRNZZZZZZGSWZZZGUJGUJZZZZZZZZZZZZHAUHAUZZZZZZHAUHAWHAWHEBHEBHINHINHRVHRBHRVHSBHSBHUNHUNHUNHYEHYEZZZZZZZZZZZZZZZINDINDIBOIBOIIIIIIISLISLITAITSITAZZZIUKIUSIUSIUKIUKJPNJPNJPNZZZZZZZZZZZZJAVZZZZZZJAVJAVKATKATKATZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZKKZKKZZZZZZZKALKALZZZZZZKHMKHMKDIKDIKORZZZKORKNKKNKZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZKURKURKURZZZZZZZZZKYRKYRZZZZZZZZZZZZLBXLBXZZZZZZZZZZZZZZZZZZZZZZZZZZZLAOLAOZZZZZZZZZLTHLTHZZZZZZZZZZZZZZZZZZLVILVIZZZZZZZZZZZZZZZZZZZZZMLGMLGZZZZZZZZZZZZMRIMRIMKIMKIMYMMYMMONMNNMNNMNGMNGMNMZZZZZZMWKMWKMARMARMSLMSBMSLZZZMLTMLTZZZZZZMYAMYAZZZZZZZZZZZZNORNORZZZZZZZZZZZZZZZZZZNEPNEINEPNLDZZZNLBZZZZZZNLDZZZZZZZZZZZZNONNONZZZZZZNORNQONQOZZZZZZNSONSOZZZZZZZZZZZZOCIOCIORMORMZZZORIORIZZZZZZZZZPANPAPPAPPANZZZZZZPLKPLKZZZZZZPRSPRSPASPASPTBPTAPTBZZZZZZZZZZZZZZZZZZZZZPTGZZZZZZENJENUJPNARAQUCQUTQUTQUBQUBQUEQUPRMCRMCZZZZZZROMRODROMZZZZZZRUSZZZZZZZZZRUMRUSZZZKINKINZZZZZZSANSANSAHSAHZZZZZZZZZZZZSIPSIPSIPZZZZZZSMESMGSMESMFZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZSINSINSKYSKYSLVSLVSMBSMASMBSMKSMJSMKSMNSMNSMSSMSSNASNASNASOMZZZZZZZZZSOMSQISQIZZZZZZSRBSROSRNSRBSRQSROZZZSRMSRSSRLSRPSRMZZZZZZZZZZZZZZZZZZSOTZZZSOTSVEZZZSVFSVESWKZZZSWKZZZZZZZZZZZZSYRSYRTAITAITAMZZZZZZTELTELZZZZZZZZZTAJTAJTAJTHATHATIRTIRTIEZZZZZZTUKTUKTSNTSBTSNZZZZZZTRKZZZTRKTSOTSOTTTTTTZZZZZZTZAZZZZZZTZATZAZZZTZMTZMUIGUIGUKRUKRURDURIURDUZBZZZZZZUZCUZCUZBUZBZZZZZZZZZZZZZZZZZZZZZVITVITZZZZZZZZZZZZZZZZZZZZZZZZWOLWOLIVLXHOXHOZZZZZZZZZZZZZZZZZZYORZZZYORZZZZZZZHGZHGZHGCHSCHSCHTCHSCHSCHSCHSZZZZZZZHHZHHZHHZHMZHMZHMZHIZHIZHICHTCHTCHTZULZUL"u8;

		private static ReadOnlySpan<byte> NameIndexToNumericData => new byte[15552]
		{
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 73, 17, 0, 48, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 62, 17, 0, 16, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 71,
			17, 0, 32, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 73, 17, 0,
			48, 240, 0, 0, 54, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 209, 17, 0, 96, 6,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 254, 17, 0, 80, 240, 0, 4,
			54, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 209, 17, 0, 96, 6, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 0, 128, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 49, 17, 0,
			128, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 89, 17, 0, 160, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 89, 17, 0, 160, 240, 0, 0,
			94, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 73, 17, 0, 192, 143, 0, 4, 94, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 73,
			17, 0, 192, 143, 0, 0, 1, 78, 130, 208,
			39, 20, 79, 196, 0, 0, 0, 205, 16, 2,
			16, 143, 0, 16, 0, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 152, 158, 16, 0, 224, 240,
			0, 56, 1, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 224, 16, 0, 240, 143, 0, 60,
			1, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			0, 17, 16, 1, 0, 143, 0, 16, 0, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 62,
			16, 1, 16, 240, 0, 20, 1, 78, 130, 208,
			39, 20, 79, 196, 0, 0, 0, 4, 17, 1,
			33, 44, 0, 12, 1, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 67, 16, 1, 48, 143,
			0, 16, 0, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 71, 16, 1, 64, 240, 0, 16,
			0, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			0, 117, 16, 1, 80, 240, 0, 8, 1, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 121,
			16, 1, 96, 143, 0, 44, 1, 78, 130, 208,
			39, 20, 79, 196, 0, 0, 0, 126, 16, 1,
			112, 143, 0, 16, 0, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 50, 16, 1, 128, 240,
			0, 52, 1, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 136, 16, 1, 144, 143, 0, 48,
			1, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			0, 139, 16, 1, 160, 143, 0, 16, 1, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 148,
			17, 1, 176, 143, 0, 24, 1, 78, 130, 208,
			39, 20, 79, 196, 0, 0, 0, 159, 17, 1,
			193, 44, 0, 16, 0, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 162, 16, 1, 208, 240,
			0, 32, 1, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 164, 16, 1, 224, 143, 0, 16,
			0, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			0, 184, 16, 1, 240, 240, 0, 64, 1, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 197,
			16, 2, 0, 143, 0, 4, 1, 78, 130, 208,
			39, 20, 79, 196, 0, 0, 0, 205, 16, 2,
			16, 143, 0, 16, 0, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 219, 16, 2, 32, 240,
			0, 16, 0, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 216, 16, 2, 48, 240, 0, 16,
			0, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			1, 20, 16, 2, 64, 240, 0, 40, 1, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 222,
			16, 2, 80, 143, 0, 16, 0, 78, 130, 208,
			39, 20, 79, 196, 0, 0, 0, 41, 16, 2,
			96, 240, 0, 28, 1, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 234, 17, 2, 113, 44,
			0, 36, 1, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 1, 5, 16, 2, 128, 143, 0, 0,
			122, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 46, 1, 2, 160, 42, 0, 4, 122, 78,
			67, 82, 39, 16, 79, 60, 0, 0, 0, 46,
			1, 2, 160, 42, 0, 0, 77, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 1, 2,
			192, 143, 0, 4, 77, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 1, 2, 192, 143,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 239, 17, 2, 224, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 239, 17, 2, 224, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 217,
			17, 3, 0, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 217, 17, 3,
			0, 240, 0, 0, 44, 78, 99, 89, 39, 97,
			81, 169, 0, 0, 0, 5, 17, 3, 80, 53,
			0, 116, 44, 78, 51, 98, 39, 23, 81, 144,
			0, 0, 0, 5, 17, 3, 48, 51, 0, 8,
			44, 78, 51, 98, 39, 23, 81, 144, 0, 0,
			0, 5, 17, 3, 48, 51, 0, 120, 44, 78,
			99, 89, 39, 97, 81, 169, 0, 0, 0, 5,
			17, 3, 80, 53, 0, 4, 44, 78, 99, 89,
			39, 97, 81, 169, 0, 0, 0, 5, 17, 3,
			80, 53, 0, 0, 109, 78, 51, 98, 39, 23,
			81, 144, 0, 0, 0, 203, 17, 3, 112, 55,
			0, 4, 109, 78, 51, 98, 39, 23, 81, 144,
			0, 0, 0, 203, 17, 3, 112, 55, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 49, 17, 3, 144, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 3, 144, 240, 0, 0, 35, 78, 51, 98,
			39, 23, 1, 244, 0, 0, 0, 29, 17, 3,
			176, 59, 0, 4, 35, 78, 51, 98, 39, 23,
			1, 244, 0, 0, 0, 29, 17, 3, 176, 59,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 1, 7, 17, 3, 208, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			1, 7, 17, 3, 208, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 239,
			17, 3, 240, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 239, 17, 3,
			240, 240, 0, 0, 2, 78, 51, 98, 39, 23,
			82, 33, 0, 0, 0, 35, 17, 4, 16, 65,
			0, 4, 2, 78, 51, 98, 39, 23, 82, 33,
			0, 0, 0, 35, 17, 4, 16, 65, 0, 0,
			102, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 175, 17, 4, 48, 240, 0, 4, 102, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 175,
			17, 4, 48, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 157, 17, 4,
			96, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 157, 17, 4, 96, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 157, 17, 4, 96, 240, 0, 0,
			69, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 23, 1, 4, 128, 143, 0, 8, 69, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 23,
			1, 4, 128, 143, 0, 4, 69, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 1, 4,
			144, 143, 0, 0, 81, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 45, 1, 4, 176, 143,
			0, 4, 81, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 45, 1, 4, 176, 143, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 113, 17, 4, 192, 240, 0, 0, 126, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 84,
			17, 4, 224, 78, 0, 4, 126, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 84, 17, 4,
			224, 78, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 17, 5, 0, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 113, 17, 5, 0, 240, 0, 120,
			26, 78, 35, 84, 39, 98, 3, 102, 0, 0,
			0, 25, 17, 5, 80, 85, 0, 100, 26, 78,
			51, 87, 39, 98, 3, 102, 0, 0, 0, 25,
			17, 5, 48, 83, 0, 32, 26, 78, 51, 87,
			39, 98, 3, 102, 0, 0, 0, 25, 17, 5,
			48, 83, 0, 104, 26, 78, 35, 84, 39, 98,
			3, 102, 0, 0, 0, 25, 17, 5, 80, 85,
			0, 20, 26, 78, 35, 84, 39, 98, 3, 102,
			0, 0, 0, 25, 17, 5, 80, 85, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 71, 17, 5, 112, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 71,
			17, 5, 112, 240, 0, 0, 3, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 217, 17, 5,
			160, 90, 0, 16, 0, 78, 67, 82, 0, 2,
			1, 244, 0, 0, 0, 8, 17, 5, 144, 240,
			0, 4, 3, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 217, 17, 5, 160, 90, 0, 8,
			3, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 217, 17, 5, 176, 90, 0, 16, 0, 78,
			67, 82, 0, 2, 1, 244, 0, 0, 0, 84,
			17, 5, 192, 240, 0, 16, 0, 78, 67, 82,
			0, 2, 1, 244, 0, 0, 0, 118, 17, 5,
			208, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 203, 17, 5, 240, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 203, 17, 5, 240, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 240, 17, 6, 16, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 240,
			17, 6, 16, 240, 0, 0, 92, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 244, 1, 6,
			64, 240, 0, 124, 92, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 244, 1, 6, 64, 240,
			0, 4, 92, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 244, 1, 6, 64, 240, 0, 0,
			131, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 84, 17, 6, 96, 102, 0, 4, 131, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 84,
			17, 6, 96, 102, 0, 0, 5, 78, 35, 84,
			39, 45, 1, 244, 0, 0, 0, 75, 17, 6,
			128, 104, 0, 4, 5, 78, 35, 84, 39, 45,
			1, 244, 0, 0, 0, 75, 17, 6, 128, 104,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 203, 17, 6, 160, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 203, 17, 6, 160, 240, 0, 0, 82, 78,
			67, 82, 39, 16, 79, 61, 0, 0, 0, 242,
			17, 6, 192, 108, 0, 4, 82, 78, 67, 82,
			39, 16, 79, 61, 0, 0, 0, 242, 17, 6,
			192, 108, 0, 0, 6, 78, 67, 82, 39, 16,
			79, 53, 0, 0, 0, 61, 17, 6, 224, 110,
			0, 4, 6, 78, 67, 82, 39, 16, 79, 53,
			0, 0, 0, 61, 17, 6, 224, 110, 0, 16,
			0, 78, 67, 82, 0, 2, 1, 244, 0, 0,
			0, 93, 17, 6, 240, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 129,
			17, 7, 16, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 129, 17, 7,
			16, 240, 0, 0, 7, 78, 67, 82, 39, 16,
			79, 49, 0, 0, 0, 94, 17, 7, 96, 118,
			0, 12, 7, 78, 67, 82, 39, 16, 79, 49,
			0, 0, 0, 14, 17, 7, 48, 115, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 49, 0, 0,
			0, 21, 17, 7, 64, 240, 0, 8, 7, 78,
			67, 82, 39, 16, 79, 49, 0, 0, 0, 223,
			17, 7, 80, 117, 0, 4, 7, 78, 67, 82,
			39, 16, 79, 49, 0, 0, 0, 94, 17, 7,
			96, 118, 1, 4, 7, 78, 67, 82, 39, 16,
			79, 49, 0, 0, 0, 94, 17, 7, 96, 118,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 118, 17, 7, 128, 240, 0, 20,
			7, 78, 67, 82, 39, 16, 79, 49, 0, 0,
			0, 145, 17, 7, 144, 121, 0, 16, 7, 78,
			67, 82, 39, 16, 79, 49, 0, 0, 0, 147,
			17, 7, 160, 122, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 173, 17, 7,
			192, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 173, 17, 7, 192, 240,
			0, 124, 46, 78, 67, 82, 39, 16, 3, 102,
			0, 0, 0, 94, 17, 7, 224, 126, 0, 8,
			46, 78, 67, 82, 39, 16, 3, 102, 0, 0,
			0, 94, 17, 7, 224, 126, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 8, 0, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 49, 17, 8,
			0, 240, 0, 0, 101, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 165, 33, 8, 32, 143,
			0, 4, 101, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 165, 33, 8, 32, 143, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 210, 17, 8, 64, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 210,
			17, 8, 64, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 34, 18, 8,
			96, 240, 0, 12, 81, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 34, 18, 8, 96, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 129, 17, 8, 128, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 129, 17, 8, 128, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 89,
			17, 8, 160, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 89, 17, 8,
			160, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 232, 17, 8, 176, 240,
			0, 0, 8, 78, 82, 225, 39, 22, 79, 49,
			0, 0, 0, 98, 17, 8, 224, 142, 0, 16,
			0, 78, 82, 225, 39, 22, 79, 49, 0, 0,
			0, 59, 17, 8, 208, 240, 0, 4, 8, 78,
			82, 225, 39, 22, 79, 49, 0, 0, 0, 98,
			17, 8, 224, 142, 0, 0, 9, 78, 65, 181,
			39, 16, 0, 37, 0, 0, 0, 244, 1, 15,
			0, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 152, 158, 1, 9, 0, 240,
			0, 36, 9, 78, 67, 82, 39, 16, 1, 244,
			0, 153, 50, 72, 1, 9, 16, 145, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			41, 45, 1, 9, 32, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 2,
			1, 9, 48, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 1, 44, 1, 9,
			64, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 10, 1, 9, 80, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 14, 1, 9, 96, 240, 0, 12,
			9, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 12, 1, 9, 112, 151, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 18,
			1, 9, 128, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 21, 1, 9,
			144, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 38, 1, 9, 160, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 20, 1, 9, 176, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 22, 1, 9, 192, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 19,
			1, 9, 208, 240, 0, 40, 9, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 24, 1, 9,
			224, 158, 0, 16, 9, 78, 67, 82, 39, 16,
			0, 37, 0, 0, 0, 39, 1, 9, 240, 159,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 1, 55, 1, 10, 0, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 223, 1, 10, 16, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 1, 56,
			1, 10, 32, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 49, 1, 10,
			48, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 1, 53, 1, 10, 64, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 59, 1, 10, 80, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 94, 1, 10, 96, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 61,
			1, 10, 112, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 63, 1, 10,
			128, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 71, 1, 10, 144, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 77, 1, 10, 160, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 78, 1, 10, 176, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 1, 59,
			1, 10, 192, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 80, 1, 10,
			208, 240, 0, 8, 9, 78, 67, 82, 39, 16,
			79, 61, 0, 0, 0, 242, 1, 10, 224, 174,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 91, 1, 10, 240, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			1, 68, 1, 11, 0, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 89,
			1, 11, 16, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 90, 1, 11,
			32, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 86, 1, 11, 48, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 1, 66, 1, 11, 64, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 101, 1, 11, 80, 240, 0, 60, 9, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 104,
			1, 11, 96, 240, 0, 56, 9, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 111, 17, 11,
			112, 240, 0, 24, 9, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 68, 1, 11, 128, 184,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 117, 1, 11, 144, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			59, 22, 1, 11, 160, 240, 0, 64, 9, 78,
			65, 181, 39, 16, 0, 37, 0, 0, 0, 113,
			1, 11, 176, 187, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 114, 1, 11,
			192, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 1, 72, 1, 11, 208, 240,
			0, 32, 9, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 124, 1, 11, 224, 190, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 129, 1, 11, 240, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 133,
			1, 12, 0, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 207, 1, 12,
			16, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 1, 51, 1, 12, 32, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 218, 1, 12, 48, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 142, 1, 12, 64, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 146,
			1, 12, 80, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 149, 1, 12,
			96, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 199, 1, 12, 112, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 151, 1, 12, 128, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			1, 81, 1, 12, 144, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 1, 76,
			1, 12, 160, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 163, 1, 12,
			176, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 160, 1, 12, 192, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 156, 1, 12, 208, 240, 0, 68,
			9, 78, 65, 181, 39, 16, 0, 37, 0, 0,
			0, 167, 1, 12, 224, 206, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 254,
			1, 12, 240, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 1, 80, 1, 13,
			0, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 175, 1, 13, 16, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 176, 1, 13, 32, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 180, 1, 13, 48, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 1, 79,
			1, 13, 64, 240, 0, 20, 9, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 183, 1, 13,
			80, 213, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 194, 1, 13, 96, 240,
			0, 52, 9, 78, 65, 181, 39, 16, 1, 244,
			0, 0, 0, 201, 1, 13, 112, 215, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 190, 1, 13, 128, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 1, 83,
			1, 13, 144, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 202, 1, 13,
			160, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 195, 1, 13, 176, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 204, 1, 13, 192, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 30, 1, 13, 208, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 208,
			1, 13, 224, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 219, 1, 13,
			240, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 221, 1, 14, 0, 240,
			0, 72, 9, 78, 65, 181, 39, 16, 0, 37,
			0, 0, 0, 215, 1, 14, 16, 225, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			1, 87, 1, 14, 32, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 212,
			1, 14, 48, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 213, 1, 14,
			64, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 1, 20, 1, 14, 80, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 120, 247, 1, 14, 96, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			1, 4, 1, 14, 112, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 1, 93,
			1, 14, 128, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 1, 91, 1, 14,
			144, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 231, 1, 14, 160, 240,
			0, 44, 9, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 225, 1, 14, 176, 235, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 236, 1, 14, 192, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 239,
			1, 14, 208, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 240, 1, 14,
			224, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 9, 165, 93, 64, 1, 14, 240, 240,
			0, 4, 9, 78, 65, 181, 39, 16, 0, 37,
			0, 0, 0, 244, 1, 15, 0, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 248, 1, 15, 16, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 1, 95,
			1, 15, 32, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 252, 1, 15,
			48, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 174, 1, 15, 64, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 1, 3, 1, 15, 80, 240, 0, 28,
			9, 78, 65, 181, 39, 16, 1, 244, 0, 0,
			0, 209, 1, 15, 96, 246, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 1, 7,
			1, 15, 112, 240, 0, 48, 9, 78, 65, 181,
			39, 16, 1, 244, 0, 0, 1, 8, 1, 15,
			128, 248, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 152, 158, 17, 15, 160, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 152, 158, 17, 15, 160, 240, 0, 0,
			10, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 217, 17, 16, 97, 6, 0, 88, 10, 78,
			67, 82, 39, 16, 79, 60, 9, 165, 93, 65,
			17, 15, 192, 240, 0, 44, 10, 78, 67, 82,
			39, 16, 79, 60, 0, 0, 0, 11, 17, 15,
			208, 253, 0, 64, 10, 78, 67, 82, 39, 16,
			79, 60, 0, 0, 0, 26, 17, 15, 224, 254,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 32, 17, 15, 240, 240, 0, 52,
			10, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 46, 17, 16, 1, 0, 0, 36, 10, 78,
			67, 82, 39, 16, 79, 60, 0, 0, 0, 51,
			17, 16, 17, 1, 0, 20, 10, 78, 67, 82,
			39, 16, 79, 60, 0, 0, 0, 54, 17, 16,
			33, 2, 0, 92, 10, 78, 67, 82, 39, 16,
			79, 60, 0, 0, 0, 56, 17, 16, 48, 240,
			0, 28, 10, 78, 67, 82, 39, 16, 79, 60,
			0, 0, 0, 65, 17, 16, 65, 4, 0, 48,
			10, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 66, 17, 16, 81, 5, 0, 12, 10, 78,
			67, 82, 39, 16, 79, 60, 0, 0, 0, 217,
			17, 16, 97, 6, 0, 4, 10, 78, 67, 82,
			39, 16, 79, 60, 0, 0, 0, 217, 17, 16,
			113, 7, 0, 16, 0, 78, 67, 82, 39, 16,
			79, 60, 0, 0, 0, 69, 17, 16, 128, 240,
			0, 16, 10, 78, 67, 82, 39, 16, 79, 60,
			0, 0, 0, 99, 17, 16, 145, 9, 0, 72,
			10, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 106, 17, 16, 161, 10, 0, 8, 10, 78,
			67, 82, 39, 16, 79, 60, 0, 0, 0, 166,
			1, 16, 177, 11, 0, 76, 10, 78, 67, 82,
			39, 16, 79, 60, 0, 0, 0, 182, 17, 16,
			193, 12, 0, 24, 10, 78, 67, 82, 39, 16,
			79, 60, 0, 0, 0, 192, 17, 16, 209, 13,
			0, 40, 10, 78, 67, 82, 39, 16, 79, 60,
			0, 0, 0, 187, 17, 16, 225, 14, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 201, 17, 16, 240, 240, 0, 80, 10, 78,
			67, 82, 39, 16, 79, 60, 0, 0, 0, 202,
			17, 17, 1, 16, 0, 60, 10, 78, 67, 82,
			39, 16, 79, 60, 0, 0, 0, 185, 17, 17,
			17, 17, 0, 68, 10, 78, 67, 82, 39, 16,
			79, 60, 0, 0, 0, 72, 17, 17, 33, 18,
			0, 84, 10, 78, 67, 82, 39, 16, 79, 60,
			0, 0, 0, 244, 1, 17, 49, 19, 0, 56,
			10, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 246, 17, 17, 65, 20, 0, 32, 10, 78,
			67, 82, 39, 16, 79, 60, 0, 0, 0, 249,
			17, 17, 81, 21, 0, 0, 37, 78, 147, 7,
			39, 45, 1, 244, 0, 0, 0, 70, 17, 17,
			113, 23, 0, 4, 37, 78, 147, 7, 39, 45,
			1, 244, 0, 0, 0, 70, 17, 17, 113, 23,
			0, 0, 45, 78, 67, 82, 0, 2, 1, 244,
			0, 0, 0, 217, 17, 17, 144, 240, 0, 4,
			45, 78, 67, 82, 0, 2, 1, 244, 0, 0,
			0, 217, 17, 17, 144, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 17, 176, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 49, 17, 17,
			176, 240, 0, 0, 41, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 116, 48, 17, 208, 143,
			0, 4, 41, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 116, 48, 17, 208, 143, 0, 0,
			103, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 210, 17, 18, 33, 34, 0, 16, 0, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 49,
			17, 17, 240, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 100, 17, 18,
			0, 240, 0, 124, 103, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 210, 17, 18, 33, 34,
			0, 8, 103, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 210, 17, 18, 33, 34, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 162, 17, 18, 48, 240, 0, 4, 103, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 175,
			17, 18, 64, 240, 0, 0, 11, 78, 67, 82,
			39, 16, 79, 54, 0, 0, 0, 77, 17, 18,
			97, 38, 0, 4, 11, 78, 67, 82, 39, 16,
			79, 54, 0, 0, 0, 77, 17, 18, 97, 38,
			0, 0, 100, 78, 65, 181, 39, 16, 1, 244,
			0, 0, 0, 201, 17, 18, 129, 40, 0, 4,
			100, 78, 65, 181, 39, 16, 1, 244, 0, 0,
			0, 201, 17, 18, 129, 40, 0, 0, 56, 78,
			67, 82, 39, 95, 79, 53, 0, 0, 0, 81,
			17, 18, 177, 43, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 61, 17, 18,
			160, 240, 0, 4, 56, 78, 67, 82, 39, 95,
			79, 53, 0, 0, 0, 81, 17, 18, 177, 43,
			0, 0, 12, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 84, 17, 19, 193, 60, 0, 28,
			12, 78, 67, 82, 39, 16, 79, 73, 0, 153,
			50, 72, 17, 18, 209, 60, 0, 8, 12, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 21,
			17, 18, 225, 46, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 245, 17, 18,
			240, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 38, 17, 19, 0, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 28, 17, 19, 16, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 73, 9, 165,
			92, 79, 17, 19, 32, 240, 0, 12, 12, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 39,
			17, 19, 49, 51, 0, 36, 12, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 44, 17, 19,
			64, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 55, 17, 19, 80, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 43, 17, 19, 96, 240, 0, 16,
			12, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 223, 17, 19, 113, 55, 0, 48, 12, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 119,
			17, 19, 128, 240, 0, 44, 12, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 49, 17, 19,
			144, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 62, 17, 19, 160, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 4, 17, 19, 176, 240, 0, 4,
			12, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 84, 17, 19, 193, 60, 0, 16, 0, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 87,
			17, 19, 208, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 1, 61, 17, 19,
			224, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 100, 17, 19, 240, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 1, 65, 17, 20, 0, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 69, 17, 20, 16, 240, 0, 60, 12, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 103,
			17, 20, 32, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 50, 17, 20,
			48, 240, 0, 20, 12, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 147, 17, 20, 65, 68,
			0, 56, 12, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 159, 17, 20, 80, 240, 0, 24,
			12, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 158, 17, 20, 97, 70, 0, 16, 0, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 123, 218,
			17, 20, 112, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 149, 17, 20,
			128, 240, 0, 52, 12, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 157, 17, 20, 144, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 1, 74, 17, 20, 160, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 162, 17, 20, 176, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 160,
			17, 20, 192, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 1, 78, 17, 20,
			208, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 173, 17, 20, 224, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 1, 62, 17, 20, 240, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 206, 17, 21, 0, 240, 0, 32, 12, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 198,
			17, 21, 16, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 204, 17, 21,
			32, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 208, 17, 21, 48, 240,
			0, 40, 12, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 210, 17, 21, 64, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 222, 17, 21, 80, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 41,
			17, 21, 96, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 232, 17, 21,
			112, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 234, 17, 21, 128, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 174, 17, 21, 144, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			1, 96, 17, 21, 160, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 1, 75,
			17, 21, 176, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 118, 17, 21,
			208, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 118, 17, 21, 208, 240,
			0, 0, 98, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 176, 17, 21, 241, 95, 0, 4,
			98, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 176, 17, 21, 241, 95, 0, 0, 60, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 68,
			17, 22, 17, 97, 0, 8, 60, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 68, 17, 22,
			17, 97, 0, 0, 145, 78, 67, 82, 39, 16,
			79, 61, 0, 0, 0, 242, 17, 22, 49, 99,
			0, 4, 145, 78, 67, 82, 39, 16, 79, 61,
			0, 0, 0, 242, 17, 22, 49, 99, 0, 0,
			86, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 217, 17, 22, 81, 101, 0, 4, 86, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 217,
			17, 22, 81, 101, 0, 0, 116, 78, 67, 82,
			39, 16, 79, 60, 0, 0, 0, 185, 1, 22,
			113, 103, 0, 4, 116, 78, 67, 82, 39, 16,
			79, 60, 0, 0, 0, 185, 1, 22, 113, 103,
			0, 0, 132, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 223, 17, 22, 144, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 223, 17, 22, 144, 240, 0, 4, 132, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 84,
			17, 22, 161, 106, 0, 16, 0, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 145, 17, 22,
			176, 240, 0, 0, 71, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 1, 22, 208, 143,
			0, 4, 71, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 113, 1, 22, 208, 143, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 129, 17, 22, 240, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 129,
			17, 22, 240, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 59, 22, 17, 23,
			16, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 59, 22, 17, 23, 16, 240,
			0, 0, 104, 78, 65, 181, 39, 16, 0, 37,
			0, 0, 0, 175, 17, 23, 97, 118, 0, 124,
			104, 78, 65, 181, 39, 16, 0, 37, 0, 0,
			0, 175, 17, 23, 97, 118, 0, 16, 0, 78,
			65, 181, 39, 16, 1, 244, 0, 0, 0, 89,
			17, 23, 64, 240, 0, 16, 0, 78, 65, 181,
			39, 16, 1, 244, 0, 0, 0, 173, 17, 23,
			80, 240, 0, 4, 104, 78, 65, 181, 39, 16,
			0, 37, 0, 0, 0, 175, 17, 23, 97, 118,
			0, 0, 117, 78, 65, 181, 39, 16, 0, 37,
			0, 0, 0, 244, 17, 23, 129, 120, 0, 4,
			117, 78, 65, 181, 39, 16, 0, 37, 0, 0,
			0, 244, 17, 23, 129, 120, 0, 0, 13, 78,
			115, 94, 39, 21, 1, 244, 0, 0, 0, 117,
			1, 23, 160, 143, 0, 4, 13, 78, 115, 94,
			39, 21, 1, 244, 0, 0, 0, 117, 1, 23,
			160, 143, 0, 0, 57, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 1, 23, 192, 143,
			0, 4, 57, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 113, 1, 23, 192, 143, 0, 0,
			26, 78, 35, 84, 39, 98, 1, 244, 0, 0,
			0, 108, 17, 23, 241, 127, 0, 16, 26, 78,
			35, 84, 39, 98, 3, 102, 0, 0, 0, 25,
			17, 23, 225, 126, 0, 4, 26, 78, 35, 84,
			39, 98, 1, 244, 0, 0, 0, 108, 17, 23,
			241, 127, 0, 0, 46, 78, 67, 82, 39, 16,
			3, 102, 0, 0, 0, 94, 17, 24, 17, 129,
			0, 4, 46, 78, 67, 82, 39, 16, 3, 102,
			0, 0, 0, 94, 17, 24, 17, 129, 0, 0,
			14, 78, 35, 84, 39, 45, 1, 244, 0, 0,
			0, 109, 17, 24, 49, 131, 0, 4, 14, 78,
			35, 84, 39, 45, 1, 244, 0, 0, 0, 109,
			17, 24, 49, 131, 1, 4, 14, 78, 35, 84,
			39, 45, 1, 244, 0, 0, 0, 109, 17, 24,
			49, 131, 0, 0, 43, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 7, 1, 24, 97, 134,
			0, 4, 43, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 7, 1, 24, 97, 134, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 84, 17, 24, 144, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 152, 158,
			17, 24, 128, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 84, 17, 24,
			144, 240, 0, 0, 105, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 175, 17, 24, 176, 240,
			0, 4, 105, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 175, 17, 24, 176, 240, 0, 0,
			33, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 111, 17, 24, 209, 141, 0, 4, 33, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 111,
			17, 24, 209, 141, 0, 0, 112, 78, 65, 181,
			39, 16, 0, 37, 0, 0, 0, 175, 17, 24,
			241, 143, 0, 4, 112, 78, 65, 181, 39, 16,
			0, 37, 0, 0, 0, 175, 17, 24, 241, 143,
			0, 0, 120, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 45, 17, 25, 16, 143, 0, 4,
			120, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 45, 17, 25, 16, 143, 0, 0, 15, 78,
			67, 82, 39, 95, 81, 135, 0, 0, 0, 110,
			17, 25, 49, 147, 0, 4, 15, 78, 67, 82,
			39, 95, 81, 135, 0, 0, 0, 110, 17, 25,
			49, 147, 0, 0, 16, 78, 67, 82, 39, 16,
			79, 56, 0, 0, 0, 118, 17, 25, 97, 150,
			0, 8, 16, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 223, 17, 25, 81, 149, 0, 4,
			16, 78, 67, 82, 39, 16, 79, 56, 0, 0,
			0, 118, 17, 25, 97, 150, 0, 16, 0, 78,
			67, 82, 39, 16, 79, 56, 0, 0, 0, 214,
			17, 25, 112, 240, 0, 0, 93, 78, 65, 181,
			39, 16, 0, 37, 0, 0, 0, 39, 1, 25,
			193, 156, 0, 120, 93, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 39, 1, 25, 160, 143,
			0, 4, 93, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 39, 1, 25, 160, 143, 0, 124,
			93, 78, 65, 181, 39, 16, 0, 37, 0, 0,
			0, 39, 1, 25, 193, 156, 0, 8, 93, 78,
			65, 181, 39, 16, 0, 37, 0, 0, 0, 39,
			1, 25, 193, 156, 0, 0, 17, 58, 67, 164,
			39, 17, 79, 66, 0, 0, 0, 122, 1, 25,
			225, 158, 0, 4, 17, 58, 67, 164, 39, 17,
			79, 66, 0, 0, 0, 122, 1, 25, 225, 158,
			4, 4, 17, 58, 67, 164, 39, 17, 79, 66,
			0, 0, 0, 122, 1, 25, 225, 158, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 49, 17, 26, 16, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 26, 16, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 239, 17, 26,
			48, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 239, 17, 26, 48, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 111, 17, 26, 129, 168, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 111, 17, 26, 97, 168, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 111,
			17, 26, 97, 168, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 111, 17, 26,
			129, 168, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 111, 17, 26, 129, 168,
			0, 0, 55, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 88, 17, 26, 161, 170, 0, 4,
			55, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 88, 17, 26, 161, 170, 1, 4, 55, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 88,
			17, 26, 161, 170, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 4, 17, 26,
			208, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 4, 17, 26, 208, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 129, 17, 26, 240, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 129, 17, 26, 240, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 239,
			17, 27, 16, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 239, 17, 27,
			16, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 57, 17, 27, 48, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 57, 17, 27, 48, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 157, 17, 27, 80, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 157,
			17, 27, 80, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 129, 17, 27,
			112, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 129, 17, 27, 112, 240,
			0, 0, 63, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 137, 17, 27, 145, 185, 0, 4,
			63, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 137, 17, 27, 145, 185, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 27, 176, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 49, 17, 27,
			176, 240, 0, 0, 111, 78, 67, 82, 39, 16,
			79, 53, 0, 0, 0, 93, 17, 27, 209, 189,
			0, 4, 111, 78, 67, 82, 39, 16, 79, 53,
			0, 0, 0, 93, 17, 27, 209, 189, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 129, 17, 27, 240, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 129,
			17, 27, 240, 240, 0, 0, 83, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 40, 2, 28,
			16, 143, 0, 4, 83, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 40, 2, 28, 16, 143,
			0, 0, 75, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 113, 1, 28, 48, 143, 0, 4,
			75, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 113, 1, 28, 48, 143, 0, 0, 18, 59,
			83, 181, 39, 19, 81, 97, 0, 0, 0, 134,
			1, 28, 97, 198, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 131, 17, 28,
			80, 240, 0, 4, 18, 59, 83, 181, 39, 19,
			81, 97, 0, 0, 0, 134, 1, 28, 97, 198,
			0, 0, 87, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 113, 1, 28, 128, 143, 0, 4,
			87, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 113, 1, 28, 128, 143, 0, 0, 113, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 175,
			17, 28, 160, 240, 0, 4, 113, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 175, 17, 28,
			160, 240, 0, 0, 96, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 18, 28, 208, 240,
			0, 4, 96, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 113, 18, 28, 208, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 113, 18, 28, 208, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 113,
			1, 28, 240, 187, 0, 8, 96, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 1, 28,
			240, 187, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 239, 17, 29, 16, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 239, 17, 29, 16, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 49, 17, 29, 48, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 29, 48, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 94, 17, 29,
			80, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 94, 17, 29, 80, 240,
			0, 0, 146, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 121, 48, 29, 128, 143, 0, 124,
			146, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			0, 121, 48, 29, 128, 143, 0, 4, 146, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 121,
			48, 29, 128, 143, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 116, 16, 29,
			144, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 242, 17, 29, 176, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 242, 17, 29, 176, 240, 0, 0,
			64, 78, 51, 98, 39, 23, 81, 144, 0, 0,
			0, 130, 17, 29, 209, 221, 0, 4, 64, 78,
			51, 98, 39, 23, 81, 144, 0, 0, 0, 130,
			17, 29, 209, 221, 0, 0, 118, 78, 65, 181,
			39, 16, 0, 37, 0, 0, 152, 158, 1, 29,
			240, 143, 0, 4, 118, 78, 65, 181, 39, 16,
			0, 37, 0, 0, 152, 158, 1, 29, 240, 143,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 239, 17, 30, 16, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 239, 17, 30, 16, 240, 0, 0, 110, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 147,
			17, 30, 49, 227, 0, 4, 110, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 147, 17, 30,
			49, 227, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 240, 17, 30, 80, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 240, 17, 30, 80, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 244, 17, 30, 112, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 244,
			17, 30, 112, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 44, 17, 30,
			160, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 9, 17, 30, 144, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 44, 17, 30, 160, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 55, 17, 30, 176, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 43,
			17, 30, 192, 240, 0, 0, 84, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 138, 17, 30,
			224, 143, 0, 4, 84, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 138, 17, 30, 224, 143,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 116, 18, 31, 16, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 121, 18, 31, 0, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 116,
			18, 31, 16, 240, 0, 0, 39, 78, 147, 7,
			39, 45, 1, 244, 0, 0, 0, 141, 17, 31,
			49, 243, 0, 4, 39, 78, 147, 7, 39, 45,
			1, 244, 0, 0, 0, 141, 17, 31, 49, 243,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 44, 17, 31, 80, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 44, 17, 31, 80, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 129,
			17, 31, 112, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 129, 17, 31,
			112, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 129, 17, 31, 144, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 129, 17, 31, 144, 240, 0, 0,
			38, 78, 147, 7, 39, 45, 1, 244, 0, 0,
			0, 140, 17, 31, 177, 251, 0, 4, 38, 78,
			147, 7, 39, 45, 1, 244, 0, 0, 0, 140,
			17, 31, 177, 251, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 129, 17, 31,
			208, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 129, 17, 31, 208, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 239, 17, 31, 224, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 129, 17, 32, 0, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 129,
			17, 32, 0, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 160, 17, 32,
			32, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 160, 17, 32, 32, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 149, 17, 32, 64, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 149, 17, 32, 64, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 168,
			17, 32, 96, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 168, 17, 32,
			96, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 49, 17, 32, 128, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 49, 17, 32, 128, 240, 0, 0,
			129, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 183, 1, 32, 162, 10, 0, 4, 129, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 183,
			1, 32, 162, 10, 0, 0, 47, 78, 51, 98,
			39, 23, 1, 244, 0, 0, 76, 162, 17, 32,
			194, 12, 0, 4, 47, 78, 51, 98, 39, 23,
			1, 244, 0, 0, 76, 162, 17, 32, 194, 12,
			0, 0, 76, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 113, 17, 32, 224, 143, 0, 4,
			76, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 113, 17, 32, 224, 143, 0, 0, 80, 78,
			51, 98, 39, 23, 81, 144, 0, 0, 0, 154,
			17, 33, 18, 17, 0, 120, 80, 78, 51, 98,
			39, 23, 81, 144, 0, 0, 0, 154, 17, 33,
			18, 17, 0, 4, 80, 78, 51, 98, 39, 23,
			81, 144, 0, 0, 0, 154, 17, 33, 18, 17,
			0, 124, 80, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 45, 1, 33, 50, 19, 0, 8,
			80, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 45, 1, 33, 50, 19, 0, 12, 80, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 154,
			1, 33, 66, 20, 0, 0, 88, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 1, 33,
			96, 187, 0, 4, 88, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 1, 33, 96, 187,
			0, 0, 124, 78, 67, 82, 39, 16, 0, 37,
			0, 0, 0, 39, 1, 33, 128, 240, 0, 4,
			124, 78, 67, 82, 39, 16, 0, 37, 0, 0,
			0, 39, 1, 33, 128, 240, 0, 0, 78, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 113,
			1, 33, 160, 143, 0, 4, 78, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 1, 33,
			160, 143, 0, 0, 62, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 167, 17, 33, 210, 29,
			0, 8, 62, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 37, 17, 33, 194, 28, 0, 4,
			62, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 167, 17, 33, 210, 29, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 215,
			17, 33, 224, 240, 0, 0, 58, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 163, 17, 34,
			2, 32, 0, 4, 58, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 163, 17, 34, 2, 32,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 49, 17, 34, 32, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 49, 17, 34, 32, 240, 0, 0, 85, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 27,
			18, 34, 64, 240, 0, 4, 85, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 27, 18, 34,
			64, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 116, 18, 34, 96, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 116, 18, 34, 96, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 254, 17, 34, 128, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 254,
			17, 34, 128, 240, 0, 124, 20, 78, 67, 82,
			39, 16, 79, 53, 0, 0, 0, 177, 17, 34,
			162, 42, 0, 4, 20, 78, 67, 82, 39, 16,
			79, 53, 0, 0, 0, 177, 17, 34, 162, 42,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 53,
			0, 0, 0, 220, 17, 34, 176, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			1, 8, 17, 34, 208, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 1, 8,
			17, 34, 208, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 94, 17, 34,
			240, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 94, 17, 34, 240, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 176, 17, 35, 0, 240, 0, 0,
			97, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 178, 1, 35, 48, 143, 0, 8, 97, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 113,
			18, 35, 32, 240, 0, 4, 97, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 178, 1, 35,
			48, 143, 0, 0, 19, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 176, 17, 35, 146, 57,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 1, 46, 17, 35, 80, 240, 0, 8,
			19, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 21, 17, 35, 98, 54, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 9, 165, 93, 66,
			17, 35, 112, 240, 0, 16, 0, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 1, 17, 17, 35,
			128, 240, 0, 4, 19, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 176, 17, 35, 146, 57,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 181, 17, 35, 160, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			120, 247, 17, 35, 176, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 35, 208, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 49, 17, 35,
			208, 240, 0, 120, 20, 78, 67, 82, 39, 16,
			79, 53, 0, 0, 0, 177, 17, 35, 242, 63,
			0, 8, 20, 78, 67, 82, 39, 16, 79, 53,
			0, 0, 0, 177, 17, 35, 242, 63, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 49, 17, 36, 16, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 49,
			17, 36, 16, 240, 0, 0, 20, 78, 67, 82,
			39, 16, 79, 53, 0, 0, 0, 177, 17, 34,
			162, 42, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 100, 34, 36, 64, 143,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 100, 34, 36, 64, 143, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 209, 17, 36, 96, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 209,
			17, 36, 96, 240, 0, 0, 108, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 209, 17, 36,
			130, 72, 0, 4, 108, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 209, 17, 36, 130, 72,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 1, 20, 17, 36, 160, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			1, 20, 17, 36, 160, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 240,
			17, 36, 192, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 240, 17, 36,
			192, 240, 0, 0, 130, 78, 67, 82, 39, 16,
			79, 73, 0, 0, 0, 84, 17, 36, 226, 78,
			0, 4, 130, 78, 67, 82, 39, 16, 79, 73,
			0, 0, 0, 84, 17, 36, 226, 78, 0, 0,
			114, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 73, 17, 37, 0, 240, 0, 4, 114, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 73,
			17, 37, 0, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 129, 17, 37,
			16, 240, 0, 0, 72, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 1, 37, 48, 143,
			0, 4, 72, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 113, 1, 37, 48, 143, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 88, 17, 37, 80, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 88,
			17, 37, 80, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 203, 17, 37,
			96, 240, 0, 0, 70, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 1, 37, 160, 143,
			0, 124, 70, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 190, 18, 37, 144, 143, 0, 8,
			70, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			0, 190, 18, 37, 144, 143, 0, 4, 70, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 113,
			1, 37, 160, 143, 0, 0, 121, 78, 67, 82,
			39, 16, 1, 244, 0, 153, 50, 72, 1, 37,
			192, 145, 0, 4, 121, 78, 67, 82, 39, 16,
			1, 244, 0, 153, 50, 72, 1, 37, 192, 145,
			0, 0, 21, 78, 35, 84, 39, 45, 81, 144,
			0, 0, 0, 191, 17, 37, 226, 94, 0, 4,
			21, 78, 35, 84, 39, 45, 81, 144, 0, 0,
			0, 191, 17, 37, 226, 94, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 152, 158,
			17, 38, 0, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 152, 158, 17, 38,
			0, 240, 0, 0, 140, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 3, 18, 38, 32, 143,
			0, 4, 140, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 3, 18, 38, 32, 143, 0, 0,
			99, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 3, 18, 38, 64, 143, 0, 4, 99, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 3,
			18, 38, 64, 143, 0, 0, 22, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 32, 17, 38,
			114, 103, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 9, 17, 38, 96, 240,
			0, 4, 22, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 32, 17, 38, 114, 103, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 223, 17, 38, 128, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 57,
			17, 38, 144, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 69, 17, 38,
			160, 240, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 196, 17, 38, 176, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 147, 17, 38, 192, 240, 0, 16,
			0, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 151, 17, 38, 208, 240, 0, 16, 0, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 168,
			17, 38, 224, 240, 0, 8, 22, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 193, 17, 38,
			242, 111, 0, 16, 0, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 233, 17, 39, 0, 240,
			0, 16, 0, 78, 67, 82, 39, 16, 1, 244,
			0, 111, 96, 231, 17, 39, 16, 240, 0, 9,
			1, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 124, 1, 39, 32, 190, 0, 5, 1, 78,
			35, 84, 39, 45, 81, 144, 0, 0, 0, 244,
			65, 39, 50, 115, 0, 5, 254, 58, 67, 164,
			39, 17, 79, 66, 0, 0, 0, 122, 1, 39,
			66, 116, 0, 9, 255, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 205, 16, 39, 80, 143,
			0, 0, 134, 78, 67, 82, 39, 16, 79, 60,
			0, 0, 0, 99, 1, 39, 130, 120, 0, 124,
			134, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 99, 1, 39, 130, 120, 0, 4, 134, 78,
			67, 82, 39, 16, 79, 60, 0, 0, 0, 99,
			1, 39, 130, 120, 0, 0, 107, 78, 67, 82,
			39, 16, 79, 60, 0, 0, 0, 26, 1, 39,
			162, 122, 0, 4, 107, 78, 67, 82, 39, 16,
			79, 60, 0, 0, 0, 26, 1, 39, 162, 122,
			0, 8, 107, 78, 67, 82, 39, 16, 79, 60,
			0, 0, 0, 66, 1, 39, 178, 123, 0, 12,
			107, 78, 67, 82, 39, 16, 79, 60, 0, 0,
			0, 187, 1, 39, 194, 124, 0, 0, 23, 78,
			67, 82, 39, 16, 79, 49, 0, 0, 0, 223,
			17, 39, 226, 126, 0, 4, 23, 78, 67, 82,
			39, 16, 79, 49, 0, 0, 0, 223, 17, 39,
			226, 126, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 38, 17, 40, 0, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 38, 17, 40, 0, 240, 0, 0,
			24, 78, 35, 84, 39, 45, 81, 144, 0, 0,
			0, 200, 17, 40, 50, 131, 0, 8, 24, 78,
			35, 84, 0, 2, 1, 244, 0, 0, 0, 152,
			17, 40, 32, 240, 0, 4, 24, 78, 35, 84,
			39, 45, 81, 144, 0, 0, 0, 200, 17, 40,
			50, 131, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 239, 17, 40, 80, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 239, 17, 40, 80, 240, 0, 0,
			25, 78, 51, 98, 39, 23, 81, 144, 0, 0,
			0, 203, 17, 40, 178, 139, 0, 16, 0, 78,
			51, 98, 0, 2, 1, 244, 0, 0, 0, 29,
			17, 40, 112, 240, 0, 16, 0, 78, 51, 98,
			0, 2, 1, 244, 0, 0, 0, 130, 17, 40,
			128, 240, 0, 16, 0, 78, 51, 98, 0, 2,
			1, 244, 0, 0, 0, 137, 17, 40, 144, 240,
			0, 8, 25, 78, 51, 98, 0, 2, 1, 244,
			0, 0, 0, 152, 17, 40, 160, 240, 0, 4,
			25, 78, 51, 98, 39, 23, 81, 144, 0, 0,
			0, 203, 17, 40, 178, 139, 0, 16, 0, 78,
			51, 98, 0, 2, 1, 244, 0, 0, 0, 241,
			17, 40, 192, 240, 0, 0, 135, 78, 65, 181,
			39, 16, 0, 37, 0, 0, 0, 204, 17, 40,
			226, 142, 0, 4, 135, 78, 65, 181, 39, 16,
			0, 37, 0, 0, 0, 204, 17, 40, 226, 142,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 239, 17, 41, 0, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 239, 17, 41, 0, 240, 0, 0, 79, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 113,
			1, 41, 32, 143, 0, 4, 79, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 1, 41,
			32, 143, 0, 0, 133, 78, 51, 98, 39, 23,
			81, 144, 0, 0, 0, 203, 17, 41, 66, 148,
			0, 4, 133, 78, 51, 98, 39, 23, 81, 144,
			0, 0, 0, 203, 17, 41, 66, 148, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 129, 17, 41, 96, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 129,
			17, 41, 96, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 239, 17, 41,
			128, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 239, 17, 41, 128, 240,
			0, 0, 89, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 190, 18, 41, 176, 143, 0, 124,
			89, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			0, 190, 18, 41, 176, 143, 0, 8, 89, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 190,
			18, 41, 176, 143, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 1, 41,
			208, 187, 0, 4, 89, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 113, 1, 41, 208, 187,
			0, 0, 59, 78, 67, 82, 39, 16, 79, 53,
			0, 0, 0, 177, 17, 42, 2, 160, 0, 12,
			59, 78, 67, 82, 39, 16, 79, 54, 0, 0,
			0, 77, 17, 41, 242, 159, 0, 4, 59, 78,
			67, 82, 39, 16, 79, 53, 0, 0, 0, 177,
			17, 42, 2, 160, 0, 8, 59, 78, 67, 82,
			39, 16, 79, 54, 0, 0, 0, 221, 17, 42,
			18, 161, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 168, 17, 42, 48, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 168, 17, 42, 48, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 157, 17, 42, 80, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 157,
			17, 42, 80, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 55, 17, 42,
			112, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 55, 17, 42, 112, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 159, 17, 42, 192, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 159, 17, 42, 160, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 159,
			17, 42, 160, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 159, 17, 42,
			192, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 159, 17, 42, 192, 240,
			0, 0, 91, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 42, 17, 42, 224, 143, 0, 4,
			91, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 42, 17, 42, 224, 143, 0, 0, 27, 78,
			35, 84, 39, 45, 81, 144, 0, 0, 0, 143,
			17, 43, 2, 176, 0, 4, 27, 78, 35, 84,
			39, 45, 81, 144, 0, 0, 0, 143, 17, 43,
			2, 176, 0, 0, 36, 78, 35, 84, 39, 45,
			81, 144, 0, 0, 0, 212, 17, 43, 34, 178,
			0, 4, 36, 78, 35, 84, 39, 45, 81, 144,
			0, 0, 0, 212, 17, 43, 34, 178, 0, 120,
			59, 78, 67, 82, 39, 16, 79, 54, 0, 0,
			0, 221, 17, 43, 82, 181, 0, 24, 59, 78,
			67, 82, 39, 16, 79, 53, 0, 0, 0, 177,
			17, 43, 66, 180, 0, 28, 59, 78, 67, 82,
			39, 16, 79, 54, 0, 0, 0, 221, 17, 43,
			82, 181, 0, 124, 59, 78, 67, 82, 39, 16,
			79, 54, 0, 0, 0, 221, 17, 43, 130, 184,
			0, 16, 59, 78, 67, 82, 39, 16, 79, 53,
			0, 0, 0, 177, 17, 43, 114, 183, 0, 20,
			59, 78, 67, 82, 39, 16, 79, 54, 0, 0,
			0, 221, 17, 43, 130, 184, 0, 112, 59, 78,
			67, 82, 39, 16, 79, 54, 0, 0, 0, 77,
			17, 43, 162, 186, 0, 36, 59, 78, 67, 82,
			39, 16, 79, 54, 0, 0, 0, 77, 17, 43,
			162, 186, 0, 116, 59, 78, 67, 82, 39, 16,
			79, 54, 0, 0, 0, 77, 17, 43, 194, 188,
			0, 32, 59, 78, 67, 82, 39, 16, 79, 54,
			0, 0, 0, 77, 17, 43, 194, 188, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			1, 8, 17, 43, 240, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 1, 8,
			17, 43, 240, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 1, 8, 17, 43,
			240, 240, 0, 0, 119, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 216, 17, 44, 64, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 62, 17, 44, 16, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 73, 17, 44, 32, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 129,
			17, 44, 48, 240, 0, 4, 119, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 216, 17, 44,
			64, 240, 0, 0, 28, 78, 35, 84, 39, 45,
			81, 144, 0, 0, 0, 6, 17, 44, 98, 198,
			0, 4, 28, 78, 35, 84, 39, 45, 81, 144,
			0, 0, 0, 6, 17, 44, 98, 198, 0, 16,
			0, 78, 35, 84, 39, 45, 81, 144, 0, 0,
			76, 162, 17, 44, 112, 240, 0, 16, 0, 78,
			35, 84, 39, 45, 81, 144, 0, 151, 73, 65,
			17, 44, 128, 240, 0, 124, 26, 78, 35, 84,
			39, 45, 1, 244, 0, 0, 1, 15, 17, 45,
			66, 212, 0, 108, 26, 78, 51, 87, 39, 23,
			82, 33, 0, 0, 1, 15, 17, 44, 226, 206,
			0, 28, 26, 78, 51, 87, 39, 23, 82, 33,
			0, 0, 0, 25, 17, 44, 178, 203, 0, 12,
			26, 78, 51, 87, 39, 23, 82, 33, 0, 0,
			1, 13, 17, 44, 194, 204, 0, 48, 26, 78,
			51, 87, 39, 23, 82, 33, 0, 0, 1, 14,
			17, 44, 210, 205, 0, 40, 26, 78, 51, 87,
			39, 23, 82, 33, 0, 0, 1, 15, 17, 44,
			226, 206, 0, 16, 0, 78, 51, 87, 39, 23,
			82, 33, 0, 151, 73, 65, 17, 44, 240, 240,
			0, 112, 26, 78, 35, 84, 39, 45, 1, 244,
			0, 0, 1, 15, 17, 45, 66, 212, 0, 24,
			26, 78, 35, 84, 39, 98, 3, 102, 0, 0,
			0, 25, 17, 45, 18, 209, 0, 8, 26, 78,
			35, 84, 39, 45, 1, 244, 0, 0, 1, 13,
			17, 45, 34, 210, 0, 44, 26, 78, 35, 84,
			39, 45, 1, 244, 0, 0, 1, 14, 17, 45,
			50, 211, 0, 36, 26, 78, 35, 84, 39, 45,
			1, 244, 0, 0, 1, 15, 17, 45, 66, 212,
			0, 16, 0, 78, 35, 84, 39, 45, 1, 244,
			0, 151, 73, 65, 17, 45, 80, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 209, 17, 45, 128, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 1, 4,
			17, 45, 112, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 209, 17, 45,
			128, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 71, 17, 45, 160, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 71, 17, 45, 160, 240, 0, 0,
			48, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 209, 17, 45, 208, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 146,
			17, 45, 192, 240, 0, 4, 48, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 209, 17, 45,
			208, 240, 0, 0, 29, 78, 67, 82, 39, 16,
			79, 54, 0, 0, 0, 221, 17, 46, 18, 225,
			0, 16, 0, 78, 67, 82, 39, 16, 79, 54,
			0, 153, 6, 245, 17, 45, 240, 240, 0, 8,
			29, 78, 67, 82, 39, 16, 79, 54, 0, 0,
			0, 77, 17, 46, 2, 224, 0, 4, 29, 78,
			67, 82, 39, 16, 79, 54, 0, 0, 0, 221,
			17, 46, 18, 225, 0, 0, 65, 78, 65, 181,
			39, 16, 1, 244, 0, 0, 0, 129, 17, 46,
			66, 228, 0, 16, 0, 78, 65, 181, 39, 16,
			1, 244, 0, 0, 0, 44, 17, 46, 50, 228,
			0, 4, 65, 78, 65, 181, 39, 16, 1, 244,
			0, 0, 0, 129, 17, 46, 66, 228, 0, 16,
			0, 78, 65, 181, 39, 16, 1, 244, 0, 0,
			0, 239, 17, 46, 80, 240, 0, 16, 0, 78,
			65, 181, 39, 16, 1, 244, 0, 0, 0, 240,
			17, 46, 96, 240, 0, 16, 0, 0, 0, 1,
			0, 0, 1, 244, 0, 0, 0, 44, 1, 46,
			128, 240, 0, 16, 0, 0, 0, 1, 0, 0,
			1, 244, 0, 0, 0, 44, 17, 46, 128, 240,
			0, 0, 90, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 222, 1, 46, 160, 143, 0, 4,
			90, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 222, 1, 46, 160, 143, 0, 0, 73, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 113,
			1, 46, 192, 143, 0, 4, 73, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 1, 46,
			192, 143, 0, 8, 73, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 42, 17, 46, 208, 143,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 167, 17, 46, 224, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 215, 17, 46, 240, 240, 0, 0, 74, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 113,
			17, 47, 16, 143, 0, 4, 74, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 113, 17, 47,
			16, 143, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 240, 17, 47, 64, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 129, 17, 47, 48, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 240, 17, 47, 64, 240, 0, 0, 40, 78,
			51, 98, 39, 23, 81, 144, 0, 0, 0, 228,
			17, 47, 114, 247, 0, 124, 40, 78, 51, 98,
			39, 23, 81, 144, 0, 0, 0, 228, 17, 47,
			114, 247, 0, 4, 40, 78, 51, 98, 39, 23,
			81, 144, 0, 0, 0, 228, 17, 47, 114, 247,
			0, 0, 30, 54, 163, 106, 39, 37, 81, 102,
			0, 0, 0, 227, 1, 47, 144, 143, 0, 4,
			30, 54, 163, 106, 39, 37, 81, 102, 0, 0,
			0, 227, 1, 47, 144, 143, 0, 0, 115, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 71,
			17, 47, 176, 143, 0, 8, 115, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 71, 17, 47,
			176, 143, 0, 4, 115, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 73, 17, 47, 192, 143,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 71, 17, 47, 224, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 71, 17, 47, 224, 240, 0, 0, 66, 78,
			35, 84, 39, 45, 81, 144, 0, 0, 0, 238,
			17, 48, 3, 0, 0, 4, 66, 78, 35, 84,
			39, 45, 81, 144, 0, 0, 0, 238, 17, 48,
			3, 0, 0, 0, 50, 78, 67, 82, 39, 16,
			1, 244, 0, 0, 0, 209, 17, 48, 51, 3,
			0, 8, 50, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 19, 17, 48, 35, 2, 0, 4,
			50, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 209, 17, 48, 51, 3, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 231,
			17, 48, 80, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 231, 17, 48,
			80, 240, 0, 0, 31, 78, 99, 89, 39, 97,
			81, 169, 0, 0, 0, 235, 17, 48, 131, 8,
			0, 16, 0, 78, 99, 89, 39, 97, 81, 169,
			0, 0, 0, 59, 17, 48, 112, 240, 0, 4,
			31, 78, 99, 89, 39, 97, 81, 169, 0, 0,
			0, 235, 17, 48, 131, 8, 0, 0, 49, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 209,
			17, 48, 160, 240, 0, 4, 49, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 209, 17, 48,
			160, 240, 0, 0, 68, 78, 51, 98, 39, 23,
			81, 144, 0, 0, 0, 203, 17, 48, 195, 12,
			0, 4, 68, 78, 51, 98, 39, 23, 81, 144,
			0, 0, 0, 203, 17, 48, 195, 12, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 173, 17, 48, 224, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 173,
			17, 48, 224, 240, 0, 0, 95, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 4, 17, 49,
			51, 19, 0, 16, 0, 78, 130, 208, 39, 20,
			79, 196, 0, 0, 0, 159, 17, 49, 16, 240,
			0, 4, 95, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 159, 17, 49, 16, 240, 0, 124,
			95, 78, 67, 82, 39, 16, 79, 73, 0, 0,
			0, 4, 17, 49, 51, 19, 0, 8, 95, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 4,
			17, 49, 51, 19, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 159, 17, 49,
			64, 240, 0, 120, 95, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 159, 17, 49, 97, 60,
			0, 16, 95, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 159, 17, 49, 97, 60, 0, 0,
			128, 78, 130, 208, 39, 20, 79, 196, 0, 0,
			0, 45, 1, 49, 128, 143, 0, 4, 128, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 45,
			1, 49, 128, 143, 0, 0, 34, 78, 51, 98,
			39, 33, 1, 244, 0, 0, 0, 241, 17, 49,
			163, 26, 0, 4, 34, 78, 51, 98, 39, 33,
			1, 244, 0, 0, 0, 241, 17, 49, 163, 26,
			0, 0, 32, 78, 130, 208, 39, 20, 79, 196,
			0, 0, 0, 190, 17, 49, 208, 143, 0, 8,
			32, 78, 130, 208, 0, 2, 1, 244, 0, 0,
			0, 113, 18, 49, 192, 240, 0, 4, 32, 78,
			130, 208, 39, 20, 79, 196, 0, 0, 0, 190,
			17, 49, 208, 143, 0, 0, 67, 78, 99, 89,
			39, 45, 1, 244, 0, 0, 0, 247, 17, 50,
			67, 36, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 3, 18, 50, 0, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 3, 18, 50, 0, 240, 0, 120,
			67, 78, 51, 98, 39, 23, 81, 144, 0, 0,
			0, 247, 17, 50, 35, 34, 0, 8, 67, 78,
			51, 98, 39, 23, 81, 144, 0, 0, 0, 247,
			17, 50, 35, 34, 0, 124, 67, 78, 99, 89,
			39, 45, 1, 244, 0, 0, 0, 247, 17, 50,
			67, 36, 0, 4, 67, 78, 99, 89, 39, 45,
			1, 244, 0, 0, 0, 247, 17, 50, 67, 36,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 142, 17, 50, 144, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 142, 17, 50, 112, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 142,
			17, 50, 112, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 142, 17, 50,
			144, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 142, 17, 50, 144, 240,
			0, 0, 51, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 209, 17, 50, 176, 240, 0, 4,
			51, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 209, 17, 50, 176, 240, 0, 0, 42, 78,
			164, 234, 39, 16, 1, 244, 0, 0, 0, 251,
			1, 50, 208, 143, 0, 4, 42, 78, 164, 234,
			39, 16, 1, 244, 0, 0, 0, 251, 1, 50,
			208, 143, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 152, 158, 17, 50, 240, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 152, 158, 17, 50, 240, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 239, 17, 51, 16, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 239,
			17, 51, 16, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 223, 17, 51,
			48, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 223, 17, 51, 48, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 73, 17, 51, 80, 240, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 73, 17, 51, 80, 240, 0, 0, 136, 78,
			67, 82, 39, 16, 79, 73, 0, 0, 0, 210,
			17, 51, 115, 55, 0, 4, 136, 78, 67, 82,
			39, 16, 79, 73, 0, 0, 0, 210, 17, 51,
			115, 55, 1, 0, 127, 78, 65, 181, 39, 16,
			0, 37, 0, 0, 0, 244, 1, 255, 255, 255,
			0, 0, 52, 78, 67, 82, 39, 16, 1, 244,
			0, 0, 0, 209, 17, 51, 163, 58, 0, 4,
			52, 78, 67, 82, 39, 16, 1, 244, 0, 0,
			0, 209, 17, 51, 163, 58, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 240,
			17, 51, 192, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 240, 17, 51,
			192, 240, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 49, 17, 51, 224, 240,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 49, 17, 51, 224, 240, 0, 0,
			61, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			152, 158, 17, 52, 0, 240, 0, 4, 61, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 152, 158,
			17, 52, 0, 240, 0, 0, 106, 78, 65, 181,
			39, 16, 0, 37, 0, 0, 0, 175, 17, 52,
			51, 67, 0, 16, 0, 78, 65, 181, 39, 16,
			1, 244, 0, 0, 0, 28, 17, 52, 32, 240,
			0, 4, 106, 78, 65, 181, 39, 16, 0, 37,
			0, 0, 0, 175, 17, 52, 51, 67, 0, 16,
			0, 0, 0, 1, 0, 2, 1, 244, 0, 0,
			0, 104, 1, 52, 80, 240, 0, 16, 0, 0,
			0, 1, 0, 2, 1, 244, 0, 0, 0, 104,
			1, 52, 80, 240, 0, 16, 0, 0, 0, 1,
			0, 2, 1, 244, 0, 0, 0, 159, 17, 52,
			129, 60, 0, 16, 0, 0, 0, 1, 0, 2,
			1, 244, 0, 0, 0, 159, 17, 52, 129, 60,
			0, 16, 0, 0, 0, 1, 0, 2, 1, 244,
			0, 0, 0, 159, 17, 52, 129, 60, 0, 120,
			4, 58, 131, 168, 39, 24, 1, 244, 0, 0,
			0, 45, 1, 52, 195, 76, 0, 0, 4, 58,
			131, 168, 0, 0, 1, 244, 0, 0, 0, 45,
			1, 52, 195, 76, 0, 124, 4, 59, 99, 182,
			0, 0, 1, 244, 0, 0, 0, 104, 1, 53,
			51, 83, 0, 8, 4, 58, 131, 168, 39, 24,
			1, 244, 0, 0, 0, 45, 1, 52, 195, 76,
			5, 8, 4, 58, 131, 168, 39, 24, 1, 244,
			0, 0, 0, 45, 1, 52, 195, 76, 2, 8,
			4, 58, 131, 168, 39, 24, 1, 244, 0, 0,
			0, 45, 1, 52, 195, 76, 0, 0, 4, 58,
			131, 168, 39, 24, 1, 244, 0, 0, 0, 45,
			1, 52, 195, 76, 0, 16, 0, 58, 131, 168,
			39, 24, 1, 244, 0, 0, 0, 104, 17, 53,
			0, 240, 0, 16, 0, 58, 131, 168, 39, 24,
			1, 244, 0, 0, 0, 151, 17, 53, 16, 240,
			0, 124, 4, 59, 99, 182, 39, 18, 1, 244,
			0, 0, 0, 104, 1, 53, 51, 83, 0, 12,
			4, 59, 99, 182, 39, 18, 1, 244, 0, 0,
			0, 104, 1, 53, 51, 83, 4, 12, 4, 59,
			99, 182, 39, 18, 1, 244, 0, 0, 0, 104,
			1, 53, 51, 83, 0, 20, 4, 59, 99, 182,
			39, 18, 1, 244, 0, 0, 0, 151, 1, 53,
			83, 85, 4, 20, 4, 59, 99, 182, 39, 18,
			1, 244, 0, 0, 0, 151, 1, 53, 83, 85,
			2, 20, 4, 59, 99, 182, 39, 18, 1, 244,
			0, 0, 0, 151, 1, 53, 83, 85, 0, 16,
			4, 58, 131, 168, 39, 24, 1, 244, 0, 0,
			0, 215, 1, 53, 131, 88, 5, 16, 4, 58,
			131, 168, 39, 24, 1, 244, 0, 0, 0, 215,
			1, 53, 131, 88, 2, 16, 4, 58, 131, 168,
			39, 24, 1, 244, 0, 0, 0, 215, 1, 53,
			131, 88, 0, 4, 4, 59, 99, 182, 39, 18,
			1, 244, 0, 0, 0, 237, 1, 53, 179, 91,
			3, 4, 4, 59, 99, 182, 39, 18, 1, 244,
			0, 0, 0, 237, 1, 53, 179, 91, 4, 4,
			4, 59, 99, 182, 39, 18, 1, 244, 0, 0,
			0, 237, 1, 53, 179, 91, 0, 0, 53, 78,
			67, 82, 39, 16, 1, 244, 0, 0, 0, 209,
			17, 53, 243, 95, 0, 4, 53, 78, 67, 82,
			39, 16, 1, 244, 0, 0, 0, 209, 17, 53,
			243, 95
		};

		internal static int GetLocaleDataNumericPart(string cultureName, IcuLocaleDataParts part)
		{
			int num = SearchCultureName(cultureName);
			if (num < 0)
			{
				return -1;
			}
			ReadOnlySpan<byte> readOnlySpan = NameIndexToNumericData.Slice(num * 18, 18);
			return part switch
			{
				IcuLocaleDataParts.Lcid => readOnlySpan[2] | (readOnlySpan[1] << 8) | (readOnlySpan[0] << 16), 
				IcuLocaleDataParts.AnsiCodePage => ((readOnlySpan[4] & 0xF0) >> 4) | ((readOnlySpan[3] & 0xFF) << 4), 
				IcuLocaleDataParts.OemCodePage => readOnlySpan[5] | ((readOnlySpan[4] & 0xF) << 8), 
				IcuLocaleDataParts.MacCodePage => readOnlySpan[7] | (readOnlySpan[6] << 8), 
				IcuLocaleDataParts.EbcdicCodePage => readOnlySpan[9] | (readOnlySpan[8] << 8), 
				IcuLocaleDataParts.GeoId => readOnlySpan[13] | (readOnlySpan[12] << 8) | (readOnlySpan[11] << 16) | (readOnlySpan[10] << 24), 
				IcuLocaleDataParts.DigitSubstitutionOrListSeparator => ResolveDigitListSeparator(readOnlySpan[14]), 
				IcuLocaleDataParts.SpecificLocaleIndex => ResolveIndex(((readOnlySpan[16] & 0xF0) >> 4) | ((readOnlySpan[15] & 0xFF) << 4)), 
				IcuLocaleDataParts.ConsoleLocaleIndex => ResolveIndex(readOnlySpan[17] | ((readOnlySpan[16] & 0xF) << 8)), 
				_ => -1, 
			};
			static int ResolveDigitListSeparator(int value)
			{
				return ((value & 0xF0) << 12) | (value & 0xF);
			}
			static int ResolveIndex(int value)
			{
				if (value != 4095)
				{
					return value;
				}
				return -1;
			}
		}

		internal static string GetThreeLetterWindowsLanguageName(string cultureName)
		{
			int num = SearchCultureName(cultureName);
			if (num < 0)
			{
				return null;
			}
			return GetString(ThreeLetterWindowsLanguageName.Slice(num * 3, 3));
		}

		private static string GetLocaleDataMappedCulture(string cultureName, IcuLocaleDataParts part)
		{
			int localeDataNumericPart = GetLocaleDataNumericPart(cultureName, part);
			if (localeDataNumericPart < 0)
			{
				return "";
			}
			return GetString(GetCultureName(localeDataNumericPart));
		}

		internal static string GetSpecificCultureName(string cultureName)
		{
			return GetLocaleDataMappedCulture(cultureName, IcuLocaleDataParts.SpecificLocaleIndex);
		}

		internal static string GetConsoleUICulture(string cultureName)
		{
			return GetLocaleDataMappedCulture(cultureName, IcuLocaleDataParts.ConsoleLocaleIndex);
		}

		private static int SearchCultureName(string name)
		{
			if (name.Length > 14)
			{
				return -1;
			}
			Span<byte> span = stackalloc byte[name.Length];
			for (int i = 0; i < name.Length; i++)
			{
				char c = name[i];
				span[i] = (((uint)(c - 65) <= 25u) ? ((byte)(c | 0x20u)) : ((byte)c));
			}
			ReadOnlySpan<byte> other = span;
			int num = 0;
			int num2 = 863;
			while (num <= num2)
			{
				int num3 = num + (num2 - num >> 1);
				int num4 = GetCultureName(num3).SequenceCompareTo(other);
				if (num4 == 0)
				{
					return num3;
				}
				if (num4 < 0)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return ~num;
		}

		private static ReadOnlySpan<byte> GetCultureName(int localeNameIndice)
		{
			ReadOnlySpan<byte> localesNamesIndexes = LocalesNamesIndexes;
			int num = localeNameIndice * 2;
			int num2 = localesNamesIndexes[num];
			int num3 = localesNamesIndexes[num + 1];
			int start = (num2 << 4) | (num3 >> 4);
			int length = num3 & 0xF;
			return CultureNames.Slice(start, length);
		}

		private static string GetString(ReadOnlySpan<byte> buffer)
		{
			string text = string.FastAllocateString(buffer.Length);
			Span<char> span = new Span<char>(ref text.GetRawStringData(), buffer.Length);
			for (int i = 0; i < buffer.Length; i++)
			{
				span[i] = (char)buffer[i];
			}
			return text;
		}
	}
	public sealed class IdnMapping
	{
		private bool _allowUnassigned;

		private bool _useStd3AsciiRules;

		private static readonly char[] s_dotSeparators = new char[4] { '.', '。', '．', '｡' };

		public bool AllowUnassigned
		{
			get
			{
				return _allowUnassigned;
			}
			set
			{
				_allowUnassigned = value;
			}
		}

		public bool UseStd3AsciiRules
		{
			get
			{
				return _useStd3AsciiRules;
			}
			set
			{
				_useStd3AsciiRules = value;
			}
		}

		private uint IcuFlags => (AllowUnassigned ? 1u : 0u) | (UseStd3AsciiRules ? 2u : 0u);

		private uint NlsFlags => (AllowUnassigned ? 1u : 0u) | (UseStd3AsciiRules ? 2u : 0u);

		public string GetAscii(string unicode)
		{
			return GetAscii(unicode, 0);
		}

		public string GetAscii(string unicode, int index)
		{
			if (unicode == null)
			{
				throw new ArgumentNullException("unicode");
			}
			return GetAscii(unicode, index, unicode.Length - index);
		}

		public unsafe string GetAscii(string unicode, int index, int count)
		{
			if (unicode == null)
			{
				throw new ArgumentNullException("unicode");
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (index > unicode.Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (index > unicode.Length - count)
			{
				throw new ArgumentOutOfRangeException("unicode", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				throw new ArgumentException(SR.Argument_IdnBadLabelSize, "unicode");
			}
			if (unicode[index + count - 1] == '\0')
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequence, index + count - 1), "unicode");
			}
			if (GlobalizationMode.Invariant)
			{
				return GetAsciiInvariant(unicode, index, count);
			}
			fixed (char* ptr = unicode)
			{
				if (!GlobalizationMode.UseNls)
				{
					return IcuGetAsciiCore(unicode, ptr + index, count);
				}
				return NlsGetAsciiCore(unicode, ptr + index, count);
			}
		}

		public string GetUnicode(string ascii)
		{
			return GetUnicode(ascii, 0);
		}

		public string GetUnicode(string ascii, int index)
		{
			if (ascii == null)
			{
				throw new ArgumentNullException("ascii");
			}
			return GetUnicode(ascii, index, ascii.Length - index);
		}

		public unsafe string GetUnicode(string ascii, int index, int count)
		{
			if (ascii == null)
			{
				throw new ArgumentNullException("ascii");
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (index > ascii.Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (index > ascii.Length - count)
			{
				throw new ArgumentOutOfRangeException("ascii", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count > 0 && ascii[index + count - 1] == '\0')
			{
				throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
			}
			if (GlobalizationMode.Invariant)
			{
				return GetUnicodeInvariant(ascii, index, count);
			}
			fixed (char* ptr = ascii)
			{
				if (!GlobalizationMode.UseNls)
				{
					return IcuGetUnicodeCore(ascii, ptr + index, count);
				}
				return NlsGetUnicodeCore(ascii, ptr + index, count);
			}
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is IdnMapping idnMapping && _allowUnassigned == idnMapping._allowUnassigned)
			{
				return _useStd3AsciiRules == idnMapping._useStd3AsciiRules;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (_allowUnassigned ? 100 : 200) + (_useStd3AsciiRules ? 1000 : 2000);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static string GetStringForOutput(string originalString, char* input, int inputLength, char* output, int outputLength)
		{
			if (originalString.Length == inputLength && inputLength == outputLength && Ordinal.EqualsIgnoreCase(ref *input, ref *output, inputLength))
			{
				return originalString;
			}
			return new string(output, 0, outputLength);
		}

		private string GetAsciiInvariant(string unicode, int index, int count)
		{
			if (index > 0 || count < unicode.Length)
			{
				unicode = unicode.Substring(index, count);
			}
			if (ValidateStd3AndAscii(unicode, UseStd3AsciiRules, bCheckAscii: true))
			{
				return unicode;
			}
			if (unicode[^1] <= '\u001f')
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequence, unicode.Length - 1), "unicode");
			}
			if (UseStd3AsciiRules)
			{
				ValidateStd3AndAscii(unicode, bUseStd3: true, bCheckAscii: false);
			}
			return PunycodeEncode(unicode);
		}

		private static bool ValidateStd3AndAscii(string unicode, bool bUseStd3, bool bCheckAscii)
		{
			if (unicode.Length == 0)
			{
				throw new ArgumentException(SR.Argument_IdnBadLabelSize, "unicode");
			}
			int num = -1;
			for (int i = 0; i < unicode.Length; i++)
			{
				if (unicode[i] <= '\u001f')
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequence, i), "unicode");
				}
				if (bCheckAscii && unicode[i] >= '\u007f')
				{
					return false;
				}
				if (IsDot(unicode[i]))
				{
					if (i == num + 1)
					{
						throw new ArgumentException(SR.Argument_IdnBadLabelSize, "unicode");
					}
					if (i - num > 64)
					{
						throw new ArgumentException(SR.Argument_IdnBadLabelSize, "unicode");
					}
					if (bUseStd3 && i > 0)
					{
						ValidateStd3(unicode[i - 1], bNextToDot: true);
					}
					num = i;
				}
				else if (bUseStd3)
				{
					ValidateStd3(unicode[i], i == num + 1);
				}
			}
			if (num == -1 && unicode.Length > 63)
			{
				throw new ArgumentException(SR.Argument_IdnBadLabelSize, "unicode");
			}
			if (unicode.Length > 255 - ((!IsDot(unicode[^1])) ? 1 : 0))
			{
				throw new ArgumentException(SR.Format(SR.Argument_IdnBadNameSize, 255 - ((!IsDot(unicode[^1])) ? 1 : 0)), "unicode");
			}
			if (bUseStd3 && !IsDot(unicode[^1]))
			{
				ValidateStd3(unicode[^1], bNextToDot: true);
			}
			return true;
		}

		private static string PunycodeEncode(string unicode)
		{
			if (unicode.Length == 0)
			{
				throw new ArgumentException(SR.Argument_IdnBadLabelSize, "unicode");
			}
			StringBuilder stringBuilder = new StringBuilder(unicode.Length);
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			while (num < unicode.Length)
			{
				num = unicode.IndexOfAny(s_dotSeparators, num2);
				if (num < 0)
				{
					num = unicode.Length;
				}
				if (num == num2)
				{
					if (num == unicode.Length)
					{
						break;
					}
					throw new ArgumentException(SR.Argument_IdnBadLabelSize, "unicode");
				}
				stringBuilder.Append("xn--");
				bool flag = false;
				StrongBidiCategory bidiCategory = CharUnicodeInfo.GetBidiCategory(unicode, num2);
				if (bidiCategory == StrongBidiCategory.StrongRightToLeft)
				{
					flag = true;
					int num4 = num - 1;
					if (char.IsLowSurrogate(unicode, num4))
					{
						num4--;
					}
					bidiCategory = CharUnicodeInfo.GetBidiCategory(unicode, num4);
					if (bidiCategory != StrongBidiCategory.StrongRightToLeft)
					{
						throw new ArgumentException(SR.Argument_IdnBadBidi, "unicode");
					}
				}
				int num5 = 0;
				for (int i = num2; i < num; i++)
				{
					StrongBidiCategory bidiCategory2 = CharUnicodeInfo.GetBidiCategory(unicode, i);
					if (flag && bidiCategory2 == StrongBidiCategory.StrongLeftToRight)
					{
						throw new ArgumentException(SR.Argument_IdnBadBidi, "unicode");
					}
					if (!flag && bidiCategory2 == StrongBidiCategory.StrongRightToLeft)
					{
						throw new ArgumentException(SR.Argument_IdnBadBidi, "unicode");
					}
					if (Basic(unicode[i]))
					{
						stringBuilder.Append(EncodeBasic(unicode[i]));
						num5++;
					}
					else if (char.IsSurrogatePair(unicode, i))
					{
						i++;
					}
				}
				int num6 = num5;
				if (num6 == num - num2)
				{
					stringBuilder.Remove(num3, "xn--".Length);
				}
				else
				{
					if (unicode.Length - num2 >= "xn--".Length && unicode.Substring(num2, "xn--".Length).Equals("xn--", StringComparison.OrdinalIgnoreCase))
					{
						throw new ArgumentException(SR.Argument_IdnBadPunycode, "unicode");
					}
					int num7 = 0;
					if (num6 > 0)
					{
						stringBuilder.Append('-');
					}
					int num8 = 128;
					int num9 = 0;
					int num10 = 72;
					while (num5 < num - num2)
					{
						int num11 = 0;
						int num12 = 134217727;
						for (int j = num2; j < num; j += ((!IsSupplementary(num11)) ? 1 : 2))
						{
							num11 = char.ConvertToUtf32(unicode, j);
							if (num11 >= num8 && num11 < num12)
							{
								num12 = num11;
							}
						}
						num9 += (num12 - num8) * (num5 - num7 + 1);
						num8 = num12;
						for (int j = num2; j < num; j += ((!IsSupplementary(num11)) ? 1 : 2))
						{
							num11 = char.ConvertToUtf32(unicode, j);
							if (num11 < num8)
							{
								num9++;
							}
							if (num11 != num8)
							{
								continue;
							}
							int num13 = num9;
							int num14 = 36;
							while (true)
							{
								int num15 = ((num14 <= num10) ? 1 : ((num14 >= num10 + 26) ? 26 : (num14 - num10)));
								if (num13 < num15)
								{
									break;
								}
								stringBuilder.Append(EncodeDigit(num15 + (num13 - num15) % (36 - num15)));
								num13 = (num13 - num15) / (36 - num15);
								num14 += 36;
							}
							stringBuilder.Append(EncodeDigit(num13));
							num10 = Adapt(num9, num5 - num7 + 1, num5 == num6);
							num9 = 0;
							num5++;
							if (IsSupplementary(num12))
							{
								num5++;
								num7++;
							}
						}
						num9++;
						num8++;
					}
				}
				if (stringBuilder.Length - num3 > 63)
				{
					throw new ArgumentException(SR.Argument_IdnBadLabelSize, "unicode");
				}
				if (num != unicode.Length)
				{
					stringBuilder.Append('.');
				}
				num2 = num + 1;
				num3 = stringBuilder.Length;
			}
			if (stringBuilder.Length > 255 - ((!IsDot(unicode[^1])) ? 1 : 0))
			{
				throw new ArgumentException(SR.Format(SR.Argument_IdnBadNameSize, 255 - ((!IsDot(unicode[^1])) ? 1 : 0)), "unicode");
			}
			return stringBuilder.ToString();
		}

		private static bool IsDot(char c)
		{
			if (c != '.' && c != '。' && c != '．')
			{
				return c == '｡';
			}
			return true;
		}

		private static bool IsSupplementary(int cTest)
		{
			return cTest >= 65536;
		}

		private static bool Basic(uint cp)
		{
			return cp < 128;
		}

		private static void ValidateStd3(char c, bool bNextToDot)
		{
			if (c > ',')
			{
				switch (c)
				{
				default:
					if ((c < '[' || c > '`') && (c < '{' || c > '\u007f') && !(c == '-' && bNextToDot))
					{
						return;
					}
					break;
				case '/':
				case ':':
				case ';':
				case '<':
				case '=':
				case '>':
				case '?':
				case '@':
					break;
				}
			}
			throw new ArgumentException(SR.Format(SR.Argument_IdnBadStd3, c), "c");
		}

		private string GetUnicodeInvariant(string ascii, int index, int count)
		{
			if (index > 0 || count < ascii.Length)
			{
				ascii = ascii.Substring(index, count);
			}
			string text = PunycodeDecode(ascii);
			if (!ascii.Equals(GetAscii(text), StringComparison.OrdinalIgnoreCase))
			{
				throw new ArgumentException(SR.Argument_IdnIllegalName, "ascii");
			}
			return text;
		}

		private static string PunycodeDecode(string ascii)
		{
			if (ascii.Length == 0)
			{
				throw new ArgumentException(SR.Argument_IdnBadLabelSize, "ascii");
			}
			if (ascii.Length > 255 - ((!IsDot(ascii[^1])) ? 1 : 0))
			{
				throw new ArgumentException(SR.Format(SR.Argument_IdnBadNameSize, 255 - ((!IsDot(ascii[^1])) ? 1 : 0)), "ascii");
			}
			StringBuilder stringBuilder = new StringBuilder(ascii.Length);
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			while (num < ascii.Length)
			{
				num = ascii.IndexOf('.', num2);
				if (num < 0 || num > ascii.Length)
				{
					num = ascii.Length;
				}
				if (num == num2)
				{
					if (num == ascii.Length)
					{
						break;
					}
					throw new ArgumentException(SR.Argument_IdnBadLabelSize, "ascii");
				}
				if (num - num2 > 63)
				{
					throw new ArgumentException(SR.Argument_IdnBadLabelSize, "ascii");
				}
				if (ascii.Length < "xn--".Length + num2 || string.Compare(ascii, num2, "xn--", 0, "xn--".Length, StringComparison.OrdinalIgnoreCase) != 0)
				{
					stringBuilder.Append(ascii, num2, num - num2);
				}
				else
				{
					num2 += "xn--".Length;
					int num4 = ascii.LastIndexOf('-', num - 1);
					if (num4 == num - 1)
					{
						throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
					}
					int num5;
					if (num4 <= num2)
					{
						num5 = 0;
					}
					else
					{
						num5 = num4 - num2;
						for (int i = num2; i < num2 + num5; i++)
						{
							if (ascii[i] > '\u007f')
							{
								throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
							}
							stringBuilder.Append((char)((ascii[i] >= 'A' && ascii[i] <= 'Z') ? (ascii[i] - 65 + 97) : ascii[i]));
						}
					}
					int num6 = num2 + ((num5 > 0) ? (num5 + 1) : 0);
					int num7 = 128;
					int num8 = 72;
					int num9 = 0;
					int num10 = 0;
					while (num6 < num)
					{
						int num11 = num9;
						int num12 = 1;
						int num13 = 36;
						while (true)
						{
							if (num6 >= num)
							{
								throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
							}
							int num14 = DecodeDigit(ascii[num6++]);
							if (num14 > (134217727 - num9) / num12)
							{
								throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
							}
							num9 += num14 * num12;
							int num15 = ((num13 <= num8) ? 1 : ((num13 >= num8 + 26) ? 26 : (num13 - num8)));
							if (num14 < num15)
							{
								break;
							}
							if (num12 > 134217727 / (36 - num15))
							{
								throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
							}
							num12 *= 36 - num15;
							num13 += 36;
						}
						num8 = Adapt(num9 - num11, stringBuilder.Length - num3 - num10 + 1, num11 == 0);
						if (num9 / (stringBuilder.Length - num3 - num10 + 1) > 134217727 - num7)
						{
							throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
						}
						num7 += num9 / (stringBuilder.Length - num3 - num10 + 1);
						num9 %= stringBuilder.Length - num3 - num10 + 1;
						if (num7 < 0 || num7 > 1114111 || (num7 >= 55296 && num7 <= 57343))
						{
							throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
						}
						string value = char.ConvertFromUtf32(num7);
						int num17;
						if (num10 > 0)
						{
							int num16 = num9;
							num17 = num3;
							while (num16 > 0)
							{
								if (num17 >= stringBuilder.Length)
								{
									throw new ArgumentException(SR.Argument_IdnBadPunycode, "ascii");
								}
								if (char.IsSurrogate(stringBuilder[num17]))
								{
									num17++;
								}
								num16--;
								num17++;
							}
						}
						else
						{
							num17 = num3 + num9;
						}
						stringBuilder.Insert(num17, value);
						if (IsSupplementary(num7))
						{
							num10++;
						}
						num9++;
					}
					bool flag = false;
					StrongBidiCategory bidiCategory = CharUnicodeInfo.GetBidiCategory(stringBuilder, num3);
					if (bidiCategory == StrongBidiCategory.StrongRightToLeft)
					{
						flag = true;
					}
					for (int j = num3; j < stringBuilder.Length; j++)
					{
						if (!char.IsLowSurrogate(stringBuilder[j]))
						{
							bidiCategory = CharUnicodeInfo.GetBidiCategory(stringBuilder, j);
							if ((flag && bidiCategory == StrongBidiCategory.StrongLeftToRight) || (!flag && bidiCategory == StrongBidiCategory.StrongRightToLeft))
							{
								throw new ArgumentException(SR.Argument_IdnBadBidi, "ascii");
							}
						}
					}
					if (flag && bidiCategory != StrongBidiCategory.StrongRightToLeft)
					{
						throw new ArgumentException(SR.Argument_IdnBadBidi, "ascii");
					}
				}
				if (num - num2 > 63)
				{
					throw new ArgumentException(SR.Argument_IdnBadLabelSize, "ascii");
				}
				if (num != ascii.Length)
				{
					stringBuilder.Append('.');
				}
				num2 = num + 1;
				num3 = stringBuilder.Length;
			}
			if (stringBuilder.Length > 255 - ((!IsDot(stringBuilder[stringBuilder.Length - 1])) ? 1 : 0))
			{
				throw new ArgumentException(SR.Format(SR.Argument_IdnBadNameSize, 255 - ((!IsDot(stringBuilder[stringBuilder.Length - 1])) ? 1 : 0)), "ascii");
			}
			return stringBuilder.ToString();
		}

		private static int DecodeDigit(char cp)
		{
			if (cp >= '0' && cp <= '9')
			{
				return cp - 48 + 26;
			}
			if (cp >= 'a' && cp <= 'z')
			{
				return cp - 97;
			}
			if (cp >= 'A' && cp <= 'Z')
			{
				return cp - 65;
			}
			throw new ArgumentException(SR.Argument_IdnBadPunycode, "cp");
		}

		private static int Adapt(int delta, int numpoints, bool firsttime)
		{
			delta = (firsttime ? (delta / 700) : (delta / 2));
			delta += delta / numpoints;
			uint num = 0u;
			while (delta > 455)
			{
				delta /= 35;
				num += 36;
			}
			return (int)(num + 36 * delta / (delta + 38));
		}

		private static char EncodeBasic(char bcp)
		{
			if (HasUpperCaseFlag(bcp))
			{
				bcp = (char)(bcp + 32);
			}
			return bcp;
		}

		private static bool HasUpperCaseFlag(char punychar)
		{
			if (punychar >= 'A')
			{
				return punychar <= 'Z';
			}
			return false;
		}

		private static char EncodeDigit(int d)
		{
			if (d > 25)
			{
				return (char)(d - 26 + 48);
			}
			return (char)(d + 97);
		}

		private unsafe string IcuGetAsciiCore(string unicodeString, char* unicode, int count)
		{
			uint icuFlags = IcuFlags;
			CheckInvalidIdnCharacters(unicode, count, icuFlags, "unicode");
			int num = (int)Math.Min((long)count * 3L + 4, 512L);
			int num2;
			if (num < 512)
			{
				char* ptr = stackalloc char[num];
				num2 = Interop.Globalization.ToAscii(icuFlags, unicode, count, ptr, num);
				if (num2 > 0 && num2 <= num)
				{
					return GetStringForOutput(unicodeString, unicode, count, ptr, num2);
				}
			}
			else
			{
				num2 = Interop.Globalization.ToAscii(icuFlags, unicode, count, null, 0);
			}
			if (num2 == 0)
			{
				throw new ArgumentException(SR.Argument_IdnIllegalName, "unicode");
			}
			char[] array = new char[num2];
			fixed (char* ptr2 = &array[0])
			{
				num2 = Interop.Globalization.ToAscii(icuFlags, unicode, count, ptr2, num2);
				if (num2 == 0 || num2 > array.Length)
				{
					throw new ArgumentException(SR.Argument_IdnIllegalName, "unicode");
				}
				return GetStringForOutput(unicodeString, unicode, count, ptr2, num2);
			}
		}

		private unsafe string IcuGetUnicodeCore(string asciiString, char* ascii, int count)
		{
			uint icuFlags = IcuFlags;
			CheckInvalidIdnCharacters(ascii, count, icuFlags, "ascii");
			if (count < 512)
			{
				char* output = stackalloc char[count];
				return IcuGetUnicodeCore(asciiString, ascii, count, icuFlags, output, count, reattempt: true);
			}
			char[] array = new char[count];
			fixed (char* output2 = &array[0])
			{
				return IcuGetUnicodeCore(asciiString, ascii, count, icuFlags, output2, count, reattempt: true);
			}
		}

		private unsafe string IcuGetUnicodeCore(string asciiString, char* ascii, int count, uint flags, char* output, int outputLength, bool reattempt)
		{
			int num = Interop.Globalization.ToUnicode(flags, ascii, count, output, outputLength);
			if (num == 0)
			{
				throw new ArgumentException(SR.Argument_IdnIllegalName, "ascii");
			}
			if (num <= outputLength)
			{
				return GetStringForOutput(asciiString, ascii, count, output, num);
			}
			if (reattempt)
			{
				fixed (char* output2 = new char[num])
				{
					return IcuGetUnicodeCore(asciiString, ascii, count, flags, output2, num, reattempt: false);
				}
			}
			throw new ArgumentException(SR.Argument_IdnIllegalName, "ascii");
		}

		private unsafe static void CheckInvalidIdnCharacters(char* s, int count, uint flags, string paramName)
		{
			if ((flags & 2u) != 0)
			{
				return;
			}
			for (int i = 0; i < count; i++)
			{
				char c = s[i];
				if (c <= '\u001f' || c == '\u007f')
				{
					throw new ArgumentException(SR.Argument_IdnIllegalName, paramName);
				}
			}
		}

		private unsafe string NlsGetAsciiCore(string unicodeString, char* unicode, int count)
		{
			uint nlsFlags = NlsFlags;
			int num = Interop.Normaliz.IdnToAscii(nlsFlags, unicode, count, null, 0);
			if (num == 0)
			{
				ThrowForZeroLength(unicode: true);
			}
			if (num < 512)
			{
				char* output = stackalloc char[num];
				return NlsGetAsciiCore(unicodeString, unicode, count, nlsFlags, output, num);
			}
			char[] array = new char[num];
			fixed (char* output2 = &array[0])
			{
				return NlsGetAsciiCore(unicodeString, unicode, count, nlsFlags, output2, num);
			}
		}

		private unsafe static string NlsGetAsciiCore(string unicodeString, char* unicode, int count, uint flags, char* output, int outputLength)
		{
			int num = Interop.Normaliz.IdnToAscii(flags, unicode, count, output, outputLength);
			if (num == 0)
			{
				ThrowForZeroLength(unicode: true);
			}
			return GetStringForOutput(unicodeString, unicode, count, output, num);
		}

		private unsafe string NlsGetUnicodeCore(string asciiString, char* ascii, int count)
		{
			uint nlsFlags = NlsFlags;
			int num = Interop.Normaliz.IdnToUnicode(nlsFlags, ascii, count, null, 0);
			if (num == 0)
			{
				ThrowForZeroLength(unicode: false);
			}
			if (num < 512)
			{
				char* output = stackalloc char[num];
				return NlsGetUnicodeCore(asciiString, ascii, count, nlsFlags, output, num);
			}
			char[] array = new char[num];
			fixed (char* output2 = &array[0])
			{
				return NlsGetUnicodeCore(asciiString, ascii, count, nlsFlags, output2, num);
			}
		}

		private unsafe static string NlsGetUnicodeCore(string asciiString, char* ascii, int count, uint flags, char* output, int outputLength)
		{
			int num = Interop.Normaliz.IdnToUnicode(flags, ascii, count, output, outputLength);
			if (num == 0)
			{
				ThrowForZeroLength(unicode: false);
			}
			return GetStringForOutput(asciiString, ascii, count, output, num);
		}

		[DoesNotReturn]
		private static void ThrowForZeroLength(bool unicode)
		{
			int lastPInvokeError = Marshal.GetLastPInvokeError();
			throw new ArgumentException((lastPInvokeError == 123) ? SR.Argument_IdnIllegalName : (unicode ? SR.Argument_InvalidCharSequenceNoIndex : SR.Argument_IdnBadPunycode), unicode ? "unicode" : "ascii");
		}
	}
	internal static class InternalGlobalizationHelper
	{
		internal static long TimeToTicks(int hour, int minute, int second)
		{
			long num = (long)hour * 3600L + (long)minute * 60L + second;
			if (num > 922337203685L || num < -922337203685L)
			{
				throw new ArgumentOutOfRangeException(null, SR.Overflow_TimeSpanTooLong);
			}
			return num * 10000000;
		}
	}
	internal static class InvariantModeCasing
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static char ToLower(char c)
		{
			return CharUnicodeInfo.ToLower(c);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static char ToUpper(char c)
		{
			return CharUnicodeInfo.ToUpper(c);
		}

		internal static string ToLower(string s)
		{
			if (s.Length == 0)
			{
				return string.Empty;
			}
			ReadOnlySpan<char> readOnlySpan = s;
			int num = 0;
			while (num < s.Length)
			{
				if (char.IsHighSurrogate(readOnlySpan[num]) && num < s.Length - 1 && char.IsLowSurrogate(readOnlySpan[num + 1]))
				{
					SurrogateCasing.ToLower(readOnlySpan[num], readOnlySpan[num + 1], out var hr, out var lr);
					if (readOnlySpan[num] != hr || readOnlySpan[num + 1] != lr)
					{
						break;
					}
					num += 2;
				}
				else
				{
					if (ToLower(readOnlySpan[num]) != readOnlySpan[num])
					{
						break;
					}
					num++;
				}
			}
			if (num >= s.Length)
			{
				return s;
			}
			return string.Create(s.Length, (s, num), delegate(Span<char> destination, (string s, int i) state)
			{
				ReadOnlySpan<char> readOnlySpan2 = state.s;
				readOnlySpan2.Slice(0, state.i).CopyTo(destination);
				ToLower(readOnlySpan2.Slice(state.i), destination.Slice(state.i));
			});
		}

		internal static string ToUpper(string s)
		{
			if (s.Length == 0)
			{
				return string.Empty;
			}
			ReadOnlySpan<char> readOnlySpan = s;
			int num = 0;
			while (num < s.Length)
			{
				if (char.IsHighSurrogate(readOnlySpan[num]) && num < s.Length - 1 && char.IsLowSurrogate(readOnlySpan[num + 1]))
				{
					SurrogateCasing.ToUpper(readOnlySpan[num], readOnlySpan[num + 1], out var hr, out var lr);
					if (readOnlySpan[num] != hr || readOnlySpan[num + 1] != lr)
					{
						break;
					}
					num += 2;
				}
				else
				{
					if (ToUpper(readOnlySpan[num]) != readOnlySpan[num])
					{
						break;
					}
					num++;
				}
			}
			if (num >= s.Length)
			{
				return s;
			}
			return string.Create(s.Length, (s, num), delegate(Span<char> destination, (string s, int i) state)
			{
				ReadOnlySpan<char> readOnlySpan2 = state.s;
				readOnlySpan2.Slice(0, state.i).CopyTo(destination);
				ToUpper(readOnlySpan2.Slice(state.i), destination.Slice(state.i));
			});
		}

		internal static void ToUpper(ReadOnlySpan<char> source, Span<char> destination)
		{
			for (int i = 0; i < source.Length; i++)
			{
				char c = source[i];
				if (char.IsHighSurrogate(c) && i < source.Length - 1)
				{
					char c2 = source[i + 1];
					if (char.IsLowSurrogate(c2))
					{
						SurrogateCasing.ToUpper(c, c2, out var hr, out var lr);
						destination[i] = hr;
						destination[i + 1] = lr;
						i++;
						continue;
					}
				}
				destination[i] = ToUpper(c);
			}
		}

		internal static void ToLower(ReadOnlySpan<char> source, Span<char> destination)
		{
			for (int i = 0; i < source.Length; i++)
			{
				char c = source[i];
				if (char.IsHighSurrogate(c) && i < source.Length - 1)
				{
					char c2 = source[i + 1];
					if (char.IsLowSurrogate(c2))
					{
						SurrogateCasing.ToLower(c, c2, out var hr, out var lr);
						destination[i] = hr;
						destination[i + 1] = lr;
						i++;
						continue;
					}
				}
				destination[i] = ToLower(c);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static (uint, int) GetScalar(ref char source, int index, int length)
		{
			char c = source;
			if (!char.IsHighSurrogate(c) || index >= length - 1)
			{
				return (c, 1);
			}
			char c2 = Unsafe.Add(ref source, 1);
			if (!char.IsLowSurrogate(c2))
			{
				return (c, 1);
			}
			return (UnicodeUtility.GetScalarFromUtf16SurrogatePair(c, c2), 2);
		}

		internal static int CompareStringIgnoreCase(ref char strA, int lengthA, ref char strB, int lengthB)
		{
			int num = Math.Min(lengthA, lengthB);
			ref char source = ref strA;
			ref char source2 = ref strB;
			int num2 = 0;
			while (num2 < num)
			{
				var (num3, num4) = GetScalar(ref source, num2, lengthA);
				var (num5, elementOffset) = GetScalar(ref source2, num2, lengthB);
				if (num3 == num5)
				{
					num2 += num4;
					source = ref Unsafe.Add(ref source, num4);
					source2 = ref Unsafe.Add(ref source2, elementOffset);
					continue;
				}
				uint num6 = CharUnicodeInfo.ToUpper(num3);
				uint num7 = CharUnicodeInfo.ToUpper(num5);
				if (num6 == num7)
				{
					num2 += num4;
					source = ref Unsafe.Add(ref source, num4);
					source2 = ref Unsafe.Add(ref source2, elementOffset);
					continue;
				}
				return (int)(num3 - num5);
			}
			return lengthA - lengthB;
		}

		internal unsafe static int IndexOfIgnoreCase(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
		{
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(value))
				{
					char* ptr2 = ptr + (source.Length - value.Length);
					char* ptr4 = ptr3 + value.Length - 1;
					for (char* ptr5 = ptr; ptr5 <= ptr2; ptr5++)
					{
						char* ptr6 = ptr3;
						char* ptr7 = ptr5;
						while (ptr6 <= ptr4)
						{
							if (!char.IsHighSurrogate(*ptr6) || ptr6 == ptr4)
							{
								if (*ptr6 != *ptr7 && ToUpper(*ptr6) != ToUpper(*ptr7))
								{
									break;
								}
								ptr6++;
								ptr7++;
							}
							else if (char.IsHighSurrogate(*ptr7) && char.IsLowSurrogate(ptr7[1]) && char.IsLowSurrogate(ptr6[1]))
							{
								if (!SurrogateCasing.Equal(*ptr7, ptr7[1], *ptr6, ptr6[1]))
								{
									break;
								}
								ptr7 += 2;
								ptr6 += 2;
							}
							else
							{
								if (*ptr6 != *ptr7)
								{
									break;
								}
								ptr7++;
								ptr6++;
							}
						}
						if (ptr6 > ptr4)
						{
							return (int)(ptr5 - ptr);
						}
					}
					return -1;
				}
			}
		}

		internal unsafe static int LastIndexOfIgnoreCase(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
		{
			fixed (char* ptr3 = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr = &MemoryMarshal.GetReference(value))
				{
					char* ptr2 = ptr + value.Length - 1;
					for (char* ptr4 = ptr3 + (source.Length - value.Length); ptr4 >= ptr3; ptr4--)
					{
						char* ptr5 = ptr;
						char* ptr6 = ptr4;
						while (ptr5 <= ptr2)
						{
							if (!char.IsHighSurrogate(*ptr5) || ptr5 == ptr2)
							{
								if (*ptr5 != *ptr6 && ToUpper(*ptr5) != ToUpper(*ptr6))
								{
									break;
								}
								ptr5++;
								ptr6++;
							}
							else if (char.IsHighSurrogate(*ptr6) && char.IsLowSurrogate(ptr6[1]) && char.IsLowSurrogate(ptr5[1]))
							{
								if (!SurrogateCasing.Equal(*ptr6, ptr6[1], *ptr5, ptr5[1]))
								{
									break;
								}
								ptr6 += 2;
								ptr5 += 2;
							}
							else
							{
								if (*ptr5 != *ptr6)
								{
									break;
								}
								ptr6++;
								ptr5++;
							}
						}
						if (ptr5 > ptr2)
						{
							return (int)(ptr4 - ptr3);
						}
					}
					return -1;
				}
			}
		}
	}
	public static class ISOWeek
	{
		public static int GetWeekOfYear(DateTime date)
		{
			int weekNumber = GetWeekNumber(date);
			if (weekNumber < 1)
			{
				return GetWeeksInYear(date.Year - 1);
			}
			if (weekNumber > GetWeeksInYear(date.Year))
			{
				return 1;
			}
			return weekNumber;
		}

		public static int GetYear(DateTime date)
		{
			int weekNumber = GetWeekNumber(date);
			if (weekNumber < 1)
			{
				return date.Year - 1;
			}
			if (weekNumber > GetWeeksInYear(date.Year))
			{
				return date.Year + 1;
			}
			return date.Year;
		}

		public static DateTime GetYearStart(int year)
		{
			return ToDateTime(year, 1, DayOfWeek.Monday);
		}

		public static DateTime GetYearEnd(int year)
		{
			return ToDateTime(year, GetWeeksInYear(year), DayOfWeek.Sunday);
		}

		public static int GetWeeksInYear(int year)
		{
			if (year < 1 || year > 9999)
			{
				throw new ArgumentOutOfRangeException("year", SR.ArgumentOutOfRange_Year);
			}
			if (P(year) == 4 || P(year - 1) == 3)
			{
				return 53;
			}
			return 52;
			static int P(int y)
			{
				return (y + y / 4 - y / 100 + y / 400) % 7;
			}
		}

		public static DateTime ToDateTime(int year, int week, DayOfWeek dayOfWeek)
		{
			if (year < 1 || year > 9999)
			{
				throw new ArgumentOutOfRangeException("year", SR.ArgumentOutOfRange_Year);
			}
			if (week < 1 || week > 53)
			{
				throw new ArgumentOutOfRangeException("week", SR.ArgumentOutOfRange_Week_ISO);
			}
			if (dayOfWeek < DayOfWeek.Sunday || dayOfWeek > (DayOfWeek)7)
			{
				throw new ArgumentOutOfRangeException("dayOfWeek", SR.ArgumentOutOfRange_DayOfWeek);
			}
			int num = GetWeekday(new DateTime(year, 1, 4).DayOfWeek) + 3;
			int num2 = week * 7 + GetWeekday(dayOfWeek) - num;
			return new DateTime(year, 1, 1).AddDays(num2 - 1);
		}

		private static int GetWeekNumber(DateTime date)
		{
			return (date.DayOfYear - GetWeekday(date.DayOfWeek) + 10) / 7;
		}

		private static int GetWeekday(DayOfWeek dayOfWeek)
		{
			if (dayOfWeek != 0)
			{
				return (int)dayOfWeek;
			}
			return 7;
		}
	}
	public class JapaneseCalendar : Calendar
	{
		private static readonly DateTime s_calendarMinValue = new DateTime(1868, 9, 8);

		private static volatile EraInfo[] s_japaneseEraInfo;

		internal static volatile Calendar s_defaultInstance;

		internal GregorianCalendarHelper _helper;

		private static readonly string[] s_abbreviatedEnglishEraNames = new string[5] { "M", "T", "S", "H", "R" };

		public override DateTime MinSupportedDateTime => s_calendarMinValue;

		public override DateTime MaxSupportedDateTime => DateTime.MaxValue;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.SolarCalendar;

		internal override CalendarId ID => CalendarId.JAPAN;

		public override int[] Eras => _helper.Eras;

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 99);
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > _helper.MaxYear)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, _helper.MaxYear));
				}
				_twoDigitYearMax = value;
			}
		}

		internal static EraInfo[] GetEraInfo()
		{
			object obj = s_japaneseEraInfo;
			if (obj == null)
			{
				obj = (s_japaneseEraInfo = (GlobalizationMode.UseNls ? NlsGetJapaneseEras() : IcuGetJapaneseEras()));
				if (obj == null)
				{
					obj = new EraInfo[5]
					{
						new EraInfo(5, 2019, 5, 1, 2018, 1, 7981, "令和", "令", "R"),
						new EraInfo(4, 1989, 1, 8, 1988, 1, 31, "平成", "平", "H"),
						new EraInfo(3, 1926, 12, 25, 1925, 1, 64, "昭和", "昭", "S"),
						new EraInfo(2, 1912, 7, 30, 1911, 1, 15, "大正", "大", "T"),
						new EraInfo(1, 1868, 1, 1, 1867, 1, 45, "明治", "明", "M")
					};
					s_japaneseEraInfo = (EraInfo[])obj;
				}
			}
			return (EraInfo[])obj;
		}

		internal static Calendar GetDefaultInstance()
		{
			return s_defaultInstance ?? (s_defaultInstance = new JapaneseCalendar());
		}

		public JapaneseCalendar()
		{
			try
			{
				new CultureInfo("ja-JP");
			}
			catch (ArgumentException innerException)
			{
				throw new TypeInitializationException(GetType().ToString(), innerException);
			}
			_helper = new GregorianCalendarHelper(this, GetEraInfo());
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			return _helper.AddMonths(time, months);
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return _helper.AddYears(time, years);
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			return _helper.GetDaysInMonth(year, month, era);
		}

		public override int GetDaysInYear(int year, int era)
		{
			return _helper.GetDaysInYear(year, era);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return _helper.GetDayOfMonth(time);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return _helper.GetDayOfWeek(time);
		}

		public override int GetDayOfYear(DateTime time)
		{
			return _helper.GetDayOfYear(time);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			return _helper.GetMonthsInYear(year, era);
		}

		public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
		{
			return _helper.GetWeekOfYear(time, rule, firstDayOfWeek);
		}

		public override int GetEra(DateTime time)
		{
			return _helper.GetEra(time);
		}

		public override int GetMonth(DateTime time)
		{
			return _helper.GetMonth(time);
		}

		public override int GetYear(DateTime time)
		{
			return _helper.GetYear(time);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			return _helper.IsLeapDay(year, month, day, era);
		}

		public override bool IsLeapYear(int year, int era)
		{
			return _helper.IsLeapYear(year, era);
		}

		public override int GetLeapMonth(int year, int era)
		{
			return _helper.GetLeapMonth(year, era);
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			return _helper.IsLeapMonth(year, month, era);
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			return _helper.ToDateTime(year, month, day, hour, minute, second, millisecond, era);
		}

		public override int ToFourDigitYear(int year)
		{
			if (year <= 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedPosNum);
			}
			if (year > _helper.MaxYear)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, _helper.MaxYear));
			}
			return year;
		}

		internal static string[] EraNames()
		{
			EraInfo[] eraInfo = GetEraInfo();
			string[] array = new string[eraInfo.Length];
			for (int i = 0; i < eraInfo.Length; i++)
			{
				array[i] = eraInfo[eraInfo.Length - i - 1].eraName;
			}
			return array;
		}

		internal static string[] AbbrevEraNames()
		{
			EraInfo[] eraInfo = GetEraInfo();
			string[] array = new string[eraInfo.Length];
			for (int i = 0; i < eraInfo.Length; i++)
			{
				array[i] = eraInfo[eraInfo.Length - i - 1].abbrevEraName;
			}
			return array;
		}

		internal static string[] EnglishEraNames()
		{
			EraInfo[] eraInfo = GetEraInfo();
			string[] array = new string[eraInfo.Length];
			for (int i = 0; i < eraInfo.Length; i++)
			{
				array[i] = eraInfo[eraInfo.Length - i - 1].englishEraName;
			}
			return array;
		}

		internal override bool IsValidYear(int year, int era)
		{
			return _helper.IsValidYear(year, era);
		}

		private static EraInfo[] IcuGetJapaneseEras()
		{
			if (GlobalizationMode.Invariant)
			{
				return null;
			}
			if (!CalendarData.EnumCalendarInfo("ja-JP", CalendarId.JAPAN, CalendarDataType.EraNames, out var calendarData))
			{
				return null;
			}
			List<EraInfo> list = new List<EraInfo>();
			int num = 9999;
			int latestJapaneseEra = Interop.Globalization.GetLatestJapaneseEra();
			for (int num2 = latestJapaneseEra; num2 >= 0; num2--)
			{
				if (!GetJapaneseEraStartDate(num2, out var dateTime))
				{
					return null;
				}
				if (dateTime < s_calendarMinValue)
				{
					break;
				}
				list.Add(new EraInfo(num2, dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Year - 1, 1, num - dateTime.Year + 1, calendarData[num2], GetAbbreviatedEraName(calendarData, num2), ""));
				num = dateTime.Year;
			}
			if (!CalendarData.EnumCalendarInfo("ja", CalendarId.JAPAN, CalendarDataType.AbbrevEraNames, out var calendarData2))
			{
				calendarData2 = s_abbreviatedEnglishEraNames;
			}
			if (calendarData2[^1].Length == 0 || calendarData2[^1][0] > '\u007f')
			{
				calendarData2 = s_abbreviatedEnglishEraNames;
			}
			int num3 = ((calendarData2 == s_abbreviatedEnglishEraNames) ? (list.Count - 1) : (calendarData2.Length - 1));
			for (int i = 0; i < list.Count; i++)
			{
				list[i].era = list.Count - i;
				if (num3 < calendarData2.Length)
				{
					list[i].englishEraName = calendarData2[num3];
				}
				num3--;
			}
			return list.ToArray();
		}

		private static string GetAbbreviatedEraName(string[] eraNames, int eraIndex)
		{
			return eraNames[eraIndex].Substring(0, 1);
		}

		private static bool GetJapaneseEraStartDate(int era, out DateTime dateTime)
		{
			dateTime = default(DateTime);
			int startYear;
			int startMonth;
			int startDay;
			bool japaneseEraStartDate = Interop.Globalization.GetJapaneseEraStartDate(era, out startYear, out startMonth, out startDay);
			if (japaneseEraStartDate)
			{
				dateTime = new DateTime(startYear, startMonth, startDay);
			}
			return japaneseEraStartDate;
		}

		private static EraInfo[] NlsGetJapaneseEras()
		{
			int num = 0;
			EraInfo[] array = null;
			try
			{
				using RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("System\\CurrentControlSet\\Control\\Nls\\Calendars\\Japanese\\Eras");
				if (registryKey == null)
				{
					return null;
				}
				string[] valueNames = registryKey.GetValueNames();
				if (valueNames != null && valueNames.Length != 0)
				{
					array = new EraInfo[valueNames.Length];
					for (int i = 0; i < valueNames.Length; i++)
					{
						EraInfo eraFromValue = GetEraFromValue(valueNames[i], registryKey.GetValue(valueNames[i])?.ToString());
						if (eraFromValue != null)
						{
							array[num] = eraFromValue;
							num++;
						}
					}
				}
			}
			catch (SecurityException)
			{
				return null;
			}
			catch (IOException)
			{
				return null;
			}
			catch (UnauthorizedAccessException)
			{
				return null;
			}
			if (num < 4)
			{
				return null;
			}
			Array.Resize(ref array, num);
			Array.Sort(array, CompareEraRanges);
			for (int j = 0; j < array.Length; j++)
			{
				array[j].era = array.Length - j;
				if (j == 0)
				{
					array[0].maxEraYear = 9999 - array[0].yearOffset;
				}
				else
				{
					array[j].maxEraYear = array[j - 1].yearOffset + 1 - array[j].yearOffset;
				}
			}
			return array;
		}

		private static int CompareEraRanges(EraInfo a, EraInfo b)
		{
			return b.ticks.CompareTo(a.ticks);
		}

		private static EraInfo GetEraFromValue(string value, string data)
		{
			if (value == null || data == null)
			{
				return null;
			}
			if (value.Length != 10)
			{
				return null;
			}
			ReadOnlySpan<char> readOnlySpan = value.AsSpan();
			if (!int.TryParse(readOnlySpan.Slice(0, 4), NumberStyles.None, NumberFormatInfo.InvariantInfo, out var result) || !int.TryParse(readOnlySpan.Slice(5, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out var result2) || !int.TryParse(readOnlySpan.Slice(8, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out var result3))
			{
				return null;
			}
			string[] array = data.Split('_');
			if (array.Length != 4)
			{
				return null;
			}
			if (array[0].Length == 0 || array[1].Length == 0 || array[2].Length == 0 || array[3].Length == 0)
			{
				return null;
			}
			return new EraInfo(0, result, result2, result3, result - 1, 1, 0, array[0], array[1], array[3]);
		}
	}
	public class JapaneseLunisolarCalendar : EastAsianLunisolarCalendar
	{
		public const int JapaneseEra = 1;

		private readonly GregorianCalendarHelper _helper;

		private static readonly DateTime s_minDate = new DateTime(1960, 1, 28);

		private static readonly DateTime s_maxDate = new DateTime(new DateTime(2050, 1, 22, 23, 59, 59, 999).Ticks + 9999);

		private static readonly int[,] s_yinfo = new int[90, 4]
		{
			{ 6, 1, 28, 44368 },
			{ 0, 2, 15, 43856 },
			{ 0, 2, 5, 19296 },
			{ 4, 1, 25, 42352 },
			{ 0, 2, 13, 42352 },
			{ 0, 2, 2, 21104 },
			{ 3, 1, 22, 26928 },
			{ 0, 2, 9, 55632 },
			{ 7, 1, 30, 27304 },
			{ 0, 2, 17, 22176 },
			{ 0, 2, 6, 39632 },
			{ 5, 1, 27, 19176 },
			{ 0, 2, 15, 19168 },
			{ 0, 2, 3, 42208 },
			{ 4, 1, 23, 53864 },
			{ 0, 2, 11, 53840 },
			{ 8, 1, 31, 54600 },
			{ 0, 2, 18, 46400 },
			{ 0, 2, 7, 54944 },
			{ 6, 1, 28, 38608 },
			{ 0, 2, 16, 38320 },
			{ 0, 2, 5, 18864 },
			{ 4, 1, 25, 42200 },
			{ 0, 2, 13, 42160 },
			{ 10, 2, 2, 45656 },
			{ 0, 2, 20, 27216 },
			{ 0, 2, 9, 27968 },
			{ 6, 1, 29, 46504 },
			{ 0, 2, 18, 11104 },
			{ 0, 2, 6, 38320 },
			{ 5, 1, 27, 18872 },
			{ 0, 2, 15, 18800 },
			{ 0, 2, 4, 25776 },
			{ 3, 1, 23, 27216 },
			{ 0, 2, 10, 59984 },
			{ 8, 1, 31, 27976 },
			{ 0, 2, 19, 23248 },
			{ 0, 2, 8, 11104 },
			{ 5, 1, 28, 37744 },
			{ 0, 2, 16, 37600 },
			{ 0, 2, 5, 51552 },
			{ 4, 1, 24, 58536 },
			{ 0, 2, 12, 54432 },
			{ 0, 2, 1, 55888 },
			{ 2, 1, 22, 23208 },
			{ 0, 2, 9, 22208 },
			{ 7, 1, 29, 43736 },
			{ 0, 2, 18, 9680 },
			{ 0, 2, 7, 37584 },
			{ 5, 1, 26, 51544 },
			{ 0, 2, 14, 43344 },
			{ 0, 2, 3, 46240 },
			{ 3, 1, 23, 47696 },
			{ 0, 2, 10, 46416 },
			{ 9, 1, 31, 21928 },
			{ 0, 2, 19, 19360 },
			{ 0, 2, 8, 42416 },
			{ 5, 1, 28, 21176 },
			{ 0, 2, 16, 21168 },
			{ 0, 2, 5, 43344 },
			{ 4, 1, 25, 46248 },
			{ 0, 2, 12, 27296 },
			{ 0, 2, 1, 44368 },
			{ 2, 1, 22, 21928 },
			{ 0, 2, 10, 19296 },
			{ 6, 1, 29, 42352 },
			{ 0, 2, 17, 42352 },
			{ 0, 2, 7, 21104 },
			{ 5, 1, 27, 26928 },
			{ 0, 2, 13, 55600 },
			{ 0, 2, 3, 23200 },
			{ 3, 1, 23, 43856 },
			{ 0, 2, 11, 38608 },
			{ 11, 1, 31, 19176 },
			{ 0, 2, 19, 19168 },
			{ 0, 2, 8, 42192 },
			{ 6, 1, 28, 53864 },
			{ 0, 2, 15, 53840 },
			{ 0, 2, 4, 54560 },
			{ 5, 1, 24, 55968 },
			{ 0, 2, 12, 46752 },
			{ 0, 2, 1, 38608 },
			{ 2, 1, 22, 19160 },
			{ 0, 2, 10, 18864 },
			{ 7, 1, 30, 42168 },
			{ 0, 2, 17, 42160 },
			{ 0, 2, 6, 45648 },
			{ 5, 1, 26, 46376 },
			{ 0, 2, 14, 27968 },
			{ 0, 2, 2, 44448 }
		};

		public override DateTime MinSupportedDateTime => s_minDate;

		public override DateTime MaxSupportedDateTime => s_maxDate;

		protected override int DaysInYearBeforeMinSupportedYear => 354;

		internal override int MinCalendarYear => 1960;

		internal override int MaxCalendarYear => 2049;

		internal override DateTime MinDate => s_minDate;

		internal override DateTime MaxDate => s_maxDate;

		internal override EraInfo[]? CalEraInfo => JapaneseCalendar.GetEraInfo();

		internal override CalendarId BaseCalendarID => CalendarId.JAPAN;

		internal override CalendarId ID => CalendarId.JAPANESELUNISOLAR;

		public override int[] Eras => _helper.Eras;

		internal override int GetYearInfo(int lunarYear, int index)
		{
			if (lunarYear < 1960 || lunarYear > 2049)
			{
				throw new ArgumentOutOfRangeException("year", lunarYear, SR.Format(SR.ArgumentOutOfRange_Range, 1960, 2049));
			}
			return s_yinfo[lunarYear - 1960, index];
		}

		internal override int GetYear(int year, DateTime time)
		{
			return _helper.GetYear(year, time);
		}

		internal override int GetGregorianYear(int year, int era)
		{
			return _helper.GetGregorianYear(year, era);
		}

		private static EraInfo[] TrimEras(EraInfo[] baseEras)
		{
			EraInfo[] array = new EraInfo[baseEras.Length];
			int num = 0;
			for (int i = 0; i < baseEras.Length; i++)
			{
				if (baseEras[i].yearOffset + baseEras[i].minEraYear < 2049)
				{
					if (baseEras[i].yearOffset + baseEras[i].maxEraYear < 1960)
					{
						break;
					}
					array[num] = baseEras[i];
					num++;
				}
			}
			if (num == 0)
			{
				return baseEras;
			}
			Array.Resize(ref array, num);
			return array;
		}

		public JapaneseLunisolarCalendar()
		{
			_helper = new GregorianCalendarHelper(this, TrimEras(JapaneseCalendar.GetEraInfo()));
		}

		public override int GetEra(DateTime time)
		{
			return _helper.GetEra(time);
		}
	}
	public class JulianCalendar : Calendar
	{
		public static readonly int JulianEra = 1;

		private static readonly int[] s_daysToMonth365 = new int[13]
		{
			0, 31, 59, 90, 120, 151, 181, 212, 243, 273,
			304, 334, 365
		};

		private static readonly int[] s_daysToMonth366 = new int[13]
		{
			0, 31, 60, 91, 121, 152, 182, 213, 244, 274,
			305, 335, 366
		};

		internal int MaxYear = 9999;

		public override DateTime MinSupportedDateTime => DateTime.MinValue;

		public override DateTime MaxSupportedDateTime => DateTime.MaxValue;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.SolarCalendar;

		internal override CalendarId ID => CalendarId.JULIAN;

		public override int[] Eras => new int[1] { JulianEra };

		public override int TwoDigitYearMax
		{
			get
			{
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > MaxYear)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, MaxYear));
				}
				_twoDigitYearMax = value;
			}
		}

		public JulianCalendar()
		{
			_twoDigitYearMax = 2029;
		}

		internal static void CheckEraRange(int era)
		{
			if (era != 0 && era != JulianEra)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
		}

		internal void CheckYearEraRange(int year, int era)
		{
			CheckEraRange(era);
			if (year <= 0 || year > MaxYear)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, MaxYear));
			}
		}

		internal static void CheckMonthRange(int month)
		{
			if (month < 1 || month > 12)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
		}

		internal static void CheckDayRange(int year, int month, int day)
		{
			if (year == 1 && month == 1 && day < 3)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
			}
			int[] array = ((year % 4 == 0) ? s_daysToMonth366 : s_daysToMonth365);
			int num = array[month] - array[month - 1];
			if (day < 1 || day > num)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Range, 1, num));
			}
		}

		internal static int GetDatePart(long ticks, int part)
		{
			long num = ticks + 1728000000000L;
			int num2 = (int)(num / 864000000000L);
			int num3 = num2 / 1461;
			num2 -= num3 * 1461;
			int num4 = num2 / 365;
			if (num4 == 4)
			{
				num4 = 3;
			}
			if (part == 0)
			{
				return num3 * 4 + num4 + 1;
			}
			num2 -= num4 * 365;
			if (part == 1)
			{
				return num2 + 1;
			}
			int[] array = ((num4 == 3) ? s_daysToMonth366 : s_daysToMonth365);
			int i;
			for (i = (num2 >> 5) + 1; num2 >= array[i]; i++)
			{
			}
			if (part == 2)
			{
				return i;
			}
			return num2 - array[i - 1] + 1;
		}

		internal static long DateToTicks(int year, int month, int day)
		{
			int[] array = ((year % 4 == 0) ? s_daysToMonth366 : s_daysToMonth365);
			int num = year - 1;
			int num2 = num * 365 + num / 4 + array[month - 1] + day - 1;
			return (num2 - 2) * 864000000000L;
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			if (months < -120000 || months > 120000)
			{
				throw new ArgumentOutOfRangeException("months", months, SR.Format(SR.ArgumentOutOfRange_Range, -120000, 120000));
			}
			int datePart = GetDatePart(time.Ticks, 0);
			int datePart2 = GetDatePart(time.Ticks, 2);
			int num = GetDatePart(time.Ticks, 3);
			int num2 = datePart2 - 1 + months;
			if (num2 >= 0)
			{
				datePart2 = num2 % 12 + 1;
				datePart += num2 / 12;
			}
			else
			{
				datePart2 = 12 + (num2 + 1) % 12;
				datePart += (num2 - 11) / 12;
			}
			int[] array = ((datePart % 4 == 0 && (datePart % 100 != 0 || datePart % 400 == 0)) ? s_daysToMonth366 : s_daysToMonth365);
			int num3 = array[datePart2] - array[datePart2 - 1];
			if (num > num3)
			{
				num = num3;
			}
			long ticks = DateToTicks(datePart, datePart2, num) + time.Ticks % 864000000000L;
			Calendar.CheckAddResult(ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return new DateTime(ticks);
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return AddMonths(time, years * 12);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 3);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return (DayOfWeek)((int)(time.Ticks / 864000000000L + 1) % 7);
		}

		public override int GetDayOfYear(DateTime time)
		{
			return GetDatePart(time.Ticks, 1);
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			CheckYearEraRange(year, era);
			CheckMonthRange(month);
			int[] array = ((year % 4 == 0) ? s_daysToMonth366 : s_daysToMonth365);
			return array[month] - array[month - 1];
		}

		public override int GetDaysInYear(int year, int era)
		{
			if (!IsLeapYear(year, era))
			{
				return 365;
			}
			return 366;
		}

		public override int GetEra(DateTime time)
		{
			return JulianEra;
		}

		public override int GetMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 2);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			CheckYearEraRange(year, era);
			return 12;
		}

		public override int GetYear(DateTime time)
		{
			return GetDatePart(time.Ticks, 0);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			CheckMonthRange(month);
			if (IsLeapYear(year, era))
			{
				CheckDayRange(year, month, day);
				if (month == 2)
				{
					return day == 29;
				}
				return false;
			}
			CheckDayRange(year, month, day);
			return false;
		}

		public override int GetLeapMonth(int year, int era)
		{
			CheckYearEraRange(year, era);
			return 0;
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			CheckYearEraRange(year, era);
			CheckMonthRange(month);
			return false;
		}

		public override bool IsLeapYear(int year, int era)
		{
			CheckYearEraRange(year, era);
			return year % 4 == 0;
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			CheckYearEraRange(year, era);
			CheckMonthRange(month);
			CheckDayRange(year, month, day);
			if (millisecond < 0 || millisecond >= 1000)
			{
				throw new ArgumentOutOfRangeException("millisecond", millisecond, SR.Format(SR.ArgumentOutOfRange_Range, 0, 999));
			}
			if (hour < 0 || hour >= 24 || minute < 0 || minute >= 60 || second < 0 || second >= 60)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadHourMinuteSecond);
			}
			return new DateTime(DateToTicks(year, month, day) + new TimeSpan(0, hour, minute, second, millisecond).Ticks);
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (year > MaxYear)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Bounds_Lower_Upper, 1, MaxYear));
			}
			return base.ToFourDigitYear(year);
		}
	}
	public class KoreanCalendar : Calendar
	{
		public const int KoreanEra = 1;

		private static readonly EraInfo[] s_koreanEraInfo = new EraInfo[1]
		{
			new EraInfo(1, 1, 1, 1, -2333, 2334, 12332)
		};

		private readonly GregorianCalendarHelper _helper;

		public override DateTime MinSupportedDateTime => DateTime.MinValue;

		public override DateTime MaxSupportedDateTime => DateTime.MaxValue;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.SolarCalendar;

		internal override CalendarId ID => CalendarId.KOREA;

		public override int[] Eras => _helper.Eras;

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 4362);
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > _helper.MaxYear)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, _helper.MaxYear));
				}
				_twoDigitYearMax = value;
			}
		}

		public KoreanCalendar()
		{
			try
			{
				new CultureInfo("ko-KR");
			}
			catch (ArgumentException innerException)
			{
				throw new TypeInitializationException(GetType().ToString(), innerException);
			}
			_helper = new GregorianCalendarHelper(this, s_koreanEraInfo);
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			return _helper.AddMonths(time, months);
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return _helper.AddYears(time, years);
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			return _helper.GetDaysInMonth(year, month, era);
		}

		public override int GetDaysInYear(int year, int era)
		{
			return _helper.GetDaysInYear(year, era);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return _helper.GetDayOfMonth(time);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return _helper.GetDayOfWeek(time);
		}

		public override int GetDayOfYear(DateTime time)
		{
			return _helper.GetDayOfYear(time);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			return _helper.GetMonthsInYear(year, era);
		}

		public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
		{
			return _helper.GetWeekOfYear(time, rule, firstDayOfWeek);
		}

		public override int GetEra(DateTime time)
		{
			return _helper.GetEra(time);
		}

		public override int GetMonth(DateTime time)
		{
			return _helper.GetMonth(time);
		}

		public override int GetYear(DateTime time)
		{
			return _helper.GetYear(time);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			return _helper.IsLeapDay(year, month, day, era);
		}

		public override bool IsLeapYear(int year, int era)
		{
			return _helper.IsLeapYear(year, era);
		}

		public override int GetLeapMonth(int year, int era)
		{
			return _helper.GetLeapMonth(year, era);
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			return _helper.IsLeapMonth(year, month, era);
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			return _helper.ToDateTime(year, month, day, hour, minute, second, millisecond, era);
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return _helper.ToFourDigitYear(year, TwoDigitYearMax);
		}
	}
	public class KoreanLunisolarCalendar : EastAsianLunisolarCalendar
	{
		public const int GregorianEra = 1;

		private static readonly DateTime s_minDate = new DateTime(918, 2, 19);

		private static readonly DateTime s_maxDate = new DateTime(new DateTime(2051, 2, 10, 23, 59, 59, 999).Ticks + 9999);

		private static readonly int[,] s_yinfo = new int[1133, 4]
		{
			{ 0, 2, 19, 21936 },
			{ 0, 2, 9, 17872 },
			{ 6, 1, 29, 41688 },
			{ 0, 2, 16, 41648 },
			{ 0, 2, 5, 43344 },
			{ 4, 1, 25, 46248 },
			{ 0, 2, 13, 27936 },
			{ 12, 2, 1, 44384 },
			{ 0, 2, 20, 43872 },
			{ 0, 2, 10, 21936 },
			{ 8, 1, 31, 17848 },
			{ 0, 2, 18, 17776 },
			{ 0, 2, 7, 21168 },
			{ 5, 1, 27, 26960 },
			{ 0, 2, 14, 59728 },
			{ 0, 2, 3, 27296 },
			{ 1, 1, 23, 44368 },
			{ 0, 2, 11, 43856 },
			{ 11, 2, 1, 21344 },
			{ 0, 2, 18, 51904 },
			{ 0, 2, 7, 58720 },
			{ 7, 1, 28, 53928 },
			{ 0, 2, 16, 53920 },
			{ 0, 2, 4, 55632 },
			{ 3, 1, 25, 23208 },
			{ 0, 2, 13, 22176 },
			{ 12, 2, 2, 42704 },
			{ 0, 2, 20, 38352 },
			{ 0, 2, 10, 19152 },
			{ 7, 1, 30, 42200 },
			{ 0, 2, 18, 42192 },
			{ 0, 2, 6, 45664 },
			{ 5, 1, 26, 46416 },
			{ 0, 2, 14, 45936 },
			{ 0, 1, 5, 43728 },
			{ 1, 1, 23, 38352 },
			{ 0, 2, 11, 38320 },
			{ 9, 2, 1, 19128 },
			{ 0, 2, 20, 18864 },
			{ 0, 2, 8, 42160 },
			{ 7, 1, 28, 43672 },
			{ 0, 2, 16, 27296 },
			{ 0, 2, 5, 44368 },
			{ 3, 1, 25, 19880 },
			{ 0, 2, 13, 11104 },
			{ 12, 2, 2, 38256 },
			{ 0, 2, 21, 41840 },
			{ 0, 2, 10, 20848 },
			{ 8, 1, 30, 25776 },
			{ 0, 2, 17, 54448 },
			{ 0, 2, 7, 23184 },
			{ 5, 1, 26, 27472 },
			{ 0, 2, 14, 22224 },
			{ 0, 2, 4, 10976 },
			{ 2, 1, 24, 37744 },
			{ 0, 2, 11, 41696 },
			{ 10, 1, 31, 51560 },
			{ 0, 2, 19, 43344 },
			{ 0, 2, 8, 54432 },
			{ 7, 1, 27, 55952 },
			{ 0, 2, 15, 46496 },
			{ 0, 2, 5, 22224 },
			{ 3, 1, 26, 10968 },
			{ 0, 2, 13, 9680 },
			{ 12, 2, 2, 37592 },
			{ 0, 2, 21, 37552 },
			{ 0, 2, 10, 43344 },
			{ 9, 1, 29, 46248 },
			{ 0, 2, 17, 44192 },
			{ 0, 2, 6, 44368 },
			{ 5, 1, 27, 21936 },
			{ 0, 2, 14, 19376 },
			{ 0, 2, 4, 9648 },
			{ 2, 1, 24, 37560 },
			{ 0, 2, 12, 21168 },
			{ 10, 1, 31, 26968 },
			{ 0, 2, 19, 22864 },
			{ 0, 2, 8, 27296 },
			{ 7, 1, 28, 43856 },
			{ 0, 2, 15, 43872 },
			{ 0, 2, 5, 19296 },
			{ 3, 1, 25, 42352 },
			{ 0, 2, 13, 9584 },
			{ 12, 2, 3, 21168 },
			{ 0, 2, 21, 53920 },
			{ 0, 2, 10, 54608 },
			{ 9, 1, 31, 23208 },
			{ 0, 2, 18, 22176 },
			{ 0, 2, 7, 38608 },
			{ 5, 1, 28, 19176 },
			{ 0, 2, 16, 19152 },
			{ 0, 2, 4, 42192 },
			{ 2, 1, 24, 53864 },
			{ 0, 2, 12, 45664 },
			{ 10, 2, 1, 46416 },
			{ 0, 2, 19, 44368 },
			{ 0, 2, 9, 13728 },
			{ 6, 1, 29, 38352 },
			{ 0, 2, 17, 38320 },
			{ 0, 2, 6, 18864 },
			{ 4, 1, 26, 42200 },
			{ 0, 2, 14, 42160 },
			{ 12, 2, 3, 43608 },
			{ 0, 2, 21, 27296 },
			{ 0, 2, 10, 44368 },
			{ 9, 1, 31, 11688 },
			{ 0, 2, 19, 11088 },
			{ 0, 2, 7, 38256 },
			{ 5, 1, 28, 18800 },
			{ 0, 2, 15, 51568 },
			{ 0, 2, 5, 25776 },
			{ 2, 1, 24, 27216 },
			{ 0, 2, 11, 55952 },
			{ 10, 2, 1, 27472 },
			{ 0, 2, 20, 26320 },
			{ 0, 2, 9, 9952 },
			{ 6, 1, 29, 37744 },
			{ 0, 2, 17, 37600 },
			{ 0, 2, 6, 51552 },
			{ 4, 1, 25, 54440 },
			{ 0, 2, 13, 54432 },
			{ 12, 2, 2, 54928 },
			{ 0, 2, 21, 46464 },
			{ 0, 2, 9, 54960 },
			{ 9, 1, 31, 9944 },
			{ 0, 2, 19, 9680 },
			{ 0, 2, 8, 37552 },
			{ 5, 1, 27, 43352 },
			{ 0, 2, 15, 43344 },
			{ 0, 2, 4, 46240 },
			{ 1, 1, 24, 46424 },
			{ 0, 2, 12, 11600 },
			{ 11, 2, 1, 21936 },
			{ 0, 2, 20, 19376 },
			{ 0, 2, 10, 9648 },
			{ 7, 1, 29, 21176 },
			{ 0, 2, 17, 21168 },
			{ 0, 2, 6, 26960 },
			{ 3, 1, 26, 27304 },
			{ 0, 2, 13, 27296 },
			{ 12, 2, 2, 43864 },
			{ 0, 2, 22, 10064 },
			{ 0, 2, 11, 19296 },
			{ 8, 1, 30, 42352 },
			{ 0, 2, 18, 42336 },
			{ 0, 2, 7, 53856 },
			{ 5, 1, 27, 59696 },
			{ 0, 2, 14, 54608 },
			{ 0, 2, 4, 23200 },
			{ 1, 1, 24, 43856 },
			{ 0, 2, 12, 38608 },
			{ 11, 2, 1, 19176 },
			{ 0, 2, 20, 18896 },
			{ 0, 2, 9, 42192 },
			{ 7, 1, 29, 53864 },
			{ 0, 2, 16, 43616 },
			{ 0, 2, 5, 46416 },
			{ 4, 1, 26, 22184 },
			{ 0, 2, 14, 13728 },
			{ 0, 2, 2, 38352 },
			{ 1, 1, 23, 19352 },
			{ 0, 2, 11, 17840 },
			{ 9, 1, 31, 42168 },
			{ 0, 2, 18, 25776 },
			{ 0, 2, 7, 43600 },
			{ 6, 1, 27, 46408 },
			{ 0, 2, 15, 27472 },
			{ 0, 2, 4, 11680 },
			{ 2, 1, 24, 38320 },
			{ 0, 2, 12, 37744 },
			{ 12, 2, 2, 18800 },
			{ 0, 2, 19, 51568 },
			{ 0, 2, 9, 25776 },
			{ 8, 1, 29, 27216 },
			{ 0, 2, 16, 55888 },
			{ 0, 2, 5, 23360 },
			{ 4, 1, 25, 43880 },
			{ 0, 2, 14, 10976 },
			{ 0, 2, 3, 58896 },
			{ 2, 1, 22, 51568 },
			{ 0, 2, 10, 51552 },
			{ 9, 1, 30, 54440 },
			{ 0, 2, 18, 21664 },
			{ 0, 2, 7, 54864 },
			{ 6, 1, 28, 23208 },
			{ 0, 2, 16, 21968 },
			{ 0, 2, 6, 9936 },
			{ 2, 1, 25, 37608 },
			{ 0, 2, 13, 37552 },
			{ 10, 2, 2, 43352 },
			{ 0, 2, 21, 43344 },
			{ 0, 2, 9, 46240 },
			{ 8, 1, 29, 46416 },
			{ 0, 2, 17, 44368 },
			{ 0, 2, 7, 21936 },
			{ 4, 1, 27, 9656 },
			{ 0, 2, 15, 17776 },
			{ 0, 2, 4, 21168 },
			{ 1, 1, 24, 43352 },
			{ 0, 2, 11, 26960 },
			{ 9, 1, 31, 29352 },
			{ 0, 2, 19, 23200 },
			{ 0, 2, 8, 43856 },
			{ 5, 1, 28, 19304 },
			{ 0, 2, 16, 19296 },
			{ 0, 2, 5, 42352 },
			{ 3, 1, 26, 21104 },
			{ 0, 2, 12, 53856 },
			{ 11, 2, 1, 59696 },
			{ 0, 2, 20, 54608 },
			{ 0, 2, 10, 23200 },
			{ 8, 1, 29, 39824 },
			{ 0, 2, 17, 38608 },
			{ 0, 2, 7, 19168 },
			{ 4, 1, 27, 42216 },
			{ 0, 2, 14, 42192 },
			{ 0, 2, 3, 53840 },
			{ 2, 1, 23, 55592 },
			{ 0, 2, 11, 46400 },
			{ 10, 1, 30, 54952 },
			{ 0, 2, 19, 11680 },
			{ 0, 2, 8, 38352 },
			{ 6, 1, 29, 19160 },
			{ 0, 2, 16, 18864 },
			{ 0, 2, 5, 42160 },
			{ 4, 1, 25, 45656 },
			{ 0, 2, 13, 27216 },
			{ 11, 2, 1, 46376 },
			{ 0, 2, 20, 27456 },
			{ 0, 2, 9, 43872 },
			{ 8, 1, 30, 38320 },
			{ 0, 2, 17, 39280 },
			{ 0, 2, 7, 18800 },
			{ 4, 1, 27, 25784 },
			{ 0, 2, 15, 21680 },
			{ 12, 2, 3, 27216 },
			{ 0, 2, 21, 55888 },
			{ 0, 2, 11, 23232 },
			{ 10, 1, 31, 43880 },
			{ 0, 2, 19, 9952 },
			{ 0, 2, 8, 37600 },
			{ 6, 1, 28, 51568 },
			{ 0, 2, 16, 51552 },
			{ 0, 2, 4, 54432 },
			{ 2, 1, 24, 55888 },
			{ 0, 2, 12, 54608 },
			{ 11, 2, 2, 22184 },
			{ 0, 2, 20, 21936 },
			{ 0, 2, 10, 9680 },
			{ 7, 1, 30, 37608 },
			{ 0, 2, 18, 37488 },
			{ 0, 2, 6, 43344 },
			{ 5, 1, 26, 54440 },
			{ 0, 2, 14, 46240 },
			{ 0, 2, 3, 46416 },
			{ 1, 1, 23, 22184 },
			{ 0, 2, 11, 19888 },
			{ 9, 2, 1, 9648 },
			{ 0, 2, 19, 42352 },
			{ 0, 2, 8, 21168 },
			{ 6, 1, 28, 43352 },
			{ 0, 2, 16, 26960 },
			{ 0, 2, 5, 27296 },
			{ 3, 1, 24, 44368 },
			{ 0, 2, 12, 43856 },
			{ 11, 2, 2, 19304 },
			{ 0, 2, 21, 19168 },
			{ 0, 2, 9, 42352 },
			{ 7, 1, 30, 21104 },
			{ 0, 2, 17, 53392 },
			{ 0, 1, 8, 29848 },
			{ 5, 1, 26, 27304 },
			{ 0, 2, 14, 23200 },
			{ 0, 2, 3, 39760 },
			{ 2, 1, 24, 19304 },
			{ 0, 2, 11, 19168 },
			{ 10, 1, 31, 42216 },
			{ 0, 2, 19, 42192 },
			{ 0, 2, 8, 53856 },
			{ 6, 1, 27, 54568 },
			{ 0, 2, 15, 46368 },
			{ 0, 2, 4, 54944 },
			{ 2, 1, 25, 22224 },
			{ 0, 2, 12, 38352 },
			{ 12, 2, 2, 18904 },
			{ 0, 2, 21, 18864 },
			{ 0, 2, 10, 42160 },
			{ 8, 1, 29, 43608 },
			{ 0, 2, 17, 27216 },
			{ 0, 2, 6, 46400 },
			{ 4, 1, 26, 46496 },
			{ 0, 2, 13, 43872 },
			{ 0, 2, 3, 38320 },
			{ 2, 1, 24, 18872 },
			{ 0, 2, 12, 18800 },
			{ 9, 1, 31, 25784 },
			{ 0, 2, 19, 21680 },
			{ 0, 2, 8, 27216 },
			{ 7, 1, 28, 27944 },
			{ 0, 2, 15, 23232 },
			{ 0, 2, 4, 43872 },
			{ 3, 1, 25, 37744 },
			{ 0, 2, 13, 37600 },
			{ 12, 2, 1, 51568 },
			{ 0, 2, 20, 51552 },
			{ 0, 2, 9, 54432 },
			{ 8, 1, 29, 55888 },
			{ 0, 2, 16, 46416 },
			{ 0, 2, 6, 22176 },
			{ 5, 1, 26, 43736 },
			{ 0, 2, 15, 9680 },
			{ 0, 2, 3, 37600 },
			{ 2, 1, 23, 51544 },
			{ 0, 2, 11, 43344 },
			{ 9, 1, 31, 54440 },
			{ 0, 2, 18, 45728 },
			{ 0, 2, 7, 46416 },
			{ 7, 1, 28, 22184 },
			{ 0, 2, 16, 19872 },
			{ 0, 2, 4, 42416 },
			{ 4, 1, 25, 21176 },
			{ 0, 2, 13, 21168 },
			{ 12, 2, 2, 43320 },
			{ 0, 2, 20, 26928 },
			{ 0, 2, 9, 27296 },
			{ 8, 1, 29, 44368 },
			{ 0, 2, 17, 44624 },
			{ 0, 2, 6, 19296 },
			{ 4, 1, 26, 42352 },
			{ 0, 2, 14, 42352 },
			{ 0, 2, 4, 21104 },
			{ 2, 1, 23, 26928 },
			{ 0, 2, 10, 58672 },
			{ 10, 1, 31, 27800 },
			{ 0, 2, 19, 23200 },
			{ 0, 2, 7, 23248 },
			{ 6, 1, 28, 19304 },
			{ 0, 2, 16, 19168 },
			{ 0, 2, 5, 42208 },
			{ 4, 1, 24, 53864 },
			{ 0, 2, 12, 53856 },
			{ 11, 2, 1, 54568 },
			{ 0, 2, 20, 46368 },
			{ 0, 2, 8, 46752 },
			{ 9, 1, 29, 22224 },
			{ 0, 2, 17, 21872 },
			{ 0, 2, 7, 18896 },
			{ 5, 1, 26, 42200 },
			{ 0, 2, 14, 42160 },
			{ 0, 2, 3, 43600 },
			{ 1, 1, 23, 46376 },
			{ 0, 2, 10, 46368 },
			{ 11, 1, 30, 46528 },
			{ 0, 2, 18, 43872 },
			{ 0, 2, 8, 38320 },
			{ 6, 1, 28, 18872 },
			{ 0, 2, 16, 18800 },
			{ 0, 2, 5, 25776 },
			{ 3, 1, 25, 27224 },
			{ 0, 2, 12, 27216 },
			{ 11, 2, 1, 27432 },
			{ 0, 2, 20, 23232 },
			{ 0, 2, 9, 43872 },
			{ 8, 1, 29, 10984 },
			{ 0, 2, 17, 18912 },
			{ 0, 2, 6, 42192 },
			{ 5, 1, 26, 53848 },
			{ 0, 2, 13, 45648 },
			{ 0, 2, 2, 46368 },
			{ 2, 1, 22, 62096 },
			{ 0, 2, 10, 46496 },
			{ 10, 1, 30, 38352 },
			{ 0, 2, 18, 38320 },
			{ 0, 2, 8, 18864 },
			{ 6, 1, 28, 42168 },
			{ 0, 2, 15, 42160 },
			{ 0, 2, 4, 43600 },
			{ 4, 1, 24, 46376 },
			{ 0, 2, 12, 27968 },
			{ 12, 1, 31, 44384 },
			{ 0, 2, 19, 43872 },
			{ 0, 2, 9, 37744 },
			{ 8, 1, 30, 2424 },
			{ 0, 2, 18, 18800 },
			{ 0, 2, 7, 25776 },
			{ 5, 1, 27, 27216 },
			{ 0, 2, 14, 55888 },
			{ 0, 2, 3, 23200 },
			{ 1, 1, 23, 43872 },
			{ 0, 2, 11, 42720 },
			{ 11, 2, 1, 37608 },
			{ 0, 2, 19, 37600 },
			{ 0, 2, 8, 51552 },
			{ 7, 1, 28, 54440 },
			{ 0, 2, 16, 54432 },
			{ 0, 2, 4, 54608 },
			{ 3, 1, 25, 23208 },
			{ 0, 2, 13, 22176 },
			{ 0, 2, 2, 42704 },
			{ 1, 1, 22, 37608 },
			{ 0, 2, 10, 37552 },
			{ 8, 1, 30, 42328 },
			{ 0, 2, 18, 43344 },
			{ 0, 2, 6, 45728 },
			{ 5, 1, 26, 46416 },
			{ 0, 2, 14, 44368 },
			{ 0, 2, 4, 19872 },
			{ 1, 1, 23, 42448 },
			{ 0, 2, 11, 42352 },
			{ 9, 2, 1, 21176 },
			{ 0, 2, 20, 21104 },
			{ 0, 2, 8, 26928 },
			{ 7, 1, 28, 27288 },
			{ 0, 2, 16, 27296 },
			{ 0, 2, 5, 43856 },
			{ 3, 1, 25, 19368 },
			{ 0, 2, 13, 19296 },
			{ 12, 2, 2, 42608 },
			{ 0, 2, 21, 41696 },
			{ 0, 2, 9, 53600 },
			{ 8, 1, 29, 59696 },
			{ 0, 2, 17, 54432 },
			{ 0, 2, 6, 55968 },
			{ 5, 1, 26, 23376 },
			{ 0, 2, 14, 22224 },
			{ 0, 2, 4, 19168 },
			{ 2, 1, 24, 41704 },
			{ 0, 2, 11, 41680 },
			{ 10, 1, 31, 53592 },
			{ 0, 2, 19, 43600 },
			{ 0, 2, 8, 46368 },
			{ 7, 1, 27, 54944 },
			{ 0, 2, 15, 44448 },
			{ 0, 2, 5, 21968 },
			{ 3, 1, 26, 18904 },
			{ 0, 2, 13, 17840 },
			{ 0, 2, 2, 41648 },
			{ 1, 1, 22, 53592 },
			{ 0, 2, 10, 43600 },
			{ 9, 1, 29, 46376 },
			{ 0, 2, 17, 27424 },
			{ 0, 2, 6, 44384 },
			{ 5, 1, 27, 21936 },
			{ 0, 2, 14, 37744 },
			{ 0, 2, 4, 17776 },
			{ 3, 1, 24, 41656 },
			{ 0, 2, 12, 21168 },
			{ 10, 1, 31, 43600 },
			{ 0, 2, 18, 55632 },
			{ 0, 2, 8, 23200 },
			{ 7, 1, 28, 43872 },
			{ 0, 2, 15, 42720 },
			{ 0, 2, 5, 21216 },
			{ 3, 1, 25, 50544 },
			{ 0, 2, 13, 42336 },
			{ 11, 2, 1, 53928 },
			{ 0, 2, 20, 53920 },
			{ 0, 2, 9, 54608 },
			{ 9, 1, 30, 23208 },
			{ 0, 2, 17, 22176 },
			{ 0, 2, 6, 42704 },
			{ 5, 1, 27, 21224 },
			{ 0, 2, 15, 21168 },
			{ 0, 2, 3, 43216 },
			{ 2, 1, 23, 53928 },
			{ 0, 2, 11, 45728 },
			{ 10, 1, 31, 46416 },
			{ 0, 2, 18, 44368 },
			{ 0, 2, 8, 19872 },
			{ 6, 1, 28, 42448 },
			{ 0, 2, 16, 42352 },
			{ 0, 2, 5, 20912 },
			{ 4, 1, 25, 43192 },
			{ 0, 2, 13, 25904 },
			{ 12, 2, 2, 27288 },
			{ 0, 2, 20, 23200 },
			{ 0, 2, 9, 43856 },
			{ 9, 1, 30, 11176 },
			{ 0, 2, 18, 11104 },
			{ 0, 2, 6, 50032 },
			{ 5, 1, 27, 20848 },
			{ 0, 2, 14, 51552 },
			{ 0, 2, 3, 58544 },
			{ 3, 1, 24, 27280 },
			{ 0, 2, 11, 55968 },
			{ 11, 2, 1, 23376 },
			{ 0, 2, 20, 22224 },
			{ 0, 2, 9, 10976 },
			{ 7, 1, 29, 41704 },
			{ 0, 2, 17, 41680 },
			{ 0, 2, 6, 53584 },
			{ 4, 1, 25, 54440 },
			{ 0, 2, 13, 46368 },
			{ 12, 2, 2, 46736 },
			{ 0, 2, 21, 44448 },
			{ 0, 2, 10, 21968 },
			{ 9, 1, 31, 9688 },
			{ 0, 2, 19, 17840 },
			{ 0, 2, 8, 41648 },
			{ 5, 1, 27, 43352 },
			{ 0, 2, 15, 43344 },
			{ 0, 2, 4, 46368 },
			{ 1, 1, 24, 46416 },
			{ 0, 2, 11, 43872 },
			{ 12, 2, 1, 21936 },
			{ 0, 2, 20, 19312 },
			{ 0, 2, 10, 17776 },
			{ 7, 1, 29, 21176 },
			{ 0, 2, 17, 21168 },
			{ 0, 2, 6, 26960 },
			{ 4, 1, 26, 27816 },
			{ 0, 2, 13, 23200 },
			{ 12, 2, 2, 39760 },
			{ 0, 2, 21, 42720 },
			{ 0, 2, 11, 19168 },
			{ 8, 1, 30, 42352 },
			{ 0, 2, 18, 42336 },
			{ 0, 2, 7, 53920 },
			{ 6, 1, 27, 59728 },
			{ 0, 2, 14, 54608 },
			{ 0, 2, 4, 22176 },
			{ 2, 1, 24, 43728 },
			{ 0, 2, 12, 38368 },
			{ 11, 2, 1, 19176 },
			{ 0, 2, 20, 18864 },
			{ 0, 2, 9, 42192 },
			{ 7, 1, 29, 53872 },
			{ 0, 2, 16, 45728 },
			{ 0, 2, 5, 46416 },
			{ 4, 1, 26, 22184 },
			{ 0, 2, 14, 11680 },
			{ 0, 2, 2, 38320 },
			{ 1, 1, 23, 19128 },
			{ 0, 2, 11, 18864 },
			{ 9, 1, 31, 42168 },
			{ 0, 2, 18, 25776 },
			{ 0, 2, 7, 27280 },
			{ 6, 1, 27, 44368 },
			{ 0, 2, 15, 27472 },
			{ 0, 2, 4, 11104 },
			{ 2, 1, 24, 38256 },
			{ 0, 2, 12, 37744 },
			{ 11, 2, 2, 18800 },
			{ 0, 2, 19, 51552 },
			{ 0, 2, 8, 58544 },
			{ 7, 1, 29, 27280 },
			{ 0, 2, 16, 55968 },
			{ 0, 2, 5, 23248 },
			{ 3, 1, 26, 11112 },
			{ 0, 2, 14, 9952 },
			{ 0, 2, 3, 37600 },
			{ 2, 1, 22, 51560 },
			{ 0, 2, 10, 51536 },
			{ 9, 1, 30, 54440 },
			{ 0, 2, 18, 46240 },
			{ 0, 2, 6, 46736 },
			{ 6, 1, 27, 22224 },
			{ 0, 2, 15, 21936 },
			{ 0, 2, 5, 9680 },
			{ 2, 1, 24, 37592 },
			{ 0, 2, 12, 37552 },
			{ 10, 2, 1, 43352 },
			{ 0, 2, 20, 26960 },
			{ 0, 2, 8, 29856 },
			{ 8, 1, 28, 46416 },
			{ 0, 2, 16, 43872 },
			{ 0, 2, 6, 21424 },
			{ 4, 1, 26, 9656 },
			{ 0, 2, 14, 9584 },
			{ 0, 2, 3, 21168 },
			{ 1, 1, 23, 43352 },
			{ 0, 2, 10, 26960 },
			{ 9, 1, 30, 27304 },
			{ 0, 2, 18, 23200 },
			{ 0, 2, 7, 43856 },
			{ 5, 1, 27, 19304 },
			{ 0, 2, 15, 19168 },
			{ 0, 2, 4, 42352 },
			{ 3, 1, 25, 21104 },
			{ 0, 2, 11, 53920 },
			{ 11, 1, 31, 55632 },
			{ 0, 2, 19, 46416 },
			{ 0, 2, 9, 22176 },
			{ 7, 1, 29, 38608 },
			{ 0, 2, 17, 38352 },
			{ 0, 2, 7, 19168 },
			{ 4, 1, 27, 42200 },
			{ 0, 2, 14, 42192 },
			{ 0, 2, 3, 53840 },
			{ 1, 1, 23, 54608 },
			{ 0, 2, 11, 46416 },
			{ 9, 1, 31, 22184 },
			{ 0, 2, 19, 11680 },
			{ 0, 2, 8, 38320 },
			{ 5, 1, 29, 18872 },
			{ 0, 2, 16, 18800 },
			{ 0, 2, 5, 42160 },
			{ 4, 1, 25, 45656 },
			{ 0, 2, 13, 27280 },
			{ 12, 2, 1, 44368 },
			{ 0, 2, 20, 23376 },
			{ 0, 2, 10, 11104 },
			{ 8, 1, 30, 38256 },
			{ 0, 2, 17, 37616 },
			{ 0, 2, 7, 18800 },
			{ 4, 1, 27, 25776 },
			{ 0, 2, 14, 54432 },
			{ 12, 2, 2, 59984 },
			{ 0, 2, 21, 54928 },
			{ 0, 2, 11, 22224 },
			{ 10, 2, 1, 11112 },
			{ 0, 2, 19, 9952 },
			{ 0, 2, 8, 21216 },
			{ 6, 1, 28, 51560 },
			{ 0, 2, 16, 51536 },
			{ 0, 2, 4, 54432 },
			{ 2, 1, 24, 55888 },
			{ 0, 2, 12, 46480 },
			{ 12, 2, 2, 22224 },
			{ 0, 2, 20, 21936 },
			{ 0, 2, 10, 9680 },
			{ 7, 1, 30, 37592 },
			{ 0, 2, 18, 37552 },
			{ 0, 2, 6, 43344 },
			{ 5, 1, 26, 46248 },
			{ 0, 2, 14, 27808 },
			{ 0, 2, 3, 44368 },
			{ 1, 1, 23, 21936 },
			{ 0, 2, 11, 19376 },
			{ 9, 2, 1, 9656 },
			{ 0, 2, 20, 9584 },
			{ 0, 2, 8, 21168 },
			{ 6, 1, 28, 43344 },
			{ 0, 2, 15, 59728 },
			{ 0, 2, 5, 27296 },
			{ 3, 1, 24, 44368 },
			{ 0, 2, 12, 43856 },
			{ 11, 2, 2, 19304 },
			{ 0, 2, 21, 19168 },
			{ 0, 2, 9, 42352 },
			{ 7, 1, 30, 21096 },
			{ 0, 2, 17, 53856 },
			{ 0, 2, 6, 55632 },
			{ 5, 1, 26, 23208 },
			{ 0, 2, 14, 22176 },
			{ 0, 2, 3, 38608 },
			{ 2, 1, 24, 19176 },
			{ 0, 2, 11, 19168 },
			{ 10, 1, 31, 42200 },
			{ 0, 2, 19, 42192 },
			{ 0, 2, 8, 53840 },
			{ 6, 1, 27, 54600 },
			{ 0, 2, 15, 46416 },
			{ 0, 2, 5, 13728 },
			{ 2, 1, 25, 38352 },
			{ 0, 2, 12, 38320 },
			{ 12, 2, 2, 18872 },
			{ 0, 2, 21, 18800 },
			{ 0, 2, 10, 42160 },
			{ 8, 1, 29, 45656 },
			{ 0, 2, 17, 27216 },
			{ 0, 2, 6, 27968 },
			{ 4, 1, 26, 44456 },
			{ 0, 2, 14, 11104 },
			{ 0, 2, 3, 37744 },
			{ 2, 1, 24, 18808 },
			{ 0, 2, 12, 18800 },
			{ 9, 1, 31, 25776 },
			{ 0, 2, 18, 54432 },
			{ 0, 2, 7, 59984 },
			{ 6, 1, 28, 27464 },
			{ 0, 2, 15, 22224 },
			{ 0, 2, 5, 11104 },
			{ 3, 1, 25, 37616 },
			{ 0, 2, 13, 37600 },
			{ 11, 2, 1, 51560 },
			{ 0, 2, 20, 43344 },
			{ 0, 2, 9, 54432 },
			{ 8, 1, 29, 55888 },
			{ 0, 2, 16, 46288 },
			{ 0, 2, 6, 22192 },
			{ 4, 1, 27, 9944 },
			{ 0, 2, 15, 9680 },
			{ 0, 2, 3, 37584 },
			{ 2, 1, 23, 51608 },
			{ 0, 2, 11, 43344 },
			{ 9, 1, 31, 46248 },
			{ 0, 2, 18, 27296 },
			{ 0, 2, 7, 44368 },
			{ 6, 1, 28, 21928 },
			{ 0, 2, 16, 19376 },
			{ 0, 2, 5, 9648 },
			{ 3, 1, 25, 21176 },
			{ 0, 2, 13, 21168 },
			{ 11, 2, 2, 43344 },
			{ 0, 2, 19, 59728 },
			{ 0, 2, 9, 27296 },
			{ 8, 1, 29, 44368 },
			{ 0, 2, 17, 39760 },
			{ 0, 2, 6, 19296 },
			{ 4, 1, 26, 42352 },
			{ 0, 2, 14, 42224 },
			{ 0, 2, 4, 21088 },
			{ 2, 1, 22, 59696 },
			{ 0, 2, 10, 54608 },
			{ 10, 1, 31, 23208 },
			{ 0, 2, 19, 22176 },
			{ 0, 2, 7, 38608 },
			{ 6, 1, 28, 19176 },
			{ 0, 2, 16, 18912 },
			{ 0, 2, 5, 42192 },
			{ 4, 1, 24, 53864 },
			{ 0, 2, 12, 53840 },
			{ 11, 2, 1, 54568 },
			{ 0, 2, 20, 46400 },
			{ 0, 2, 8, 46496 },
			{ 8, 1, 29, 38352 },
			{ 0, 2, 17, 38320 },
			{ 0, 2, 7, 18864 },
			{ 4, 1, 26, 42168 },
			{ 0, 2, 14, 42160 },
			{ 0, 2, 3, 43600 },
			{ 1, 1, 23, 46376 },
			{ 0, 2, 10, 27968 },
			{ 11, 1, 30, 44456 },
			{ 0, 2, 19, 11104 },
			{ 0, 2, 8, 37744 },
			{ 6, 1, 28, 18808 },
			{ 0, 2, 16, 18800 },
			{ 0, 2, 5, 25776 },
			{ 3, 1, 25, 27216 },
			{ 0, 2, 11, 55888 },
			{ 11, 2, 1, 27464 },
			{ 0, 2, 20, 22224 },
			{ 0, 2, 10, 11168 },
			{ 7, 1, 29, 37616 },
			{ 0, 2, 17, 37600 },
			{ 0, 2, 6, 51552 },
			{ 5, 1, 26, 54440 },
			{ 0, 2, 13, 54432 },
			{ 0, 2, 2, 55888 },
			{ 3, 1, 23, 23208 },
			{ 0, 2, 11, 22176 },
			{ 7, 1, 30, 42704 },
			{ 0, 2, 18, 42448 },
			{ 0, 2, 8, 37584 },
			{ 6, 1, 28, 43352 },
			{ 0, 2, 15, 43344 },
			{ 0, 2, 4, 46240 },
			{ 4, 1, 24, 46416 },
			{ 0, 2, 12, 44368 },
			{ 0, 2, 1, 21920 },
			{ 2, 1, 21, 42448 },
			{ 0, 2, 9, 42416 },
			{ 7, 1, 30, 21176 },
			{ 0, 2, 17, 21168 },
			{ 0, 2, 6, 26928 },
			{ 5, 1, 26, 29864 },
			{ 0, 2, 14, 27296 },
			{ 0, 2, 2, 44432 },
			{ 3, 1, 23, 19880 },
			{ 0, 2, 11, 19296 },
			{ 8, 1, 31, 42352 },
			{ 0, 2, 18, 42208 },
			{ 0, 2, 7, 53856 },
			{ 6, 1, 27, 59696 },
			{ 0, 2, 15, 54560 },
			{ 0, 2, 3, 55968 },
			{ 4, 1, 24, 27472 },
			{ 0, 2, 12, 22224 },
			{ 0, 2, 2, 19168 },
			{ 3, 1, 21, 42216 },
			{ 0, 2, 9, 42192 },
			{ 7, 1, 29, 53848 },
			{ 0, 2, 17, 45648 },
			{ 0, 2, 5, 54560 },
			{ 5, 1, 25, 54944 },
			{ 0, 2, 13, 46496 },
			{ 0, 2, 3, 21968 },
			{ 3, 1, 23, 19160 },
			{ 0, 2, 11, 18896 },
			{ 7, 1, 31, 42168 },
			{ 0, 2, 19, 42160 },
			{ 0, 2, 8, 43600 },
			{ 6, 1, 28, 46376 },
			{ 0, 2, 16, 27936 },
			{ 0, 2, 5, 44448 },
			{ 4, 1, 25, 21936 },
			{ 0, 2, 13, 37744 },
			{ 0, 2, 3, 18800 },
			{ 3, 1, 23, 25784 },
			{ 0, 2, 10, 42192 },
			{ 7, 1, 30, 27216 },
			{ 0, 2, 17, 55888 },
			{ 0, 2, 7, 23200 },
			{ 5, 1, 26, 43872 },
			{ 0, 2, 14, 43744 },
			{ 0, 2, 4, 37600 },
			{ 3, 1, 24, 51568 },
			{ 0, 2, 11, 51552 },
			{ 8, 1, 31, 54440 },
			{ 0, 2, 19, 54432 },
			{ 0, 2, 8, 54608 },
			{ 6, 1, 28, 23208 },
			{ 0, 2, 16, 22176 },
			{ 0, 2, 5, 42704 },
			{ 4, 1, 26, 21224 },
			{ 0, 2, 13, 21200 },
			{ 0, 2, 2, 43344 },
			{ 3, 1, 22, 58536 },
			{ 0, 2, 10, 46240 },
			{ 7, 1, 29, 46416 },
			{ 0, 2, 17, 40272 },
			{ 0, 2, 7, 21920 },
			{ 5, 1, 27, 42448 },
			{ 0, 2, 14, 42416 },
			{ 0, 2, 4, 21168 },
			{ 4, 1, 24, 43192 },
			{ 0, 2, 12, 26928 },
			{ 9, 1, 31, 27288 },
			{ 0, 2, 19, 27296 },
			{ 0, 2, 8, 43856 },
			{ 6, 1, 29, 19880 },
			{ 0, 2, 16, 19296 },
			{ 0, 2, 5, 42352 },
			{ 4, 1, 26, 20848 },
			{ 0, 2, 13, 53600 },
			{ 0, 2, 1, 59696 },
			{ 3, 1, 22, 27280 },
			{ 0, 2, 9, 55968 },
			{ 7, 1, 30, 23376 },
			{ 0, 2, 17, 22224 },
			{ 0, 2, 7, 19168 },
			{ 5, 1, 27, 42200 },
			{ 0, 2, 15, 41680 },
			{ 0, 2, 3, 53584 },
			{ 4, 1, 23, 54568 },
			{ 0, 2, 11, 46368 },
			{ 9, 1, 31, 54928 },
			{ 0, 2, 18, 44448 },
			{ 0, 2, 8, 21968 },
			{ 6, 1, 29, 10968 },
			{ 0, 2, 17, 17840 },
			{ 0, 2, 5, 41648 },
			{ 5, 1, 25, 45400 },
			{ 0, 2, 13, 43344 },
			{ 0, 2, 2, 46368 },
			{ 2, 1, 21, 46480 },
			{ 0, 2, 9, 44384 },
			{ 7, 1, 30, 21936 },
			{ 0, 2, 18, 21360 },
			{ 0, 2, 7, 17776 },
			{ 5, 1, 27, 25272 },
			{ 0, 2, 15, 21168 },
			{ 0, 2, 4, 26960 },
			{ 3, 1, 23, 27816 },
			{ 0, 2, 11, 23200 },
			{ 10, 1, 31, 43856 },
			{ 0, 2, 19, 42704 },
			{ 0, 2, 8, 19168 },
			{ 6, 1, 28, 38256 },
			{ 0, 2, 16, 42336 },
			{ 0, 2, 5, 53920 },
			{ 5, 1, 24, 59728 },
			{ 0, 2, 12, 54608 },
			{ 0, 2, 2, 23200 },
			{ 3, 1, 22, 43856 },
			{ 0, 2, 9, 42704 },
			{ 7, 1, 30, 19176 },
			{ 0, 2, 18, 19120 },
			{ 0, 2, 7, 43216 },
			{ 5, 1, 26, 53928 },
			{ 0, 2, 14, 45728 },
			{ 0, 2, 3, 46416 },
			{ 4, 1, 24, 22184 },
			{ 0, 2, 11, 19872 },
			{ 0, 1, 31, 38352 },
			{ 2, 1, 21, 19128 },
			{ 0, 2, 9, 18864 },
			{ 6, 1, 28, 43192 },
			{ 0, 2, 16, 25776 },
			{ 0, 2, 5, 27280 },
			{ 4, 1, 25, 46416 },
			{ 0, 2, 13, 27472 },
			{ 0, 2, 3, 11168 },
			{ 2, 1, 23, 38320 },
			{ 0, 2, 11, 37744 },
			{ 6, 1, 31, 20848 },
			{ 0, 2, 18, 53600 },
			{ 0, 2, 7, 58544 },
			{ 5, 1, 28, 27280 },
			{ 0, 2, 14, 55952 },
			{ 0, 2, 4, 23376 },
			{ 3, 1, 25, 11112 },
			{ 0, 2, 13, 10976 },
			{ 0, 2, 1, 41696 },
			{ 2, 1, 21, 53608 },
			{ 0, 2, 9, 51536 },
			{ 6, 1, 29, 54440 },
			{ 0, 2, 16, 46368 },
			{ 0, 2, 5, 46736 },
			{ 4, 1, 26, 22224 },
			{ 0, 2, 14, 21968 },
			{ 0, 2, 3, 9680 },
			{ 3, 1, 23, 41688 },
			{ 0, 2, 11, 41648 },
			{ 7, 1, 31, 43352 },
			{ 0, 2, 18, 43344 },
			{ 0, 2, 7, 46240 },
			{ 5, 1, 27, 46416 },
			{ 0, 2, 15, 44368 },
			{ 0, 2, 4, 21936 },
			{ 4, 1, 25, 9656 },
			{ 0, 2, 13, 9584 },
			{ 9, 2, 2, 21176 },
			{ 0, 2, 20, 21168 },
			{ 0, 2, 9, 26960 },
			{ 6, 1, 29, 27816 },
			{ 0, 2, 17, 23200 },
			{ 0, 2, 5, 43856 },
			{ 4, 1, 26, 21352 },
			{ 0, 2, 14, 19168 },
			{ 0, 2, 3, 42352 },
			{ 3, 1, 23, 21168 },
			{ 0, 2, 10, 53920 },
			{ 7, 1, 30, 59728 },
			{ 0, 2, 18, 54608 },
			{ 0, 2, 7, 23200 },
			{ 5, 1, 27, 43728 },
			{ 0, 2, 15, 38352 },
			{ 0, 2, 5, 19168 },
			{ 4, 1, 24, 42328 },
			{ 0, 2, 12, 42192 },
			{ 8, 2, 1, 53848 },
			{ 0, 2, 20, 45712 },
			{ 0, 2, 8, 46416 },
			{ 7, 1, 29, 22184 },
			{ 0, 2, 17, 11680 },
			{ 0, 2, 6, 38352 },
			{ 5, 1, 26, 19128 },
			{ 0, 2, 14, 18864 },
			{ 0, 2, 3, 42160 },
			{ 3, 1, 23, 45656 },
			{ 0, 2, 10, 27280 },
			{ 8, 1, 30, 44360 },
			{ 0, 2, 18, 27472 },
			{ 0, 2, 8, 11104 },
			{ 5, 1, 27, 38320 },
			{ 0, 2, 15, 37744 },
			{ 0, 2, 5, 18800 },
			{ 4, 1, 25, 25776 },
			{ 0, 2, 11, 58528 },
			{ 10, 1, 31, 59984 },
			{ 0, 2, 19, 55952 },
			{ 0, 2, 9, 23248 },
			{ 6, 1, 29, 11112 },
			{ 0, 2, 17, 10976 },
			{ 0, 2, 6, 37600 },
			{ 5, 1, 26, 51560 },
			{ 0, 2, 13, 51536 },
			{ 0, 2, 2, 54432 },
			{ 3, 1, 22, 55888 },
			{ 0, 2, 10, 46736 },
			{ 7, 1, 30, 22224 },
			{ 0, 2, 18, 21936 },
			{ 0, 2, 8, 9680 },
			{ 5, 1, 28, 37592 },
			{ 0, 2, 15, 37552 },
			{ 0, 2, 4, 43344 },
			{ 4, 1, 24, 54440 },
			{ 0, 2, 12, 46240 },
			{ 0, 1, 31, 46416 },
			{ 2, 1, 21, 22184 },
			{ 0, 2, 9, 21936 },
			{ 6, 1, 30, 9656 },
			{ 0, 2, 17, 9584 },
			{ 0, 2, 6, 21168 },
			{ 5, 1, 26, 43344 },
			{ 0, 2, 13, 59728 },
			{ 0, 2, 2, 27296 },
			{ 3, 1, 22, 44368 },
			{ 0, 2, 10, 43856 },
			{ 8, 1, 31, 19304 },
			{ 0, 2, 19, 19168 },
			{ 0, 2, 8, 42352 },
			{ 5, 1, 29, 21096 },
			{ 0, 2, 16, 53856 },
			{ 0, 2, 4, 55632 },
			{ 4, 1, 25, 27304 },
			{ 0, 2, 13, 22176 },
			{ 0, 2, 2, 39632 },
			{ 2, 1, 22, 19176 },
			{ 0, 2, 10, 19168 },
			{ 6, 1, 30, 42200 },
			{ 0, 2, 18, 42192 },
			{ 0, 2, 6, 53840 },
			{ 5, 1, 26, 55624 },
			{ 0, 2, 14, 46416 },
			{ 0, 2, 4, 22176 },
			{ 2, 1, 23, 38608 },
			{ 0, 2, 11, 38352 },
			{ 7, 2, 1, 19160 },
			{ 0, 2, 20, 18864 },
			{ 0, 2, 8, 42160 },
			{ 5, 1, 28, 45656 },
			{ 0, 2, 16, 27280 },
			{ 0, 2, 5, 44352 },
			{ 4, 1, 24, 46504 },
			{ 0, 2, 13, 11104 },
			{ 0, 2, 2, 38320 },
			{ 2, 1, 23, 18872 },
			{ 0, 2, 10, 18800 },
			{ 6, 1, 30, 25776 },
			{ 0, 2, 17, 58528 },
			{ 0, 2, 6, 59984 },
			{ 5, 1, 26, 27976 },
			{ 0, 2, 14, 23376 },
			{ 0, 2, 4, 11104 },
			{ 3, 1, 24, 38256 },
			{ 0, 2, 11, 37600 },
			{ 7, 1, 31, 51560 },
			{ 0, 2, 19, 51536 },
			{ 0, 2, 8, 54432 },
			{ 6, 1, 27, 55888 },
			{ 0, 2, 15, 46736 },
			{ 0, 2, 5, 22224 },
			{ 4, 1, 26, 10968 },
			{ 0, 2, 13, 9680 },
			{ 0, 2, 2, 37584 },
			{ 2, 1, 22, 51544 },
			{ 0, 2, 10, 43344 },
			{ 7, 1, 29, 54440 },
			{ 0, 2, 17, 46240 },
			{ 0, 2, 6, 46416 },
			{ 5, 1, 27, 22184 },
			{ 0, 2, 14, 19888 },
			{ 0, 2, 4, 9648 },
			{ 3, 1, 24, 37560 },
			{ 0, 2, 12, 21168 },
			{ 8, 1, 31, 43352 },
			{ 0, 2, 19, 26960 },
			{ 0, 2, 8, 27296 },
			{ 6, 1, 28, 44368 },
			{ 0, 2, 15, 43856 },
			{ 0, 2, 5, 19296 },
			{ 4, 1, 25, 42352 },
			{ 0, 2, 13, 42352 },
			{ 0, 2, 2, 21104 },
			{ 3, 1, 22, 26928 },
			{ 0, 2, 9, 55632 },
			{ 7, 1, 30, 27304 },
			{ 0, 2, 17, 22176 },
			{ 0, 2, 6, 39632 },
			{ 5, 1, 27, 19176 },
			{ 0, 2, 15, 19168 },
			{ 0, 2, 3, 42208 },
			{ 4, 1, 23, 53864 },
			{ 0, 2, 11, 53840 },
			{ 8, 1, 31, 54600 },
			{ 0, 2, 18, 46400 },
			{ 0, 2, 7, 54944 },
			{ 6, 1, 28, 38608 },
			{ 0, 2, 16, 38320 },
			{ 0, 2, 5, 18864 },
			{ 4, 1, 25, 42200 },
			{ 0, 2, 13, 42160 },
			{ 10, 2, 2, 45656 },
			{ 0, 2, 20, 27216 },
			{ 0, 2, 9, 27968 },
			{ 6, 1, 29, 46504 },
			{ 0, 2, 18, 11104 },
			{ 0, 2, 6, 38320 },
			{ 5, 1, 27, 18872 },
			{ 0, 2, 15, 18800 },
			{ 0, 2, 4, 25776 },
			{ 3, 1, 23, 27216 },
			{ 0, 2, 10, 59984 },
			{ 8, 1, 31, 27976 },
			{ 0, 2, 19, 23248 },
			{ 0, 2, 8, 11104 },
			{ 5, 1, 28, 37744 },
			{ 0, 2, 16, 37600 },
			{ 0, 2, 5, 51552 },
			{ 4, 1, 24, 58536 },
			{ 0, 2, 12, 54432 },
			{ 0, 2, 1, 55888 },
			{ 2, 1, 22, 23208 },
			{ 0, 2, 9, 22208 },
			{ 7, 1, 29, 43736 },
			{ 0, 2, 18, 9680 },
			{ 0, 2, 7, 37584 },
			{ 5, 1, 26, 51544 },
			{ 0, 2, 14, 43344 },
			{ 0, 2, 3, 46240 },
			{ 3, 1, 23, 47696 },
			{ 0, 2, 10, 46416 },
			{ 9, 1, 31, 21928 },
			{ 0, 2, 19, 19360 },
			{ 0, 2, 8, 42416 },
			{ 5, 1, 28, 21176 },
			{ 0, 2, 16, 21168 },
			{ 0, 2, 5, 43344 },
			{ 4, 1, 25, 46248 },
			{ 0, 2, 12, 27296 },
			{ 0, 2, 1, 44368 },
			{ 2, 1, 22, 21928 },
			{ 0, 2, 10, 19296 },
			{ 6, 1, 29, 42352 },
			{ 0, 2, 17, 42352 },
			{ 0, 2, 7, 21104 },
			{ 5, 1, 27, 26928 },
			{ 0, 2, 13, 55600 },
			{ 0, 2, 3, 23200 },
			{ 3, 1, 23, 43856 },
			{ 0, 2, 11, 38608 },
			{ 11, 1, 31, 19176 },
			{ 0, 2, 19, 19168 },
			{ 0, 2, 8, 42192 },
			{ 6, 1, 28, 53864 },
			{ 0, 2, 15, 53840 },
			{ 0, 2, 4, 54560 },
			{ 5, 1, 24, 55968 },
			{ 0, 2, 12, 46752 },
			{ 0, 2, 1, 38608 },
			{ 2, 1, 22, 19160 },
			{ 0, 2, 10, 18864 },
			{ 7, 1, 30, 42168 },
			{ 0, 2, 17, 42160 },
			{ 0, 2, 6, 45648 },
			{ 5, 1, 26, 46376 },
			{ 0, 2, 14, 27968 },
			{ 0, 2, 2, 44448 },
			{ 3, 1, 23, 38320 }
		};

		public override DateTime MinSupportedDateTime => s_minDate;

		public override DateTime MaxSupportedDateTime => s_maxDate;

		protected override int DaysInYearBeforeMinSupportedYear => 384;

		internal override int MinCalendarYear => 918;

		internal override int MaxCalendarYear => 2050;

		internal override DateTime MinDate => s_minDate;

		internal override DateTime MaxDate => s_maxDate;

		internal override EraInfo[]? CalEraInfo => null;

		internal override CalendarId BaseCalendarID => CalendarId.KOREA;

		internal override CalendarId ID => CalendarId.KOREANLUNISOLAR;

		public override int[] Eras => new int[1] { 1 };

		internal override int GetYearInfo(int lunarYear, int index)
		{
			if (lunarYear < 918 || lunarYear > 2050)
			{
				throw new ArgumentOutOfRangeException("year", lunarYear, SR.Format(SR.ArgumentOutOfRange_Range, 918, 2050));
			}
			return s_yinfo[lunarYear - 918, index];
		}

		internal override int GetYear(int year, DateTime time)
		{
			return year;
		}

		internal override int GetGregorianYear(int year, int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
			if (year < 918 || year > 2050)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 918, 2050));
			}
			return year;
		}

		public override int GetEra(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			return 1;
		}
	}
	internal static class Normalization
	{
		internal static bool IsNormalized(string strInput, NormalizationForm normalizationForm)
		{
			if (GlobalizationMode.Invariant)
			{
				return true;
			}
			if (!GlobalizationMode.UseNls)
			{
				return IcuIsNormalized(strInput, normalizationForm);
			}
			return NlsIsNormalized(strInput, normalizationForm);
		}

		internal static string Normalize(string strInput, NormalizationForm normalizationForm)
		{
			if (GlobalizationMode.Invariant)
			{
				return strInput;
			}
			if (!GlobalizationMode.UseNls)
			{
				return IcuNormalize(strInput, normalizationForm);
			}
			return NlsNormalize(strInput, normalizationForm);
		}

		private unsafe static bool IcuIsNormalized(string strInput, NormalizationForm normalizationForm)
		{
			ValidateArguments(strInput, normalizationForm);
			int num;
			fixed (char* src = strInput)
			{
				num = Interop.Globalization.IsNormalized(normalizationForm, src, strInput.Length);
			}
			if (num == -1)
			{
				throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, "strInput");
			}
			return num == 1;
		}

		private unsafe static string IcuNormalize(string strInput, NormalizationForm normalizationForm)
		{
			ValidateArguments(strInput, normalizationForm);
			char[] array = null;
			try
			{
				Span<char> span = ((strInput.Length > 512) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(strInput.Length))) : stackalloc char[512]);
				Span<char> span2 = span;
				for (int i = 0; i < 2; i++)
				{
					int num;
					fixed (char* src = strInput)
					{
						fixed (char* dstBuffer = &MemoryMarshal.GetReference(span2))
						{
							num = Interop.Globalization.NormalizeString(normalizationForm, src, strInput.Length, dstBuffer, span2.Length);
						}
					}
					if (num == -1)
					{
						throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, "strInput");
					}
					if (num <= span2.Length)
					{
						ReadOnlySpan<char> readOnlySpan = span2.Slice(0, num);
						return readOnlySpan.SequenceEqual(strInput) ? strInput : new string(readOnlySpan);
					}
					if (i == 0)
					{
						if (array != null)
						{
							char[] array2 = array;
							array = null;
							ArrayPool<char>.Shared.Return(array2);
						}
						span2 = (array = ArrayPool<char>.Shared.Rent(num));
					}
				}
				throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, "strInput");
			}
			finally
			{
				if (array != null)
				{
					ArrayPool<char>.Shared.Return(array);
				}
			}
		}

		private static void ValidateArguments(string strInput, NormalizationForm normalizationForm)
		{
			if (OperatingSystem.IsBrowser())
			{
			}
			if (normalizationForm != NormalizationForm.FormC && normalizationForm != NormalizationForm.FormD && normalizationForm != NormalizationForm.FormKC && normalizationForm != NormalizationForm.FormKD)
			{
				throw new ArgumentException(SR.Argument_InvalidNormalizationForm, "normalizationForm");
			}
			if (HasInvalidUnicodeSequence(strInput))
			{
				throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, "strInput");
			}
		}

		private static bool HasInvalidUnicodeSequence(string s)
		{
			for (int i = 0; i < s.Length; i++)
			{
				char c = s[i];
				if (c < '\ud800')
				{
					continue;
				}
				if (c == '\ufffe')
				{
					return true;
				}
				if (char.IsLowSurrogate(c))
				{
					return true;
				}
				if (char.IsHighSurrogate(c))
				{
					if (i + 1 >= s.Length || !char.IsLowSurrogate(s[i + 1]))
					{
						return true;
					}
					i++;
				}
			}
			return false;
		}

		private unsafe static bool NlsIsNormalized(string strInput, NormalizationForm normalizationForm)
		{
			Interop.BOOL bOOL;
			fixed (char* source = strInput)
			{
				bOOL = Interop.Normaliz.IsNormalizedString(normalizationForm, source, strInput.Length);
			}
			int lastPInvokeError = Marshal.GetLastPInvokeError();
			switch (lastPInvokeError)
			{
			case 87:
			case 1113:
				if (normalizationForm != NormalizationForm.FormC && normalizationForm != NormalizationForm.FormD && normalizationForm != NormalizationForm.FormKC && normalizationForm != NormalizationForm.FormKD)
				{
					throw new ArgumentException(SR.Argument_InvalidNormalizationForm, "normalizationForm");
				}
				throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, "strInput");
			case 8:
				throw new OutOfMemoryException();
			default:
				throw new InvalidOperationException(SR.Format(SR.UnknownError_Num, lastPInvokeError));
			case 0:
				return bOOL != Interop.BOOL.FALSE;
			}
		}

		private unsafe static string NlsNormalize(string strInput, NormalizationForm normalizationForm)
		{
			if (strInput.Length == 0)
			{
				return string.Empty;
			}
			char[] array = null;
			try
			{
				Span<char> span = ((strInput.Length > 512) ? ((Span<char>)(array = ArrayPool<char>.Shared.Rent(strInput.Length))) : stackalloc char[512]);
				Span<char> span2 = span;
				while (true)
				{
					int num;
					fixed (char* source = strInput)
					{
						fixed (char* destination = &MemoryMarshal.GetReference(span2))
						{
							num = Interop.Normaliz.NormalizeString(normalizationForm, source, strInput.Length, destination, span2.Length);
						}
					}
					int lastPInvokeError = Marshal.GetLastPInvokeError();
					switch (lastPInvokeError)
					{
					case 0:
					{
						ReadOnlySpan<char> readOnlySpan = span2.Slice(0, num);
						return readOnlySpan.SequenceEqual(strInput) ? strInput : new string(readOnlySpan);
					}
					case 122:
						num = Math.Abs(num);
						if (array != null)
						{
							char[] array2 = array;
							array = null;
							ArrayPool<char>.Shared.Return(array2);
						}
						break;
					case 87:
					case 1113:
						if (normalizationForm != NormalizationForm.FormC && normalizationForm != NormalizationForm.FormD && normalizationForm != NormalizationForm.FormKC && normalizationForm != NormalizationForm.FormKD)
						{
							throw new ArgumentException(SR.Argument_InvalidNormalizationForm, "normalizationForm");
						}
						throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex, "strInput");
					case 8:
						throw new OutOfMemoryException();
					default:
						throw new InvalidOperationException(SR.Format(SR.UnknownError_Num, lastPInvokeError));
					}
					span2 = (array = ArrayPool<char>.Shared.Rent(num));
				}
			}
			finally
			{
				if (array != null)
				{
					ArrayPool<char>.Shared.Return(array);
				}
			}
		}
	}
	public sealed class NumberFormatInfo : IFormatProvider, ICloneable
	{
		private static volatile NumberFormatInfo s_invariantInfo;

		internal int[] _numberGroupSizes = new int[1] { 3 };

		internal int[] _currencyGroupSizes = new int[1] { 3 };

		internal int[] _percentGroupSizes = new int[1] { 3 };

		internal string _positiveSign = "+";

		internal string _negativeSign = "-";

		internal string _numberDecimalSeparator = ".";

		internal string _numberGroupSeparator = ",";

		internal string _currencyGroupSeparator = ",";

		internal string _currencyDecimalSeparator = ".";

		internal string _currencySymbol = "¤";

		internal string _nanSymbol = "NaN";

		internal string _positiveInfinitySymbol = "Infinity";

		internal string _negativeInfinitySymbol = "-Infinity";

		internal string _percentDecimalSeparator = ".";

		internal string _percentGroupSeparator = ",";

		internal string _percentSymbol = "%";

		internal string _perMilleSymbol = "‰";

		internal string[] _nativeDigits = new string[10] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };

		internal int _numberDecimalDigits = 2;

		internal int _currencyDecimalDigits = 2;

		internal int _currencyPositivePattern;

		internal int _currencyNegativePattern;

		internal int _numberNegativePattern = 1;

		internal int _percentPositivePattern;

		internal int _percentNegativePattern;

		internal int _percentDecimalDigits = 2;

		internal int _digitSubstitution = 1;

		internal bool _isReadOnly;

		private bool _hasInvariantNumberSigns = true;

		private bool _allowHyphenDuringParsing;

		internal bool HasInvariantNumberSigns => _hasInvariantNumberSigns;

		internal bool AllowHyphenDuringParsing => _allowHyphenDuringParsing;

		public static NumberFormatInfo InvariantInfo
		{
			get
			{
				object obj = s_invariantInfo;
				if (obj == null)
				{
					obj = new NumberFormatInfo
					{
						_isReadOnly = true
					};
					s_invariantInfo = (NumberFormatInfo)obj;
				}
				return (NumberFormatInfo)obj;
			}
		}

		public int CurrencyDecimalDigits
		{
			get
			{
				return _currencyDecimalDigits;
			}
			set
			{
				if (value < 0 || value > 99)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 0, 99));
				}
				VerifyWritable();
				_currencyDecimalDigits = value;
			}
		}

		public string CurrencyDecimalSeparator
		{
			get
			{
				return _currencyDecimalSeparator;
			}
			set
			{
				VerifyWritable();
				VerifyDecimalSeparator(value, "value");
				_currencyDecimalSeparator = value;
			}
		}

		public bool IsReadOnly => _isReadOnly;

		public int[] CurrencyGroupSizes
		{
			get
			{
				return (int[])_currencyGroupSizes.Clone();
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				int[] array = (int[])value.Clone();
				CheckGroupSize("value", array);
				_currencyGroupSizes = array;
			}
		}

		public int[] NumberGroupSizes
		{
			get
			{
				return (int[])_numberGroupSizes.Clone();
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				int[] array = (int[])value.Clone();
				CheckGroupSize("value", array);
				_numberGroupSizes = array;
			}
		}

		public int[] PercentGroupSizes
		{
			get
			{
				return (int[])_percentGroupSizes.Clone();
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				int[] array = (int[])value.Clone();
				CheckGroupSize("value", array);
				_percentGroupSizes = array;
			}
		}

		public string CurrencyGroupSeparator
		{
			get
			{
				return _currencyGroupSeparator;
			}
			set
			{
				VerifyWritable();
				VerifyGroupSeparator(value, "value");
				_currencyGroupSeparator = value;
			}
		}

		public string CurrencySymbol
		{
			get
			{
				return _currencySymbol;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_currencySymbol = value;
			}
		}

		public static NumberFormatInfo CurrentInfo
		{
			get
			{
				CultureInfo currentCulture = CultureInfo.CurrentCulture;
				if (!currentCulture._isInherited)
				{
					NumberFormatInfo numInfo = currentCulture._numInfo;
					if (numInfo != null)
					{
						return numInfo;
					}
				}
				return (NumberFormatInfo)currentCulture.GetFormat(typeof(NumberFormatInfo));
			}
		}

		public string NaNSymbol
		{
			get
			{
				return _nanSymbol;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_nanSymbol = value;
			}
		}

		public int CurrencyNegativePattern
		{
			get
			{
				return _currencyNegativePattern;
			}
			set
			{
				if (value < 0 || value > 15)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 0, 15));
				}
				VerifyWritable();
				_currencyNegativePattern = value;
			}
		}

		public int NumberNegativePattern
		{
			get
			{
				return _numberNegativePattern;
			}
			set
			{
				if (value < 0 || value > 4)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 0, 4));
				}
				VerifyWritable();
				_numberNegativePattern = value;
			}
		}

		public int PercentPositivePattern
		{
			get
			{
				return _percentPositivePattern;
			}
			set
			{
				if (value < 0 || value > 3)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 0, 3));
				}
				VerifyWritable();
				_percentPositivePattern = value;
			}
		}

		public int PercentNegativePattern
		{
			get
			{
				return _percentNegativePattern;
			}
			set
			{
				if (value < 0 || value > 11)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 0, 11));
				}
				VerifyWritable();
				_percentNegativePattern = value;
			}
		}

		public string NegativeInfinitySymbol
		{
			get
			{
				return _negativeInfinitySymbol;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_negativeInfinitySymbol = value;
			}
		}

		public string NegativeSign
		{
			get
			{
				return _negativeSign;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_negativeSign = value;
				InitializeInvariantAndNegativeSignFlags();
			}
		}

		public int NumberDecimalDigits
		{
			get
			{
				return _numberDecimalDigits;
			}
			set
			{
				if (value < 0 || value > 99)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 0, 99));
				}
				VerifyWritable();
				_numberDecimalDigits = value;
			}
		}

		public string NumberDecimalSeparator
		{
			get
			{
				return _numberDecimalSeparator;
			}
			set
			{
				VerifyWritable();
				VerifyDecimalSeparator(value, "value");
				_numberDecimalSeparator = value;
			}
		}

		public string NumberGroupSeparator
		{
			get
			{
				return _numberGroupSeparator;
			}
			set
			{
				VerifyWritable();
				VerifyGroupSeparator(value, "value");
				_numberGroupSeparator = value;
			}
		}

		public int CurrencyPositivePattern
		{
			get
			{
				return _currencyPositivePattern;
			}
			set
			{
				if (value < 0 || value > 3)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 0, 3));
				}
				VerifyWritable();
				_currencyPositivePattern = value;
			}
		}

		public string PositiveInfinitySymbol
		{
			get
			{
				return _positiveInfinitySymbol;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_positiveInfinitySymbol = value;
			}
		}

		public string PositiveSign
		{
			get
			{
				return _positiveSign;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_positiveSign = value;
				InitializeInvariantAndNegativeSignFlags();
			}
		}

		public int PercentDecimalDigits
		{
			get
			{
				return _percentDecimalDigits;
			}
			set
			{
				if (value < 0 || value > 99)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 0, 99));
				}
				VerifyWritable();
				_percentDecimalDigits = value;
			}
		}

		public string PercentDecimalSeparator
		{
			get
			{
				return _percentDecimalSeparator;
			}
			set
			{
				VerifyWritable();
				VerifyDecimalSeparator(value, "value");
				_percentDecimalSeparator = value;
			}
		}

		public string PercentGroupSeparator
		{
			get
			{
				return _percentGroupSeparator;
			}
			set
			{
				VerifyWritable();
				VerifyGroupSeparator(value, "value");
				_percentGroupSeparator = value;
			}
		}

		public string PercentSymbol
		{
			get
			{
				return _percentSymbol;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_percentSymbol = value;
			}
		}

		public string PerMilleSymbol
		{
			get
			{
				return _perMilleSymbol;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_perMilleSymbol = value;
			}
		}

		public string[] NativeDigits
		{
			get
			{
				return (string[])_nativeDigits.Clone();
			}
			set
			{
				VerifyWritable();
				VerifyNativeDigits(value, "value");
				_nativeDigits = value;
			}
		}

		public DigitShapes DigitSubstitution
		{
			get
			{
				return (DigitShapes)_digitSubstitution;
			}
			set
			{
				VerifyWritable();
				VerifyDigitSubstitution(value, "value");
				_digitSubstitution = (int)value;
			}
		}

		public NumberFormatInfo()
		{
		}

		private static void VerifyDecimalSeparator(string decSep, string propertyName)
		{
			if (decSep == null)
			{
				throw new ArgumentNullException(propertyName);
			}
			if (decSep.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyDecString, propertyName);
			}
		}

		private static void VerifyGroupSeparator(string groupSep, string propertyName)
		{
			if (groupSep == null)
			{
				throw new ArgumentNullException(propertyName);
			}
		}

		private static void VerifyNativeDigits(string[] nativeDig, string propertyName)
		{
			if (nativeDig == null)
			{
				throw new ArgumentNullException(propertyName, SR.ArgumentNull_Array);
			}
			if (nativeDig.Length != 10)
			{
				throw new ArgumentException(SR.Argument_InvalidNativeDigitCount, propertyName);
			}
			for (int i = 0; i < nativeDig.Length; i++)
			{
				if (nativeDig[i] == null)
				{
					throw new ArgumentNullException(propertyName, SR.ArgumentNull_ArrayValue);
				}
				if (nativeDig[i].Length != 1)
				{
					if (nativeDig[i].Length != 2)
					{
						throw new ArgumentException(SR.Argument_InvalidNativeDigitValue, propertyName);
					}
					if (!char.IsSurrogatePair(nativeDig[i][0], nativeDig[i][1]))
					{
						throw new ArgumentException(SR.Argument_InvalidNativeDigitValue, propertyName);
					}
				}
				if (CharUnicodeInfo.GetDecimalDigitValue(nativeDig[i], 0) != i && CharUnicodeInfo.GetUnicodeCategory(nativeDig[i], 0) != UnicodeCategory.PrivateUse)
				{
					throw new ArgumentException(SR.Argument_InvalidNativeDigitValue, propertyName);
				}
			}
		}

		private static void VerifyDigitSubstitution(DigitShapes digitSub, string propertyName)
		{
			if ((uint)digitSub > 2u)
			{
				throw new ArgumentException(SR.Argument_InvalidDigitSubstitution, propertyName);
			}
		}

		private void InitializeInvariantAndNegativeSignFlags()
		{
			_hasInvariantNumberSigns = _positiveSign == "+" && _negativeSign == "-";
			bool flag = _negativeSign.Length == 1;
			bool flag2 = flag;
			if (flag2)
			{
				bool flag3;
				switch (_negativeSign[0])
				{
				case '‒':
				case '⁻':
				case '₋':
				case '−':
				case '➖':
				case '﹣':
				case '－':
					flag3 = true;
					break;
				default:
					flag3 = false;
					break;
				}
				flag2 = flag3;
			}
			_allowHyphenDuringParsing = flag2;
		}

		internal NumberFormatInfo(CultureData cultureData)
		{
			if (cultureData != null)
			{
				cultureData.GetNFIValues(this);
				InitializeInvariantAndNegativeSignFlags();
			}
		}

		private void VerifyWritable()
		{
			if (_isReadOnly)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
			}
		}

		public static NumberFormatInfo GetInstance(IFormatProvider? formatProvider)
		{
			if (formatProvider != null)
			{
				return GetProviderNonNull(formatProvider);
			}
			return CurrentInfo;
			static NumberFormatInfo GetProviderNonNull(IFormatProvider provider)
			{
				if (provider is CultureInfo cultureInfo && !cultureInfo._isInherited)
				{
					return cultureInfo._numInfo ?? cultureInfo.NumberFormat;
				}
				return (provider as NumberFormatInfo) ?? (provider.GetFormat(typeof(NumberFormatInfo)) as NumberFormatInfo) ?? CurrentInfo;
			}
		}

		public object Clone()
		{
			NumberFormatInfo numberFormatInfo = (NumberFormatInfo)MemberwiseClone();
			numberFormatInfo._isReadOnly = false;
			return numberFormatInfo;
		}

		internal static void CheckGroupSize(string propName, int[] groupSize)
		{
			for (int i = 0; i < groupSize.Length; i++)
			{
				if (groupSize[i] < 1)
				{
					if (i == groupSize.Length - 1 && groupSize[i] == 0)
					{
						break;
					}
					throw new ArgumentException(SR.Argument_InvalidGroupSize, propName);
				}
				if (groupSize[i] > 9)
				{
					throw new ArgumentException(SR.Argument_InvalidGroupSize, propName);
				}
			}
		}

		public object? GetFormat(Type? formatType)
		{
			if (!(formatType == typeof(NumberFormatInfo)))
			{
				return null;
			}
			return this;
		}

		public static NumberFormatInfo ReadOnly(NumberFormatInfo nfi)
		{
			if (nfi == null)
			{
				throw new ArgumentNullException("nfi");
			}
			if (nfi.IsReadOnly)
			{
				return nfi;
			}
			NumberFormatInfo numberFormatInfo = (NumberFormatInfo)nfi.MemberwiseClone();
			numberFormatInfo._isReadOnly = true;
			return numberFormatInfo;
		}

		internal static void ValidateParseStyleInteger(NumberStyles style)
		{
			if (((uint)style & 0xFFFFFE00u) != 0 && ((uint)style & 0xFFFFFDFCu) != 0)
			{
				ThrowInvalid(style);
			}
			static void ThrowInvalid(NumberStyles value)
			{
				if (((uint)value & 0xFFFFFC00u) != 0)
				{
					throw new ArgumentException(SR.Argument_InvalidNumberStyles, "style");
				}
				throw new ArgumentException(SR.Arg_InvalidHexStyle);
			}
		}

		internal static void ValidateParseStyleFloatingPoint(NumberStyles style)
		{
			if (((uint)style & 0xFFFFFE00u) != 0)
			{
				ThrowInvalid(style);
			}
			static void ThrowInvalid(NumberStyles value)
			{
				if (((uint)value & 0xFFFFFC00u) != 0)
				{
					throw new ArgumentException(SR.Argument_InvalidNumberStyles, "style");
				}
				throw new ArgumentException(SR.Arg_HexStyleNotSupported);
			}
		}
	}
	[Flags]
	public enum NumberStyles
	{
		None = 0,
		AllowLeadingWhite = 1,
		AllowTrailingWhite = 2,
		AllowLeadingSign = 4,
		AllowTrailingSign = 8,
		AllowParentheses = 0x10,
		AllowDecimalPoint = 0x20,
		AllowThousands = 0x40,
		AllowExponent = 0x80,
		AllowCurrencySymbol = 0x100,
		AllowHexSpecifier = 0x200,
		Integer = 7,
		HexNumber = 0x203,
		Number = 0x6F,
		Float = 0xA7,
		Currency = 0x17F,
		Any = 0x1FF
	}
	internal static class Ordinal
	{
		internal static int CompareStringIgnoreCase(ref char strA, int lengthA, ref char strB, int lengthB)
		{
			int num = Math.Min(lengthA, lengthB);
			int num2 = num;
			ref char reference = ref strA;
			ref char reference2 = ref strB;
			char c = '\u007f';
			while (num != 0 && reference <= c && reference2 <= c)
			{
				if (reference == reference2 || ((reference | 0x20) == (reference2 | 0x20) && (uint)((reference | 0x20) - 97) <= 25u))
				{
					num--;
					reference = ref Unsafe.Add(ref reference, 1);
					reference2 = ref Unsafe.Add(ref reference2, 1);
					continue;
				}
				int num3 = reference;
				int num4 = reference2;
				if ((uint)(reference - 97) <= 25u)
				{
					num3 -= 32;
				}
				if ((uint)(reference2 - 97) <= 25u)
				{
					num4 -= 32;
				}
				return num3 - num4;
			}
			if (num == 0)
			{
				return lengthA - lengthB;
			}
			num2 -= num;
			return CompareStringIgnoreCaseNonAscii(ref reference, lengthA - num2, ref reference2, lengthB - num2);
		}

		internal static int CompareStringIgnoreCaseNonAscii(ref char strA, int lengthA, ref char strB, int lengthB)
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.CompareStringIgnoreCase(ref strA, lengthA, ref strB, lengthB);
			}
			if (GlobalizationMode.UseNls)
			{
				return CompareInfo.NlsCompareStringOrdinalIgnoreCase(ref strA, lengthA, ref strB, lengthB);
			}
			return OrdinalCasing.CompareStringIgnoreCase(ref strA, lengthA, ref strB, lengthB);
		}

		internal static bool EqualsIgnoreCase(ref char charA, ref char charB, int length)
		{
			IntPtr zero = IntPtr.Zero;
			while (true)
			{
				switch (length)
				{
				default:
				{
					uint num3 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, zero)));
					uint num4 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, zero)));
					if (Utf16Utility.AllCharsInUInt32AreAscii(num3 | num4))
					{
						if (Utf16Utility.UInt32OrdinalIgnoreCaseAscii(num3, num4))
						{
							goto IL_0041;
						}
						return false;
					}
					break;
				}
				case 1:
				{
					uint num = Unsafe.AddByteOffset(ref charA, zero);
					uint num2 = Unsafe.AddByteOffset(ref charB, zero);
					if ((num | num2) <= 127)
					{
						if (num == num2)
						{
							return true;
						}
						num |= 0x20u;
						if (num - 97 > 25)
						{
							return false;
						}
						if (num != (num2 | 0x20))
						{
							return false;
						}
						return true;
					}
					break;
				}
				case 0:
					return true;
				}
				break;
				IL_0041:
				zero += 4;
				length -= 2;
			}
			return CompareStringIgnoreCase(ref Unsafe.AddByteOffset(ref charA, zero), length, ref Unsafe.AddByteOffset(ref charB, zero), length) == 0;
		}

		internal static int IndexOf(string source, string value, int startIndex, int count, bool ignoreCase)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
			}
			if (!source.TryGetSpan(startIndex, count, out var slice))
			{
				if ((uint)startIndex > (uint)source.Length)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.startIndex, ExceptionResource.ArgumentOutOfRange_Index);
				}
				else
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_Count);
				}
			}
			int num = (ignoreCase ? IndexOfOrdinalIgnoreCase(slice, value) : slice.IndexOf(value));
			if (num < 0)
			{
				return num;
			}
			return num + startIndex;
		}

		internal static int IndexOfOrdinalIgnoreCase(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
		{
			if (value.Length == 0)
			{
				return 0;
			}
			if (value.Length > source.Length)
			{
				return -1;
			}
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.IndexOfIgnoreCase(source, value);
			}
			if (GlobalizationMode.UseNls)
			{
				return CompareInfo.NlsIndexOfOrdinalCore(source, value, ignoreCase: true, fromBeginning: true);
			}
			return OrdinalCasing.IndexOf(source, value);
		}

		internal static int LastIndexOfOrdinalIgnoreCase(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
		{
			if (value.Length == 0)
			{
				return source.Length;
			}
			if (value.Length > source.Length)
			{
				return -1;
			}
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.LastIndexOfIgnoreCase(source, value);
			}
			if (GlobalizationMode.UseNls)
			{
				return CompareInfo.NlsIndexOfOrdinalCore(source, value, ignoreCase: true, fromBeginning: false);
			}
			return OrdinalCasing.LastIndexOf(source, value);
		}

		internal static int ToUpperOrdinal(ReadOnlySpan<char> source, Span<char> destination)
		{
			if (source.Overlaps(destination))
			{
				throw new InvalidOperationException(SR.InvalidOperation_SpanOverlappedOperation);
			}
			if (destination.Length < source.Length)
			{
				return -1;
			}
			if (GlobalizationMode.Invariant)
			{
				InvariantModeCasing.ToUpper(source, destination);
				return source.Length;
			}
			if (GlobalizationMode.UseNls)
			{
				TextInfo.Invariant.ChangeCaseToUpper(source, destination);
				return source.Length;
			}
			OrdinalCasing.ToUpperOrdinal(source, destination);
			return source.Length;
		}
	}
	internal static class OrdinalCasing
	{
		private static ushort[] s_noCasingPage = Array.Empty<ushort>();

		private static ushort[] s_basicLatin = new ushort[256]
		{
			0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
			10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
			20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
			30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
			40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
			50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
			60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
			70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
			80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
			90, 91, 92, 93, 94, 95, 96, 65, 66, 67,
			68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
			78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
			88, 89, 90, 123, 124, 125, 126, 127, 128, 129,
			130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
			140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
			150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
			160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
			170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
			180, 924, 182, 183, 184, 185, 186, 187, 188, 189,
			190, 191, 192, 193, 194, 195, 196, 197, 198, 199,
			200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
			210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
			220, 221, 222, 223, 192, 193, 194, 195, 196, 197,
			198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
			208, 209, 210, 211, 212, 213, 214, 247, 216, 217,
			218, 219, 220, 221, 222, 376
		};

		private static ushort[][] s_casingTable = InitCasingTable();

		private static ReadOnlySpan<byte> s_casingTableInit => new byte[32]
		{
			0, 0, 76, 0, 55, 224, 31, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 254,
			244, 15, 255, 255, 255, 255, 254, 255, 255, 255,
			255, 200
		};

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static char ToUpper(char c)
		{
			int num = (int)c >> 8;
			if (num == 0)
			{
				return (char)s_basicLatin[(uint)c];
			}
			ushort[] array = s_casingTable[num];
			if (array == s_noCasingPage)
			{
				return c;
			}
			if (array == null)
			{
				array = InitOrdinalCasingPage(num);
			}
			return (char)array[c & 0xFF];
		}

		internal static void ToUpperOrdinal(ReadOnlySpan<char> source, Span<char> destination)
		{
			for (int i = 0; i < source.Length; i++)
			{
				char c = source[i];
				if (c <= 'ÿ')
				{
					destination[i] = (char)s_basicLatin[(uint)c];
					continue;
				}
				if (char.IsHighSurrogate(c) && i < source.Length - 1)
				{
					char c2 = source[i + 1];
					if (char.IsLowSurrogate(c2))
					{
						SurrogateCasing.ToUpper(c, c2, out destination[i], out destination[i + 1]);
						i++;
						continue;
					}
				}
				destination[i] = ToUpper(c);
			}
		}

		internal static int CompareStringIgnoreCase(ref char strA, int lengthA, ref char strB, int lengthB)
		{
			int num = Math.Min(lengthA, lengthB);
			ref char reference = ref strA;
			ref char reference2 = ref strB;
			int num2 = 0;
			while (num2 < num)
			{
				char c = reference;
				char c2 = reference2;
				char c3 = '\0';
				if (!char.IsHighSurrogate(c) || num2 >= lengthA - 1 || !char.IsLowSurrogate(c3 = Unsafe.Add(ref reference, 1)))
				{
					if (!char.IsHighSurrogate(c2) || num2 >= lengthB - 1 || !char.IsLowSurrogate(Unsafe.Add(ref reference2, 1)))
					{
						if (c2 == c)
						{
							num2++;
							reference = ref Unsafe.Add(ref reference, 1);
							reference2 = ref Unsafe.Add(ref reference2, 1);
							continue;
						}
						char c4 = ToUpper(c);
						char c5 = ToUpper(c2);
						if (c4 == c5)
						{
							num2++;
							reference = ref Unsafe.Add(ref reference, 1);
							reference2 = ref Unsafe.Add(ref reference2, 1);
							continue;
						}
						return c - c2;
					}
					return -1;
				}
				char c6 = '\0';
				if (!char.IsHighSurrogate(c2) || num2 >= lengthB - 1 || !char.IsLowSurrogate(c6 = Unsafe.Add(ref reference2, 1)))
				{
					return 1;
				}
				if (c == c2 && c3 == c6)
				{
					num2 += 2;
					reference = ref Unsafe.Add(ref reference, 2);
					reference2 = ref Unsafe.Add(ref reference2, 2);
					continue;
				}
				uint num3 = CharUnicodeInfo.ToUpper(UnicodeUtility.GetScalarFromUtf16SurrogatePair(c, c3));
				uint num4 = CharUnicodeInfo.ToUpper(UnicodeUtility.GetScalarFromUtf16SurrogatePair(c2, c6));
				if (num3 == num4)
				{
					num2 += 2;
					reference = ref Unsafe.Add(ref reference, 2);
					reference2 = ref Unsafe.Add(ref reference2, 2);
					continue;
				}
				return (int)(num3 - num4);
			}
			return lengthA - lengthB;
		}

		internal unsafe static int IndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
		{
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(value))
				{
					char* ptr2 = ptr + (source.Length - value.Length);
					char* ptr4 = ptr3 + value.Length - 1;
					for (char* ptr5 = ptr; ptr5 <= ptr2; ptr5++)
					{
						char* ptr6 = ptr3;
						char* ptr7 = ptr5;
						while (ptr6 <= ptr4)
						{
							if (!char.IsHighSurrogate(*ptr6) || ptr6 == ptr4)
							{
								if (*ptr6 != *ptr7 && ToUpper(*ptr6) != ToUpper(*ptr7))
								{
									break;
								}
								ptr6++;
								ptr7++;
							}
							else if (char.IsHighSurrogate(*ptr7) && char.IsLowSurrogate(ptr7[1]) && char.IsLowSurrogate(ptr6[1]))
							{
								if (!SurrogateCasing.Equal(*ptr7, ptr7[1], *ptr6, ptr6[1]))
								{
									break;
								}
								ptr7 += 2;
								ptr6 += 2;
							}
							else
							{
								if (*ptr6 != *ptr7)
								{
									break;
								}
								ptr7++;
								ptr6++;
							}
						}
						if (ptr6 > ptr4)
						{
							return (int)(ptr5 - ptr);
						}
					}
					return -1;
				}
			}
		}

		internal unsafe static int LastIndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value)
		{
			fixed (char* ptr3 = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr = &MemoryMarshal.GetReference(value))
				{
					char* ptr2 = ptr + value.Length - 1;
					for (char* ptr4 = ptr3 + (source.Length - value.Length); ptr4 >= ptr3; ptr4--)
					{
						char* ptr5 = ptr;
						char* ptr6 = ptr4;
						while (ptr5 <= ptr2)
						{
							if (!char.IsHighSurrogate(*ptr5) || ptr5 == ptr2)
							{
								if (*ptr5 != *ptr6 && ToUpper(*ptr5) != ToUpper(*ptr6))
								{
									break;
								}
								ptr5++;
								ptr6++;
							}
							else if (char.IsHighSurrogate(*ptr6) && char.IsLowSurrogate(ptr6[1]) && char.IsLowSurrogate(ptr5[1]))
							{
								if (!SurrogateCasing.Equal(*ptr6, ptr6[1], *ptr5, ptr5[1]))
								{
									break;
								}
								ptr6 += 2;
								ptr5 += 2;
							}
							else
							{
								if (*ptr5 != *ptr6)
								{
									break;
								}
								ptr6++;
								ptr5++;
							}
						}
						if (ptr5 > ptr2)
						{
							return (int)(ptr4 - ptr3);
						}
					}
					return -1;
				}
			}
		}

		private static ushort[][] InitCasingTable()
		{
			ushort[][] array = new ushort[s_casingTableInit.Length * 8][];
			for (int i = 0; i < s_casingTableInit.Length * 8; i++)
			{
				byte b = (byte)(s_casingTableInit[i / 8] >> 7 - i % 8);
				if ((b & 1) == 1)
				{
					array[i] = s_noCasingPage;
				}
			}
			array[0] = s_basicLatin;
			return array;
		}

		private unsafe static ushort[] InitOrdinalCasingPage(int pageNumber)
		{
			ushort[] array = new ushort[256];
			fixed (ushort* ptr = array)
			{
				char* pTarget = (char*)ptr;
				Interop.Globalization.InitOrdinalCasingPage(pageNumber, pTarget);
			}
			Volatile.Write(ref s_casingTable[pageNumber], array);
			return array;
		}
	}
	public class PersianCalendar : Calendar
	{
		public static readonly int PersianEra = 1;

		private static readonly long s_persianEpoch = new DateTime(622, 3, 22).Ticks / 864000000000L;

		private static readonly int[] s_daysToMonth = new int[13]
		{
			0, 31, 62, 93, 124, 155, 186, 216, 246, 276,
			306, 336, 366
		};

		private static readonly DateTime s_minDate = new DateTime(622, 3, 22);

		private static readonly DateTime s_maxDate = DateTime.MaxValue;

		public override DateTime MinSupportedDateTime => s_minDate;

		public override DateTime MaxSupportedDateTime => s_maxDate;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.SolarCalendar;

		internal override CalendarId BaseCalendarID => CalendarId.GREGORIAN;

		internal override CalendarId ID => CalendarId.PERSIAN;

		public override int[] Eras => new int[1] { PersianEra };

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 1410);
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > 9378)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, 9378));
				}
				_twoDigitYearMax = value;
			}
		}

		private static long GetAbsoluteDatePersian(int year, int month, int day)
		{
			if (year < 1 || year > 9378 || month < 1 || month > 12)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
			}
			int num = DaysInPreviousMonths(month) + day - 1;
			int num2 = (int)(365.242189 * (double)(year - 1));
			long num3 = CalendricalCalculationsHelper.PersianNewYearOnOrBefore(s_persianEpoch + num2 + 180);
			return num3 + num;
		}

		internal static void CheckTicksRange(long ticks)
		{
			if (ticks < s_minDate.Ticks || ticks > s_maxDate.Ticks)
			{
				throw new ArgumentOutOfRangeException("time", ticks, SR.Format(SR.ArgumentOutOfRange_CalendarRange, s_minDate, s_maxDate));
			}
		}

		internal static void CheckEraRange(int era)
		{
			if (era != 0 && era != PersianEra)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
		}

		internal static void CheckYearRange(int year, int era)
		{
			CheckEraRange(era);
			if (year < 1 || year > 9378)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, 9378));
			}
		}

		internal static void CheckYearMonthRange(int year, int month, int era)
		{
			CheckYearRange(year, era);
			if (year == 9378 && month > 10)
			{
				throw new ArgumentOutOfRangeException("month", month, SR.Format(SR.ArgumentOutOfRange_Range, 1, 10));
			}
			if (month < 1 || month > 12)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
		}

		private static int MonthFromOrdinalDay(int ordinalDay)
		{
			int i;
			for (i = 0; ordinalDay > s_daysToMonth[i]; i++)
			{
			}
			return i;
		}

		private static int DaysInPreviousMonths(int month)
		{
			month--;
			return s_daysToMonth[month];
		}

		internal int GetDatePart(long ticks, int part)
		{
			CheckTicksRange(ticks);
			long num = ticks / 864000000000L + 1;
			long num2 = CalendricalCalculationsHelper.PersianNewYearOnOrBefore(num);
			int num3 = (int)Math.Floor((double)(num2 - s_persianEpoch) / 365.242189 + 0.5) + 1;
			if (part == 0)
			{
				return num3;
			}
			int num4 = (int)(num - CalendricalCalculationsHelper.GetNumberOfDays(ToDateTime(num3, 1, 1, 0, 0, 0, 0, 1)));
			if (part == 1)
			{
				return num4;
			}
			int num5 = MonthFromOrdinalDay(num4);
			if (part == 2)
			{
				return num5;
			}
			int result = num4 - DaysInPreviousMonths(num5);
			if (part == 3)
			{
				return result;
			}
			throw new InvalidOperationException(SR.InvalidOperation_DateTimeParsing);
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			if (months < -120000 || months > 120000)
			{
				throw new ArgumentOutOfRangeException("months", months, SR.Format(SR.ArgumentOutOfRange_Range, -120000, 120000));
			}
			int datePart = GetDatePart(time.Ticks, 0);
			int datePart2 = GetDatePart(time.Ticks, 2);
			int num = GetDatePart(time.Ticks, 3);
			int num2 = datePart2 - 1 + months;
			if (num2 >= 0)
			{
				datePart2 = num2 % 12 + 1;
				datePart += num2 / 12;
			}
			else
			{
				datePart2 = 12 + (num2 + 1) % 12;
				datePart += (num2 - 11) / 12;
			}
			int daysInMonth = GetDaysInMonth(datePart, datePart2);
			if (num > daysInMonth)
			{
				num = daysInMonth;
			}
			long ticks = GetAbsoluteDatePersian(datePart, datePart2, num) * 864000000000L + time.Ticks % 864000000000L;
			Calendar.CheckAddResult(ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return new DateTime(ticks);
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return AddMonths(time, years * 12);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 3);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return (DayOfWeek)((int)(time.Ticks / 864000000000L + 1) % 7);
		}

		public override int GetDayOfYear(DateTime time)
		{
			return GetDatePart(time.Ticks, 1);
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			CheckYearMonthRange(year, month, era);
			if (month == 10 && year == 9378)
			{
				return 13;
			}
			int num = s_daysToMonth[month] - s_daysToMonth[month - 1];
			if (month == 12 && !IsLeapYear(year))
			{
				num--;
			}
			return num;
		}

		public override int GetDaysInYear(int year, int era)
		{
			CheckYearRange(year, era);
			if (year == 9378)
			{
				return s_daysToMonth[9] + 13;
			}
			if (!IsLeapYear(year, 0))
			{
				return 365;
			}
			return 366;
		}

		public override int GetEra(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			return PersianEra;
		}

		public override int GetMonth(DateTime time)
		{
			return GetDatePart(time.Ticks, 2);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			CheckYearRange(year, era);
			if (year == 9378)
			{
				return 10;
			}
			return 12;
		}

		public override int GetYear(DateTime time)
		{
			return GetDatePart(time.Ticks, 0);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			int daysInMonth = GetDaysInMonth(year, month, era);
			if (day < 1 || day > daysInMonth)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Day, daysInMonth, month));
			}
			if (IsLeapYear(year, era) && month == 12)
			{
				return day == 30;
			}
			return false;
		}

		public override int GetLeapMonth(int year, int era)
		{
			CheckYearRange(year, era);
			return 0;
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			CheckYearMonthRange(year, month, era);
			return false;
		}

		public override bool IsLeapYear(int year, int era)
		{
			CheckYearRange(year, era);
			if (year == 9378)
			{
				return false;
			}
			return GetAbsoluteDatePersian(year + 1, 1, 1) - GetAbsoluteDatePersian(year, 1, 1) == 366;
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			int daysInMonth = GetDaysInMonth(year, month, era);
			if (day < 1 || day > daysInMonth)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Day, daysInMonth, month));
			}
			long absoluteDatePersian = GetAbsoluteDatePersian(year, month, day);
			if (absoluteDatePersian < 0)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
			}
			return new DateTime(absoluteDatePersian * 864000000000L + Calendar.TimeToTicks(hour, minute, second, millisecond));
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (year < 100)
			{
				return base.ToFourDigitYear(year);
			}
			if (year > 9378)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, 9378));
			}
			return year;
		}
	}
	public class RegionInfo
	{
		private string _name;

		private readonly CultureData _cultureData;

		internal static volatile RegionInfo s_currentRegionInfo;

		public static RegionInfo CurrentRegion
		{
			get
			{
				RegionInfo regionInfo = s_currentRegionInfo;
				if (regionInfo == null)
				{
					regionInfo = new RegionInfo(CultureData.GetCurrentRegionData());
					regionInfo._name = regionInfo._cultureData.RegionName;
					s_currentRegionInfo = regionInfo;
				}
				return regionInfo;
			}
		}

		public virtual string Name => _name;

		public virtual string EnglishName => _cultureData.EnglishCountryName;

		public virtual string DisplayName => _cultureData.LocalizedCountryName;

		public virtual string NativeName => _cultureData.NativeCountryName;

		public virtual string TwoLetterISORegionName => _cultureData.TwoLetterISOCountryName;

		public virtual string ThreeLetterISORegionName => _cultureData.ThreeLetterISOCountryName;

		public virtual string ThreeLetterWindowsRegionName => ThreeLetterISORegionName;

		public virtual bool IsMetric => _cultureData.MeasurementSystem == 0;

		public virtual int GeoId => _cultureData.GeoId;

		public virtual string CurrencyEnglishName => _cultureData.CurrencyEnglishName;

		public virtual string CurrencyNativeName => _cultureData.CurrencyNativeName;

		public virtual string CurrencySymbol => _cultureData.CurrencySymbol;

		public virtual string ISOCurrencySymbol => _cultureData.ISOCurrencySymbol;

		public RegionInfo(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_NoRegionInvariantCulture, "name");
			}
			_cultureData = CultureData.GetCultureDataForRegion(name, useUserOverride: true) ?? throw new ArgumentException(SR.Format(SR.Argument_InvalidCultureName, name), "name");
			if (_cultureData.IsNeutralCulture)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidNeutralRegionName, name), "name");
			}
			_name = _cultureData.RegionName;
		}

		public RegionInfo(int culture)
		{
			switch (culture)
			{
			case 127:
				throw new ArgumentException(SR.Argument_NoRegionInvariantCulture);
			case 0:
				throw new ArgumentException(SR.Format(SR.Argument_CultureIsNeutral, culture), "culture");
			case 3072:
				throw new ArgumentException(SR.Format(SR.Argument_CustomCultureCannotBePassedByNumber, culture), "culture");
			}
			_cultureData = CultureData.GetCultureData(culture, bUseUserOverride: true);
			_name = _cultureData.RegionName;
			if (_cultureData.IsNeutralCulture)
			{
				throw new ArgumentException(SR.Format(SR.Argument_CultureIsNeutral, culture), "culture");
			}
		}

		internal RegionInfo(CultureData cultureData)
		{
			_cultureData = cultureData;
			_name = _cultureData.RegionName;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is RegionInfo regionInfo)
			{
				return Name.Equals(regionInfo.Name);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Name.GetHashCode();
		}

		public override string ToString()
		{
			return Name;
		}
	}
	public sealed class SortKey
	{
		private readonly CompareInfo _compareInfo;

		private readonly CompareOptions _options;

		private readonly string _string;

		private readonly byte[] _keyData;

		public string OriginalString => _string;

		public byte[] KeyData => (byte[])_keyData.Clone();

		internal SortKey(CompareInfo compareInfo, string str, CompareOptions options, byte[] keyData)
		{
			_keyData = keyData;
			_compareInfo = compareInfo;
			_options = options;
			_string = str;
		}

		public static int Compare(SortKey sortkey1, SortKey sortkey2)
		{
			if (sortkey1 == null)
			{
				throw new ArgumentNullException("sortkey1");
			}
			if (sortkey2 == null)
			{
				throw new ArgumentNullException("sortkey2");
			}
			byte[] keyData = sortkey1._keyData;
			byte[] keyData2 = sortkey2._keyData;
			return new ReadOnlySpan<byte>(keyData).SequenceCompareTo(keyData2);
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is SortKey sortKey)
			{
				return new ReadOnlySpan<byte>(_keyData).SequenceEqual(sortKey._keyData);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _compareInfo.GetHashCode(_string, _options);
		}

		public override string ToString()
		{
			return $"SortKey - {_compareInfo.Name}, {_options}, {_string}";
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class SortVersion : IEquatable<SortVersion?>
	{
		private readonly int m_NlsVersion;

		private Guid m_SortId;

		public int FullVersion => m_NlsVersion;

		public Guid SortId => m_SortId;

		public SortVersion(int fullVersion, Guid sortId)
		{
			m_SortId = sortId;
			m_NlsVersion = fullVersion;
		}

		internal SortVersion(int nlsVersion, int effectiveId, Guid customVersion)
		{
			m_NlsVersion = nlsVersion;
			if (customVersion == Guid.Empty)
			{
				byte h = (byte)(effectiveId >> 24);
				byte i = (byte)((effectiveId & 0xFF0000) >> 16);
				byte j = (byte)((effectiveId & 0xFF00) >> 8);
				byte k = (byte)((uint)effectiveId & 0xFFu);
				customVersion = new Guid(0, 0, 0, 0, 0, 0, 0, h, i, j, k);
			}
			m_SortId = customVersion;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is SortVersion other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals([NotNullWhen(true)] SortVersion? other)
		{
			if (other == null)
			{
				return false;
			}
			if (m_NlsVersion == other.m_NlsVersion)
			{
				return m_SortId == other.m_SortId;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (m_NlsVersion * 7) | m_SortId.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(SortVersion? left, SortVersion? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			return right.Equals(left);
		}

		public static bool operator !=(SortVersion? left, SortVersion? right)
		{
			return !(left == right);
		}
	}
	public class StringInfo
	{
		private string _str;

		private int[] _indexes;

		private int[]? Indexes
		{
			get
			{
				if (_indexes == null && String.Length > 0)
				{
					_indexes = ParseCombiningCharacters(String);
				}
				return _indexes;
			}
		}

		public string String
		{
			get
			{
				return _str;
			}
			[MemberNotNull("_str")]
			set
			{
				_str = value ?? throw new ArgumentNullException("value");
				_indexes = null;
			}
		}

		public int LengthInTextElements
		{
			get
			{
				int[]? indexes = Indexes;
				if (indexes == null)
				{
					return 0;
				}
				return indexes.Length;
			}
		}

		public StringInfo()
			: this(string.Empty)
		{
		}

		public StringInfo(string value)
		{
			String = value;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is StringInfo stringInfo)
			{
				return _str.Equals(stringInfo._str);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _str.GetHashCode();
		}

		public string SubstringByTextElements(int startingTextElement)
		{
			int[]? indexes = Indexes;
			return SubstringByTextElements(startingTextElement, ((indexes != null) ? indexes.Length : 0) - startingTextElement);
		}

		public string SubstringByTextElements(int startingTextElement, int lengthInTextElements)
		{
			int[] array = Indexes ?? Array.Empty<int>();
			if ((uint)startingTextElement >= (uint)array.Length)
			{
				throw new ArgumentOutOfRangeException("startingTextElement", startingTextElement, SR.Arg_ArgumentOutOfRangeException);
			}
			if ((uint)lengthInTextElements > (uint)(array.Length - startingTextElement))
			{
				throw new ArgumentOutOfRangeException("lengthInTextElements", lengthInTextElements, SR.Arg_ArgumentOutOfRangeException);
			}
			int num = array[startingTextElement];
			Index end = ^0;
			if ((uint)(startingTextElement + lengthInTextElements) < (uint)array.Length)
			{
				end = array[startingTextElement + lengthInTextElements];
			}
			return String[num..end];
		}

		public static string GetNextTextElement(string str)
		{
			return GetNextTextElement(str, 0);
		}

		public static string GetNextTextElement(string str, int index)
		{
			int nextTextElementLength = GetNextTextElementLength(str, index);
			return str.Substring(index, nextTextElementLength);
		}

		public static int GetNextTextElementLength(string str)
		{
			return GetNextTextElementLength(str, 0);
		}

		public static int GetNextTextElementLength(string str, int index)
		{
			if (str == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.str);
			}
			if ((uint)index > (uint)str.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return GetNextTextElementLength(str.AsSpan(index));
		}

		public static int GetNextTextElementLength(ReadOnlySpan<char> str)
		{
			return TextSegmentationUtility.GetLengthOfFirstUtf16ExtendedGraphemeCluster(str);
		}

		public static TextElementEnumerator GetTextElementEnumerator(string str)
		{
			return GetTextElementEnumerator(str, 0);
		}

		public static TextElementEnumerator GetTextElementEnumerator(string str, int index)
		{
			if (str == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.str);
			}
			if ((uint)index > (uint)str.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return new TextElementEnumerator(str, index);
		}

		public static int[] ParseCombiningCharacters(string str)
		{
			if (str == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.str);
			}
			Span<int> initialSpan = stackalloc int[64];
			ValueListBuilder<int> valueListBuilder = new ValueListBuilder<int>(initialSpan);
			ReadOnlySpan<char> str2 = str;
			while (!str2.IsEmpty)
			{
				valueListBuilder.Append(str.Length - str2.Length);
				str2 = str2.Slice(GetNextTextElementLength(str2));
			}
			int[] result = valueListBuilder.AsSpan().ToArray();
			valueListBuilder.Dispose();
			return result;
		}
	}
	internal enum StrongBidiCategory
	{
		Other = 0,
		StrongLeftToRight = 0x20,
		StrongRightToLeft = 0x40
	}
	internal static class SurrogateCasing
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ToUpper(char h, char l, out char hr, out char lr)
		{
			UnicodeUtility.GetUtf16SurrogatesFromSupplementaryPlaneScalar(CharUnicodeInfo.ToUpper(UnicodeUtility.GetScalarFromUtf16SurrogatePair(h, l)), out hr, out lr);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ToLower(char h, char l, out char hr, out char lr)
		{
			UnicodeUtility.GetUtf16SurrogatesFromSupplementaryPlaneScalar(CharUnicodeInfo.ToLower(UnicodeUtility.GetScalarFromUtf16SurrogatePair(h, l)), out hr, out lr);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool Equal(char h1, char l1, char h2, char l2)
		{
			ToUpper(h1, l1, out var hr, out var lr);
			ToUpper(h2, l2, out var hr2, out var lr2);
			if (hr == hr2)
			{
				return lr == lr2;
			}
			return false;
		}
	}
	public class TaiwanCalendar : Calendar
	{
		private static readonly EraInfo[] s_taiwanEraInfo = new EraInfo[1]
		{
			new EraInfo(1, 1912, 1, 1, 1911, 1, 8088)
		};

		private static volatile Calendar s_defaultInstance;

		private readonly GregorianCalendarHelper _helper;

		private static readonly DateTime s_calendarMinValue = new DateTime(1912, 1, 1);

		public override DateTime MinSupportedDateTime => s_calendarMinValue;

		public override DateTime MaxSupportedDateTime => DateTime.MaxValue;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.SolarCalendar;

		internal override CalendarId ID => CalendarId.TAIWAN;

		public override int[] Eras => _helper.Eras;

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 99);
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > _helper.MaxYear)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, _helper.MaxYear));
				}
				_twoDigitYearMax = value;
			}
		}

		internal static Calendar GetDefaultInstance()
		{
			return s_defaultInstance ?? (s_defaultInstance = new TaiwanCalendar());
		}

		public TaiwanCalendar()
		{
			try
			{
				new CultureInfo("zh-TW");
			}
			catch (ArgumentException innerException)
			{
				throw new TypeInitializationException(GetType().ToString(), innerException);
			}
			_helper = new GregorianCalendarHelper(this, s_taiwanEraInfo);
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			return _helper.AddMonths(time, months);
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return _helper.AddYears(time, years);
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			return _helper.GetDaysInMonth(year, month, era);
		}

		public override int GetDaysInYear(int year, int era)
		{
			return _helper.GetDaysInYear(year, era);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return _helper.GetDayOfMonth(time);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return _helper.GetDayOfWeek(time);
		}

		public override int GetDayOfYear(DateTime time)
		{
			return _helper.GetDayOfYear(time);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			return _helper.GetMonthsInYear(year, era);
		}

		public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
		{
			return _helper.GetWeekOfYear(time, rule, firstDayOfWeek);
		}

		public override int GetEra(DateTime time)
		{
			return _helper.GetEra(time);
		}

		public override int GetMonth(DateTime time)
		{
			return _helper.GetMonth(time);
		}

		public override int GetYear(DateTime time)
		{
			return _helper.GetYear(time);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			return _helper.IsLeapDay(year, month, day, era);
		}

		public override bool IsLeapYear(int year, int era)
		{
			return _helper.IsLeapYear(year, era);
		}

		public override int GetLeapMonth(int year, int era)
		{
			return _helper.GetLeapMonth(year, era);
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			return _helper.IsLeapMonth(year, month, era);
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			return _helper.ToDateTime(year, month, day, hour, minute, second, millisecond, era);
		}

		public override int ToFourDigitYear(int year)
		{
			if (year <= 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedPosNum);
			}
			if (year > _helper.MaxYear)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1, _helper.MaxYear));
			}
			return year;
		}
	}
	public class TaiwanLunisolarCalendar : EastAsianLunisolarCalendar
	{
		private static readonly EraInfo[] s_taiwanLunisolarEraInfo = new EraInfo[1]
		{
			new EraInfo(1, 1912, 1, 1, 1911, 1, 8088)
		};

		private readonly GregorianCalendarHelper _helper;

		private static readonly DateTime s_minDate = new DateTime(1912, 2, 18);

		private static readonly DateTime s_maxDate = new DateTime(new DateTime(2051, 2, 10, 23, 59, 59, 999).Ticks + 9999);

		private static readonly int[,] s_yinfo = new int[139, 4]
		{
			{ 0, 2, 18, 42192 },
			{ 0, 2, 6, 53840 },
			{ 5, 1, 26, 54568 },
			{ 0, 2, 14, 46400 },
			{ 0, 2, 3, 54944 },
			{ 2, 1, 23, 38608 },
			{ 0, 2, 11, 38320 },
			{ 7, 2, 1, 18872 },
			{ 0, 2, 20, 18800 },
			{ 0, 2, 8, 42160 },
			{ 5, 1, 28, 45656 },
			{ 0, 2, 16, 27216 },
			{ 0, 2, 5, 27968 },
			{ 4, 1, 24, 44456 },
			{ 0, 2, 13, 11104 },
			{ 0, 2, 2, 38256 },
			{ 2, 1, 23, 18808 },
			{ 0, 2, 10, 18800 },
			{ 6, 1, 30, 25776 },
			{ 0, 2, 17, 54432 },
			{ 0, 2, 6, 59984 },
			{ 5, 1, 26, 27976 },
			{ 0, 2, 14, 23248 },
			{ 0, 2, 4, 11104 },
			{ 3, 1, 24, 37744 },
			{ 0, 2, 11, 37600 },
			{ 7, 1, 31, 51560 },
			{ 0, 2, 19, 51536 },
			{ 0, 2, 8, 54432 },
			{ 6, 1, 27, 55888 },
			{ 0, 2, 15, 46416 },
			{ 0, 2, 5, 22176 },
			{ 4, 1, 25, 43736 },
			{ 0, 2, 13, 9680 },
			{ 0, 2, 2, 37584 },
			{ 2, 1, 22, 51544 },
			{ 0, 2, 10, 43344 },
			{ 7, 1, 29, 46248 },
			{ 0, 2, 17, 27808 },
			{ 0, 2, 6, 46416 },
			{ 5, 1, 27, 21928 },
			{ 0, 2, 14, 19872 },
			{ 0, 2, 3, 42416 },
			{ 3, 1, 24, 21176 },
			{ 0, 2, 12, 21168 },
			{ 8, 1, 31, 43344 },
			{ 0, 2, 18, 59728 },
			{ 0, 2, 8, 27296 },
			{ 6, 1, 28, 44368 },
			{ 0, 2, 15, 43856 },
			{ 0, 2, 5, 19296 },
			{ 4, 1, 25, 42352 },
			{ 0, 2, 13, 42352 },
			{ 0, 2, 2, 21088 },
			{ 3, 1, 21, 59696 },
			{ 0, 2, 9, 55632 },
			{ 7, 1, 30, 23208 },
			{ 0, 2, 17, 22176 },
			{ 0, 2, 6, 38608 },
			{ 5, 1, 27, 19176 },
			{ 0, 2, 15, 19152 },
			{ 0, 2, 3, 42192 },
			{ 4, 1, 23, 53864 },
			{ 0, 2, 11, 53840 },
			{ 8, 1, 31, 54568 },
			{ 0, 2, 18, 46400 },
			{ 0, 2, 7, 46752 },
			{ 6, 1, 28, 38608 },
			{ 0, 2, 16, 38320 },
			{ 0, 2, 5, 18864 },
			{ 4, 1, 25, 42168 },
			{ 0, 2, 13, 42160 },
			{ 10, 2, 2, 45656 },
			{ 0, 2, 20, 27216 },
			{ 0, 2, 9, 27968 },
			{ 6, 1, 29, 44448 },
			{ 0, 2, 17, 43872 },
			{ 0, 2, 6, 38256 },
			{ 5, 1, 27, 18808 },
			{ 0, 2, 15, 18800 },
			{ 0, 2, 4, 25776 },
			{ 3, 1, 23, 27216 },
			{ 0, 2, 10, 59984 },
			{ 8, 1, 31, 27432 },
			{ 0, 2, 19, 23232 },
			{ 0, 2, 7, 43872 },
			{ 5, 1, 28, 37736 },
			{ 0, 2, 16, 37600 },
			{ 0, 2, 5, 51552 },
			{ 4, 1, 24, 54440 },
			{ 0, 2, 12, 54432 },
			{ 0, 2, 1, 55888 },
			{ 2, 1, 22, 23208 },
			{ 0, 2, 9, 22176 },
			{ 7, 1, 29, 43736 },
			{ 0, 2, 18, 9680 },
			{ 0, 2, 7, 37584 },
			{ 5, 1, 26, 51544 },
			{ 0, 2, 14, 43344 },
			{ 0, 2, 3, 46240 },
			{ 4, 1, 23, 46416 },
			{ 0, 2, 10, 44368 },
			{ 9, 1, 31, 21928 },
			{ 0, 2, 19, 19360 },
			{ 0, 2, 8, 42416 },
			{ 6, 1, 28, 21176 },
			{ 0, 2, 16, 21168 },
			{ 0, 2, 5, 43312 },
			{ 4, 1, 25, 29864 },
			{ 0, 2, 12, 27296 },
			{ 0, 2, 1, 44368 },
			{ 2, 1, 22, 19880 },
			{ 0, 2, 10, 19296 },
			{ 6, 1, 29, 42352 },
			{ 0, 2, 17, 42208 },
			{ 0, 2, 6, 53856 },
			{ 5, 1, 26, 59696 },
			{ 0, 2, 13, 54576 },
			{ 0, 2, 3, 23200 },
			{ 3, 1, 23, 27472 },
			{ 0, 2, 11, 38608 },
			{ 11, 1, 31, 19176 },
			{ 0, 2, 19, 19152 },
			{ 0, 2, 8, 42192 },
			{ 6, 1, 28, 53848 },
			{ 0, 2, 15, 53840 },
			{ 0, 2, 4, 54560 },
			{ 5, 1, 24, 55968 },
			{ 0, 2, 12, 46496 },
			{ 0, 2, 1, 22224 },
			{ 2, 1, 22, 19160 },
			{ 0, 2, 10, 18864 },
			{ 7, 1, 30, 42168 },
			{ 0, 2, 17, 42160 },
			{ 0, 2, 6, 43600 },
			{ 5, 1, 26, 46376 },
			{ 0, 2, 14, 27936 },
			{ 0, 2, 2, 44448 },
			{ 3, 1, 23, 21936 }
		};

		public override DateTime MinSupportedDateTime => s_minDate;

		public override DateTime MaxSupportedDateTime => s_maxDate;

		protected override int DaysInYearBeforeMinSupportedYear => 384;

		internal override int MinCalendarYear => 1912;

		internal override int MaxCalendarYear => 2050;

		internal override DateTime MinDate => s_minDate;

		internal override DateTime MaxDate => s_maxDate;

		internal override EraInfo[]? CalEraInfo => s_taiwanLunisolarEraInfo;

		internal override CalendarId BaseCalendarID => CalendarId.TAIWAN;

		internal override CalendarId ID => CalendarId.TAIWANLUNISOLAR;

		public override int[] Eras => _helper.Eras;

		internal override int GetYearInfo(int lunarYear, int index)
		{
			if (lunarYear < 1912 || lunarYear > 2050)
			{
				throw new ArgumentOutOfRangeException("year", lunarYear, SR.Format(SR.ArgumentOutOfRange_Range, 1912, 2050));
			}
			return s_yinfo[lunarYear - 1912, index];
		}

		internal override int GetYear(int year, DateTime time)
		{
			return _helper.GetYear(year, time);
		}

		internal override int GetGregorianYear(int year, int era)
		{
			return _helper.GetGregorianYear(year, era);
		}

		public TaiwanLunisolarCalendar()
		{
			_helper = new GregorianCalendarHelper(this, s_taiwanLunisolarEraInfo);
		}

		public override int GetEra(DateTime time)
		{
			return _helper.GetEra(time);
		}
	}
	public class TextElementEnumerator : System.Collections.IEnumerator
	{
		private readonly string _str;

		private readonly int _strStartIndex;

		private int _currentTextElementOffset;

		private int _currentTextElementLength;

		private string _currentTextElementSubstr;

		public object Current => GetTextElement();

		public int ElementIndex
		{
			get
			{
				if (_currentTextElementOffset >= _str.Length)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
				return _currentTextElementOffset - _strStartIndex;
			}
		}

		internal TextElementEnumerator(string str, int startIndex)
		{
			_str = str;
			_strStartIndex = startIndex;
			Reset();
		}

		public bool MoveNext()
		{
			_currentTextElementSubstr = null;
			int num = (_currentTextElementOffset += _currentTextElementLength);
			_currentTextElementLength = 0;
			if (num >= _str.Length)
			{
				return false;
			}
			_currentTextElementLength = TextSegmentationUtility.GetLengthOfFirstUtf16ExtendedGraphemeCluster(_str.AsSpan(num));
			return true;
		}

		public string GetTextElement()
		{
			string text = _currentTextElementSubstr;
			if (text == null)
			{
				if (_currentTextElementOffset >= _str.Length)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
				text = (_currentTextElementSubstr = _str.Substring(_currentTextElementOffset, _currentTextElementLength));
			}
			return text;
		}

		public void Reset()
		{
			_currentTextElementOffset = _str.Length;
			_currentTextElementLength = _strStartIndex - _str.Length;
			_currentTextElementSubstr = null;
		}
	}
	public sealed class TextInfo : ICloneable, IDeserializationCallback
	{
		private enum Tristate : byte
		{
			NotInitialized,
			False,
			True
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private readonly struct ToUpperConversion
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private readonly struct ToLowerConversion
		{
		}

		private string _listSeparator;

		private bool _isReadOnly;

		private readonly string _cultureName;

		private readonly CultureData _cultureData;

		private readonly string _textInfoName;

		private Tristate _isAsciiCasingSameAsInvariant;

		internal static readonly TextInfo Invariant = new TextInfo(CultureData.Invariant, readOnly: true)
		{
			_isAsciiCasingSameAsInvariant = Tristate.True
		};

		private Tristate _needsTurkishCasing;

		private IntPtr _sortHandle;

		public int ANSICodePage => _cultureData.ANSICodePage;

		public int OEMCodePage => _cultureData.OEMCodePage;

		public int MacCodePage => _cultureData.MacCodePage;

		public int EBCDICCodePage => _cultureData.EBCDICCodePage;

		public int LCID => CultureInfo.GetCultureInfo(_textInfoName).LCID;

		public string CultureName => _textInfoName;

		public bool IsReadOnly => _isReadOnly;

		public string ListSeparator
		{
			get
			{
				return _listSeparator ?? (_listSeparator = _cultureData.ListSeparator);
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				VerifyWritable();
				_listSeparator = value;
			}
		}

		private bool IsAsciiCasingSameAsInvariant
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (_isAsciiCasingSameAsInvariant == Tristate.NotInitialized)
				{
					PopulateIsAsciiCasingSameAsInvariant();
				}
				return _isAsciiCasingSameAsInvariant == Tristate.True;
			}
		}

		public bool IsRightToLeft => _cultureData.IsRightToLeft;

		private bool IsInvariant => _cultureName.Length == 0;

		internal TextInfo(CultureData cultureData)
		{
			_cultureData = cultureData;
			_cultureName = _cultureData.CultureName;
			_textInfoName = _cultureData.TextInfoName;
			if (GlobalizationMode.UseNls)
			{
				_sortHandle = CompareInfo.NlsGetSortHandle(_textInfoName);
			}
		}

		private TextInfo(CultureData cultureData, bool readOnly)
			: this(cultureData)
		{
			SetReadOnlyState(readOnly);
		}

		void IDeserializationCallback.OnDeserialization(object sender)
		{
			throw new PlatformNotSupportedException();
		}

		public object Clone()
		{
			object obj = MemberwiseClone();
			((TextInfo)obj).SetReadOnlyState(readOnly: false);
			return obj;
		}

		public static TextInfo ReadOnly(TextInfo textInfo)
		{
			if (textInfo == null)
			{
				throw new ArgumentNullException("textInfo");
			}
			if (textInfo.IsReadOnly)
			{
				return textInfo;
			}
			TextInfo textInfo2 = (TextInfo)textInfo.MemberwiseClone();
			textInfo2.SetReadOnlyState(readOnly: true);
			return textInfo2;
		}

		private void VerifyWritable()
		{
			if (_isReadOnly)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
			}
		}

		internal void SetReadOnlyState(bool readOnly)
		{
			_isReadOnly = readOnly;
		}

		public char ToLower(char c)
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.ToLower(c);
			}
			if (UnicodeUtility.IsAsciiCodePoint(c) && IsAsciiCasingSameAsInvariant)
			{
				return ToLowerAsciiInvariant(c);
			}
			return ChangeCase(c, toUpper: false);
		}

		internal static char ToLowerInvariant(char c)
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.ToLower(c);
			}
			if (UnicodeUtility.IsAsciiCodePoint(c))
			{
				return ToLowerAsciiInvariant(c);
			}
			return Invariant.ChangeCase(c, toUpper: false);
		}

		public string ToLower(string str)
		{
			if (str == null)
			{
				throw new ArgumentNullException("str");
			}
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.ToLower(str);
			}
			return ChangeCaseCommon<ToLowerConversion>(str);
		}

		private unsafe char ChangeCase(char c, bool toUpper)
		{
			char result = '\0';
			ChangeCaseCore(&c, 1, &result, 1, toUpper);
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ChangeCaseToLower(ReadOnlySpan<char> source, Span<char> destination)
		{
			ChangeCaseCommon<ToLowerConversion>(ref MemoryMarshal.GetReference(source), ref MemoryMarshal.GetReference(destination), source.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ChangeCaseToUpper(ReadOnlySpan<char> source, Span<char> destination)
		{
			ChangeCaseCommon<ToUpperConversion>(ref MemoryMarshal.GetReference(source), ref MemoryMarshal.GetReference(destination), source.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void ChangeCaseCommon<TConversion>(ReadOnlySpan<char> source, Span<char> destination) where TConversion : struct
		{
			ChangeCaseCommon<TConversion>(ref MemoryMarshal.GetReference(source), ref MemoryMarshal.GetReference(destination), source.Length);
		}

		private unsafe void ChangeCaseCommon<TConversion>(ref char source, ref char destination, int charCount) where TConversion : struct
		{
			bool flag = typeof(TConversion) == typeof(ToUpperConversion);
			if (charCount == 0)
			{
				return;
			}
			fixed (char* ptr = &source)
			{
				fixed (char* ptr2 = &destination)
				{
					nuint num = 0u;
					if (IsAsciiCasingSameAsInvariant)
					{
						if (charCount < 4)
						{
							goto IL_00e5;
						}
						nuint num2 = (uint)(charCount - 4);
						while (true)
						{
							uint value = Unsafe.ReadUnaligned<uint>(ptr + num);
							if (!Utf16Utility.AllCharsInUInt32AreAscii(value))
							{
								break;
							}
							value = (flag ? Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(value) : Utf16Utility.ConvertAllAsciiCharsInUInt32ToLowercase(value));
							Unsafe.WriteUnaligned(ptr2 + num, value);
							value = Unsafe.ReadUnaligned<uint>(ptr + num + 2);
							if (Utf16Utility.AllCharsInUInt32AreAscii(value))
							{
								value = (flag ? Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(value) : Utf16Utility.ConvertAllAsciiCharsInUInt32ToLowercase(value));
								Unsafe.WriteUnaligned(ptr2 + num + 2, value);
								num += 4;
								if (num <= num2)
								{
									continue;
								}
								goto IL_00e5;
							}
							num += 2;
							break;
						}
						goto IL_0171;
					}
					goto IL_0178;
					IL_0178:
					ChangeCaseCore(ptr + num, charCount, ptr2 + num, charCount, flag);
					return;
					IL_0171:
					charCount -= (int)num;
					goto IL_0178;
					IL_00e5:
					if (((uint)charCount & 2u) != 0)
					{
						uint value2 = Unsafe.ReadUnaligned<uint>(ptr + num);
						if (!Utf16Utility.AllCharsInUInt32AreAscii(value2))
						{
							goto IL_0171;
						}
						value2 = (flag ? Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(value2) : Utf16Utility.ConvertAllAsciiCharsInUInt32ToLowercase(value2));
						Unsafe.WriteUnaligned(ptr2 + num, value2);
						num += 2;
					}
					if (((uint)charCount & (true ? 1u : 0u)) != 0)
					{
						uint num3 = ptr[num];
						if (num3 <= 127)
						{
							num3 = (flag ? Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(num3) : Utf16Utility.ConvertAllAsciiCharsInUInt32ToLowercase(num3));
							ptr2[num] = (char)num3;
							return;
						}
						goto IL_0171;
					}
				}
			}
		}

		private unsafe string ChangeCaseCommon<TConversion>(string source) where TConversion : struct
		{
			bool flag = typeof(TConversion) == typeof(ToUpperConversion);
			if (source.Length == 0)
			{
				return string.Empty;
			}
			fixed (char* ptr = source)
			{
				nuint num = 0u;
				if (IsAsciiCasingSameAsInvariant)
				{
					if (source.Length < 2)
					{
						goto IL_0095;
					}
					nuint num2 = (uint)(source.Length - 2);
					while (true)
					{
						uint value = Unsafe.ReadUnaligned<uint>(ptr + num);
						if (!Utf16Utility.AllCharsInUInt32AreAscii(value))
						{
							break;
						}
						if (!(flag ? Utf16Utility.UInt32ContainsAnyLowercaseAsciiChar(value) : Utf16Utility.UInt32ContainsAnyUppercaseAsciiChar(value)))
						{
							num += 2;
							if (num <= num2)
							{
								continue;
							}
							goto IL_0095;
						}
						goto IL_00d1;
					}
				}
				goto IL_0121;
				IL_00d1:
				string text = string.FastAllocateString(source.Length);
				Span<char> destination = new Span<char>(ref text.GetRawStringData(), text.Length);
				source.AsSpan(0, (int)num).CopyTo(destination);
				ChangeCaseCommon<TConversion>(source.AsSpan((int)num), destination.Slice((int)num));
				return text;
				IL_0095:
				if (((uint)source.Length & (true ? 1u : 0u)) != 0)
				{
					uint num3 = ptr[num];
					if (num3 > 127)
					{
						goto IL_0121;
					}
					if (flag ? (num3 - 97 <= 25) : (num3 - 65 <= 25))
					{
						goto IL_00d1;
					}
				}
				return source;
				IL_0121:
				string text2 = string.FastAllocateString(source.Length);
				if (num != 0)
				{
					Span<char> destination2 = new Span<char>(ref text2.GetRawStringData(), text2.Length);
					source.AsSpan(0, (int)num).CopyTo(destination2);
				}
				fixed (char* ptr2 = text2)
				{
					ChangeCaseCore(ptr + num, source.Length - (int)num, ptr2 + num, text2.Length - (int)num, flag);
				}
				return text2;
			}
		}

		internal unsafe static string ToLowerAsciiInvariant(string s)
		{
			if (s.Length == 0)
			{
				return string.Empty;
			}
			fixed (char* ptr = s)
			{
				int i;
				for (i = 0; i < s.Length && (uint)(ptr[i] - 65) > 25u; i++)
				{
				}
				if (i >= s.Length)
				{
					return s;
				}
				string text = string.FastAllocateString(s.Length);
				fixed (char* ptr2 = text)
				{
					for (int j = 0; j < i; j++)
					{
						ptr2[j] = ptr[j];
					}
					ptr2[i] = (char)(ptr[i] | 0x20u);
					for (i++; i < s.Length; i++)
					{
						ptr2[i] = ToLowerAsciiInvariant(ptr[i]);
					}
				}
				return text;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static char ToLowerAsciiInvariant(char c)
		{
			if (UnicodeUtility.IsInRangeInclusive(c, 65u, 90u))
			{
				c = (char)(byte)(c | 0x20u);
			}
			return c;
		}

		public char ToUpper(char c)
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.ToUpper(c);
			}
			if (UnicodeUtility.IsAsciiCodePoint(c) && IsAsciiCasingSameAsInvariant)
			{
				return ToUpperAsciiInvariant(c);
			}
			return ChangeCase(c, toUpper: true);
		}

		internal static char ToUpperInvariant(char c)
		{
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.ToUpper(c);
			}
			if (UnicodeUtility.IsAsciiCodePoint(c))
			{
				return ToUpperAsciiInvariant(c);
			}
			return Invariant.ChangeCase(c, toUpper: true);
		}

		public string ToUpper(string str)
		{
			if (str == null)
			{
				throw new ArgumentNullException("str");
			}
			if (GlobalizationMode.Invariant)
			{
				return InvariantModeCasing.ToUpper(str);
			}
			return ChangeCaseCommon<ToUpperConversion>(str);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static char ToUpperAsciiInvariant(char c)
		{
			if (UnicodeUtility.IsInRangeInclusive(c, 97u, 122u))
			{
				c = (char)(c & 0x5Fu);
			}
			return c;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void PopulateIsAsciiCasingSameAsInvariant()
		{
			bool flag = CultureInfo.GetCultureInfo(_textInfoName).CompareInfo.Compare("abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", CompareOptions.IgnoreCase) == 0;
			_isAsciiCasingSameAsInvariant = ((!flag) ? Tristate.False : Tristate.True);
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is TextInfo textInfo)
			{
				return CultureName.Equals(textInfo.CultureName);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return CultureName.GetHashCode();
		}

		public override string ToString()
		{
			return "TextInfo - " + _cultureData.CultureName;
		}

		public string ToTitleCase(string str)
		{
			if (str == null)
			{
				throw new ArgumentNullException("str");
			}
			if (str.Length == 0)
			{
				return str;
			}
			StringBuilder result = new StringBuilder();
			string text = null;
			bool flag = CultureName.StartsWith("nl-", StringComparison.OrdinalIgnoreCase);
			int num;
			for (num = 0; num < str.Length; num++)
			{
				UnicodeCategory unicodeCategoryInternal = CharUnicodeInfo.GetUnicodeCategoryInternal(str, num, out var charLength);
				if (char.CheckLetter(unicodeCategoryInternal))
				{
					if (flag && num < str.Length - 1 && (str[num] == 'i' || str[num] == 'I') && (str[num + 1] == 'j' || str[num + 1] == 'J'))
					{
						result.Append("IJ");
						num += 2;
					}
					else
					{
						num = AddTitlecaseLetter(ref result, ref str, num, charLength) + 1;
					}
					int num2 = num;
					bool flag2 = unicodeCategoryInternal == UnicodeCategory.LowercaseLetter;
					while (num < str.Length)
					{
						unicodeCategoryInternal = CharUnicodeInfo.GetUnicodeCategoryInternal(str, num, out charLength);
						if (IsLetterCategory(unicodeCategoryInternal))
						{
							if (unicodeCategoryInternal == UnicodeCategory.LowercaseLetter)
							{
								flag2 = true;
							}
							num += charLength;
						}
						else if (str[num] == '\'')
						{
							num++;
							if (flag2)
							{
								if (text == null)
								{
									text = ToLower(str);
								}
								result.Append(text, num2, num - num2);
							}
							else
							{
								result.Append(str, num2, num - num2);
							}
							num2 = num;
							flag2 = true;
						}
						else
						{
							if (IsWordSeparator(unicodeCategoryInternal))
							{
								break;
							}
							num += charLength;
						}
					}
					int num3 = num - num2;
					if (num3 > 0)
					{
						if (flag2)
						{
							if (text == null)
							{
								text = ToLower(str);
							}
							result.Append(text, num2, num3);
						}
						else
						{
							result.Append(str, num2, num3);
						}
					}
					if (num < str.Length)
					{
						num = AddNonLetter(ref result, ref str, num, charLength);
					}
				}
				else
				{
					num = AddNonLetter(ref result, ref str, num, charLength);
				}
			}
			return result.ToString();
		}

		private static int AddNonLetter(ref StringBuilder result, ref string input, int inputIndex, int charLen)
		{
			if (charLen == 2)
			{
				result.Append(input[inputIndex++]);
				result.Append(input[inputIndex]);
			}
			else
			{
				result.Append(input[inputIndex]);
			}
			return inputIndex;
		}

		private int AddTitlecaseLetter(ref StringBuilder result, ref string input, int inputIndex, int charLen)
		{
			if (charLen == 2)
			{
				ReadOnlySpan<char> source = input.AsSpan(inputIndex, 2);
				if (GlobalizationMode.Invariant)
				{
					SurrogateCasing.ToUpper(source[0], source[1], out var hr, out var lr);
					result.Append(hr);
					result.Append(lr);
				}
				else
				{
					Span<char> span = stackalloc char[2];
					ChangeCaseToUpper(source, span);
					result.Append(span);
				}
				inputIndex++;
			}
			else
			{
				switch (input[inputIndex])
				{
				case 'DŽ':
				case 'Dž':
				case 'dž':
					result.Append('Dž');
					break;
				case 'LJ':
				case 'Lj':
				case 'lj':
					result.Append('Lj');
					break;
				case 'NJ':
				case 'Nj':
				case 'nj':
					result.Append('Nj');
					break;
				case 'DZ':
				case 'Dz':
				case 'dz':
					result.Append('Dz');
					break;
				default:
					result.Append(GlobalizationMode.Invariant ? InvariantModeCasing.ToUpper(input[inputIndex]) : ToUpper(input[inputIndex]));
					break;
				}
			}
			return inputIndex;
		}

		private unsafe void ChangeCaseCore(char* src, int srcLen, char* dstBuffer, int dstBufferCapacity, bool bToUpper)
		{
			if (GlobalizationMode.UseNls)
			{
				NlsChangeCase(src, srcLen, dstBuffer, dstBufferCapacity, bToUpper);
			}
			else
			{
				IcuChangeCase(src, srcLen, dstBuffer, dstBufferCapacity, bToUpper);
			}
		}

		private static bool IsWordSeparator(UnicodeCategory category)
		{
			return (0x1FFCF800 & (1 << (int)category)) != 0;
		}

		private static bool IsLetterCategory(UnicodeCategory uc)
		{
			if (uc != 0 && uc != UnicodeCategory.LowercaseLetter && uc != UnicodeCategory.TitlecaseLetter && uc != UnicodeCategory.ModifierLetter)
			{
				return uc == UnicodeCategory.OtherLetter;
			}
			return true;
		}

		private static bool NeedsTurkishCasing(string localeName)
		{
			return CultureInfo.GetCultureInfo(localeName).CompareInfo.Compare("ı", "I", CompareOptions.IgnoreCase) == 0;
		}

		internal unsafe void IcuChangeCase(char* src, int srcLen, char* dstBuffer, int dstBufferCapacity, bool bToUpper)
		{
			if (IsInvariant)
			{
				Interop.Globalization.ChangeCaseInvariant(src, srcLen, dstBuffer, dstBufferCapacity, bToUpper);
				return;
			}
			if (_needsTurkishCasing == Tristate.NotInitialized)
			{
				_needsTurkishCasing = ((!NeedsTurkishCasing(_textInfoName)) ? Tristate.False : Tristate.True);
			}
			if (_needsTurkishCasing == Tristate.True)
			{
				Interop.Globalization.ChangeCaseTurkish(src, srcLen, dstBuffer, dstBufferCapacity, bToUpper);
			}
			else
			{
				Interop.Globalization.ChangeCase(src, srcLen, dstBuffer, dstBufferCapacity, bToUpper);
			}
		}

		private unsafe void NlsChangeCase(char* pSource, int pSourceLen, char* pResult, int pResultLen, bool toUpper)
		{
			uint num = ((!IsInvariantLocale(_textInfoName)) ? 16777216u : 0u);
			if (Interop.Kernel32.LCMapStringEx((_sortHandle != IntPtr.Zero) ? null : _textInfoName, num | (toUpper ? 512u : 256u), pSource, pSourceLen, pResult, pSourceLen, null, null, _sortHandle) == 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
			}
		}

		private static bool IsInvariantLocale(string localeName)
		{
			return localeName == "";
		}
	}
	public class ThaiBuddhistCalendar : Calendar
	{
		private static readonly EraInfo[] s_thaiBuddhistEraInfo = new EraInfo[1]
		{
			new EraInfo(1, 1, 1, 1, -543, 544, 10542)
		};

		public const int ThaiBuddhistEra = 1;

		private readonly GregorianCalendarHelper _helper;

		public override DateTime MinSupportedDateTime => DateTime.MinValue;

		public override DateTime MaxSupportedDateTime => DateTime.MaxValue;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.SolarCalendar;

		internal override CalendarId ID => CalendarId.THAI;

		public override int[] Eras => _helper.Eras;

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 2572);
				}
				return _twoDigitYearMax;
			}
			set
			{
				VerifyWritable();
				if (value < 99 || value > _helper.MaxYear)
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 99, _helper.MaxYear));
				}
				_twoDigitYearMax = value;
			}
		}

		public ThaiBuddhistCalendar()
		{
			_helper = new GregorianCalendarHelper(this, s_thaiBuddhistEraInfo);
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			return _helper.AddMonths(time, months);
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return _helper.AddYears(time, years);
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			return _helper.GetDaysInMonth(year, month, era);
		}

		public override int GetDaysInYear(int year, int era)
		{
			return _helper.GetDaysInYear(year, era);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return _helper.GetDayOfMonth(time);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return _helper.GetDayOfWeek(time);
		}

		public override int GetDayOfYear(DateTime time)
		{
			return _helper.GetDayOfYear(time);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			return _helper.GetMonthsInYear(year, era);
		}

		public override int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
		{
			return _helper.GetWeekOfYear(time, rule, firstDayOfWeek);
		}

		public override int GetEra(DateTime time)
		{
			return _helper.GetEra(time);
		}

		public override int GetMonth(DateTime time)
		{
			return _helper.GetMonth(time);
		}

		public override int GetYear(DateTime time)
		{
			return _helper.GetYear(time);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			return _helper.IsLeapDay(year, month, day, era);
		}

		public override bool IsLeapYear(int year, int era)
		{
			return _helper.IsLeapYear(year, era);
		}

		public override int GetLeapMonth(int year, int era)
		{
			return _helper.GetLeapMonth(year, era);
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			return _helper.IsLeapMonth(year, month, era);
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			return _helper.ToDateTime(year, month, day, hour, minute, second, millisecond, era);
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return _helper.ToFourDigitYear(year, TwoDigitYearMax);
		}
	}
	internal static class TimeSpanFormat
	{
		private enum StandardFormat
		{
			C,
			G,
			g
		}

		internal struct FormatLiterals
		{
			internal string AppCompatLiteral;

			internal int dd;

			internal int hh;

			internal int mm;

			internal int ss;

			internal int ff;

			private string[] _literals;

			internal string Start => _literals[0];

			internal string DayHourSep => _literals[1];

			internal string HourMinuteSep => _literals[2];

			internal string MinuteSecondSep => _literals[3];

			internal string SecondFractionSep => _literals[4];

			internal string End => _literals[5];

			internal static FormatLiterals InitInvariant(bool isNegative)
			{
				FormatLiterals result = default(FormatLiterals);
				result._literals = new string[6];
				result._literals[0] = (isNegative ? "-" : string.Empty);
				result._literals[1] = ".";
				result._literals[2] = ":";
				result._literals[3] = ":";
				result._literals[4] = ".";
				result._literals[5] = string.Empty;
				result.AppCompatLiteral = ":.";
				result.dd = 2;
				result.hh = 2;
				result.mm = 2;
				result.ss = 2;
				result.ff = 7;
				return result;
			}

			internal void Init(ReadOnlySpan<char> format, bool useInvariantFieldLengths)
			{
				dd = (hh = (mm = (ss = (ff = 0))));
				_literals = new string[6];
				for (int i = 0; i < _literals.Length; i++)
				{
					_literals[i] = string.Empty;
				}
				StringBuilder stringBuilder = StringBuilderCache.Acquire();
				bool flag = false;
				char c = '\'';
				int num = 0;
				for (int j = 0; j < format.Length; j++)
				{
					switch (format[j])
					{
					case '"':
					case '\'':
						if (flag && c == format[j])
						{
							if (num < 0 || num > 5)
							{
								return;
							}
							_literals[num] = stringBuilder.ToString();
							stringBuilder.Length = 0;
							flag = false;
						}
						else if (!flag)
						{
							c = format[j];
							flag = true;
						}
						continue;
					case '\\':
						if (!flag)
						{
							j++;
							continue;
						}
						break;
					case 'd':
						if (!flag)
						{
							num = 1;
							dd++;
						}
						continue;
					case 'h':
						if (!flag)
						{
							num = 2;
							hh++;
						}
						continue;
					case 'm':
						if (!flag)
						{
							num = 3;
							mm++;
						}
						continue;
					case 's':
						if (!flag)
						{
							num = 4;
							ss++;
						}
						continue;
					case 'F':
					case 'f':
						if (!flag)
						{
							num = 5;
							ff++;
						}
						continue;
					}
					stringBuilder.Append(format[j]);
				}
				AppCompatLiteral = MinuteSecondSep + SecondFractionSep;
				if (useInvariantFieldLengths)
				{
					dd = 2;
					hh = 2;
					mm = 2;
					ss = 2;
					ff = 7;
				}
				else
				{
					if (dd < 1 || dd > 2)
					{
						dd = 2;
					}
					if (hh < 1 || hh > 2)
					{
						hh = 2;
					}
					if (mm < 1 || mm > 2)
					{
						mm = 2;
					}
					if (ss < 1 || ss > 2)
					{
						ss = 2;
					}
					if (ff < 1 || ff > 7)
					{
						ff = 7;
					}
				}
				StringBuilderCache.Release(stringBuilder);
			}
		}

		internal static readonly FormatLiterals PositiveInvariantFormatLiterals = FormatLiterals.InitInvariant(isNegative: false);

		internal static readonly FormatLiterals NegativeInvariantFormatLiterals = FormatLiterals.InitInvariant(isNegative: true);

		internal static string Format(TimeSpan value, string format, IFormatProvider formatProvider)
		{
			if (string.IsNullOrEmpty(format))
			{
				return FormatC(value);
			}
			if (format.Length == 1)
			{
				char c = format[0];
				if (c == 'c' || (c | 0x20) == 116)
				{
					return FormatC(value);
				}
				if ((c | 0x20) == 103)
				{
					return FormatG(value, DateTimeFormatInfo.GetInstance(formatProvider), (c == 'G') ? StandardFormat.G : StandardFormat.g);
				}
				throw new FormatException(SR.Format_InvalidString);
			}
			return StringBuilderCache.GetStringAndRelease(FormatCustomized(value, format, DateTimeFormatInfo.GetInstance(formatProvider)));
		}

		internal static bool TryFormat(TimeSpan value, Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider formatProvider)
		{
			if (format.Length == 0)
			{
				return TryFormatStandard(value, StandardFormat.C, null, destination, out charsWritten);
			}
			if (format.Length == 1)
			{
				char c = format[0];
				if (c == 'c' || (c | 0x20) == 116)
				{
					return TryFormatStandard(value, StandardFormat.C, null, destination, out charsWritten);
				}
				return TryFormatStandard(value, c switch
				{
					'G' => StandardFormat.G, 
					'g' => StandardFormat.g, 
					_ => throw new FormatException(SR.Format_InvalidString), 
				}, DateTimeFormatInfo.GetInstance(formatProvider).DecimalSeparator, destination, out charsWritten);
			}
			StringBuilder stringBuilder = FormatCustomized(value, format, DateTimeFormatInfo.GetInstance(formatProvider));
			if (stringBuilder.Length <= destination.Length)
			{
				stringBuilder.CopyTo(0, destination, stringBuilder.Length);
				charsWritten = stringBuilder.Length;
				StringBuilderCache.Release(stringBuilder);
				return true;
			}
			charsWritten = 0;
			StringBuilderCache.Release(stringBuilder);
			return false;
		}

		internal static string FormatC(TimeSpan value)
		{
			Span<char> destination = stackalloc char[26];
			TryFormatStandard(value, StandardFormat.C, null, destination, out var charsWritten);
			return new string(destination.Slice(0, charsWritten));
		}

		private static string FormatG(TimeSpan value, DateTimeFormatInfo dtfi, StandardFormat format)
		{
			string decimalSeparator = dtfi.DecimalSeparator;
			int num = 25 + decimalSeparator.Length;
			Span<char> span = ((num >= 128) ? ((Span<char>)new char[num]) : stackalloc char[num]);
			Span<char> destination = span;
			TryFormatStandard(value, format, decimalSeparator, destination, out var charsWritten);
			return new string(destination.Slice(0, charsWritten));
		}

		private static bool TryFormatStandard(TimeSpan value, StandardFormat format, string decimalSeparator, Span<char> destination, out int charsWritten)
		{
			int num = 8;
			long num2 = value.Ticks;
			uint valueWithoutTrailingZeros;
			ulong num3;
			if (num2 < 0)
			{
				num = 9;
				num2 = -num2;
				if (num2 < 0)
				{
					valueWithoutTrailingZeros = 4775808u;
					num3 = 922337203685uL;
					goto IL_0050;
				}
			}
			(ulong Quotient, ulong Remainder) tuple = Math.DivRem((ulong)num2, 10000000uL);
			num3 = tuple.Quotient;
			ulong item = tuple.Remainder;
			valueWithoutTrailingZeros = (uint)item;
			goto IL_0050;
			IL_0050:
			int num4 = 0;
			switch (format)
			{
			case StandardFormat.C:
				if (valueWithoutTrailingZeros != 0)
				{
					num4 = 7;
					num += num4 + 1;
				}
				break;
			case StandardFormat.G:
				num4 = 7;
				num += num4 + 1;
				break;
			default:
				if (valueWithoutTrailingZeros != 0)
				{
					num4 = 7 - FormattingHelpers.CountDecimalTrailingZeros(valueWithoutTrailingZeros, out valueWithoutTrailingZeros);
					num += num4 + 1;
				}
				break;
			}
			ulong num5 = 0uL;
			ulong num6 = 0uL;
			if (num3 != 0)
			{
				(num5, num6) = Math.DivRem(num3, 60uL);
			}
			ulong num7 = 0uL;
			ulong num8 = 0uL;
			if (num5 != 0)
			{
				(num7, num8) = Math.DivRem(num5, 60uL);
			}
			uint num9 = 0u;
			uint num10 = 0u;
			if (num7 != 0)
			{
				(num9, num10) = Math.DivRem((uint)num7, 24u);
			}
			int num11 = 2;
			if (format == StandardFormat.g && num10 < 10)
			{
				num11 = 1;
				num--;
			}
			int num12 = 0;
			if (num9 != 0)
			{
				num12 = FormattingHelpers.CountDigits(num9);
				num += num12 + 1;
			}
			else if (format == StandardFormat.G)
			{
				num += 2;
				num12 = 1;
			}
			if (destination.Length < num)
			{
				charsWritten = 0;
				return false;
			}
			int num13 = 0;
			if (value.Ticks < 0)
			{
				destination[num13++] = '-';
			}
			if (num12 != 0)
			{
				WriteDigits(num9, destination.Slice(num13, num12));
				num13 += num12;
				destination[num13++] = ((format == StandardFormat.C) ? '.' : ':');
			}
			if (num11 == 2)
			{
				WriteTwoDigits(num10, destination.Slice(num13));
				num13 += 2;
			}
			else
			{
				destination[num13++] = (char)(48 + num10);
			}
			destination[num13++] = ':';
			WriteTwoDigits((uint)num8, destination.Slice(num13));
			num13 += 2;
			destination[num13++] = ':';
			WriteTwoDigits((uint)num6, destination.Slice(num13));
			num13 += 2;
			if (num4 != 0)
			{
				if (format == StandardFormat.C)
				{
					destination[num13++] = '.';
				}
				else if (decimalSeparator.Length == 1)
				{
					destination[num13++] = decimalSeparator[0];
				}
				else
				{
					decimalSeparator.CopyTo(destination);
					num13 += decimalSeparator.Length;
				}
				WriteDigits(valueWithoutTrailingZeros, destination.Slice(num13, num4));
				num13 += num4;
			}
			charsWritten = num;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteTwoDigits(uint value, Span<char> buffer)
		{
			uint num = 48 + value;
			value /= 10;
			buffer[1] = (char)(num - value * 10);
			buffer[0] = (char)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteDigits(uint value, Span<char> buffer)
		{
			for (int num = buffer.Length - 1; num >= 1; num--)
			{
				uint num2 = 48 + value;
				value /= 10;
				buffer[num] = (char)(num2 - value * 10);
			}
			buffer[0] = (char)(48 + value);
		}

		private static StringBuilder FormatCustomized(TimeSpan value, ReadOnlySpan<char> format, DateTimeFormatInfo dtfi, StringBuilder result = null)
		{
			bool flag = false;
			if (result == null)
			{
				result = StringBuilderCache.Acquire();
				flag = true;
			}
			int num = (int)(value.Ticks / 864000000000L);
			long num2 = value.Ticks % 864000000000L;
			if (value.Ticks < 0)
			{
				num = -num;
				num2 = -num2;
			}
			int value2 = (int)(num2 / 36000000000L % 24);
			int value3 = (int)(num2 / 600000000 % 60);
			int value4 = (int)(num2 / 10000000 % 60);
			int num3 = (int)(num2 % 10000000);
			long num4 = 0L;
			int num6;
			for (int i = 0; i < format.Length; i += num6)
			{
				char c = format[i];
				switch (c)
				{
				case 'h':
					num6 = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (num6 <= 2)
					{
						DateTimeFormat.FormatDigits(result, value2, num6);
						continue;
					}
					break;
				case 'm':
					num6 = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (num6 <= 2)
					{
						DateTimeFormat.FormatDigits(result, value3, num6);
						continue;
					}
					break;
				case 's':
					num6 = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (num6 <= 2)
					{
						DateTimeFormat.FormatDigits(result, value4, num6);
						continue;
					}
					break;
				case 'f':
					num6 = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (num6 <= 7)
					{
						num4 = num3;
						num4 /= TimeSpanParse.Pow10(7 - num6);
						result.AppendSpanFormattable(num4, DateTimeFormat.fixedNumberFormats[num6 - 1], CultureInfo.InvariantCulture);
						continue;
					}
					break;
				case 'F':
					num6 = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (num6 <= 7)
					{
						num4 = num3;
						num4 /= TimeSpanParse.Pow10(7 - num6);
						int num7 = num6;
						while (num7 > 0 && num4 % 10 == 0L)
						{
							num4 /= 10;
							num7--;
						}
						if (num7 > 0)
						{
							result.AppendSpanFormattable(num4, DateTimeFormat.fixedNumberFormats[num7 - 1], CultureInfo.InvariantCulture);
						}
						continue;
					}
					break;
				case 'd':
					num6 = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (num6 <= 8)
					{
						DateTimeFormat.FormatDigits(result, num, num6, overrideLengthLimit: true);
						continue;
					}
					break;
				case '"':
				case '\'':
					num6 = DateTimeFormat.ParseQuoteString(format, i, result);
					continue;
				case '%':
				{
					int num5 = DateTimeFormat.ParseNextChar(format, i);
					if (num5 >= 0 && num5 != 37)
					{
						char reference = (char)num5;
						StringBuilder stringBuilder = FormatCustomized(value, MemoryMarshal.CreateReadOnlySpan(ref reference, 1), dtfi, result);
						num6 = 2;
						continue;
					}
					break;
				}
				case '\\':
				{
					int num5 = DateTimeFormat.ParseNextChar(format, i);
					if (num5 >= 0)
					{
						result.Append((char)num5);
						num6 = 2;
						continue;
					}
					break;
				}
				}
				if (flag)
				{
					StringBuilderCache.Release(result);
				}
				throw new FormatException(SR.Format_InvalidString);
			}
			return result;
		}
	}
	internal static class TimeSpanParse
	{
		[Flags]
		private enum TimeSpanStandardStyles : byte
		{
			None = 0,
			Invariant = 1,
			Localized = 2,
			RequireFull = 4,
			Any = 3
		}

		private enum TTT : byte
		{
			None,
			End,
			Num,
			Sep,
			NumOverflow
		}

		private ref struct TimeSpanToken
		{
			internal TTT _ttt;

			internal int _num;

			internal int _zeroes;

			internal ReadOnlySpan<char> _sep;

			public TimeSpanToken(TTT type)
				: this(type, 0, 0, default(ReadOnlySpan<char>))
			{
			}

			public TimeSpanToken(int number)
				: this(TTT.Num, number, 0, default(ReadOnlySpan<char>))
			{
			}

			public TimeSpanToken(int number, int leadingZeroes)
				: this(TTT.Num, number, leadingZeroes, default(ReadOnlySpan<char>))
			{
			}

			public TimeSpanToken(TTT type, int number, int leadingZeroes, ReadOnlySpan<char> separator)
			{
				_ttt = type;
				_num = number;
				_zeroes = leadingZeroes;
				_sep = separator;
			}

			public bool NormalizeAndValidateFraction()
			{
				if (_num == 0)
				{
					return true;
				}
				if (_zeroes == 0 && _num > 9999999)
				{
					return false;
				}
				int num = (int)Math.Floor(Math.Log10(_num)) + 1 + _zeroes;
				if (num == 7)
				{
					return true;
				}
				if (num < 7)
				{
					_num *= (int)Pow10(7 - num);
					return true;
				}
				_num = (int)Math.Round((double)_num / (double)Pow10(num - 7), MidpointRounding.AwayFromZero);
				return true;
			}
		}

		private ref struct TimeSpanTokenizer
		{
			private readonly ReadOnlySpan<char> _value;

			private int _pos;

			internal bool EOL => _pos >= _value.Length - 1;

			internal char NextChar
			{
				get
				{
					int num = ++_pos;
					if ((uint)num >= (uint)_value.Length)
					{
						return '\0';
					}
					return _value[num];
				}
			}

			internal TimeSpanTokenizer(ReadOnlySpan<char> input)
				: this(input, 0)
			{
			}

			internal TimeSpanTokenizer(ReadOnlySpan<char> input, int startPosition)
			{
				_value = input;
				_pos = startPosition;
			}

			internal TimeSpanToken GetNextToken()
			{
				int pos = _pos;
				if (pos >= _value.Length)
				{
					return new TimeSpanToken(TTT.End);
				}
				int num = _value[pos] - 48;
				if ((uint)num <= 9u)
				{
					int num2 = 0;
					if (num == 0)
					{
						num2 = 1;
						int num3;
						while (true)
						{
							if (++_pos >= _value.Length || (uint)(num3 = _value[_pos] - 48) > 9u)
							{
								return new TimeSpanToken(TTT.Num, 0, num2, default(ReadOnlySpan<char>));
							}
							if (num3 != 0)
							{
								break;
							}
							num2++;
						}
						num = num3;
					}
					while (++_pos < _value.Length)
					{
						int num4 = _value[_pos] - 48;
						if ((uint)num4 > 9u)
						{
							break;
						}
						num = num * 10 + num4;
						if ((num & 0xF0000000u) != 0L)
						{
							return new TimeSpanToken(TTT.NumOverflow);
						}
					}
					return new TimeSpanToken(TTT.Num, num, num2, default(ReadOnlySpan<char>));
				}
				int num5 = 1;
				while (++_pos < _value.Length && (uint)(_value[_pos] - 48) > 9u)
				{
					num5++;
				}
				return new TimeSpanToken(TTT.Sep, 0, 0, _value.Slice(pos, num5));
			}

			internal void BackOne()
			{
				if (_pos > 0)
				{
					_pos--;
				}
			}
		}

		private ref struct TimeSpanRawInfo
		{
			internal TTT _lastSeenTTT;

			internal int _tokenCount;

			internal int _sepCount;

			internal int _numCount;

			private TimeSpanFormat.FormatLiterals _posLoc;

			private TimeSpanFormat.FormatLiterals _negLoc;

			private bool _posLocInit;

			private bool _negLocInit;

			private string _fullPosPattern;

			private string _fullNegPattern;

			internal TimeSpanToken _numbers0;

			internal TimeSpanToken _numbers1;

			internal TimeSpanToken _numbers2;

			internal TimeSpanToken _numbers3;

			internal TimeSpanToken _numbers4;

			internal ReadOnlySpan<char> _literals0;

			internal ReadOnlySpan<char> _literals1;

			internal ReadOnlySpan<char> _literals2;

			internal ReadOnlySpan<char> _literals3;

			internal ReadOnlySpan<char> _literals4;

			internal ReadOnlySpan<char> _literals5;

			internal TimeSpanFormat.FormatLiterals PositiveLocalized
			{
				get
				{
					if (!_posLocInit)
					{
						_posLoc = default(TimeSpanFormat.FormatLiterals);
						_posLoc.Init(_fullPosPattern, useInvariantFieldLengths: false);
						_posLocInit = true;
					}
					return _posLoc;
				}
			}

			internal TimeSpanFormat.FormatLiterals NegativeLocalized
			{
				get
				{
					if (!_negLocInit)
					{
						_negLoc = default(TimeSpanFormat.FormatLiterals);
						_negLoc.Init(_fullNegPattern, useInvariantFieldLengths: false);
						_negLocInit = true;
					}
					return _negLoc;
				}
			}

			internal bool FullAppCompatMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 5 && _numCount == 4 && _literals0.EqualsOrdinal(pattern.Start) && _literals1.EqualsOrdinal(pattern.DayHourSep) && _literals2.EqualsOrdinal(pattern.HourMinuteSep) && _literals3.EqualsOrdinal(pattern.AppCompatLiteral))
				{
					return _literals4.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal bool PartialAppCompatMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 4 && _numCount == 3 && _literals0.EqualsOrdinal(pattern.Start) && _literals1.EqualsOrdinal(pattern.HourMinuteSep) && _literals2.EqualsOrdinal(pattern.AppCompatLiteral))
				{
					return _literals3.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal bool FullMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 6 && _numCount == 5 && _literals0.EqualsOrdinal(pattern.Start) && _literals1.EqualsOrdinal(pattern.DayHourSep) && _literals2.EqualsOrdinal(pattern.HourMinuteSep) && _literals3.EqualsOrdinal(pattern.MinuteSecondSep) && _literals4.EqualsOrdinal(pattern.SecondFractionSep))
				{
					return _literals5.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal bool FullDMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 2 && _numCount == 1 && _literals0.EqualsOrdinal(pattern.Start))
				{
					return _literals1.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal bool FullHMMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 3 && _numCount == 2 && _literals0.EqualsOrdinal(pattern.Start) && _literals1.EqualsOrdinal(pattern.HourMinuteSep))
				{
					return _literals2.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal bool FullDHMMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 4 && _numCount == 3 && _literals0.EqualsOrdinal(pattern.Start) && _literals1.EqualsOrdinal(pattern.DayHourSep) && _literals2.EqualsOrdinal(pattern.HourMinuteSep))
				{
					return _literals3.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal bool FullHMSMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 4 && _numCount == 3 && _literals0.EqualsOrdinal(pattern.Start) && _literals1.EqualsOrdinal(pattern.HourMinuteSep) && _literals2.EqualsOrdinal(pattern.MinuteSecondSep))
				{
					return _literals3.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal bool FullDHMSMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 5 && _numCount == 4 && _literals0.EqualsOrdinal(pattern.Start) && _literals1.EqualsOrdinal(pattern.DayHourSep) && _literals2.EqualsOrdinal(pattern.HourMinuteSep) && _literals3.EqualsOrdinal(pattern.MinuteSecondSep))
				{
					return _literals4.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal bool FullHMSFMatch(TimeSpanFormat.FormatLiterals pattern)
			{
				if (_sepCount == 5 && _numCount == 4 && _literals0.EqualsOrdinal(pattern.Start) && _literals1.EqualsOrdinal(pattern.HourMinuteSep) && _literals2.EqualsOrdinal(pattern.MinuteSecondSep) && _literals3.EqualsOrdinal(pattern.SecondFractionSep))
				{
					return _literals4.EqualsOrdinal(pattern.End);
				}
				return false;
			}

			internal void Init(DateTimeFormatInfo dtfi)
			{
				_lastSeenTTT = TTT.None;
				_tokenCount = 0;
				_sepCount = 0;
				_numCount = 0;
				_fullPosPattern = dtfi.FullTimeSpanPositivePattern;
				_fullNegPattern = dtfi.FullTimeSpanNegativePattern;
				_posLocInit = false;
				_negLocInit = false;
			}

			internal bool ProcessToken(ref TimeSpanToken tok, ref TimeSpanResult result)
			{
				switch (tok._ttt)
				{
				case TTT.Num:
					if ((_tokenCount == 0 && !AddSep(default(ReadOnlySpan<char>), ref result)) || !AddNum(tok, ref result))
					{
						return false;
					}
					break;
				case TTT.Sep:
					if (!AddSep(tok._sep, ref result))
					{
						return false;
					}
					break;
				case TTT.NumOverflow:
					return result.SetOverflowFailure();
				default:
					return result.SetBadTimeSpanFailure();
				}
				_lastSeenTTT = tok._ttt;
				return true;
			}

			private bool AddSep(ReadOnlySpan<char> sep, ref TimeSpanResult result)
			{
				if (_sepCount >= 6 || _tokenCount >= 11)
				{
					return result.SetBadTimeSpanFailure();
				}
				switch (_sepCount++)
				{
				case 0:
					_literals0 = sep;
					break;
				case 1:
					_literals1 = sep;
					break;
				case 2:
					_literals2 = sep;
					break;
				case 3:
					_literals3 = sep;
					break;
				case 4:
					_literals4 = sep;
					break;
				default:
					_literals5 = sep;
					break;
				}
				_tokenCount++;
				return true;
			}

			private bool AddNum(TimeSpanToken num, ref TimeSpanResult result)
			{
				if (_numCount >= 5 || _tokenCount >= 11)
				{
					return result.SetBadTimeSpanFailure();
				}
				switch (_numCount++)
				{
				case 0:
					_numbers0 = num;
					break;
				case 1:
					_numbers1 = num;
					break;
				case 2:
					_numbers2 = num;
					break;
				case 3:
					_numbers3 = num;
					break;
				default:
					_numbers4 = num;
					break;
				}
				_tokenCount++;
				return true;
			}
		}

		private ref struct TimeSpanResult
		{
			internal TimeSpan parsedTimeSpan;

			private readonly bool _throwOnFailure;

			private readonly ReadOnlySpan<char> _originalTimeSpanString;

			internal TimeSpanResult(bool throwOnFailure, ReadOnlySpan<char> originalTimeSpanString)
			{
				parsedTimeSpan = default(TimeSpan);
				_throwOnFailure = throwOnFailure;
				_originalTimeSpanString = originalTimeSpanString;
			}

			internal bool SetNoFormatSpecifierFailure()
			{
				if (!_throwOnFailure)
				{
					return false;
				}
				throw new FormatException(SR.Format_NoFormatSpecifier);
			}

			internal bool SetBadQuoteFailure(char failingCharacter)
			{
				if (!_throwOnFailure)
				{
					return false;
				}
				throw new FormatException(SR.Format(SR.Format_BadQuote, failingCharacter));
			}

			internal bool SetInvalidStringFailure()
			{
				if (!_throwOnFailure)
				{
					return false;
				}
				throw new FormatException(SR.Format_InvalidString);
			}

			internal bool SetArgumentNullFailure(string argumentName)
			{
				if (!_throwOnFailure)
				{
					return false;
				}
				throw new ArgumentNullException(argumentName, SR.ArgumentNull_String);
			}

			internal bool SetOverflowFailure()
			{
				if (!_throwOnFailure)
				{
					return false;
				}
				throw new OverflowException(SR.Format(SR.Overflow_TimeSpanElementTooLarge, new string(_originalTimeSpanString)));
			}

			internal bool SetBadTimeSpanFailure()
			{
				if (!_throwOnFailure)
				{
					return false;
				}
				throw new FormatException(SR.Format(SR.Format_BadTimeSpan, new string(_originalTimeSpanString)));
			}

			internal bool SetBadFormatSpecifierFailure(char? formatSpecifierCharacter = null)
			{
				if (!_throwOnFailure)
				{
					return false;
				}
				throw new FormatException(SR.Format(SR.Format_BadFormatSpecifier, formatSpecifierCharacter));
			}
		}

		private ref struct StringParser
		{
			private ReadOnlySpan<char> _str;

			private char _ch;

			private int _pos;

			private int _len;

			internal void NextChar()
			{
				if (_pos < _len)
				{
					_pos++;
				}
				_ch = ((_pos < _len) ? _str[_pos] : '\0');
			}

			internal char NextNonDigit()
			{
				for (int i = _pos; i < _len; i++)
				{
					char c = _str[i];
					if (c < '0' || c > '9')
					{
						return c;
					}
				}
				return '\0';
			}

			internal bool TryParse(ReadOnlySpan<char> input, ref TimeSpanResult result)
			{
				result.parsedTimeSpan = default(TimeSpan);
				_str = input;
				_len = input.Length;
				_pos = -1;
				NextChar();
				SkipBlanks();
				bool flag = false;
				if (_ch == '-')
				{
					flag = true;
					NextChar();
				}
				long time;
				if (NextNonDigit() == ':')
				{
					if (!ParseTime(out time, ref result))
					{
						return false;
					}
				}
				else
				{
					if (!ParseInt(10675199, out var i, ref result))
					{
						return false;
					}
					time = i * 864000000000L;
					if (_ch == '.')
					{
						NextChar();
						if (!ParseTime(out var time2, ref result))
						{
							return false;
						}
						time += time2;
					}
				}
				if (flag)
				{
					time = -time;
					if (time > 0)
					{
						return result.SetOverflowFailure();
					}
				}
				else if (time < 0)
				{
					return result.SetOverflowFailure();
				}
				SkipBlanks();
				if (_pos < _len)
				{
					return result.SetBadTimeSpanFailure();
				}
				result.parsedTimeSpan = new TimeSpan(time);
				return true;
			}

			internal bool ParseInt(int max, out int i, ref TimeSpanResult result)
			{
				i = 0;
				int pos = _pos;
				while (_ch >= '0' && _ch <= '9')
				{
					if ((i & 0xF0000000u) != 0L)
					{
						return result.SetOverflowFailure();
					}
					i = i * 10 + _ch - 48;
					if (i < 0)
					{
						return result.SetOverflowFailure();
					}
					NextChar();
				}
				if (pos == _pos)
				{
					return result.SetBadTimeSpanFailure();
				}
				if (i > max)
				{
					return result.SetOverflowFailure();
				}
				return true;
			}

			internal bool ParseTime(out long time, ref TimeSpanResult result)
			{
				time = 0L;
				if (!ParseInt(23, out var i, ref result))
				{
					return false;
				}
				time = i * 36000000000L;
				if (_ch != ':')
				{
					return result.SetBadTimeSpanFailure();
				}
				NextChar();
				if (!ParseInt(59, out i, ref result))
				{
					return false;
				}
				time += (long)i * 600000000L;
				if (_ch == ':')
				{
					NextChar();
					if (_ch != '.')
					{
						if (!ParseInt(59, out i, ref result))
						{
							return false;
						}
						time += (long)i * 10000000L;
					}
					if (_ch == '.')
					{
						NextChar();
						int num = 10000000;
						while (num > 1 && _ch >= '0' && _ch <= '9')
						{
							num /= 10;
							time += (_ch - 48) * num;
							NextChar();
						}
					}
				}
				return true;
			}

			internal void SkipBlanks()
			{
				while (_ch == ' ' || _ch == '\t')
				{
					NextChar();
				}
			}
		}

		internal static long Pow10(int pow)
		{
			return pow switch
			{
				0 => 1L, 
				1 => 10L, 
				2 => 100L, 
				3 => 1000L, 
				4 => 10000L, 
				5 => 100000L, 
				6 => 1000000L, 
				7 => 10000000L, 
				_ => (long)Math.Pow(10.0, pow), 
			};
		}

		private static bool TryTimeToTicks(bool positive, TimeSpanToken days, TimeSpanToken hours, TimeSpanToken minutes, TimeSpanToken seconds, TimeSpanToken fraction, out long result)
		{
			if (days._num > 10675199 || hours._num > 23 || minutes._num > 59 || seconds._num > 59 || !fraction.NormalizeAndValidateFraction())
			{
				result = 0L;
				return false;
			}
			long num = ((long)days._num * 3600L * 24 + (long)hours._num * 3600L + (long)minutes._num * 60L + seconds._num) * 1000;
			if (num > 922337203685477L || num < -922337203685477L)
			{
				result = 0L;
				return false;
			}
			result = num * 10000 + fraction._num;
			if (positive && result < 0)
			{
				result = 0L;
				return false;
			}
			return true;
		}

		internal static TimeSpan Parse(ReadOnlySpan<char> input, IFormatProvider formatProvider)
		{
			TimeSpanResult result = new TimeSpanResult(throwOnFailure: true, input);
			bool flag = TryParseTimeSpan(input, TimeSpanStandardStyles.Any, formatProvider, ref result);
			return result.parsedTimeSpan;
		}

		internal static bool TryParse(ReadOnlySpan<char> input, IFormatProvider formatProvider, out TimeSpan result)
		{
			TimeSpanResult result2 = new TimeSpanResult(throwOnFailure: false, input);
			if (TryParseTimeSpan(input, TimeSpanStandardStyles.Any, formatProvider, ref result2))
			{
				result = result2.parsedTimeSpan;
				return true;
			}
			result = default(TimeSpan);
			return false;
		}

		internal static TimeSpan ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, TimeSpanStyles styles)
		{
			TimeSpanResult result = new TimeSpanResult(throwOnFailure: true, input);
			bool flag = TryParseExactTimeSpan(input, format, formatProvider, styles, ref result);
			return result.parsedTimeSpan;
		}

		internal static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result)
		{
			TimeSpanResult result2 = new TimeSpanResult(throwOnFailure: false, input);
			if (TryParseExactTimeSpan(input, format, formatProvider, styles, ref result2))
			{
				result = result2.parsedTimeSpan;
				return true;
			}
			result = default(TimeSpan);
			return false;
		}

		internal static TimeSpan ParseExactMultiple(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles)
		{
			TimeSpanResult result = new TimeSpanResult(throwOnFailure: true, input);
			bool flag = TryParseExactMultipleTimeSpan(input, formats, formatProvider, styles, ref result);
			return result.parsedTimeSpan;
		}

		internal static bool TryParseExactMultiple(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result)
		{
			TimeSpanResult result2 = new TimeSpanResult(throwOnFailure: false, input);
			if (TryParseExactMultipleTimeSpan(input, formats, formatProvider, styles, ref result2))
			{
				result = result2.parsedTimeSpan;
				return true;
			}
			result = default(TimeSpan);
			return false;
		}

		private static bool TryParseTimeSpan(ReadOnlySpan<char> input, TimeSpanStandardStyles style, IFormatProvider formatProvider, ref TimeSpanResult result)
		{
			input = input.Trim();
			if (input.IsEmpty)
			{
				return result.SetBadTimeSpanFailure();
			}
			TimeSpanTokenizer timeSpanTokenizer = new TimeSpanTokenizer(input);
			TimeSpanRawInfo raw = default(TimeSpanRawInfo);
			raw.Init(DateTimeFormatInfo.GetInstance(formatProvider));
			TimeSpanToken tok = timeSpanTokenizer.GetNextToken();
			while (tok._ttt != TTT.End)
			{
				if (!raw.ProcessToken(ref tok, ref result))
				{
					return result.SetBadTimeSpanFailure();
				}
				tok = timeSpanTokenizer.GetNextToken();
			}
			if (!ProcessTerminalState(ref raw, style, ref result))
			{
				return result.SetBadTimeSpanFailure();
			}
			return true;
		}

		private static bool ProcessTerminalState(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
		{
			if (raw._lastSeenTTT == TTT.Num)
			{
				TimeSpanToken tok = default(TimeSpanToken);
				tok._ttt = TTT.Sep;
				if (!raw.ProcessToken(ref tok, ref result))
				{
					return result.SetBadTimeSpanFailure();
				}
			}
			return raw._numCount switch
			{
				1 => ProcessTerminal_D(ref raw, style, ref result), 
				2 => ProcessTerminal_HM(ref raw, style, ref result), 
				3 => ProcessTerminal_HM_S_D(ref raw, style, ref result), 
				4 => ProcessTerminal_HMS_F_D(ref raw, style, ref result), 
				5 => ProcessTerminal_DHMSF(ref raw, style, ref result), 
				_ => result.SetBadTimeSpanFailure(), 
			};
		}

		private static bool ProcessTerminal_DHMSF(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
		{
			if (raw._sepCount != 6)
			{
				return result.SetBadTimeSpanFailure();
			}
			bool flag = (style & TimeSpanStandardStyles.Invariant) != 0;
			bool flag2 = (style & TimeSpanStandardStyles.Localized) != 0;
			bool flag3 = false;
			bool flag4 = false;
			if (flag)
			{
				if (raw.FullMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag4 = true;
					flag3 = true;
				}
				if (!flag4 && raw.FullMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag4 = true;
					flag3 = false;
				}
			}
			if (flag2)
			{
				if (!flag4 && raw.FullMatch(raw.PositiveLocalized))
				{
					flag4 = true;
					flag3 = true;
				}
				if (!flag4 && raw.FullMatch(raw.NegativeLocalized))
				{
					flag4 = true;
					flag3 = false;
				}
			}
			if (flag4)
			{
				if (!TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, raw._numbers4, out var result2))
				{
					return result.SetOverflowFailure();
				}
				if (!flag3)
				{
					result2 = -result2;
					if (result2 > 0)
					{
						return result.SetOverflowFailure();
					}
				}
				result.parsedTimeSpan = new TimeSpan(result2);
				return true;
			}
			return result.SetBadTimeSpanFailure();
		}

		private static bool ProcessTerminal_HMS_F_D(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
		{
			if (raw._sepCount != 5 || (style & TimeSpanStandardStyles.RequireFull) != 0)
			{
				return result.SetBadTimeSpanFailure();
			}
			bool flag = (style & TimeSpanStandardStyles.Invariant) != 0;
			bool flag2 = (style & TimeSpanStandardStyles.Localized) != 0;
			long result2 = 0L;
			bool flag3 = false;
			bool flag4 = false;
			bool flag5 = false;
			TimeSpanToken timeSpanToken = new TimeSpanToken(0);
			if (flag)
			{
				if (raw.FullHMSFMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullDHMSMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullAppCompatMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, raw._numbers3, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullHMSFMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullDHMSMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullAppCompatMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, raw._numbers3, out result2);
					flag5 = flag5 || !flag4;
				}
			}
			if (flag2)
			{
				if (!flag4 && raw.FullHMSFMatch(raw.PositiveLocalized))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullDHMSMatch(raw.PositiveLocalized))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullAppCompatMatch(raw.PositiveLocalized))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, raw._numbers3, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullHMSFMatch(raw.NegativeLocalized))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullDHMSMatch(raw.NegativeLocalized))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, raw._numbers3, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullAppCompatMatch(raw.NegativeLocalized))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, raw._numbers3, out result2);
					flag5 = flag5 || !flag4;
				}
			}
			if (flag4)
			{
				if (!flag3)
				{
					result2 = -result2;
					if (result2 > 0)
					{
						return result.SetOverflowFailure();
					}
				}
				result.parsedTimeSpan = new TimeSpan(result2);
				return true;
			}
			if (!flag5)
			{
				return result.SetBadTimeSpanFailure();
			}
			return result.SetOverflowFailure();
		}

		private static bool ProcessTerminal_HM_S_D(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
		{
			if (raw._sepCount != 4 || (style & TimeSpanStandardStyles.RequireFull) != 0)
			{
				return result.SetBadTimeSpanFailure();
			}
			bool flag = (style & TimeSpanStandardStyles.Invariant) != 0;
			bool flag2 = (style & TimeSpanStandardStyles.Localized) != 0;
			bool flag3 = false;
			bool flag4 = false;
			bool flag5 = false;
			TimeSpanToken timeSpanToken = new TimeSpanToken(0);
			long result2 = 0L;
			if (flag)
			{
				if (raw.FullHMSMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullDHMMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.PartialAppCompatMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, timeSpanToken, raw._numbers2, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullHMSMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullDHMMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.PartialAppCompatMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, timeSpanToken, raw._numbers2, out result2);
					flag5 = flag5 || !flag4;
				}
			}
			if (flag2)
			{
				if (!flag4 && raw.FullHMSMatch(raw.PositiveLocalized))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullDHMMatch(raw.PositiveLocalized))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.PartialAppCompatMatch(raw.PositiveLocalized))
				{
					flag3 = true;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, timeSpanToken, raw._numbers2, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullHMSMatch(raw.NegativeLocalized))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.FullDHMMatch(raw.NegativeLocalized))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, raw._numbers0, raw._numbers1, raw._numbers2, timeSpanToken, timeSpanToken, out result2);
					flag5 = flag5 || !flag4;
				}
				if (!flag4 && raw.PartialAppCompatMatch(raw.NegativeLocalized))
				{
					flag3 = false;
					flag4 = TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, timeSpanToken, raw._numbers2, out result2);
					flag5 = flag5 || !flag4;
				}
			}
			if (flag4)
			{
				if (!flag3)
				{
					result2 = -result2;
					if (result2 > 0)
					{
						return result.SetOverflowFailure();
					}
				}
				result.parsedTimeSpan = new TimeSpan(result2);
				return true;
			}
			if (!flag5)
			{
				return result.SetBadTimeSpanFailure();
			}
			return result.SetOverflowFailure();
		}

		private static bool ProcessTerminal_HM(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
		{
			if (raw._sepCount != 3 || (style & TimeSpanStandardStyles.RequireFull) != 0)
			{
				return result.SetBadTimeSpanFailure();
			}
			bool flag = (style & TimeSpanStandardStyles.Invariant) != 0;
			bool flag2 = (style & TimeSpanStandardStyles.Localized) != 0;
			bool flag3 = false;
			bool flag4 = false;
			if (flag)
			{
				if (raw.FullHMMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag4 = true;
					flag3 = true;
				}
				if (!flag4 && raw.FullHMMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag4 = true;
					flag3 = false;
				}
			}
			if (flag2)
			{
				if (!flag4 && raw.FullHMMatch(raw.PositiveLocalized))
				{
					flag4 = true;
					flag3 = true;
				}
				if (!flag4 && raw.FullHMMatch(raw.NegativeLocalized))
				{
					flag4 = true;
					flag3 = false;
				}
			}
			if (flag4)
			{
				TimeSpanToken timeSpanToken = new TimeSpanToken(0);
				if (!TryTimeToTicks(flag3, timeSpanToken, raw._numbers0, raw._numbers1, timeSpanToken, timeSpanToken, out var result2))
				{
					return result.SetOverflowFailure();
				}
				if (!flag3)
				{
					result2 = -result2;
					if (result2 > 0)
					{
						return result.SetOverflowFailure();
					}
				}
				result.parsedTimeSpan = new TimeSpan(result2);
				return true;
			}
			return result.SetBadTimeSpanFailure();
		}

		private static bool ProcessTerminal_D(ref TimeSpanRawInfo raw, TimeSpanStandardStyles style, ref TimeSpanResult result)
		{
			if (raw._sepCount != 2 || (style & TimeSpanStandardStyles.RequireFull) != 0)
			{
				return result.SetBadTimeSpanFailure();
			}
			bool flag = (style & TimeSpanStandardStyles.Invariant) != 0;
			bool flag2 = (style & TimeSpanStandardStyles.Localized) != 0;
			bool flag3 = false;
			bool flag4 = false;
			if (flag)
			{
				if (raw.FullDMatch(TimeSpanFormat.PositiveInvariantFormatLiterals))
				{
					flag4 = true;
					flag3 = true;
				}
				if (!flag4 && raw.FullDMatch(TimeSpanFormat.NegativeInvariantFormatLiterals))
				{
					flag4 = true;
					flag3 = false;
				}
			}
			if (flag2)
			{
				if (!flag4 && raw.FullDMatch(raw.PositiveLocalized))
				{
					flag4 = true;
					flag3 = true;
				}
				if (!flag4 && raw.FullDMatch(raw.NegativeLocalized))
				{
					flag4 = true;
					flag3 = false;
				}
			}
			if (flag4)
			{
				TimeSpanToken timeSpanToken = new TimeSpanToken(0);
				if (!TryTimeToTicks(flag3, raw._numbers0, timeSpanToken, timeSpanToken, timeSpanToken, timeSpanToken, out var result2))
				{
					return result.SetOverflowFailure();
				}
				if (!flag3)
				{
					result2 = -result2;
					if (result2 > 0)
					{
						return result.SetOverflowFailure();
					}
				}
				result.parsedTimeSpan = new TimeSpan(result2);
				return true;
			}
			return result.SetBadTimeSpanFailure();
		}

		private static bool TryParseExactTimeSpan(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, TimeSpanStyles styles, ref TimeSpanResult result)
		{
			if (format.Length == 0)
			{
				return result.SetBadFormatSpecifierFailure();
			}
			if (format.Length == 1)
			{
				switch (format[0])
				{
				case 'T':
				case 'c':
				case 't':
					return TryParseTimeSpanConstant(input, ref result);
				case 'g':
					return TryParseTimeSpan(input, TimeSpanStandardStyles.Localized, formatProvider, ref result);
				case 'G':
					return TryParseTimeSpan(input, TimeSpanStandardStyles.Localized | TimeSpanStandardStyles.RequireFull, formatProvider, ref result);
				default:
					return result.SetBadFormatSpecifierFailure(format[0]);
				}
			}
			return TryParseByFormat(input, format, styles, ref result);
		}

		private static bool TryParseByFormat(ReadOnlySpan<char> input, ReadOnlySpan<char> format, TimeSpanStyles styles, ref TimeSpanResult result)
		{
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			bool flag5 = false;
			int result2 = 0;
			int result3 = 0;
			int result4 = 0;
			int result5 = 0;
			int zeroes = 0;
			int result6 = 0;
			int i = 0;
			TimeSpanTokenizer tokenizer = new TimeSpanTokenizer(input, -1);
			int returnValue;
			for (; i < format.Length; i += returnValue)
			{
				char c = format[i];
				switch (c)
				{
				case 'h':
					returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (returnValue > 2 || flag2 || !ParseExactDigits(ref tokenizer, returnValue, out result3))
					{
						return result.SetInvalidStringFailure();
					}
					flag2 = true;
					break;
				case 'm':
					returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (returnValue > 2 || flag3 || !ParseExactDigits(ref tokenizer, returnValue, out result4))
					{
						return result.SetInvalidStringFailure();
					}
					flag3 = true;
					break;
				case 's':
					returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (returnValue > 2 || flag4 || !ParseExactDigits(ref tokenizer, returnValue, out result5))
					{
						return result.SetInvalidStringFailure();
					}
					flag4 = true;
					break;
				case 'f':
					returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (returnValue > 7 || flag5 || !ParseExactDigits(ref tokenizer, returnValue, returnValue, out zeroes, out result6))
					{
						return result.SetInvalidStringFailure();
					}
					flag5 = true;
					break;
				case 'F':
					returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (returnValue > 7 || flag5)
					{
						return result.SetInvalidStringFailure();
					}
					ParseExactDigits(ref tokenizer, returnValue, returnValue, out zeroes, out result6);
					flag5 = true;
					break;
				case 'd':
				{
					returnValue = DateTimeFormat.ParseRepeatPattern(format, i, c);
					if (returnValue > 8 || flag || !ParseExactDigits(ref tokenizer, (returnValue < 2) ? 1 : returnValue, (returnValue < 2) ? 8 : returnValue, out var _, out result2))
					{
						return result.SetInvalidStringFailure();
					}
					flag = true;
					break;
				}
				case '"':
				case '\'':
				{
					StringBuilder stringBuilder = StringBuilderCache.Acquire();
					if (!DateTimeParse.TryParseQuoteString(format, i, stringBuilder, out returnValue))
					{
						StringBuilderCache.Release(stringBuilder);
						return result.SetBadQuoteFailure(c);
					}
					if (!ParseExactLiteral(ref tokenizer, stringBuilder))
					{
						StringBuilderCache.Release(stringBuilder);
						return result.SetInvalidStringFailure();
					}
					StringBuilderCache.Release(stringBuilder);
					break;
				}
				case '%':
				{
					int num = DateTimeFormat.ParseNextChar(format, i);
					if (num >= 0 && num != 37)
					{
						returnValue = 1;
						break;
					}
					return result.SetInvalidStringFailure();
				}
				case '\\':
				{
					int num = DateTimeFormat.ParseNextChar(format, i);
					if (num >= 0 && tokenizer.NextChar == (ushort)num)
					{
						returnValue = 2;
						break;
					}
					return result.SetInvalidStringFailure();
				}
				default:
					return result.SetInvalidStringFailure();
				}
			}
			if (!tokenizer.EOL)
			{
				return result.SetBadTimeSpanFailure();
			}
			bool flag6 = (styles & TimeSpanStyles.AssumeNegative) == 0;
			if (TryTimeToTicks(flag6, new TimeSpanToken(result2), new TimeSpanToken(result3), new TimeSpanToken(result4), new TimeSpanToken(result5), new TimeSpanToken(result6, zeroes), out var result7))
			{
				if (!flag6)
				{
					result7 = -result7;
				}
				result.parsedTimeSpan = new TimeSpan(result7);
				return true;
			}
			return result.SetOverflowFailure();
		}

		private static bool ParseExactDigits(ref TimeSpanTokenizer tokenizer, int minDigitLength, out int result)
		{
			int maxDigitLength = ((minDigitLength == 1) ? 2 : minDigitLength);
			int zeroes;
			return ParseExactDigits(ref tokenizer, minDigitLength, maxDigitLength, out zeroes, out result);
		}

		private static bool ParseExactDigits(ref TimeSpanTokenizer tokenizer, int minDigitLength, int maxDigitLength, out int zeroes, out int result)
		{
			int num = 0;
			int num2 = 0;
			int i;
			for (i = 0; i < maxDigitLength; i++)
			{
				char nextChar = tokenizer.NextChar;
				if (nextChar < '0' || nextChar > '9')
				{
					tokenizer.BackOne();
					break;
				}
				num = num * 10 + (nextChar - 48);
				if (num == 0)
				{
					num2++;
				}
			}
			zeroes = num2;
			result = num;
			return i >= minDigitLength;
		}

		private static bool ParseExactLiteral(ref TimeSpanTokenizer tokenizer, StringBuilder enquotedString)
		{
			for (int i = 0; i < enquotedString.Length; i++)
			{
				if (enquotedString[i] != tokenizer.NextChar)
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryParseTimeSpanConstant(ReadOnlySpan<char> input, ref TimeSpanResult result)
		{
			return default(StringParser).TryParse(input, ref result);
		}

		private static bool TryParseExactMultipleTimeSpan(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, ref TimeSpanResult result)
		{
			if (formats == null)
			{
				return result.SetArgumentNullFailure("formats");
			}
			if (input.Length == 0)
			{
				return result.SetBadTimeSpanFailure();
			}
			if (formats.Length == 0)
			{
				return result.SetNoFormatSpecifierFailure();
			}
			foreach (string text in formats)
			{
				if (string.IsNullOrEmpty(text))
				{
					return result.SetBadFormatSpecifierFailure();
				}
				TimeSpanResult result2 = new TimeSpanResult(throwOnFailure: false, input);
				if (TryParseExactTimeSpan(input, text, formatProvider, styles, ref result2))
				{
					result.parsedTimeSpan = result2.parsedTimeSpan;
					return true;
				}
			}
			return result.SetBadTimeSpanFailure();
		}
	}
	[Flags]
	public enum TimeSpanStyles
	{
		None = 0,
		AssumeNegative = 1
	}
	public class UmAlQuraCalendar : Calendar
	{
		private struct DateMapping
		{
			internal int HijriMonthsLengthFlags;

			internal DateTime GregorianDate;

			internal DateMapping(int MonthsLengthFlags, int GYear, int GMonth, int GDay)
			{
				HijriMonthsLengthFlags = MonthsLengthFlags;
				GregorianDate = new DateTime(GYear, GMonth, GDay);
			}
		}

		private static readonly DateMapping[] s_hijriYearInfo = InitDateMapping();

		public const int UmAlQuraEra = 1;

		private static readonly DateTime s_minDate = new DateTime(1900, 4, 30);

		private static readonly DateTime s_maxDate = new DateTime(new DateTime(2077, 11, 16, 23, 59, 59, 999).Ticks + 9999);

		public override DateTime MinSupportedDateTime => s_minDate;

		public override DateTime MaxSupportedDateTime => s_maxDate;

		public override CalendarAlgorithmType AlgorithmType => CalendarAlgorithmType.LunarCalendar;

		internal override CalendarId BaseCalendarID => CalendarId.HIJRI;

		internal override CalendarId ID => CalendarId.UMALQURA;

		protected override int DaysInYearBeforeMinSupportedYear => 355;

		public override int[] Eras => new int[1] { 1 };

		public override int TwoDigitYearMax
		{
			get
			{
				if (_twoDigitYearMax == -1)
				{
					_twoDigitYearMax = Calendar.GetSystemTwoDigitYearSetting(ID, 1451);
				}
				return _twoDigitYearMax;
			}
			set
			{
				if (value != 99 && (value < 1318 || value > 1500))
				{
					throw new ArgumentOutOfRangeException("value", value, SR.Format(SR.ArgumentOutOfRange_Range, 1318, 1500));
				}
				VerifyWritable();
				_twoDigitYearMax = value;
			}
		}

		private static DateMapping[] InitDateMapping()
		{
			short[] array = new short[736]
			{
				746, 1900, 4, 30, 1769, 1901, 4, 19, 3794, 1902,
				4, 9, 3748, 1903, 3, 30, 3402, 1904, 3, 18,
				2710, 1905, 3, 7, 1334, 1906, 2, 24, 2741, 1907,
				2, 13, 3498, 1908, 2, 3, 2980, 1909, 1, 23,
				2889, 1910, 1, 12, 2707, 1911, 1, 1, 1323, 1911,
				12, 21, 2647, 1912, 12, 9, 1206, 1913, 11, 29,
				2741, 1914, 11, 18, 1450, 1915, 11, 8, 3413, 1916,
				10, 27, 3370, 1917, 10, 17, 2646, 1918, 10, 6,
				1198, 1919, 9, 25, 2397, 1920, 9, 13, 748, 1921,
				9, 3, 1749, 1922, 8, 23, 1706, 1923, 8, 13,
				1365, 1924, 8, 1, 1195, 1925, 7, 21, 2395, 1926,
				7, 10, 698, 1927, 6, 30, 1397, 1928, 6, 18,
				2994, 1929, 6, 8, 1892, 1930, 5, 29, 1865, 1931,
				5, 18, 1621, 1932, 5, 6, 683, 1933, 4, 25,
				1371, 1934, 4, 14, 2778, 1935, 4, 4, 1748, 1936,
				3, 24, 3785, 1937, 3, 13, 3474, 1938, 3, 3,
				3365, 1939, 2, 20, 2637, 1940, 2, 9, 685, 1941,
				1, 28, 1389, 1942, 1, 17, 2922, 1943, 1, 7,
				2898, 1943, 12, 28, 2725, 1944, 12, 16, 2635, 1945,
				12, 5, 1175, 1946, 11, 24, 2359, 1947, 11, 13,
				694, 1948, 11, 2, 1397, 1949, 10, 22, 3434, 1950,
				10, 12, 3410, 1951, 10, 2, 2710, 1952, 9, 20,
				2349, 1953, 9, 9, 605, 1954, 8, 29, 1245, 1955,
				8, 18, 2778, 1956, 8, 7, 1492, 1957, 7, 28,
				3497, 1958, 7, 17, 3410, 1959, 7, 7, 2730, 1960,
				6, 25, 1238, 1961, 6, 14, 2486, 1962, 6, 3,
				884, 1963, 5, 24, 1897, 1964, 5, 12, 1874, 1965,
				5, 2, 1701, 1966, 4, 21, 1355, 1967, 4, 10,
				2731, 1968, 3, 29, 1370, 1969, 3, 19, 2773, 1970,
				3, 8, 3538, 1971, 2, 26, 3492, 1972, 2, 16,
				3401, 1973, 2, 4, 2709, 1974, 1, 24, 1325, 1975,
				1, 13, 2653, 1976, 1, 2, 1370, 1976, 12, 22,
				2773, 1977, 12, 11, 1706, 1978, 12, 1, 1685, 1979,
				11, 20, 1323, 1980, 11, 8, 2647, 1981, 10, 28,
				1198, 1982, 10, 18, 2422, 1983, 10, 7, 1388, 1984,
				9, 26, 2901, 1985, 9, 15, 2730, 1986, 9, 5,
				2645, 1987, 8, 25, 1197, 1988, 8, 13, 2397, 1989,
				8, 2, 730, 1990, 7, 23, 1497, 1991, 7, 12,
				3506, 1992, 7, 1, 2980, 1993, 6, 21, 2890, 1994,
				6, 10, 2645, 1995, 5, 30, 693, 1996, 5, 18,
				1397, 1997, 5, 7, 2922, 1998, 4, 27, 3026, 1999,
				4, 17, 3012, 2000, 4, 6, 2953, 2001, 3, 26,
				2709, 2002, 3, 15, 1325, 2003, 3, 4, 1453, 2004,
				2, 21, 2922, 2005, 2, 10, 1748, 2006, 1, 31,
				3529, 2007, 1, 20, 3474, 2008, 1, 10, 2726, 2008,
				12, 29, 2390, 2009, 12, 18, 686, 2010, 12, 7,
				1389, 2011, 11, 26, 874, 2012, 11, 15, 2901, 2013,
				11, 4, 2730, 2014, 10, 25, 2381, 2015, 10, 14,
				1181, 2016, 10, 2, 2397, 2017, 9, 21, 698, 2018,
				9, 11, 1461, 2019, 8, 31, 1450, 2020, 8, 20,
				3413, 2021, 8, 9, 2714, 2022, 7, 30, 2350, 2023,
				7, 19, 622, 2024, 7, 7, 1373, 2025, 6, 26,
				2778, 2026, 6, 16, 1748, 2027, 6, 6, 1701, 2028,
				5, 25, 1355, 2029, 5, 14, 2711, 2030, 5, 3,
				1358, 2031, 4, 23, 2734, 2032, 4, 11, 1452, 2033,
				4, 1, 2985, 2034, 3, 21, 3474, 2035, 3, 11,
				2853, 2036, 2, 28, 1611, 2037, 2, 16, 3243, 2038,
				2, 5, 1370, 2039, 1, 26, 2901, 2040, 1, 15,
				1746, 2041, 1, 4, 3749, 2041, 12, 24, 3658, 2042,
				12, 14, 2709, 2043, 12, 3, 1325, 2044, 11, 21,
				2733, 2045, 11, 10, 876, 2046, 10, 31, 1881, 2047,
				10, 20, 1746, 2048, 10, 9, 1685, 2049, 9, 28,
				1325, 2050, 9, 17, 2651, 2051, 9, 6, 1210, 2052,
				8, 26, 2490, 2053, 8, 15, 948, 2054, 8, 5,
				2921, 2055, 7, 25, 2898, 2056, 7, 14, 2726, 2057,
				7, 3, 1206, 2058, 6, 22, 2413, 2059, 6, 11,
				748, 2060, 5, 31, 1753, 2061, 5, 20, 3762, 2062,
				5, 10, 3412, 2063, 4, 30, 3370, 2064, 4, 18,
				2646, 2065, 4, 7, 1198, 2066, 3, 27, 2413, 2067,
				3, 16, 3434, 2068, 3, 5, 2900, 2069, 2, 23,
				2857, 2070, 2, 12, 2707, 2071, 2, 1, 1323, 2072,
				1, 21, 2647, 2073, 1, 9, 1334, 2073, 12, 30,
				2741, 2074, 12, 19, 1706, 2075, 12, 9, 3731, 2076,
				11, 27, 0, 2077, 11, 17
			};
			DateMapping[] array2 = new DateMapping[array.Length / 4];
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i] = new DateMapping(array[i * 4], array[i * 4 + 1], array[i * 4 + 2], array[i * 4 + 3]);
			}
			return array2;
		}

		private static void ConvertHijriToGregorian(int HijriYear, int HijriMonth, int HijriDay, out int yg, out int mg, out int dg)
		{
			int num = HijriDay - 1;
			int num2 = HijriYear - 1318;
			DateTime gregorianDate = s_hijriYearInfo[num2].GregorianDate;
			int num3 = s_hijriYearInfo[num2].HijriMonthsLengthFlags;
			for (int i = 1; i < HijriMonth; i++)
			{
				num = num + 29 + (num3 & 1);
				num3 >>= 1;
			}
			gregorianDate.AddDays(num).GetDate(out yg, out mg, out dg);
		}

		private static long GetAbsoluteDateUmAlQura(int year, int month, int day)
		{
			ConvertHijriToGregorian(year, month, day, out var yg, out var mg, out var dg);
			return GregorianCalendar.GetAbsoluteDate(yg, mg, dg);
		}

		internal static void CheckTicksRange(long ticks)
		{
			if (ticks < s_minDate.Ticks || ticks > s_maxDate.Ticks)
			{
				throw new ArgumentOutOfRangeException("time", ticks, SR.Format(CultureInfo.InvariantCulture, SR.ArgumentOutOfRange_CalendarRange, s_minDate, s_maxDate));
			}
		}

		internal static void CheckEraRange(int era)
		{
			if (era != 0 && era != 1)
			{
				throw new ArgumentOutOfRangeException("era", era, SR.ArgumentOutOfRange_InvalidEraValue);
			}
		}

		internal static void CheckYearRange(int year, int era)
		{
			CheckEraRange(era);
			if (year < 1318 || year > 1500)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1318, 1500));
			}
		}

		internal static void CheckYearMonthRange(int year, int month, int era)
		{
			CheckYearRange(year, era);
			if (month < 1 || month > 12)
			{
				ThrowHelper.ThrowArgumentOutOfRange_Month(month);
			}
		}

		private static void ConvertGregorianToHijri(DateTime time, out int HijriYear, out int HijriMonth, out int HijriDay)
		{
			int num = (int)((time.Ticks - s_minDate.Ticks) / 864000000000L) / 355;
			while (time.CompareTo(s_hijriYearInfo[++num].GregorianDate) > 0)
			{
			}
			if (time.CompareTo(s_hijriYearInfo[num].GregorianDate) != 0)
			{
				num--;
			}
			TimeSpan timeSpan = time.Subtract(s_hijriYearInfo[num].GregorianDate);
			int num2 = num + 1318;
			int num3 = 1;
			int num4 = 1;
			double num5 = timeSpan.TotalDays;
			int num6 = s_hijriYearInfo[num].HijriMonthsLengthFlags;
			int num7 = 29 + (num6 & 1);
			while (num5 >= (double)num7)
			{
				num5 -= (double)num7;
				num6 >>= 1;
				num7 = 29 + (num6 & 1);
				num3++;
			}
			num4 += (int)num5;
			HijriDay = num4;
			HijriMonth = num3;
			HijriYear = num2;
		}

		private static int GetDatePart(DateTime time, int part)
		{
			long ticks = time.Ticks;
			CheckTicksRange(ticks);
			ConvertGregorianToHijri(time, out var HijriYear, out var HijriMonth, out var HijriDay);
			return part switch
			{
				0 => HijriYear, 
				2 => HijriMonth, 
				3 => HijriDay, 
				1 => (int)(GetAbsoluteDateUmAlQura(HijriYear, HijriMonth, HijriDay) - GetAbsoluteDateUmAlQura(HijriYear, 1, 1) + 1), 
				_ => throw new InvalidOperationException(SR.InvalidOperation_DateTimeParsing), 
			};
		}

		public override DateTime AddMonths(DateTime time, int months)
		{
			if (months < -120000 || months > 120000)
			{
				throw new ArgumentOutOfRangeException("months", months, SR.Format(SR.ArgumentOutOfRange_Range, -120000, 120000));
			}
			int datePart = GetDatePart(time, 0);
			int datePart2 = GetDatePart(time, 2);
			int num = GetDatePart(time, 3);
			int num2 = datePart2 - 1 + months;
			if (num2 >= 0)
			{
				datePart2 = num2 % 12 + 1;
				datePart += num2 / 12;
			}
			else
			{
				datePart2 = 12 + (num2 + 1) % 12;
				datePart += (num2 - 11) / 12;
			}
			if (num > 29)
			{
				int daysInMonth = GetDaysInMonth(datePart, datePart2);
				if (num > daysInMonth)
				{
					num = daysInMonth;
				}
			}
			CheckYearRange(datePart, 1);
			DateTime result = new DateTime(GetAbsoluteDateUmAlQura(datePart, datePart2, num) * 864000000000L + time.Ticks % 864000000000L);
			Calendar.CheckAddResult(result.Ticks, MinSupportedDateTime, MaxSupportedDateTime);
			return result;
		}

		public override DateTime AddYears(DateTime time, int years)
		{
			return AddMonths(time, years * 12);
		}

		public override int GetDayOfMonth(DateTime time)
		{
			return GetDatePart(time, 3);
		}

		public override DayOfWeek GetDayOfWeek(DateTime time)
		{
			return (DayOfWeek)((int)(time.Ticks / 864000000000L + 1) % 7);
		}

		public override int GetDayOfYear(DateTime time)
		{
			return GetDatePart(time, 1);
		}

		public override int GetDaysInMonth(int year, int month, int era)
		{
			CheckYearMonthRange(year, month, era);
			if ((s_hijriYearInfo[year - 1318].HijriMonthsLengthFlags & (1 << month - 1)) == 0)
			{
				return 29;
			}
			return 30;
		}

		internal static int RealGetDaysInYear(int year)
		{
			int num = 0;
			int num2 = s_hijriYearInfo[year - 1318].HijriMonthsLengthFlags;
			for (int i = 1; i <= 12; i++)
			{
				num = num + 29 + (num2 & 1);
				num2 >>= 1;
			}
			return num;
		}

		public override int GetDaysInYear(int year, int era)
		{
			CheckYearRange(year, era);
			return RealGetDaysInYear(year);
		}

		public override int GetEra(DateTime time)
		{
			CheckTicksRange(time.Ticks);
			return 1;
		}

		public override int GetMonth(DateTime time)
		{
			return GetDatePart(time, 2);
		}

		public override int GetMonthsInYear(int year, int era)
		{
			CheckYearRange(year, era);
			return 12;
		}

		public override int GetYear(DateTime time)
		{
			return GetDatePart(time, 0);
		}

		public override bool IsLeapDay(int year, int month, int day, int era)
		{
			if (day >= 1 && day <= 29)
			{
				CheckYearMonthRange(year, month, era);
				return false;
			}
			int daysInMonth = GetDaysInMonth(year, month, era);
			if (day < 1 || day > daysInMonth)
			{
				throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Day, daysInMonth, month));
			}
			return false;
		}

		public override int GetLeapMonth(int year, int era)
		{
			CheckYearRange(year, era);
			return 0;
		}

		public override bool IsLeapMonth(int year, int month, int era)
		{
			CheckYearMonthRange(year, month, era);
			return false;
		}

		public override bool IsLeapYear(int year, int era)
		{
			CheckYearRange(year, era);
			return RealGetDaysInYear(year) == 355;
		}

		public override DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
		{
			if (day >= 1 && day <= 29)
			{
				CheckYearMonthRange(year, month, era);
			}
			else
			{
				int daysInMonth = GetDaysInMonth(year, month, era);
				if (day < 1 || day > daysInMonth)
				{
					throw new ArgumentOutOfRangeException("day", day, SR.Format(SR.ArgumentOutOfRange_Day, daysInMonth, month));
				}
			}
			long absoluteDateUmAlQura = GetAbsoluteDateUmAlQura(year, month, day);
			if (absoluteDateUmAlQura < 0)
			{
				throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
			}
			return new DateTime(absoluteDateUmAlQura * 864000000000L + Calendar.TimeToTicks(hour, minute, second, millisecond));
		}

		public override int ToFourDigitYear(int year)
		{
			if (year < 0)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (year < 100)
			{
				return base.ToFourDigitYear(year);
			}
			if (year < 1318 || year > 1500)
			{
				throw new ArgumentOutOfRangeException("year", year, SR.Format(SR.ArgumentOutOfRange_Range, 1318, 1500));
			}
			return year;
		}
	}
	public enum UnicodeCategory
	{
		UppercaseLetter,
		LowercaseLetter,
		TitlecaseLetter,
		ModifierLetter,
		OtherLetter,
		NonSpacingMark,
		SpacingCombiningMark,
		EnclosingMark,
		DecimalDigitNumber,
		LetterNumber,
		OtherNumber,
		SpaceSeparator,
		LineSeparator,
		ParagraphSeparator,
		Control,
		Format,
		Surrogate,
		PrivateUse,
		ConnectorPunctuation,
		DashPunctuation,
		OpenPunctuation,
		ClosePunctuation,
		InitialQuotePunctuation,
		FinalQuotePunctuation,
		OtherPunctuation,
		MathSymbol,
		CurrencySymbol,
		ModifierSymbol,
		OtherSymbol,
		OtherNotAssigned
	}
}
namespace System.Configuration.Assemblies
{
	public enum AssemblyHashAlgorithm
	{
		None = 0,
		MD5 = 32771,
		SHA1 = 32772,
		SHA256 = 32780,
		SHA384 = 32781,
		SHA512 = 32782
	}
	public enum AssemblyVersionCompatibility
	{
		SameMachine = 1,
		SameProcess,
		SameDomain
	}
}
namespace System.ComponentModel
{
	[AttributeUsage(AttributeTargets.All)]
	public class DefaultValueAttribute : Attribute
	{
		private object _value;

		private static object s_convertFromInvariantString;

		public virtual object? Value => _value;

		[RequiresUnreferencedCode("Generic TypeConverters may require the generic types to be annotated. For example, NullableConverter requires the underlying type to be DynamicallyAccessedMembers All.")]
		public DefaultValueAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type type, string? value)
		{
			if (type == null)
			{
				return;
			}
			try
			{
				if (TryConvertFromInvariantString(type, value, out var conversionResult2))
				{
					_value = conversionResult2;
				}
				else if (type.IsSubclassOf(typeof(Enum)) && value != null)
				{
					_value = Enum.Parse(type, value, ignoreCase: true);
				}
				else if (type == typeof(TimeSpan) && value != null)
				{
					_value = TimeSpan.Parse(value);
				}
				else
				{
					_value = Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
				}
				[RequiresUnreferencedCode("Generic TypeConverters may require the generic types to be annotated. For example, NullableConverter requires the underlying type to be DynamicallyAccessedMembers All.")]
				static bool TryConvertFromInvariantString([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type typeToConvert, string stringValue, out object conversionResult)
				{
					conversionResult = null;
					if (s_convertFromInvariantString == null)
					{
						MethodInfo methodInfo = Type.GetType("System.ComponentModel.TypeDescriptor, System.ComponentModel.TypeConverter", throwOnError: false)?.GetMethod("ConvertFromInvariantString", BindingFlags.Static | BindingFlags.NonPublic);
						Volatile.Write(ref s_convertFromInvariantString, (methodInfo == null) ? new object() : methodInfo.CreateDelegate(typeof(Func<Type, string, object>)));
					}
					if (!(s_convertFromInvariantString is Func<Type, string, object> func))
					{
						return false;
					}
					try
					{
						conversionResult = func(typeToConvert, stringValue);
					}
					catch
					{
						return false;
					}
					return true;
				}
			}
			catch
			{
			}
		}

		public DefaultValueAttribute(char value)
		{
			_value = value;
		}

		public DefaultValueAttribute(byte value)
		{
			_value = value;
		}

		public DefaultValueAttribute(short value)
		{
			_value = value;
		}

		public DefaultValueAttribute(int value)
		{
			_value = value;
		}

		public DefaultValueAttribute(long value)
		{
			_value = value;
		}

		public DefaultValueAttribute(float value)
		{
			_value = value;
		}

		public DefaultValueAttribute(double value)
		{
			_value = value;
		}

		public DefaultValueAttribute(bool value)
		{
			_value = value;
		}

		public DefaultValueAttribute(string? value)
		{
			_value = value;
		}

		public DefaultValueAttribute(object? value)
		{
			_value = value;
		}

		[CLSCompliant(false)]
		public DefaultValueAttribute(sbyte value)
		{
			_value = value;
		}

		[CLSCompliant(false)]
		public DefaultValueAttribute(ushort value)
		{
			_value = value;
		}

		[CLSCompliant(false)]
		public DefaultValueAttribute(uint value)
		{
			_value = value;
		}

		[CLSCompliant(false)]
		public DefaultValueAttribute(ulong value)
		{
			_value = value;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj == this)
			{
				return true;
			}
			if (!(obj is DefaultValueAttribute defaultValueAttribute))
			{
				return false;
			}
			if (Value == null)
			{
				return defaultValueAttribute.Value == null;
			}
			return Value.Equals(defaultValueAttribute.Value);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		protected void SetValue(object? value)
		{
			_value = value;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate)]
	public sealed class EditorBrowsableAttribute : Attribute
	{
		public EditorBrowsableState State { get; }

		public EditorBrowsableAttribute(EditorBrowsableState state)
		{
			State = state;
		}

		public EditorBrowsableAttribute()
			: this(EditorBrowsableState.Always)
		{
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj == this)
			{
				return true;
			}
			if (obj is EditorBrowsableAttribute editorBrowsableAttribute)
			{
				return editorBrowsableAttribute.State == State;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
	}
	public enum EditorBrowsableState
	{
		Always,
		Never,
		Advanced
	}
}
namespace System.CodeDom.Compiler
{
	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)]
	public sealed class GeneratedCodeAttribute : Attribute
	{
		private readonly string _tool;

		private readonly string _version;

		public string? Tool => _tool;

		public string? Version => _version;

		public GeneratedCodeAttribute(string? tool, string? version)
		{
			_tool = tool;
			_version = version;
		}
	}
	public class IndentedTextWriter : TextWriter
	{
		private readonly TextWriter _writer;

		private readonly string _tabString;

		private int _indentLevel;

		private bool _tabsPending;

		public const string DefaultTabString = "    ";

		public override Encoding Encoding => _writer.Encoding;

		public override string NewLine
		{
			get
			{
				return _writer.NewLine;
			}
			[param: AllowNull]
			set
			{
				_writer.NewLine = value;
			}
		}

		public int Indent
		{
			get
			{
				return _indentLevel;
			}
			set
			{
				_indentLevel = Math.Max(value, 0);
			}
		}

		public TextWriter InnerWriter => _writer;

		public IndentedTextWriter(TextWriter writer)
			: this(writer, "    ")
		{
		}

		public IndentedTextWriter(TextWriter writer, string tabString)
			: base(CultureInfo.InvariantCulture)
		{
			if (writer == null)
			{
				throw new ArgumentNullException("writer");
			}
			_writer = writer;
			_tabString = tabString;
		}

		public override void Close()
		{
			_writer.Close();
		}

		public override ValueTask DisposeAsync()
		{
			return _writer.DisposeAsync();
		}

		public override void Flush()
		{
			_writer.Flush();
		}

		public override Task FlushAsync()
		{
			return _writer.FlushAsync();
		}

		protected virtual void OutputTabs()
		{
			if (_tabsPending)
			{
				for (int i = 0; i < _indentLevel; i++)
				{
					_writer.Write(_tabString);
				}
				_tabsPending = false;
			}
		}

		protected virtual async Task OutputTabsAsync()
		{
			if (_tabsPending)
			{
				for (int i = 0; i < _indentLevel; i++)
				{
					await _writer.WriteAsync(_tabString).ConfigureAwait(continueOnCapturedContext: false);
				}
				_tabsPending = false;
			}
		}

		public override void Write(string? s)
		{
			OutputTabs();
			_writer.Write(s);
		}

		public override void Write(bool value)
		{
			OutputTabs();
			_writer.Write(value);
		}

		public override void Write(char value)
		{
			OutputTabs();
			_writer.Write(value);
		}

		public override void Write(char[]? buffer)
		{
			OutputTabs();
			_writer.Write(buffer);
		}

		public override void Write(char[] buffer, int index, int count)
		{
			OutputTabs();
			_writer.Write(buffer, index, count);
		}

		public override void Write(double value)
		{
			OutputTabs();
			_writer.Write(value);
		}

		public override void Write(float value)
		{
			OutputTabs();
			_writer.Write(value);
		}

		public override void Write(int value)
		{
			OutputTabs();
			_writer.Write(value);
		}

		public override void Write(long value)
		{
			OutputTabs();
			_writer.Write(value);
		}

		public override void Write(object? value)
		{
			OutputTabs();
			_writer.Write(value);
		}

		public override void Write(string format, object? arg0)
		{
			OutputTabs();
			_writer.Write(format, arg0);
		}

		public override void Write(string format, object? arg0, object? arg1)
		{
			OutputTabs();
			_writer.Write(format, arg0, arg1);
		}

		public override void Write(string format, params object?[] arg)
		{
			OutputTabs();
			_writer.Write(format, arg);
		}

		public override async Task WriteAsync(char value)
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteAsync(value).ConfigureAwait(continueOnCapturedContext: false);
		}

		public override async Task WriteAsync(char[] buffer, int index, int count)
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
		}

		public override async Task WriteAsync(string? value)
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteAsync(value).ConfigureAwait(continueOnCapturedContext: false);
		}

		public override async Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteAsync(buffer, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}

		public override async Task WriteAsync(StringBuilder? value, CancellationToken cancellationToken = default(CancellationToken))
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteAsync(value, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}

		public void WriteLineNoTabs(string? s)
		{
			_writer.WriteLine(s);
		}

		public Task WriteLineNoTabsAsync(string? s)
		{
			return _writer.WriteLineAsync(s);
		}

		public override void WriteLine(string? s)
		{
			OutputTabs();
			_writer.WriteLine(s);
			_tabsPending = true;
		}

		public override void WriteLine()
		{
			OutputTabs();
			_writer.WriteLine();
			_tabsPending = true;
		}

		public override void WriteLine(bool value)
		{
			OutputTabs();
			_writer.WriteLine(value);
			_tabsPending = true;
		}

		public override void WriteLine(char value)
		{
			OutputTabs();
			_writer.WriteLine(value);
			_tabsPending = true;
		}

		public override void WriteLine(char[]? buffer)
		{
			OutputTabs();
			_writer.WriteLine(buffer);
			_tabsPending = true;
		}

		public override void WriteLine(char[] buffer, int index, int count)
		{
			OutputTabs();
			_writer.WriteLine(buffer, index, count);
			_tabsPending = true;
		}

		public override void WriteLine(double value)
		{
			OutputTabs();
			_writer.WriteLine(value);
			_tabsPending = true;
		}

		public override void WriteLine(float value)
		{
			OutputTabs();
			_writer.WriteLine(value);
			_tabsPending = true;
		}

		public override void WriteLine(int value)
		{
			OutputTabs();
			_writer.WriteLine(value);
			_tabsPending = true;
		}

		public override void WriteLine(long value)
		{
			OutputTabs();
			_writer.WriteLine(value);
			_tabsPending = true;
		}

		public override void WriteLine(object? value)
		{
			OutputTabs();
			_writer.WriteLine(value);
			_tabsPending = true;
		}

		public override void WriteLine(string format, object? arg0)
		{
			OutputTabs();
			_writer.WriteLine(format, arg0);
			_tabsPending = true;
		}

		public override void WriteLine(string format, object? arg0, object? arg1)
		{
			OutputTabs();
			_writer.WriteLine(format, arg0, arg1);
			_tabsPending = true;
		}

		public override void WriteLine(string format, params object?[] arg)
		{
			OutputTabs();
			_writer.WriteLine(format, arg);
			_tabsPending = true;
		}

		[CLSCompliant(false)]
		public override void WriteLine(uint value)
		{
			OutputTabs();
			_writer.WriteLine(value);
			_tabsPending = true;
		}

		public override async Task WriteLineAsync()
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteLineAsync().ConfigureAwait(continueOnCapturedContext: false);
			_tabsPending = true;
		}

		public override async Task WriteLineAsync(char value)
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteLineAsync(value).ConfigureAwait(continueOnCapturedContext: false);
			_tabsPending = true;
		}

		public override async Task WriteLineAsync(char[] buffer, int index, int count)
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteLineAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
			_tabsPending = true;
		}

		public override async Task WriteLineAsync(string? value)
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteLineAsync(value).ConfigureAwait(continueOnCapturedContext: false);
			_tabsPending = true;
		}

		public override async Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteLineAsync(buffer, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			_tabsPending = true;
		}

		public override async Task WriteLineAsync(StringBuilder? value, CancellationToken cancellationToken = default(CancellationToken))
		{
			await OutputTabsAsync().ConfigureAwait(continueOnCapturedContext: false);
			await _writer.WriteLineAsync(value, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			_tabsPending = true;
		}
	}
}
namespace System.Buffers
{
	public delegate void SpanAction<T, in TArg>(Span<T> span, TArg arg);
	public delegate void ReadOnlySpanAction<T, in TArg>(ReadOnlySpan<T> span, TArg arg);
	internal delegate TResult SpanFunc<TSpan, in T1, in T2, in T3, out TResult>(Span<TSpan> span, T1 arg1, T2 arg2, T3 arg3);
	public abstract class ArrayPool<T>
	{
		private static readonly TlsOverPerCoreLockedStacksArrayPool<T> s_shared = new TlsOverPerCoreLockedStacksArrayPool<T>();

		public static ArrayPool<T> Shared => s_shared;

		public static ArrayPool<T> Create()
		{
			return new ConfigurableArrayPool<T>();
		}

		public static ArrayPool<T> Create(int maxArrayLength, int maxArraysPerBucket)
		{
			return new ConfigurableArrayPool<T>(maxArrayLength, maxArraysPerBucket);
		}

		public abstract T[] Rent(int minimumLength);

		public abstract void Return(T[] array, bool clearArray = false);
	}
	[EventSource(Guid = "0866B2B8-5CEF-5DB9-2612-0C0FFD814A44", Name = "System.Buffers.ArrayPoolEventSource")]
	internal sealed class ArrayPoolEventSource : EventSource
	{
		internal enum BufferAllocatedReason
		{
			Pooled,
			OverMaximumSize,
			PoolExhausted
		}

		internal enum BufferDroppedReason
		{
			Full,
			OverMaximumSize
		}

		private const string EventSourceSuppressMessage = "Parameters to this method are primitive and are trimmer safe";

		internal static readonly ArrayPoolEventSource Log = new ArrayPoolEventSource();

		internal const int NoBucketId = -1;

		private protected override ReadOnlySpan<byte> ProviderMetadata => new byte[38]
		{
			38, 0, 83, 121, 115, 116, 101, 109, 46, 66,
			117, 102, 102, 101, 114, 115, 46, 65, 114, 114,
			97, 121, 80, 111, 111, 108, 69, 118, 101, 110,
			116, 83, 111, 117, 114, 99, 101, 0
		};

		private ArrayPoolEventSource(int _)
		{
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(1, Level = EventLevel.Verbose)]
		internal unsafe void BufferRented(int bufferId, int bufferSize, int poolId, int bucketId)
		{
			EventData* ptr = stackalloc EventData[4];
			ptr->Size = 4;
			ptr->DataPointer = (IntPtr)(&bufferId);
			ptr->Reserved = 0;
			ptr[1].Size = 4;
			ptr[1].DataPointer = (IntPtr)(&bufferSize);
			ptr[1].Reserved = 0;
			ptr[2].Size = 4;
			ptr[2].DataPointer = (IntPtr)(&poolId);
			ptr[2].Reserved = 0;
			ptr[3].Size = 4;
			ptr[3].DataPointer = (IntPtr)(&bucketId);
			ptr[3].Reserved = 0;
			WriteEventCore(1, 4, ptr);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(2, Level = EventLevel.Informational)]
		internal unsafe void BufferAllocated(int bufferId, int bufferSize, int poolId, int bucketId, BufferAllocatedReason reason)
		{
			EventData* ptr = stackalloc EventData[5];
			ptr->Size = 4;
			ptr->DataPointer = (IntPtr)(&bufferId);
			ptr->Reserved = 0;
			ptr[1].Size = 4;
			ptr[1].DataPointer = (IntPtr)(&bufferSize);
			ptr[1].Reserved = 0;
			ptr[2].Size = 4;
			ptr[2].DataPointer = (IntPtr)(&poolId);
			ptr[2].Reserved = 0;
			ptr[3].Size = 4;
			ptr[3].DataPointer = (IntPtr)(&bucketId);
			ptr[3].Reserved = 0;
			ptr[4].Size = 4;
			ptr[4].DataPointer = (IntPtr)(&reason);
			ptr[4].Reserved = 0;
			WriteEventCore(2, 5, ptr);
		}

		[Event(3, Level = EventLevel.Verbose)]
		internal void BufferReturned(int bufferId, int bufferSize, int poolId)
		{
			WriteEvent(3, bufferId, bufferSize, poolId);
		}

		[Event(4, Level = EventLevel.Informational)]
		internal void BufferTrimmed(int bufferId, int bufferSize, int poolId)
		{
			WriteEvent(4, bufferId, bufferSize, poolId);
		}

		[Event(5, Level = EventLevel.Informational)]
		internal void BufferTrimPoll(int milliseconds, int pressure)
		{
			WriteEvent(5, milliseconds, pressure);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(6, Level = EventLevel.Informational)]
		internal unsafe void BufferDropped(int bufferId, int bufferSize, int poolId, int bucketId, BufferDroppedReason reason)
		{
			EventData* ptr = stackalloc EventData[5];
			ptr->Size = 4;
			ptr->DataPointer = (IntPtr)(&bufferId);
			ptr->Reserved = 0;
			ptr[1].Size = 4;
			ptr[1].DataPointer = (IntPtr)(&bufferSize);
			ptr[1].Reserved = 0;
			ptr[2].Size = 4;
			ptr[2].DataPointer = (IntPtr)(&poolId);
			ptr[2].Reserved = 0;
			ptr[3].Size = 4;
			ptr[3].DataPointer = (IntPtr)(&bucketId);
			ptr[3].Reserved = 0;
			ptr[4].Size = 4;
			ptr[4].DataPointer = (IntPtr)(&reason);
			ptr[4].Reserved = 0;
			WriteEventCore(6, 5, ptr);
		}

		private ArrayPoolEventSource()
			: base(new Guid(140948152, 23791, 23993, 38, 18, 12, 15, 253, 129, 74, 68), "System.Buffers.ArrayPoolEventSource")
		{
		}
	}
	internal sealed class ConfigurableArrayPool<T> : ArrayPool<T>
	{
		private sealed class Bucket
		{
			internal readonly int _bufferLength;

			private readonly T[][] _buffers;

			private readonly int _poolId;

			private SpinLock _lock;

			private int _index;

			internal int Id => GetHashCode();

			internal Bucket(int bufferLength, int numberOfBuffers, int poolId)
			{
				_lock = new SpinLock(Debugger.IsAttached);
				_buffers = new T[numberOfBuffers][];
				_bufferLength = bufferLength;
				_poolId = poolId;
			}

			internal T[] Rent()
			{
				T[][] buffers = _buffers;
				T[] array = null;
				bool lockTaken = false;
				bool flag = false;
				try
				{
					_lock.Enter(ref lockTaken);
					if (_index < buffers.Length)
					{
						array = buffers[_index];
						buffers[_index++] = null;
						flag = array == null;
					}
				}
				finally
				{
					if (lockTaken)
					{
						_lock.Exit(useMemoryBarrier: false);
					}
				}
				if (flag)
				{
					array = new T[_bufferLength];
					ArrayPoolEventSource log = ArrayPoolEventSource.Log;
					if (log.IsEnabled())
					{
						log.BufferAllocated(array.GetHashCode(), _bufferLength, _poolId, Id, ArrayPoolEventSource.BufferAllocatedReason.Pooled);
					}
				}
				return array;
			}

			internal void Return(T[] array)
			{
				if (array.Length != _bufferLength)
				{
					throw new ArgumentException(SR.ArgumentException_BufferNotFromPool, "array");
				}
				bool lockTaken = false;
				bool flag;
				try
				{
					_lock.Enter(ref lockTaken);
					flag = _index != 0;
					if (flag)
					{
						_buffers[--_index] = array;
					}
				}
				finally
				{
					if (lockTaken)
					{
						_lock.Exit(useMemoryBarrier: false);
					}
				}
				if (!flag)
				{
					ArrayPoolEventSource log = ArrayPoolEventSource.Log;
					if (log.IsEnabled())
					{
						log.BufferDropped(array.GetHashCode(), _bufferLength, _poolId, Id, ArrayPoolEventSource.BufferDroppedReason.Full);
					}
				}
			}
		}

		private readonly Bucket[] _buckets;

		private int Id => GetHashCode();

		internal ConfigurableArrayPool()
			: this(1048576, 50)
		{
		}

		internal ConfigurableArrayPool(int maxArrayLength, int maxArraysPerBucket)
		{
			if (maxArrayLength <= 0)
			{
				throw new ArgumentOutOfRangeException("maxArrayLength");
			}
			if (maxArraysPerBucket <= 0)
			{
				throw new ArgumentOutOfRangeException("maxArraysPerBucket");
			}
			if (maxArrayLength > 1073741824)
			{
				maxArrayLength = 1073741824;
			}
			else if (maxArrayLength < 16)
			{
				maxArrayLength = 16;
			}
			int id = Id;
			int num = Utilities.SelectBucketIndex(maxArrayLength);
			Bucket[] array = new Bucket[num + 1];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id);
			}
			_buckets = array;
		}

		public override T[] Rent(int minimumLength)
		{
			if (minimumLength < 0)
			{
				throw new ArgumentOutOfRangeException("minimumLength");
			}
			if (minimumLength == 0)
			{
				return Array.Empty<T>();
			}
			ArrayPoolEventSource log = ArrayPoolEventSource.Log;
			int num = Utilities.SelectBucketIndex(minimumLength);
			T[] array;
			if (num < _buckets.Length)
			{
				int num2 = num;
				do
				{
					array = _buckets[num2].Rent();
					if (array != null)
					{
						if (log.IsEnabled())
						{
							log.BufferRented(array.GetHashCode(), array.Length, Id, _buckets[num2].Id);
						}
						return array;
					}
				}
				while (++num2 < _buckets.Length && num2 != num + 2);
				array = new T[_buckets[num]._bufferLength];
			}
			else
			{
				array = new T[minimumLength];
			}
			if (log.IsEnabled())
			{
				int hashCode = array.GetHashCode();
				log.BufferRented(hashCode, array.Length, Id, -1);
				log.BufferAllocated(hashCode, array.Length, Id, -1, (num >= _buckets.Length) ? ArrayPoolEventSource.BufferAllocatedReason.OverMaximumSize : ArrayPoolEventSource.BufferAllocatedReason.PoolExhausted);
			}
			return array;
		}

		public override void Return(T[] array, bool clearArray = false)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (array.Length == 0)
			{
				return;
			}
			int num = Utilities.SelectBucketIndex(array.Length);
			bool flag = num < _buckets.Length;
			if (flag)
			{
				if (clearArray)
				{
					Array.Clear(array);
				}
				_buckets[num].Return(array);
			}
			ArrayPoolEventSource log = ArrayPoolEventSource.Log;
			if (log.IsEnabled())
			{
				int hashCode = array.GetHashCode();
				log.BufferReturned(hashCode, array.Length, Id);
				if (!flag)
				{
					log.BufferDropped(hashCode, array.Length, Id, -1, ArrayPoolEventSource.BufferDroppedReason.Full);
				}
			}
		}
	}
	public interface IMemoryOwner<T> : IDisposable
	{
		Memory<T> Memory { get; }
	}
	public interface IPinnable
	{
		MemoryHandle Pin(int elementIndex);

		void Unpin();
	}
	public struct MemoryHandle : IDisposable
	{
		private unsafe void* _pointer;

		private GCHandle _handle;

		private IPinnable _pinnable;

		[CLSCompliant(false)]
		public unsafe void* Pointer => _pointer;

		[CLSCompliant(false)]
		public unsafe MemoryHandle(void* pointer, GCHandle handle = default(GCHandle), IPinnable? pinnable = null)
		{
			_pointer = pointer;
			_handle = handle;
			_pinnable = pinnable;
		}

		public unsafe void Dispose()
		{
			if (_handle.IsAllocated)
			{
				_handle.Free();
			}
			if (_pinnable != null)
			{
				_pinnable.Unpin();
				_pinnable = null;
			}
			_pointer = null;
		}
	}
	public abstract class MemoryManager<T> : IMemoryOwner<T>, IDisposable, IPinnable
	{
		public virtual Memory<T> Memory => new Memory<T>(this, GetSpan().Length);

		public abstract Span<T> GetSpan();

		public abstract MemoryHandle Pin(int elementIndex = 0);

		public abstract void Unpin();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected Memory<T> CreateMemory(int length)
		{
			return new Memory<T>(this, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected Memory<T> CreateMemory(int start, int length)
		{
			return new Memory<T>(this, start, length);
		}

		protected internal virtual bool TryGetArray(out ArraySegment<T> segment)
		{
			segment = default(ArraySegment<T>);
			return false;
		}

		void IDisposable.Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected abstract void Dispose(bool disposing);
	}
	public enum OperationStatus
	{
		Done,
		DestinationTooSmall,
		NeedMoreData,
		InvalidData
	}
	public readonly struct StandardFormat : IEquatable<StandardFormat>
	{
		public const byte NoPrecision = byte.MaxValue;

		public const byte MaxPrecision = 99;

		private readonly byte _format;

		private readonly byte _precision;

		public char Symbol => (char)_format;

		public byte Precision => _precision;

		public bool HasPrecision => _precision != byte.MaxValue;

		public bool IsDefault
		{
			get
			{
				if (_format == 0)
				{
					return _precision == 0;
				}
				return false;
			}
		}

		public StandardFormat(char symbol, byte precision = byte.MaxValue)
		{
			if (precision != byte.MaxValue && precision > 99)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_PrecisionTooLarge();
			}
			if (symbol != (byte)symbol)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_SymbolDoesNotFit();
			}
			_format = (byte)symbol;
			_precision = precision;
		}

		public static implicit operator StandardFormat(char symbol)
		{
			return new StandardFormat(symbol);
		}

		public static StandardFormat Parse(ReadOnlySpan<char> format)
		{
			ParseHelper(format, out var standardFormat, throws: true);
			return standardFormat;
		}

		public static StandardFormat Parse(string? format)
		{
			if (format != null)
			{
				return Parse(format.AsSpan());
			}
			return default(StandardFormat);
		}

		public static bool TryParse(ReadOnlySpan<char> format, out StandardFormat result)
		{
			return ParseHelper(format, out result);
		}

		private static bool ParseHelper(ReadOnlySpan<char> format, out StandardFormat standardFormat, bool throws = false)
		{
			standardFormat = default(StandardFormat);
			if (format.Length == 0)
			{
				return true;
			}
			char symbol = format[0];
			byte precision;
			if (format.Length == 1)
			{
				precision = byte.MaxValue;
			}
			else
			{
				uint num = 0u;
				for (int i = 1; i < format.Length; i++)
				{
					uint num2 = (uint)(format[i] - 48);
					if (num2 > 9)
					{
						if (!throws)
						{
							return false;
						}
						throw new FormatException(SR.Format(SR.Argument_CannotParsePrecision, (byte)99));
					}
					num = num * 10 + num2;
					if (num > 99)
					{
						if (!throws)
						{
							return false;
						}
						throw new FormatException(SR.Format(SR.Argument_PrecisionTooLarge, (byte)99));
					}
				}
				precision = (byte)num;
			}
			standardFormat = new StandardFormat(symbol, precision);
			return true;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is StandardFormat other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _format.GetHashCode() ^ _precision.GetHashCode();
		}

		public bool Equals(StandardFormat other)
		{
			if (_format == other._format)
			{
				return _precision == other._precision;
			}
			return false;
		}

		public override string ToString()
		{
			Span<char> destination = stackalloc char[3];
			return new string(destination[..Format(destination)]);
		}

		internal int Format(Span<char> destination)
		{
			int num = 0;
			char symbol = Symbol;
			if (symbol != 0 && destination.Length == 3)
			{
				destination[0] = symbol;
				num = 1;
				uint num2 = Precision;
				if (num2 != 255)
				{
					if (num2 >= 10)
					{
						uint num3;
						(num3, num2) = Math.DivRem(num2, 10u);
						destination[1] = (char)(48 + num3 % 10);
						num = 2;
					}
					destination[num] = (char)(48 + num2);
					num++;
				}
			}
			return num;
		}

		public static bool operator ==(StandardFormat left, StandardFormat right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(StandardFormat left, StandardFormat right)
		{
			return !left.Equals(right);
		}
	}
	internal sealed class TlsOverPerCoreLockedStacksArrayPool<T> : ArrayPool<T>
	{
		private sealed class PerCoreLockedStacks
		{
			private static readonly int s_lockedStackCount = Math.Min(Environment.ProcessorCount, 64);

			private readonly LockedStack[] _perCoreStacks;

			public PerCoreLockedStacks()
			{
				LockedStack[] array = new LockedStack[s_lockedStackCount];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = new LockedStack();
				}
				_perCoreStacks = array;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool TryPush(T[] array)
			{
				LockedStack[] perCoreStacks = _perCoreStacks;
				int num = (int)((uint)Thread.GetCurrentProcessorId() % (uint)s_lockedStackCount);
				for (int i = 0; i < perCoreStacks.Length; i++)
				{
					if (perCoreStacks[num].TryPush(array))
					{
						return true;
					}
					if (++num == perCoreStacks.Length)
					{
						num = 0;
					}
				}
				return false;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public T[] TryPop()
			{
				LockedStack[] perCoreStacks = _perCoreStacks;
				int num = (int)((uint)Thread.GetCurrentProcessorId() % (uint)s_lockedStackCount);
				for (int i = 0; i < perCoreStacks.Length; i++)
				{
					T[] result;
					if ((result = perCoreStacks[num].TryPop()) != null)
					{
						return result;
					}
					if (++num == perCoreStacks.Length)
					{
						num = 0;
					}
				}
				return null;
			}

			public void Trim(int currentMilliseconds, int id, Utilities.MemoryPressure pressure, int bucketSize)
			{
				LockedStack[] perCoreStacks = _perCoreStacks;
				for (int i = 0; i < perCoreStacks.Length; i++)
				{
					perCoreStacks[i].Trim(currentMilliseconds, id, pressure, bucketSize);
				}
			}
		}

		private sealed class LockedStack
		{
			private readonly T[][] _arrays = new T[8][];

			private int _count;

			private int _millisecondsTimestamp;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool TryPush(T[] array)
			{
				bool result = false;
				Monitor.Enter(this);
				T[][] arrays = _arrays;
				int count = _count;
				if ((uint)count < (uint)arrays.Length)
				{
					if (count == 0)
					{
						_millisecondsTimestamp = 0;
					}
					arrays[count] = array;
					_count = count + 1;
					result = true;
				}
				Monitor.Exit(this);
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public T[] TryPop()
			{
				T[] result = null;
				Monitor.Enter(this);
				T[][] arrays = _arrays;
				int num = _count - 1;
				if ((uint)num < (uint)arrays.Length)
				{
					result = arrays[num];
					arrays[num] = null;
					_count = num;
				}
				Monitor.Exit(this);
				return result;
			}

			public void Trim(int currentMilliseconds, int id, Utilities.MemoryPressure pressure, int bucketSize)
			{
				if (_count == 0)
				{
					return;
				}
				int num = ((pressure == Utilities.MemoryPressure.High) ? 10000 : 60000);
				lock (this)
				{
					if (_count == 0)
					{
						return;
					}
					if (_millisecondsTimestamp == 0)
					{
						_millisecondsTimestamp = currentMilliseconds;
					}
					else
					{
						if (currentMilliseconds - _millisecondsTimestamp <= num)
						{
							return;
						}
						ArrayPoolEventSource log = ArrayPoolEventSource.Log;
						int num2 = 1;
						switch (pressure)
						{
						case Utilities.MemoryPressure.High:
							num2 = 8;
							if (bucketSize > 16384)
							{
								num2++;
							}
							if (Unsafe.SizeOf<T>() > 16)
							{
								num2++;
							}
							if (Unsafe.SizeOf<T>() > 32)
							{
								num2++;
							}
							break;
						case Utilities.MemoryPressure.Medium:
							num2 = 2;
							break;
						}
						while (_count > 0 && num2-- > 0)
						{
							T[] array = _arrays[--_count];
							_arrays[_count] = null;
							if (log.IsEnabled())
							{
								log.BufferTrimmed(array.GetHashCode(), array.Length, id);
							}
						}
						_millisecondsTimestamp = ((_count > 0) ? (_millisecondsTimestamp + num / 4) : 0);
					}
				}
			}
		}

		private struct ThreadLocalArray
		{
			public T[] Array;

			public int MillisecondsTimeStamp;

			public ThreadLocalArray(T[] array)
			{
				Array = array;
				MillisecondsTimeStamp = 0;
			}
		}

		[ThreadStatic]
		private static ThreadLocalArray[] t_tlsBuckets;

		private readonly ConditionalWeakTable<ThreadLocalArray[], object> _allTlsBuckets = new ConditionalWeakTable<ThreadLocalArray[], object>();

		private readonly PerCoreLockedStacks[] _buckets = new PerCoreLockedStacks[27];

		private int _trimCallbackCreated;

		private int Id => GetHashCode();

		private PerCoreLockedStacks CreatePerCoreLockedStacks(int bucketIndex)
		{
			PerCoreLockedStacks perCoreLockedStacks = new PerCoreLockedStacks();
			return Interlocked.CompareExchange(ref _buckets[bucketIndex], perCoreLockedStacks, null) ?? perCoreLockedStacks;
		}

		public override T[] Rent(int minimumLength)
		{
			ArrayPoolEventSource log = ArrayPoolEventSource.Log;
			int num = Utilities.SelectBucketIndex(minimumLength);
			ThreadLocalArray[] array = t_tlsBuckets;
			T[] array2;
			if (array != null && (uint)num < (uint)array.Length)
			{
				array2 = array[num].Array;
				if (array2 != null)
				{
					array[num].Array = null;
					if (log.IsEnabled())
					{
						log.BufferRented(array2.GetHashCode(), array2.Length, Id, num);
					}
					return array2;
				}
			}
			PerCoreLockedStacks[] buckets = _buckets;
			if ((uint)num < (uint)buckets.Length)
			{
				PerCoreLockedStacks perCoreLockedStacks = buckets[num];
				if (perCoreLockedStacks != null)
				{
					array2 = perCoreLockedStacks.TryPop();
					if (array2 != null)
					{
						if (log.IsEnabled())
						{
							log.BufferRented(array2.GetHashCode(), array2.Length, Id, num);
						}
						return array2;
					}
				}
				minimumLength = Utilities.GetMaxSizeForBucket(num);
			}
			else
			{
				if (minimumLength == 0)
				{
					return Array.Empty<T>();
				}
				if (minimumLength < 0)
				{
					throw new ArgumentOutOfRangeException("minimumLength");
				}
			}
			array2 = GC.AllocateUninitializedArray<T>(minimumLength);
			if (log.IsEnabled())
			{
				int hashCode = array2.GetHashCode();
				log.BufferRented(hashCode, array2.Length, Id, -1);
				log.BufferAllocated(hashCode, array2.Length, Id, -1, (num >= _buckets.Length) ? ArrayPoolEventSource.BufferAllocatedReason.OverMaximumSize : ArrayPoolEventSource.BufferAllocatedReason.PoolExhausted);
			}
			return array2;
		}

		public override void Return(T[] array, bool clearArray = false)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			int num = Utilities.SelectBucketIndex(array.Length);
			ThreadLocalArray[] array2 = t_tlsBuckets ?? InitializeTlsBucketsAndTrimming();
			bool flag = false;
			bool flag2 = true;
			if ((uint)num < (uint)array2.Length)
			{
				flag = true;
				if (clearArray)
				{
					Array.Clear(array);
				}
				if (array.Length != Utilities.GetMaxSizeForBucket(num))
				{
					throw new ArgumentException(SR.ArgumentException_BufferNotFromPool, "array");
				}
				ref ThreadLocalArray reference = ref array2[num];
				T[] array3 = reference.Array;
				reference = new ThreadLocalArray(array);
				if (array3 != null)
				{
					PerCoreLockedStacks perCoreLockedStacks = _buckets[num] ?? CreatePerCoreLockedStacks(num);
					flag2 = perCoreLockedStacks.TryPush(array3);
				}
			}
			ArrayPoolEventSource log = ArrayPoolEventSource.Log;
			if (log.IsEnabled() && array.Length != 0)
			{
				log.BufferReturned(array.GetHashCode(), array.Length, Id);
				if (!(flag && flag2))
				{
					log.BufferDropped(array.GetHashCode(), array.Length, Id, flag ? num : (-1), (!flag) ? ArrayPoolEventSource.BufferDroppedReason.OverMaximumSize : ArrayPoolEventSource.BufferDroppedReason.Full);
				}
			}
		}

		public bool Trim()
		{
			int tickCount = Environment.TickCount;
			Utilities.MemoryPressure memoryPressure = Utilities.GetMemoryPressure();
			ArrayPoolEventSource log = ArrayPoolEventSource.Log;
			if (log.IsEnabled())
			{
				log.BufferTrimPoll(tickCount, (int)memoryPressure);
			}
			PerCoreLockedStacks[] buckets = _buckets;
			for (int i = 0; i < buckets.Length; i++)
			{
				buckets[i]?.Trim(tickCount, Id, memoryPressure, Utilities.GetMaxSizeForBucket(i));
			}
			if (memoryPressure == Utilities.MemoryPressure.High)
			{
				if (log.IsEnabled())
				{
					foreach (KeyValuePair<ThreadLocalArray[], object> item in (IEnumerable<KeyValuePair<ThreadLocalArray[], object>>)_allTlsBuckets)
					{
						ThreadLocalArray[] key = item.Key;
						for (int j = 0; j < key.Length; j++)
						{
							T[] array = Interlocked.Exchange(ref key[j].Array, null);
							if (array != null)
							{
								log.BufferTrimmed(array.GetHashCode(), array.Length, Id);
							}
						}
					}
				}
				else
				{
					foreach (KeyValuePair<ThreadLocalArray[], object> item2 in (IEnumerable<KeyValuePair<ThreadLocalArray[], object>>)_allTlsBuckets)
					{
						Array.Clear(item2.Key);
					}
				}
			}
			else
			{
				uint num = ((memoryPressure != Utilities.MemoryPressure.Medium) ? 30000u : 15000u);
				uint num2 = num;
				foreach (KeyValuePair<ThreadLocalArray[], object> item3 in (IEnumerable<KeyValuePair<ThreadLocalArray[], object>>)_allTlsBuckets)
				{
					ThreadLocalArray[] key2 = item3.Key;
					for (int k = 0; k < key2.Length; k++)
					{
						if (key2[k].Array == null)
						{
							continue;
						}
						int millisecondsTimeStamp = key2[k].MillisecondsTimeStamp;
						if (millisecondsTimeStamp == 0)
						{
							key2[k].MillisecondsTimeStamp = tickCount;
						}
						else if (tickCount - millisecondsTimeStamp >= num2)
						{
							T[] array2 = Interlocked.Exchange(ref key2[k].Array, null);
							if (array2 != null && log.IsEnabled())
							{
								log.BufferTrimmed(array2.GetHashCode(), array2.Length, Id);
							}
						}
					}
				}
			}
			return true;
		}

		private ThreadLocalArray[] InitializeTlsBucketsAndTrimming()
		{
			ThreadLocalArray[] array = (t_tlsBuckets = new ThreadLocalArray[27]);
			_allTlsBuckets.Add(array, null);
			if (Interlocked.Exchange(ref _trimCallbackCreated, 1) == 0)
			{
				Gen2GcCallback.Register((object s) => ((TlsOverPerCoreLockedStacksArrayPool<T>)s).Trim(), this);
			}
			return array;
		}
	}
	internal static class Utilities
	{
		internal enum MemoryPressure
		{
			Low,
			Medium,
			High
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int SelectBucketIndex(int bufferSize)
		{
			return BitOperations.Log2((uint)(bufferSize - 1) | 0xFu) - 3;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetMaxSizeForBucket(int binIndex)
		{
			return 16 << binIndex;
		}

		internal static MemoryPressure GetMemoryPressure()
		{
			GCMemoryInfo gCMemoryInfo = GC.GetGCMemoryInfo();
			if ((double)gCMemoryInfo.MemoryLoadBytes >= (double)gCMemoryInfo.HighMemoryLoadThresholdBytes * 0.9)
			{
				return MemoryPressure.High;
			}
			if ((double)gCMemoryInfo.MemoryLoadBytes >= (double)gCMemoryInfo.HighMemoryLoadThresholdBytes * 0.7)
			{
				return MemoryPressure.Medium;
			}
			return MemoryPressure.Low;
		}
	}
}
namespace System.Buffers.Text
{
	internal static class FormattingHelpers
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CountDigits(ulong value)
		{
			int num = 1;
			uint num2;
			if (value >= 10000000)
			{
				if (value >= 100000000000000L)
				{
					num2 = (uint)(value / 100000000000000L);
					num += 14;
				}
				else
				{
					num2 = (uint)(value / 10000000);
					num += 7;
				}
			}
			else
			{
				num2 = (uint)value;
			}
			if (num2 >= 10)
			{
				num = ((num2 < 100) ? (num + 1) : ((num2 < 1000) ? (num + 2) : ((num2 < 10000) ? (num + 3) : ((num2 < 100000) ? (num + 4) : ((num2 >= 1000000) ? (num + 6) : (num + 5))))));
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CountDigits(uint value)
		{
			int num = 1;
			if (value >= 100000)
			{
				value /= 100000;
				num += 5;
			}
			if (value >= 10)
			{
				num = ((value < 100) ? (num + 1) : ((value < 1000) ? (num + 2) : ((value >= 10000) ? (num + 4) : (num + 3))));
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CountHexDigits(ulong value)
		{
			return (BitOperations.Log2(value) >> 2) + 1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CountDecimalTrailingZeros(uint value, out uint valueWithoutTrailingZeros)
		{
			int num = 0;
			if (value != 0)
			{
				while (true)
				{
					uint num2 = value / 10;
					if (value != num2 * 10)
					{
						break;
					}
					value = num2;
					num++;
				}
			}
			valueWithoutTrailingZeros = value;
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char GetSymbolOrDefault(in StandardFormat format, char defaultSymbol)
		{
			char c = format.Symbol;
			if (c == '\0' && format.Precision == 0)
			{
				c = defaultSymbol;
			}
			return c;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void FillWithAsciiZeros(Span<byte> buffer)
		{
			for (int i = 0; i < buffer.Length; i++)
			{
				buffer[i] = 48;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDigits(ulong value, Span<byte> buffer)
		{
			for (int num = buffer.Length - 1; num >= 1; num--)
			{
				ulong num2 = 48 + value;
				value /= 10;
				buffer[num] = (byte)(num2 - value * 10);
			}
			buffer[0] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDigitsWithGroupSeparator(ulong value, Span<byte> buffer)
		{
			int num = 0;
			for (int num2 = buffer.Length - 1; num2 >= 1; num2--)
			{
				ulong num3 = 48 + value;
				value /= 10;
				buffer[num2] = (byte)(num3 - value * 10);
				if (num == 2)
				{
					buffer[--num2] = 44;
					num = 0;
				}
				else
				{
					num++;
				}
			}
			buffer[0] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDigits(uint value, Span<byte> buffer)
		{
			for (int num = buffer.Length - 1; num >= 1; num--)
			{
				uint num2 = 48 + value;
				value /= 10;
				buffer[num] = (byte)(num2 - value * 10);
			}
			buffer[0] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteFourDecimalDigits(uint value, Span<byte> buffer, int startingIndex = 0)
		{
			uint num = 48 + value;
			value /= 10;
			buffer[startingIndex + 3] = (byte)(num - value * 10);
			num = 48 + value;
			value /= 10;
			buffer[startingIndex + 2] = (byte)(num - value * 10);
			num = 48 + value;
			value /= 10;
			buffer[startingIndex + 1] = (byte)(num - value * 10);
			buffer[startingIndex] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteTwoDecimalDigits(uint value, Span<byte> buffer, int startingIndex = 0)
		{
			uint num = 48 + value;
			value /= 10;
			buffer[startingIndex + 1] = (byte)(num - value * 10);
			buffer[startingIndex] = (byte)(48 + value);
		}

		public static bool TryFormatThrowFormatException(out int bytesWritten)
		{
			bytesWritten = 0;
			ThrowHelper.ThrowFormatException_BadFormatSpecifier();
			return false;
		}
	}
	internal static class Utf8Constants
	{
		public static readonly TimeSpan NullUtcOffset = TimeSpan.MinValue;
	}
	public static class Utf8Formatter
	{
		[StructLayout(LayoutKind.Explicit)]
		private struct DecomposedGuid
		{
			[FieldOffset(0)]
			public Guid Guid;

			[FieldOffset(0)]
			public byte Byte00;

			[FieldOffset(1)]
			public byte Byte01;

			[FieldOffset(2)]
			public byte Byte02;

			[FieldOffset(3)]
			public byte Byte03;

			[FieldOffset(4)]
			public byte Byte04;

			[FieldOffset(5)]
			public byte Byte05;

			[FieldOffset(6)]
			public byte Byte06;

			[FieldOffset(7)]
			public byte Byte07;

			[FieldOffset(8)]
			public byte Byte08;

			[FieldOffset(9)]
			public byte Byte09;

			[FieldOffset(10)]
			public byte Byte10;

			[FieldOffset(11)]
			public byte Byte11;

			[FieldOffset(12)]
			public byte Byte12;

			[FieldOffset(13)]
			public byte Byte13;

			[FieldOffset(14)]
			public byte Byte14;

			[FieldOffset(15)]
			public byte Byte15;
		}

		private static readonly uint[] s_dayAbbreviations = new uint[7] { 7238995u, 7237453u, 6649172u, 6579543u, 7694420u, 6910534u, 7627091u };

		private static readonly uint[] s_dayAbbreviationsLowercase = new uint[7] { 7239027u, 7237485u, 6649204u, 6579575u, 7694452u, 6910566u, 7627123u };

		private static readonly uint[] s_monthAbbreviations = new uint[12]
		{
			7233866u, 6448454u, 7496013u, 7499841u, 7954765u, 7238986u, 7107914u, 6780225u, 7365971u, 7627599u,
			7761742u, 6513988u
		};

		private static readonly uint[] s_monthAbbreviationsLowercase = new uint[12]
		{
			7233898u, 6448486u, 7496045u, 7499873u, 7954797u, 7239018u, 7107946u, 6780257u, 7366003u, 7627631u,
			7761774u, 6514020u
		};

		public static bool TryFormat(bool value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			char symbolOrDefault = FormattingHelpers.GetSymbolOrDefault(in format, 'G');
			if (value)
			{
				if (symbolOrDefault == 'G')
				{
					if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, 1416787301u))
					{
						goto IL_0033;
					}
				}
				else
				{
					if (symbolOrDefault != 'l')
					{
						goto IL_0083;
					}
					if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, 1953658213u))
					{
						goto IL_0033;
					}
				}
			}
			else if (symbolOrDefault == 'G')
			{
				if (4u < (uint)destination.Length)
				{
					BinaryPrimitives.WriteUInt32BigEndian(destination, 1180789875u);
					goto IL_006e;
				}
			}
			else
			{
				if (symbolOrDefault != 'l')
				{
					goto IL_0083;
				}
				if (4u < (uint)destination.Length)
				{
					BinaryPrimitives.WriteUInt32BigEndian(destination, 1717660787u);
					goto IL_006e;
				}
			}
			bytesWritten = 0;
			return false;
			IL_0033:
			bytesWritten = 4;
			return true;
			IL_0083:
			return FormattingHelpers.TryFormatThrowFormatException(out bytesWritten);
			IL_006e:
			destination[4] = 101;
			bytesWritten = 5;
			return true;
		}

		public static bool TryFormat(DateTimeOffset value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			TimeSpan offset = Utf8Constants.NullUtcOffset;
			char c = format.Symbol;
			if (format.IsDefault)
			{
				c = 'G';
				offset = value.Offset;
			}
			return c switch
			{
				'R' => TryFormatDateTimeR(value.UtcDateTime, destination, out bytesWritten), 
				'l' => TryFormatDateTimeL(value.UtcDateTime, destination, out bytesWritten), 
				'O' => TryFormatDateTimeO(value.DateTime, value.Offset, destination, out bytesWritten), 
				'G' => TryFormatDateTimeG(value.DateTime, offset, destination, out bytesWritten), 
				_ => FormattingHelpers.TryFormatThrowFormatException(out bytesWritten), 
			};
		}

		public static bool TryFormat(DateTime value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return FormattingHelpers.GetSymbolOrDefault(in format, 'G') switch
			{
				'R' => TryFormatDateTimeR(value, destination, out bytesWritten), 
				'l' => TryFormatDateTimeL(value, destination, out bytesWritten), 
				'O' => TryFormatDateTimeO(value, Utf8Constants.NullUtcOffset, destination, out bytesWritten), 
				'G' => TryFormatDateTimeG(value, Utf8Constants.NullUtcOffset, destination, out bytesWritten), 
				_ => FormattingHelpers.TryFormatThrowFormatException(out bytesWritten), 
			};
		}

		private static bool TryFormatDateTimeG(DateTime value, TimeSpan offset, Span<byte> destination, out int bytesWritten)
		{
			int num = 19;
			if (offset != Utf8Constants.NullUtcOffset)
			{
				num += 7;
			}
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			byte b = destination[18];
			value.GetDate(out var year, out var month, out var day);
			value.GetTime(out var hour, out var minute, out var second);
			FormattingHelpers.WriteTwoDecimalDigits((uint)month, destination);
			destination[2] = 47;
			FormattingHelpers.WriteTwoDecimalDigits((uint)day, destination, 3);
			destination[5] = 47;
			FormattingHelpers.WriteFourDecimalDigits((uint)year, destination, 6);
			destination[10] = 32;
			FormattingHelpers.WriteTwoDecimalDigits((uint)hour, destination, 11);
			destination[13] = 58;
			FormattingHelpers.WriteTwoDecimalDigits((uint)minute, destination, 14);
			destination[16] = 58;
			FormattingHelpers.WriteTwoDecimalDigits((uint)second, destination, 17);
			if (offset != Utf8Constants.NullUtcOffset)
			{
				int num2 = (int)(offset.Ticks / 600000000);
				byte b2;
				if (num2 < 0)
				{
					b2 = 45;
					num2 = -num2;
				}
				else
				{
					b2 = 43;
				}
				int result;
				int value2 = Math.DivRem(num2, 60, out result);
				FormattingHelpers.WriteTwoDecimalDigits((uint)result, destination, 24);
				destination[23] = 58;
				FormattingHelpers.WriteTwoDecimalDigits((uint)value2, destination, 21);
				destination[20] = b2;
				destination[19] = 32;
			}
			return true;
		}

		private static bool TryFormatDateTimeL(DateTime value, Span<byte> destination, out int bytesWritten)
		{
			if (28u >= (uint)destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			value.GetDate(out var year, out var month, out var day);
			value.GetTime(out var hour, out var minute, out var second);
			uint num = s_dayAbbreviationsLowercase[(int)value.DayOfWeek];
			destination[0] = (byte)num;
			num >>= 8;
			destination[1] = (byte)num;
			num >>= 8;
			destination[2] = (byte)num;
			destination[3] = 44;
			destination[4] = 32;
			FormattingHelpers.WriteTwoDecimalDigits((uint)day, destination, 5);
			destination[7] = 32;
			uint num2 = s_monthAbbreviationsLowercase[month - 1];
			destination[8] = (byte)num2;
			num2 >>= 8;
			destination[9] = (byte)num2;
			num2 >>= 8;
			destination[10] = (byte)num2;
			destination[11] = 32;
			FormattingHelpers.WriteFourDecimalDigits((uint)year, destination, 12);
			destination[16] = 32;
			FormattingHelpers.WriteTwoDecimalDigits((uint)hour, destination, 17);
			destination[19] = 58;
			FormattingHelpers.WriteTwoDecimalDigits((uint)minute, destination, 20);
			destination[22] = 58;
			FormattingHelpers.WriteTwoDecimalDigits((uint)second, destination, 23);
			destination[25] = 32;
			destination[26] = 103;
			destination[27] = 109;
			destination[28] = 116;
			bytesWritten = 29;
			return true;
		}

		private static bool TryFormatDateTimeO(DateTime value, TimeSpan offset, Span<byte> destination, out int bytesWritten)
		{
			int num = 27;
			DateTimeKind dateTimeKind = DateTimeKind.Local;
			if (offset == Utf8Constants.NullUtcOffset)
			{
				dateTimeKind = value.Kind;
				switch (dateTimeKind)
				{
				case DateTimeKind.Local:
					offset = TimeZoneInfo.Local.GetUtcOffset(value);
					num += 6;
					break;
				case DateTimeKind.Utc:
					num++;
					break;
				}
			}
			else
			{
				num += 6;
			}
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			_ = ref destination[26];
			value.GetDate(out var year, out var month, out var day);
			value.GetTimePrecise(out var hour, out var minute, out var second, out var tick);
			FormattingHelpers.WriteFourDecimalDigits((uint)year, destination);
			destination[4] = 45;
			FormattingHelpers.WriteTwoDecimalDigits((uint)month, destination, 5);
			destination[7] = 45;
			FormattingHelpers.WriteTwoDecimalDigits((uint)day, destination, 8);
			destination[10] = 84;
			FormattingHelpers.WriteTwoDecimalDigits((uint)hour, destination, 11);
			destination[13] = 58;
			FormattingHelpers.WriteTwoDecimalDigits((uint)minute, destination, 14);
			destination[16] = 58;
			FormattingHelpers.WriteTwoDecimalDigits((uint)second, destination, 17);
			destination[19] = 46;
			FormattingHelpers.WriteDigits((uint)tick, destination.Slice(20, 7));
			switch (dateTimeKind)
			{
			case DateTimeKind.Local:
			{
				int num2 = (int)(offset.Ticks / 600000000);
				byte b;
				if (num2 < 0)
				{
					b = 45;
					num2 = -num2;
				}
				else
				{
					b = 43;
				}
				int result;
				int value2 = Math.DivRem(num2, 60, out result);
				FormattingHelpers.WriteTwoDecimalDigits((uint)result, destination, 31);
				destination[30] = 58;
				FormattingHelpers.WriteTwoDecimalDigits((uint)value2, destination, 28);
				destination[27] = b;
				break;
			}
			case DateTimeKind.Utc:
				destination[27] = 90;
				break;
			}
			return true;
		}

		private static bool TryFormatDateTimeR(DateTime value, Span<byte> destination, out int bytesWritten)
		{
			if (28u >= (uint)destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			value.GetDate(out var year, out var month, out var day);
			value.GetTime(out var hour, out var minute, out var second);
			uint num = s_dayAbbreviations[(int)value.DayOfWeek];
			destination[0] = (byte)num;
			num >>= 8;
			destination[1] = (byte)num;
			num >>= 8;
			destination[2] = (byte)num;
			destination[3] = 44;
			destination[4] = 32;
			FormattingHelpers.WriteTwoDecimalDigits((uint)day, destination, 5);
			destination[7] = 32;
			uint num2 = s_monthAbbreviations[month - 1];
			destination[8] = (byte)num2;
			num2 >>= 8;
			destination[9] = (byte)num2;
			num2 >>= 8;
			destination[10] = (byte)num2;
			destination[11] = 32;
			FormattingHelpers.WriteFourDecimalDigits((uint)year, destination, 12);
			destination[16] = 32;
			FormattingHelpers.WriteTwoDecimalDigits((uint)hour, destination, 17);
			destination[19] = 58;
			FormattingHelpers.WriteTwoDecimalDigits((uint)minute, destination, 20);
			destination[22] = 58;
			FormattingHelpers.WriteTwoDecimalDigits((uint)second, destination, 23);
			destination[25] = 32;
			destination[26] = 71;
			destination[27] = 77;
			destination[28] = 84;
			bytesWritten = 29;
			return true;
		}

		public unsafe static bool TryFormat(decimal value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			if (format.IsDefault)
			{
				format = 'G';
			}
			switch (format.Symbol)
			{
			case 'G':
			case 'g':
			{
				if (format.Precision != byte.MaxValue)
				{
					throw new NotSupportedException(SR.Argument_GWithPrecisionNotSupported);
				}
				byte* digits3 = stackalloc byte[31];
				Number.NumberBuffer number3 = new Number.NumberBuffer(Number.NumberBufferKind.Decimal, digits3, 31);
				Number.DecimalToNumber(ref value, ref number3);
				if (number3.Digits[0] == 0)
				{
					number3.IsNegative = false;
				}
				return TryFormatDecimalG(ref number3, destination, out bytesWritten);
			}
			case 'F':
			case 'f':
			{
				byte* digits2 = stackalloc byte[31];
				Number.NumberBuffer number2 = new Number.NumberBuffer(Number.NumberBufferKind.Decimal, digits2, 31);
				Number.DecimalToNumber(ref value, ref number2);
				byte b2 = (byte)((format.Precision == byte.MaxValue) ? 2 : format.Precision);
				Number.RoundNumber(ref number2, number2.Scale + b2, isCorrectlyRounded: false);
				return TryFormatDecimalF(ref number2, destination, out bytesWritten, b2);
			}
			case 'E':
			case 'e':
			{
				byte* digits = stackalloc byte[31];
				Number.NumberBuffer number = new Number.NumberBuffer(Number.NumberBufferKind.Decimal, digits, 31);
				Number.DecimalToNumber(ref value, ref number);
				byte b = (byte)((format.Precision == byte.MaxValue) ? 6 : format.Precision);
				Number.RoundNumber(ref number, b + 1, isCorrectlyRounded: false);
				return TryFormatDecimalE(ref number, destination, out bytesWritten, b, (byte)format.Symbol);
			}
			default:
				return FormattingHelpers.TryFormatThrowFormatException(out bytesWritten);
			}
		}

		private static bool TryFormatDecimalE(ref Number.NumberBuffer number, Span<byte> destination, out int bytesWritten, byte precision, byte exponentSymbol)
		{
			int scale = number.Scale;
			ReadOnlySpan<byte> readOnlySpan = number.Digits;
			int num = (number.IsNegative ? 1 : 0) + 1 + ((precision != 0) ? (precision + 1) : 0) + 2 + 3;
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			int num2 = 0;
			int num3 = 0;
			if (number.IsNegative)
			{
				destination[num2++] = 45;
			}
			byte b = readOnlySpan[num3];
			int num4;
			if (b == 0)
			{
				destination[num2++] = 48;
				num4 = 0;
			}
			else
			{
				destination[num2++] = b;
				num3++;
				num4 = scale - 1;
			}
			if (precision > 0)
			{
				destination[num2++] = 46;
				for (int i = 0; i < precision; i++)
				{
					byte b2 = readOnlySpan[num3];
					if (b2 == 0)
					{
						while (i++ < precision)
						{
							destination[num2++] = 48;
						}
						break;
					}
					destination[num2++] = b2;
					num3++;
				}
			}
			destination[num2++] = exponentSymbol;
			if (num4 >= 0)
			{
				destination[num2++] = 43;
			}
			else
			{
				destination[num2++] = 45;
				num4 = -num4;
			}
			destination[num2++] = 48;
			destination[num2++] = (byte)(num4 / 10 + 48);
			destination[num2++] = (byte)(num4 % 10 + 48);
			bytesWritten = num;
			return true;
		}

		private static bool TryFormatDecimalF(ref Number.NumberBuffer number, Span<byte> destination, out int bytesWritten, byte precision)
		{
			int scale = number.Scale;
			ReadOnlySpan<byte> readOnlySpan = number.Digits;
			int num = (number.IsNegative ? 1 : 0) + ((scale <= 0) ? 1 : scale) + ((precision != 0) ? (precision + 1) : 0);
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			int i = 0;
			int num2 = 0;
			if (number.IsNegative)
			{
				destination[num2++] = 45;
			}
			if (scale <= 0)
			{
				destination[num2++] = 48;
			}
			else
			{
				for (; i < scale; i++)
				{
					byte b = readOnlySpan[i];
					if (b == 0)
					{
						int num3 = scale - i;
						for (int j = 0; j < num3; j++)
						{
							destination[num2++] = 48;
						}
						break;
					}
					destination[num2++] = b;
				}
			}
			if (precision > 0)
			{
				destination[num2++] = 46;
				int k = 0;
				if (scale < 0)
				{
					int num4 = Math.Min(precision, -scale);
					for (int l = 0; l < num4; l++)
					{
						destination[num2++] = 48;
					}
					k += num4;
				}
				for (; k < precision; k++)
				{
					byte b2 = readOnlySpan[i];
					if (b2 == 0)
					{
						while (k++ < precision)
						{
							destination[num2++] = 48;
						}
						break;
					}
					destination[num2++] = b2;
					i++;
				}
			}
			bytesWritten = num;
			return true;
		}

		private static bool TryFormatDecimalG(ref Number.NumberBuffer number, Span<byte> destination, out int bytesWritten)
		{
			int scale = number.Scale;
			ReadOnlySpan<byte> readOnlySpan = number.Digits;
			int digitsCount = number.DigitsCount;
			bool flag = scale < digitsCount;
			int num;
			if (flag)
			{
				num = digitsCount + 1;
				if (scale <= 0)
				{
					num += 1 + -scale;
				}
			}
			else
			{
				num = ((scale <= 0) ? 1 : scale);
			}
			if (number.IsNegative)
			{
				num++;
			}
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			int i = 0;
			int num2 = 0;
			if (number.IsNegative)
			{
				destination[num2++] = 45;
			}
			if (scale <= 0)
			{
				destination[num2++] = 48;
			}
			else
			{
				for (; i < scale; i++)
				{
					byte b = readOnlySpan[i];
					if (b == 0)
					{
						int num3 = scale - i;
						for (int j = 0; j < num3; j++)
						{
							destination[num2++] = 48;
						}
						break;
					}
					destination[num2++] = b;
				}
			}
			if (flag)
			{
				destination[num2++] = 46;
				if (scale < 0)
				{
					int num4 = -scale;
					for (int k = 0; k < num4; k++)
					{
						destination[num2++] = 48;
					}
				}
				byte b2;
				while ((b2 = readOnlySpan[i++]) != 0)
				{
					destination[num2++] = b2;
				}
			}
			bytesWritten = num;
			return true;
		}

		public static bool TryFormat(double value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatFloatingPoint(value, destination, out bytesWritten, format);
		}

		public static bool TryFormat(float value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatFloatingPoint(value, destination, out bytesWritten, format);
		}

		private static bool TryFormatFloatingPoint<T>(T value, Span<byte> destination, out int bytesWritten, StandardFormat format) where T : ISpanFormattable
		{
			Span<char> span = default(Span<char>);
			if (!format.IsDefault)
			{
				span = stackalloc char[3];
				span = span[..format.Format(span)];
			}
			Span<char> destination2 = stackalloc char[128];
			ReadOnlySpan<char> readOnlySpan = default(Span<char>);
			if (value.TryFormat(destination2, out var charsWritten, span, CultureInfo.InvariantCulture))
			{
				readOnlySpan = destination2.Slice(0, charsWritten);
			}
			else
			{
				if (destination.Length <= 128)
				{
					bytesWritten = 0;
					return false;
				}
				readOnlySpan = value.ToString(new string(span), CultureInfo.InvariantCulture);
			}
			if (readOnlySpan.Length > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			try
			{
				bytesWritten = Encoding.UTF8.GetBytes(readOnlySpan, destination);
				return true;
			}
			catch
			{
				bytesWritten = 0;
				return false;
			}
		}

		public static bool TryFormat(Guid value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			int num;
			switch (FormattingHelpers.GetSymbolOrDefault(in format, 'D'))
			{
			case 'D':
				num = -2147483612;
				break;
			case 'B':
				num = -2139260122;
				break;
			case 'P':
				num = -2144786394;
				break;
			case 'N':
				num = 32;
				break;
			default:
				return FormattingHelpers.TryFormatThrowFormatException(out bytesWritten);
			}
			if ((byte)num > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = (byte)num;
			num >>= 8;
			if ((byte)num != 0)
			{
				destination[0] = (byte)num;
				destination = destination.Slice(1);
			}
			num >>= 8;
			DecomposedGuid decomposedGuid = default(DecomposedGuid);
			decomposedGuid.Guid = value;
			_ = ref destination[8];
			_ = BitConverter.IsLittleEndian;
			HexConverter.ToBytesBuffer(decomposedGuid.Byte03, destination, 0, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte02, destination, 2, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte01, destination, 4, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte00, destination, 6, HexConverter.Casing.Lower);
			if (num < 0)
			{
				destination[8] = 45;
				destination = destination.Slice(9);
			}
			else
			{
				destination = destination.Slice(8);
			}
			_ = ref destination[4];
			_ = BitConverter.IsLittleEndian;
			HexConverter.ToBytesBuffer(decomposedGuid.Byte05, destination, 0, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte04, destination, 2, HexConverter.Casing.Lower);
			if (num < 0)
			{
				destination[4] = 45;
				destination = destination.Slice(5);
			}
			else
			{
				destination = destination.Slice(4);
			}
			_ = ref destination[4];
			_ = BitConverter.IsLittleEndian;
			HexConverter.ToBytesBuffer(decomposedGuid.Byte07, destination, 0, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte06, destination, 2, HexConverter.Casing.Lower);
			if (num < 0)
			{
				destination[4] = 45;
				destination = destination.Slice(5);
			}
			else
			{
				destination = destination.Slice(4);
			}
			_ = ref destination[4];
			HexConverter.ToBytesBuffer(decomposedGuid.Byte08, destination, 0, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte09, destination, 2, HexConverter.Casing.Lower);
			if (num < 0)
			{
				destination[4] = 45;
				destination = destination.Slice(5);
			}
			else
			{
				destination = destination.Slice(4);
			}
			_ = ref destination[11];
			HexConverter.ToBytesBuffer(decomposedGuid.Byte10, destination, 0, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte11, destination, 2, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte12, destination, 4, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte13, destination, 6, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte14, destination, 8, HexConverter.Casing.Lower);
			HexConverter.ToBytesBuffer(decomposedGuid.Byte15, destination, 10, HexConverter.Casing.Lower);
			if ((byte)num != 0)
			{
				destination[12] = (byte)num;
			}
			return true;
		}

		public static bool TryFormat(byte value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatUInt64(value, destination, out bytesWritten, format);
		}

		[CLSCompliant(false)]
		public static bool TryFormat(sbyte value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatInt64(value, 255uL, destination, out bytesWritten, format);
		}

		[CLSCompliant(false)]
		public static bool TryFormat(ushort value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatUInt64(value, destination, out bytesWritten, format);
		}

		public static bool TryFormat(short value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatInt64(value, 65535uL, destination, out bytesWritten, format);
		}

		[CLSCompliant(false)]
		public static bool TryFormat(uint value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatUInt64(value, destination, out bytesWritten, format);
		}

		public static bool TryFormat(int value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatInt64(value, 4294967295uL, destination, out bytesWritten, format);
		}

		[CLSCompliant(false)]
		public static bool TryFormat(ulong value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatUInt64(value, destination, out bytesWritten, format);
		}

		public static bool TryFormat(long value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatInt64(value, ulong.MaxValue, destination, out bytesWritten, format);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64(long value, ulong mask, Span<byte> destination, out int bytesWritten, StandardFormat format)
		{
			if (format.IsDefault)
			{
				return TryFormatInt64Default(value, destination, out bytesWritten);
			}
			switch (format.Symbol)
			{
			case 'G':
			case 'g':
				if (format.HasPrecision)
				{
					throw new NotSupportedException(SR.Argument_GWithPrecisionNotSupported);
				}
				return TryFormatInt64D(value, format.Precision, destination, out bytesWritten);
			case 'D':
			case 'd':
				return TryFormatInt64D(value, format.Precision, destination, out bytesWritten);
			case 'N':
			case 'n':
				return TryFormatInt64N(value, format.Precision, destination, out bytesWritten);
			case 'x':
				return TryFormatUInt64X((ulong)value & mask, format.Precision, useLower: true, destination, out bytesWritten);
			case 'X':
				return TryFormatUInt64X((ulong)value & mask, format.Precision, useLower: false, destination, out bytesWritten);
			default:
				return FormattingHelpers.TryFormatThrowFormatException(out bytesWritten);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64D(long value, byte precision, Span<byte> destination, out int bytesWritten)
		{
			bool insertNegationSign = false;
			if (value < 0)
			{
				insertNegationSign = true;
				value = -value;
			}
			return TryFormatUInt64D((ulong)value, precision, destination, insertNegationSign, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64Default(long value, Span<byte> destination, out int bytesWritten)
		{
			if ((ulong)value < 10uL)
			{
				return TryFormatUInt32SingleDigit((uint)value, destination, out bytesWritten);
			}
			if (IntPtr.Size == 8)
			{
			}
			if (value <= int.MaxValue && value >= int.MinValue)
			{
				return TryFormatInt32MultipleDigits((int)value, destination, out bytesWritten);
			}
			if (value <= 4294967295000000000L && value >= -4294967295000000000L)
			{
				if (value >= 0)
				{
					return TryFormatUInt64LessThanBillionMaxUInt((ulong)value, destination, out bytesWritten);
				}
				return TryFormatInt64MoreThanNegativeBillionMaxUInt(-value, destination, out bytesWritten);
			}
			if (value >= 0)
			{
				return TryFormatUInt64MoreThanBillionMaxUInt((ulong)value, destination, out bytesWritten);
			}
			return TryFormatInt64LessThanNegativeBillionMaxUInt(-value, destination, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt32MultipleDigits(int value, Span<byte> destination, out int bytesWritten)
		{
			if (value < 0)
			{
				value = -value;
				int num = FormattingHelpers.CountDigits((uint)value);
				if (num >= destination.Length)
				{
					bytesWritten = 0;
					return false;
				}
				destination[0] = 45;
				bytesWritten = num + 1;
				FormattingHelpers.WriteDigits((uint)value, destination.Slice(1, num));
				return true;
			}
			return TryFormatUInt32MultipleDigits((uint)value, destination, out bytesWritten);
		}

		private static bool TryFormatInt64MoreThanNegativeBillionMaxUInt(long value, Span<byte> destination, out int bytesWritten)
		{
			uint num = (uint)(value / 1000000000);
			uint value2 = (uint)(value - num * 1000000000);
			int num2 = FormattingHelpers.CountDigits(num);
			int num3 = num2 + 9;
			if (num3 >= destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			destination[0] = 45;
			bytesWritten = num3 + 1;
			FormattingHelpers.WriteDigits(num, destination.Slice(1, num2));
			FormattingHelpers.WriteDigits(value2, destination.Slice(num2 + 1, 9));
			return true;
		}

		private static bool TryFormatInt64LessThanNegativeBillionMaxUInt(long value, Span<byte> destination, out int bytesWritten)
		{
			ulong num = (ulong)value / 1000000000uL;
			uint value2 = (uint)((ulong)value - num * 1000000000);
			uint num2 = (uint)(num / 1000000000);
			uint value3 = (uint)(num - num2 * 1000000000);
			int num3 = FormattingHelpers.CountDigits(num2);
			int num4 = num3 + 18;
			if (num4 >= destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			destination[0] = 45;
			bytesWritten = num4 + 1;
			FormattingHelpers.WriteDigits(num2, destination.Slice(1, num3));
			FormattingHelpers.WriteDigits(value3, destination.Slice(num3 + 1, 9));
			FormattingHelpers.WriteDigits(value2, destination.Slice(num3 + 1 + 9, 9));
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64N(long value, byte precision, Span<byte> destination, out int bytesWritten)
		{
			bool insertNegationSign = false;
			if (value < 0)
			{
				insertNegationSign = true;
				value = -value;
			}
			return TryFormatUInt64N((ulong)value, precision, destination, insertNegationSign, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt64(ulong value, Span<byte> destination, out int bytesWritten, StandardFormat format)
		{
			if (format.IsDefault)
			{
				return TryFormatUInt64Default(value, destination, out bytesWritten);
			}
			switch (format.Symbol)
			{
			case 'G':
			case 'g':
				if (format.HasPrecision)
				{
					throw new NotSupportedException(SR.Argument_GWithPrecisionNotSupported);
				}
				return TryFormatUInt64D(value, format.Precision, destination, insertNegationSign: false, out bytesWritten);
			case 'D':
			case 'd':
				return TryFormatUInt64D(value, format.Precision, destination, insertNegationSign: false, out bytesWritten);
			case 'N':
			case 'n':
				return TryFormatUInt64N(value, format.Precision, destination, insertNegationSign: false, out bytesWritten);
			case 'x':
				return TryFormatUInt64X(value, format.Precision, useLower: true, destination, out bytesWritten);
			case 'X':
				return TryFormatUInt64X(value, format.Precision, useLower: false, destination, out bytesWritten);
			default:
				return FormattingHelpers.TryFormatThrowFormatException(out bytesWritten);
			}
		}

		private static bool TryFormatUInt64D(ulong value, byte precision, Span<byte> destination, bool insertNegationSign, out int bytesWritten)
		{
			int num = FormattingHelpers.CountDigits(value);
			int num2 = ((precision != byte.MaxValue) ? precision : 0) - num;
			if (num2 < 0)
			{
				num2 = 0;
			}
			int num3 = num + num2;
			if (insertNegationSign)
			{
				num3++;
			}
			if (num3 > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num3;
			if (insertNegationSign)
			{
				destination[0] = 45;
				destination = destination.Slice(1);
			}
			if (num2 > 0)
			{
				FormattingHelpers.FillWithAsciiZeros(destination.Slice(0, num2));
			}
			FormattingHelpers.WriteDigits(value, destination.Slice(num2, num));
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt64Default(ulong value, Span<byte> destination, out int bytesWritten)
		{
			if (value < 10)
			{
				return TryFormatUInt32SingleDigit((uint)value, destination, out bytesWritten);
			}
			if (IntPtr.Size == 8)
			{
			}
			if (value <= uint.MaxValue)
			{
				return TryFormatUInt32MultipleDigits((uint)value, destination, out bytesWritten);
			}
			if (value <= 4294967295000000000L)
			{
				return TryFormatUInt64LessThanBillionMaxUInt(value, destination, out bytesWritten);
			}
			return TryFormatUInt64MoreThanBillionMaxUInt(value, destination, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt32SingleDigit(uint value, Span<byte> destination, out int bytesWritten)
		{
			if (destination.Length == 0)
			{
				bytesWritten = 0;
				return false;
			}
			destination[0] = (byte)(48 + value);
			bytesWritten = 1;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt32MultipleDigits(uint value, Span<byte> destination, out int bytesWritten)
		{
			int num = FormattingHelpers.CountDigits(value);
			if (num > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			FormattingHelpers.WriteDigits(value, destination.Slice(0, num));
			return true;
		}

		private static bool TryFormatUInt64LessThanBillionMaxUInt(ulong value, Span<byte> destination, out int bytesWritten)
		{
			uint num = (uint)(value / 1000000000);
			uint value2 = (uint)(value - num * 1000000000);
			int num2 = FormattingHelpers.CountDigits(num);
			int num3 = num2 + 9;
			if (num3 > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num3;
			FormattingHelpers.WriteDigits(num, destination.Slice(0, num2));
			FormattingHelpers.WriteDigits(value2, destination.Slice(num2, 9));
			return true;
		}

		private static bool TryFormatUInt64MoreThanBillionMaxUInt(ulong value, Span<byte> destination, out int bytesWritten)
		{
			ulong num = value / 1000000000;
			uint value2 = (uint)(value - num * 1000000000);
			uint num2 = (uint)(num / 1000000000);
			uint value3 = (uint)(num - num2 * 1000000000);
			int num3 = FormattingHelpers.CountDigits(num2);
			int num4 = num3 + 18;
			if (num4 > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num4;
			FormattingHelpers.WriteDigits(num2, destination.Slice(0, num3));
			FormattingHelpers.WriteDigits(value3, destination.Slice(num3, 9));
			FormattingHelpers.WriteDigits(value2, destination.Slice(num3 + 9, 9));
			return true;
		}

		private static bool TryFormatUInt64N(ulong value, byte precision, Span<byte> destination, bool insertNegationSign, out int bytesWritten)
		{
			int num = FormattingHelpers.CountDigits(value);
			int num2 = (num - 1) / 3;
			int num3 = ((precision == byte.MaxValue) ? 2 : precision);
			int num4 = num + num2;
			if (num3 > 0)
			{
				num4 += num3 + 1;
			}
			if (insertNegationSign)
			{
				num4++;
			}
			if (num4 > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num4;
			if (insertNegationSign)
			{
				destination[0] = 45;
				destination = destination.Slice(1);
			}
			FormattingHelpers.WriteDigitsWithGroupSeparator(value, destination.Slice(0, num + num2));
			if (num3 > 0)
			{
				destination[num + num2] = 46;
				FormattingHelpers.FillWithAsciiZeros(destination.Slice(num + num2 + 1, num3));
			}
			return true;
		}

		private static bool TryFormatUInt64X(ulong value, byte precision, bool useLower, Span<byte> destination, out int bytesWritten)
		{
			int num = FormattingHelpers.CountHexDigits(value);
			int num2 = ((precision == byte.MaxValue) ? num : Math.Max(precision, num));
			if (destination.Length < num2)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num2;
			if (useLower)
			{
				while ((uint)(--num2) < (uint)destination.Length)
				{
					destination[num2] = (byte)HexConverter.ToCharLower((int)value);
					value >>= 4;
				}
			}
			else
			{
				while ((uint)(--num2) < (uint)destination.Length)
				{
					destination[num2] = (byte)HexConverter.ToCharUpper((int)value);
					value >>= 4;
				}
			}
			return true;
		}

		public static bool TryFormat(TimeSpan value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			char c = FormattingHelpers.GetSymbolOrDefault(in format, 'c');
			switch (c)
			{
			case 'T':
			case 't':
				c = 'c';
				break;
			default:
				return FormattingHelpers.TryFormatThrowFormatException(out bytesWritten);
			case 'G':
			case 'c':
			case 'g':
				break;
			}
			int num = 8;
			long ticks = value.Ticks;
			uint valueWithoutTrailingZeros;
			ulong num2;
			if (ticks < 0)
			{
				ticks = -ticks;
				if (ticks < 0)
				{
					valueWithoutTrailingZeros = 4775808u;
					num2 = 922337203685uL;
					goto IL_008d;
				}
			}
			(ulong Quotient, ulong Remainder) tuple = Math.DivRem((ulong)Math.Abs(value.Ticks), 10000000uL);
			num2 = tuple.Quotient;
			ulong item = tuple.Remainder;
			valueWithoutTrailingZeros = (uint)item;
			goto IL_008d;
			IL_008d:
			int num3 = 0;
			switch (c)
			{
			case 'c':
				if (valueWithoutTrailingZeros != 0)
				{
					num3 = 7;
				}
				break;
			case 'G':
				num3 = 7;
				break;
			default:
				if (valueWithoutTrailingZeros != 0)
				{
					num3 = 7 - FormattingHelpers.CountDecimalTrailingZeros(valueWithoutTrailingZeros, out valueWithoutTrailingZeros);
				}
				break;
			}
			if (num3 != 0)
			{
				num += num3 + 1;
			}
			ulong num4 = 0uL;
			ulong num5 = 0uL;
			if (num2 != 0)
			{
				(num4, num5) = Math.DivRem(num2, 60uL);
			}
			ulong num6 = 0uL;
			ulong num7 = 0uL;
			if (num4 != 0)
			{
				(num6, num7) = Math.DivRem(num4, 60uL);
			}
			uint num8 = 0u;
			uint num9 = 0u;
			if (num6 != 0)
			{
				(num8, num9) = Math.DivRem((uint)num6, 24u);
			}
			int num10 = 2;
			if (num9 < 10 && c == 'g')
			{
				num10--;
				num--;
			}
			int num11 = 0;
			if (num8 == 0)
			{
				if (c == 'G')
				{
					num += 2;
					num11 = 1;
				}
			}
			else
			{
				num11 = FormattingHelpers.CountDigits(num8);
				num += num11 + 1;
			}
			if (value.Ticks < 0)
			{
				num++;
			}
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			int num12 = 0;
			if (value.Ticks < 0)
			{
				destination[num12++] = 45;
			}
			if (num11 > 0)
			{
				FormattingHelpers.WriteDigits(num8, destination.Slice(num12, num11));
				num12 += num11;
				destination[num12++] = (byte)((c == 'c') ? 46 : 58);
			}
			FormattingHelpers.WriteDigits(num9, destination.Slice(num12, num10));
			num12 += num10;
			destination[num12++] = 58;
			FormattingHelpers.WriteDigits((uint)num7, destination.Slice(num12, 2));
			num12 += 2;
			destination[num12++] = 58;
			FormattingHelpers.WriteDigits((uint)num5, destination.Slice(num12, 2));
			num12 += 2;
			if (num3 > 0)
			{
				destination[num12++] = 46;
				FormattingHelpers.WriteDigits(valueWithoutTrailingZeros, destination.Slice(num12, num3));
				num12 += num3;
			}
			return true;
		}
	}
	internal static class ParserHelpers
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsDigit(int i)
		{
			return (uint)(i - 48) <= 9u;
		}

		public static bool TryParseThrowFormatException(out int bytesConsumed)
		{
			bytesConsumed = 0;
			ThrowHelper.ThrowFormatException_BadFormatSpecifier();
			return false;
		}

		public static bool TryParseThrowFormatException<T>(out T value, out int bytesConsumed) where T : struct
		{
			value = default(T);
			return TryParseThrowFormatException(out bytesConsumed);
		}

		[DoesNotReturn]
		[StackTraceHidden]
		public static bool TryParseThrowFormatException<T>(ReadOnlySpan<byte> source, out T value, out int bytesConsumed) where T : struct
		{
			Unsafe.SkipInit<T>(out value);
			Unsafe.SkipInit<int>(out bytesConsumed);
			ThrowHelper.ThrowFormatException_BadFormatSpecifier();
			return false;
		}
	}
	public static class Utf8Parser
	{
		[Flags]
		private enum ParseNumberOptions
		{
			AllowExponent = 1
		}

		private enum ComponentParseResult : byte
		{
			NoMoreData,
			Colon,
			Period,
			ParseFailure
		}

		private struct TimeSpanSplitter
		{
			public uint V1;

			public uint V2;

			public uint V3;

			public uint V4;

			public uint V5;

			public bool IsNegative;

			public uint Separators;

			public bool TrySplitTimeSpan(ReadOnlySpan<byte> source, bool periodUsedToSeparateDay, out int bytesConsumed)
			{
				int i = 0;
				byte b = 0;
				for (; i != source.Length; i++)
				{
					b = source[i];
					if (b != 32 && b != 9)
					{
						break;
					}
				}
				if (i == source.Length)
				{
					bytesConsumed = 0;
					return false;
				}
				if (b == 45)
				{
					IsNegative = true;
					i++;
					if (i == source.Length)
					{
						bytesConsumed = 0;
						return false;
					}
				}
				if (!TryParseUInt32D(source.Slice(i), out V1, out var bytesConsumed2))
				{
					bytesConsumed = 0;
					return false;
				}
				i += bytesConsumed2;
				ComponentParseResult componentParseResult = ParseComponent(source, periodUsedToSeparateDay, ref i, out V2);
				switch (componentParseResult)
				{
				case ComponentParseResult.ParseFailure:
					bytesConsumed = 0;
					return false;
				case ComponentParseResult.NoMoreData:
					bytesConsumed = i;
					return true;
				default:
					Separators |= (uint)componentParseResult << 24;
					componentParseResult = ParseComponent(source, neverParseAsFraction: false, ref i, out V3);
					switch (componentParseResult)
					{
					case ComponentParseResult.ParseFailure:
						bytesConsumed = 0;
						return false;
					case ComponentParseResult.NoMoreData:
						bytesConsumed = i;
						return true;
					default:
						Separators |= (uint)componentParseResult << 16;
						componentParseResult = ParseComponent(source, neverParseAsFraction: false, ref i, out V4);
						switch (componentParseResult)
						{
						case ComponentParseResult.ParseFailure:
							bytesConsumed = 0;
							return false;
						case ComponentParseResult.NoMoreData:
							bytesConsumed = i;
							return true;
						default:
							Separators |= (uint)componentParseResult << 8;
							componentParseResult = ParseComponent(source, neverParseAsFraction: false, ref i, out V5);
							switch (componentParseResult)
							{
							case ComponentParseResult.ParseFailure:
								bytesConsumed = 0;
								return false;
							case ComponentParseResult.NoMoreData:
								bytesConsumed = i;
								return true;
							default:
								Separators |= (uint)componentParseResult;
								if (i != source.Length && (source[i] == 46 || source[i] == 58))
								{
									bytesConsumed = 0;
									return false;
								}
								bytesConsumed = i;
								return true;
							}
						}
					}
				}
			}

			private static ComponentParseResult ParseComponent(ReadOnlySpan<byte> source, bool neverParseAsFraction, ref int srcIndex, out uint value)
			{
				if (srcIndex == source.Length)
				{
					value = 0u;
					return ComponentParseResult.NoMoreData;
				}
				byte b = source[srcIndex];
				if (b == 58 || (b == 46 && neverParseAsFraction))
				{
					srcIndex++;
					if (!TryParseUInt32D(source.Slice(srcIndex), out value, out var bytesConsumed))
					{
						value = 0u;
						return ComponentParseResult.ParseFailure;
					}
					srcIndex += bytesConsumed;
					if (b != 58)
					{
						return ComponentParseResult.Period;
					}
					return ComponentParseResult.Colon;
				}
				if (b == 46)
				{
					srcIndex++;
					if (!TryParseTimeSpanFraction(source.Slice(srcIndex), out value, out var bytesConsumed2))
					{
						value = 0u;
						return ComponentParseResult.ParseFailure;
					}
					srcIndex += bytesConsumed2;
					return ComponentParseResult.Period;
				}
				value = 0u;
				return ComponentParseResult.NoMoreData;
			}
		}

		private static readonly int[] s_daysToMonth365 = new int[13]
		{
			0, 31, 59, 90, 120, 151, 181, 212, 243, 273,
			304, 334, 365
		};

		private static readonly int[] s_daysToMonth366 = new int[13]
		{
			0, 31, 60, 91, 121, 152, 182, 213, 244, 274,
			305, 335, 366
		};

		public static bool TryParse(ReadOnlySpan<byte> source, out bool value, out int bytesConsumed, char standardFormat = '\0')
		{
			if (standardFormat != 0 && standardFormat != 'G' && standardFormat != 'l')
			{
				ThrowHelper.ThrowFormatException_BadFormatSpecifier();
			}
			if (source.Length >= 4)
			{
				int num = BinaryPrimitives.ReadInt32LittleEndian(source) & -538976289;
				if (num == 1163219540)
				{
					bytesConsumed = 4;
					value = true;
					return true;
				}
				if (source.Length > 4 && num == 1397506374 && (source[4] & -33) == 69)
				{
					bytesConsumed = 5;
					value = false;
					return true;
				}
			}
			bytesConsumed = 0;
			value = false;
			return false;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out DateTime value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case 'R':
			{
				if (!TryParseDateTimeOffsetR(source, 0u, out var dateTimeOffset, out bytesConsumed))
				{
					value = default(DateTime);
					return false;
				}
				value = dateTimeOffset.DateTime;
				return true;
			}
			case 'l':
			{
				if (!TryParseDateTimeOffsetR(source, 32u, out var dateTimeOffset2, out bytesConsumed))
				{
					value = default(DateTime);
					return false;
				}
				value = dateTimeOffset2.DateTime;
				return true;
			}
			case 'O':
			{
				if (!TryParseDateTimeOffsetO(source, out var value2, out bytesConsumed, out var kind))
				{
					value = default(DateTime);
					bytesConsumed = 0;
					return false;
				}
				switch (kind)
				{
				case DateTimeKind.Local:
					value = value2.LocalDateTime;
					break;
				case DateTimeKind.Utc:
					value = value2.UtcDateTime;
					break;
				default:
					value = value2.DateTime;
					break;
				}
				return true;
			}
			case '\0':
			case 'G':
			{
				DateTimeOffset valueAsOffset;
				return TryParseDateTimeG(source, out value, out valueAsOffset, out bytesConsumed);
			}
			default:
				return ParserHelpers.TryParseThrowFormatException<DateTime>(out value, out bytesConsumed);
			}
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out DateTimeOffset value, out int bytesConsumed, char standardFormat = '\0')
		{
			DateTimeKind kind;
			DateTime value2;
			return standardFormat switch
			{
				'R' => TryParseDateTimeOffsetR(source, 0u, out value, out bytesConsumed), 
				'l' => TryParseDateTimeOffsetR(source, 32u, out value, out bytesConsumed), 
				'O' => TryParseDateTimeOffsetO(source, out value, out bytesConsumed, out kind), 
				'\0' => TryParseDateTimeOffsetDefault(source, out value, out bytesConsumed), 
				'G' => TryParseDateTimeG(source, out value2, out value, out bytesConsumed), 
				_ => ParserHelpers.TryParseThrowFormatException<DateTimeOffset>(out value, out bytesConsumed), 
			};
		}

		private static bool TryParseDateTimeOffsetDefault(ReadOnlySpan<byte> source, out DateTimeOffset value, out int bytesConsumed)
		{
			if (source.Length < 26)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			if (!TryParseDateTimeG(source, out var value2, out var _, out var _))
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			if (source[19] != 32)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			byte b = source[20];
			if (b != 43 && b != 45)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			uint num = (uint)(source[21] - 48);
			uint num2 = (uint)(source[22] - 48);
			if (num > 9 || num2 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			int offsetHours = (int)(num * 10 + num2);
			if (source[23] != 58)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			uint num3 = (uint)(source[24] - 48);
			uint num4 = (uint)(source[25] - 48);
			if (num3 > 9 || num4 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			int offsetMinutes = (int)(num3 * 10 + num4);
			if (!TryCreateDateTimeOffset(value2, b == 45, offsetHours, offsetMinutes, out value))
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			bytesConsumed = 26;
			return true;
		}

		private static bool TryParseDateTimeG(ReadOnlySpan<byte> source, out DateTime value, out DateTimeOffset valueAsOffset, out int bytesConsumed)
		{
			if (source.Length < 19)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num = (uint)(source[0] - 48);
			uint num2 = (uint)(source[1] - 48);
			if (num > 9 || num2 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int month = (int)(num * 10 + num2);
			if (source[2] != 47)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num3 = (uint)(source[3] - 48);
			uint num4 = (uint)(source[4] - 48);
			if (num3 > 9 || num4 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int day = (int)(num3 * 10 + num4);
			if (source[5] != 47)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num5 = (uint)(source[6] - 48);
			uint num6 = (uint)(source[7] - 48);
			uint num7 = (uint)(source[8] - 48);
			uint num8 = (uint)(source[9] - 48);
			if (num5 > 9 || num6 > 9 || num7 > 9 || num8 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int year = (int)(num5 * 1000 + num6 * 100 + num7 * 10 + num8);
			if (source[10] != 32)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num9 = (uint)(source[11] - 48);
			uint num10 = (uint)(source[12] - 48);
			if (num9 > 9 || num10 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int hour = (int)(num9 * 10 + num10);
			if (source[13] != 58)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num11 = (uint)(source[14] - 48);
			uint num12 = (uint)(source[15] - 48);
			if (num11 > 9 || num12 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int minute = (int)(num11 * 10 + num12);
			if (source[16] != 58)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num13 = (uint)(source[17] - 48);
			uint num14 = (uint)(source[18] - 48);
			if (num13 > 9 || num14 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int second = (int)(num13 * 10 + num14);
			if (!TryCreateDateTimeOffsetInterpretingDataAsLocalTime(year, month, day, hour, minute, second, 0, out valueAsOffset))
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			bytesConsumed = 19;
			value = valueAsOffset.DateTime;
			return true;
		}

		private static bool TryCreateDateTimeOffset(DateTime dateTime, bool offsetNegative, int offsetHours, int offsetMinutes, out DateTimeOffset value)
		{
			if ((uint)offsetHours > 14u)
			{
				value = default(DateTimeOffset);
				return false;
			}
			if ((uint)offsetMinutes > 59u)
			{
				value = default(DateTimeOffset);
				return false;
			}
			if (offsetHours == 14 && offsetMinutes != 0)
			{
				value = default(DateTimeOffset);
				return false;
			}
			long num = ((long)offsetHours * 3600L + (long)offsetMinutes * 60L) * 10000000;
			if (offsetNegative)
			{
				num = -num;
			}
			try
			{
				value = new DateTimeOffset(dateTime.Ticks, new TimeSpan(num));
			}
			catch (ArgumentOutOfRangeException)
			{
				value = default(DateTimeOffset);
				return false;
			}
			return true;
		}

		private static bool TryCreateDateTimeOffset(int year, int month, int day, int hour, int minute, int second, int fraction, bool offsetNegative, int offsetHours, int offsetMinutes, out DateTimeOffset value)
		{
			if (!TryCreateDateTime(year, month, day, hour, minute, second, fraction, DateTimeKind.Unspecified, out var value2))
			{
				value = default(DateTimeOffset);
				return false;
			}
			if (!TryCreateDateTimeOffset(value2, offsetNegative, offsetHours, offsetMinutes, out value))
			{
				value = default(DateTimeOffset);
				return false;
			}
			return true;
		}

		private static bool TryCreateDateTimeOffsetInterpretingDataAsLocalTime(int year, int month, int day, int hour, int minute, int second, int fraction, out DateTimeOffset value)
		{
			if (!TryCreateDateTime(year, month, day, hour, minute, second, fraction, DateTimeKind.Local, out var value2))
			{
				value = default(DateTimeOffset);
				return false;
			}
			try
			{
				value = new DateTimeOffset(value2);
			}
			catch (ArgumentOutOfRangeException)
			{
				value = default(DateTimeOffset);
				return false;
			}
			return true;
		}

		private static bool TryCreateDateTime(int year, int month, int day, int hour, int minute, int second, int fraction, DateTimeKind kind, out DateTime value)
		{
			if (year == 0)
			{
				value = default(DateTime);
				return false;
			}
			if ((uint)(month - 1) >= 12u)
			{
				value = default(DateTime);
				return false;
			}
			uint num = (uint)(day - 1);
			if (num >= 28 && num >= DateTime.DaysInMonth(year, month))
			{
				value = default(DateTime);
				return false;
			}
			if ((uint)hour > 23u)
			{
				value = default(DateTime);
				return false;
			}
			if ((uint)minute > 59u)
			{
				value = default(DateTime);
				return false;
			}
			if ((uint)second > 59u)
			{
				value = default(DateTime);
				return false;
			}
			int[] array = (DateTime.IsLeapYear(year) ? s_daysToMonth366 : s_daysToMonth365);
			int num2 = year - 1;
			int num3 = num2 * 365 + num2 / 4 - num2 / 100 + num2 / 400 + array[month - 1] + day - 1;
			long num4 = num3 * 864000000000L;
			int num5 = hour * 3600 + minute * 60 + second;
			num4 += (long)num5 * 10000000L;
			num4 += fraction;
			value = new DateTime(num4, kind);
			return true;
		}

		private static bool TryParseDateTimeOffsetO(ReadOnlySpan<byte> source, out DateTimeOffset value, out int bytesConsumed, out DateTimeKind kind)
		{
			if (source.Length < 27)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num = (uint)(source[0] - 48);
			uint num2 = (uint)(source[1] - 48);
			uint num3 = (uint)(source[2] - 48);
			uint num4 = (uint)(source[3] - 48);
			if (num > 9 || num2 > 9 || num3 > 9 || num4 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int year = (int)(num * 1000 + num2 * 100 + num3 * 10 + num4);
			if (source[4] != 45)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num5 = (uint)(source[5] - 48);
			uint num6 = (uint)(source[6] - 48);
			if (num5 > 9 || num6 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int month = (int)(num5 * 10 + num6);
			if (source[7] != 45)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num7 = (uint)(source[8] - 48);
			uint num8 = (uint)(source[9] - 48);
			if (num7 > 9 || num8 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int day = (int)(num7 * 10 + num8);
			if (source[10] != 84)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num9 = (uint)(source[11] - 48);
			uint num10 = (uint)(source[12] - 48);
			if (num9 > 9 || num10 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int hour = (int)(num9 * 10 + num10);
			if (source[13] != 58)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num11 = (uint)(source[14] - 48);
			uint num12 = (uint)(source[15] - 48);
			if (num11 > 9 || num12 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int minute = (int)(num11 * 10 + num12);
			if (source[16] != 58)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num13 = (uint)(source[17] - 48);
			uint num14 = (uint)(source[18] - 48);
			if (num13 > 9 || num14 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int second = (int)(num13 * 10 + num14);
			if (source[19] != 46)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num15 = (uint)(source[20] - 48);
			uint num16 = (uint)(source[21] - 48);
			uint num17 = (uint)(source[22] - 48);
			uint num18 = (uint)(source[23] - 48);
			uint num19 = (uint)(source[24] - 48);
			uint num20 = (uint)(source[25] - 48);
			uint num21 = (uint)(source[26] - 48);
			if (num15 > 9 || num16 > 9 || num17 > 9 || num18 > 9 || num19 > 9 || num20 > 9 || num21 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int fraction = (int)(num15 * 1000000 + num16 * 100000 + num17 * 10000 + num18 * 1000 + num19 * 100 + num20 * 10 + num21);
			byte b = (byte)((source.Length > 27) ? source[27] : 0);
			if (b != 90 && b != 43 && b != 45)
			{
				if (!TryCreateDateTimeOffsetInterpretingDataAsLocalTime(year, month, day, hour, minute, second, fraction, out value))
				{
					value = default(DateTimeOffset);
					bytesConsumed = 0;
					kind = DateTimeKind.Unspecified;
					return false;
				}
				bytesConsumed = 27;
				kind = DateTimeKind.Unspecified;
				return true;
			}
			if (b == 90)
			{
				if (!TryCreateDateTimeOffset(year, month, day, hour, minute, second, fraction, offsetNegative: false, 0, 0, out value))
				{
					value = default(DateTimeOffset);
					bytesConsumed = 0;
					kind = DateTimeKind.Unspecified;
					return false;
				}
				bytesConsumed = 28;
				kind = DateTimeKind.Utc;
				return true;
			}
			if (source.Length < 33)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num22 = (uint)(source[28] - 48);
			uint num23 = (uint)(source[29] - 48);
			if (num22 > 9 || num23 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int offsetHours = (int)(num22 * 10 + num23);
			if (source[30] != 58)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num24 = (uint)(source[31] - 48);
			uint num25 = (uint)(source[32] - 48);
			if (num24 > 9 || num25 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int offsetMinutes = (int)(num24 * 10 + num25);
			if (!TryCreateDateTimeOffset(year, month, day, hour, minute, second, fraction, b == 45, offsetHours, offsetMinutes, out value))
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			bytesConsumed = 33;
			kind = DateTimeKind.Local;
			return true;
		}

		private static bool TryParseDateTimeOffsetR(ReadOnlySpan<byte> source, uint caseFlipXorMask, out DateTimeOffset dateTimeOffset, out int bytesConsumed)
		{
			if (source.Length < 29)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num = source[0] ^ caseFlipXorMask;
			uint num2 = source[1];
			uint num3 = source[2];
			uint num4 = source[3];
			DayOfWeek dayOfWeek;
			switch ((num << 24) | (num2 << 16) | (num3 << 8) | num4)
			{
			case 1400204844u:
				dayOfWeek = DayOfWeek.Sunday;
				break;
			case 1299148332u:
				dayOfWeek = DayOfWeek.Monday;
				break;
			case 1416979756u:
				dayOfWeek = DayOfWeek.Tuesday;
				break;
			case 1466262572u:
				dayOfWeek = DayOfWeek.Wednesday;
				break;
			case 1416131884u:
				dayOfWeek = DayOfWeek.Thursday;
				break;
			case 1181903148u:
				dayOfWeek = DayOfWeek.Friday;
				break;
			case 1398895660u:
				dayOfWeek = DayOfWeek.Saturday;
				break;
			default:
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			if (source[4] != 32)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num5 = (uint)(source[5] - 48);
			uint num6 = (uint)(source[6] - 48);
			if (num5 > 9 || num6 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int day = (int)(num5 * 10 + num6);
			if (source[7] != 32)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num7 = source[8] ^ caseFlipXorMask;
			uint num8 = source[9];
			uint num9 = source[10];
			uint num10 = source[11];
			int month;
			switch ((num7 << 24) | (num8 << 16) | (num9 << 8) | num10)
			{
			case 1247899168u:
				month = 1;
				break;
			case 1181049376u:
				month = 2;
				break;
			case 1298231840u:
				month = 3;
				break;
			case 1097888288u:
				month = 4;
				break;
			case 1298233632u:
				month = 5;
				break;
			case 1249209888u:
				month = 6;
				break;
			case 1249209376u:
				month = 7;
				break;
			case 1098213152u:
				month = 8;
				break;
			case 1399156768u:
				month = 9;
				break;
			case 1331917856u:
				month = 10;
				break;
			case 1315927584u:
				month = 11;
				break;
			case 1147495200u:
				month = 12;
				break;
			default:
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num11 = (uint)(source[12] - 48);
			uint num12 = (uint)(source[13] - 48);
			uint num13 = (uint)(source[14] - 48);
			uint num14 = (uint)(source[15] - 48);
			if (num11 > 9 || num12 > 9 || num13 > 9 || num14 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int year = (int)(num11 * 1000 + num12 * 100 + num13 * 10 + num14);
			if (source[16] != 32)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num15 = (uint)(source[17] - 48);
			uint num16 = (uint)(source[18] - 48);
			if (num15 > 9 || num16 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int hour = (int)(num15 * 10 + num16);
			if (source[19] != 58)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num17 = (uint)(source[20] - 48);
			uint num18 = (uint)(source[21] - 48);
			if (num17 > 9 || num18 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int minute = (int)(num17 * 10 + num18);
			if (source[22] != 58)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num19 = (uint)(source[23] - 48);
			uint num20 = (uint)(source[24] - 48);
			if (num19 > 9 || num20 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int second = (int)(num19 * 10 + num20);
			uint num21 = source[25];
			uint num22 = source[26] ^ caseFlipXorMask;
			uint num23 = source[27] ^ caseFlipXorMask;
			uint num24 = source[28] ^ caseFlipXorMask;
			uint num25 = (num21 << 24) | (num22 << 16) | (num23 << 8) | num24;
			if (num25 != 541543764)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			if (!TryCreateDateTimeOffset(year, month, day, hour, minute, second, 0, offsetNegative: false, 0, 0, out dateTimeOffset))
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			if (dayOfWeek != dateTimeOffset.DayOfWeek)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			bytesConsumed = 29;
			return true;
		}

		public unsafe static bool TryParse(ReadOnlySpan<byte> source, out decimal value, out int bytesConsumed, char standardFormat = '\0')
		{
			ParseNumberOptions options;
			switch (standardFormat)
			{
			case '\0':
			case 'E':
			case 'G':
			case 'e':
			case 'g':
				options = ParseNumberOptions.AllowExponent;
				break;
			case 'F':
			case 'f':
				options = (ParseNumberOptions)0;
				break;
			default:
				return ParserHelpers.TryParseThrowFormatException<decimal>(out value, out bytesConsumed);
			}
			byte* digits = stackalloc byte[31];
			Number.NumberBuffer number = new Number.NumberBuffer(Number.NumberBufferKind.Decimal, digits, 31);
			if (!TryParseNumber(source, ref number, out bytesConsumed, options, out var textUsedExponentNotation))
			{
				value = default(decimal);
				return false;
			}
			if (!textUsedExponentNotation && (standardFormat == 'E' || standardFormat == 'e'))
			{
				value = default(decimal);
				bytesConsumed = 0;
				return false;
			}
			value = default(decimal);
			if (!Number.TryNumberToDecimal(ref number, ref value))
			{
				value = default(decimal);
				bytesConsumed = 0;
				return false;
			}
			return true;
		}

		public unsafe static bool TryParse(ReadOnlySpan<byte> source, out float value, out int bytesConsumed, char standardFormat = '\0')
		{
			byte* digits = stackalloc byte[114];
			Number.NumberBuffer number = new Number.NumberBuffer(Number.NumberBufferKind.FloatingPoint, digits, 114);
			if (TryParseNormalAsFloatingPoint(source, ref number, out bytesConsumed, standardFormat))
			{
				value = Number.NumberToSingle(ref number);
				return true;
			}
			return TryParseAsSpecialFloatingPoint(source, float.PositiveInfinity, float.NegativeInfinity, float.NaN, out value, out bytesConsumed);
		}

		public unsafe static bool TryParse(ReadOnlySpan<byte> source, out double value, out int bytesConsumed, char standardFormat = '\0')
		{
			byte* digits = stackalloc byte[769];
			Number.NumberBuffer number = new Number.NumberBuffer(Number.NumberBufferKind.FloatingPoint, digits, 769);
			if (TryParseNormalAsFloatingPoint(source, ref number, out bytesConsumed, standardFormat))
			{
				value = Number.NumberToDouble(ref number);
				return true;
			}
			return TryParseAsSpecialFloatingPoint(source, double.PositiveInfinity, double.NegativeInfinity, double.NaN, out value, out bytesConsumed);
		}

		private static bool TryParseNormalAsFloatingPoint(ReadOnlySpan<byte> source, ref Number.NumberBuffer number, out int bytesConsumed, char standardFormat)
		{
			ParseNumberOptions options;
			switch (standardFormat)
			{
			case '\0':
			case 'E':
			case 'G':
			case 'e':
			case 'g':
				options = ParseNumberOptions.AllowExponent;
				break;
			case 'F':
			case 'f':
				options = (ParseNumberOptions)0;
				break;
			default:
				return ParserHelpers.TryParseThrowFormatException(out bytesConsumed);
			}
			if (!TryParseNumber(source, ref number, out bytesConsumed, options, out var textUsedExponentNotation))
			{
				return false;
			}
			if (!textUsedExponentNotation && (standardFormat == 'E' || standardFormat == 'e'))
			{
				bytesConsumed = 0;
				return false;
			}
			return true;
		}

		private static bool TryParseAsSpecialFloatingPoint<T>(ReadOnlySpan<byte> source, T positiveInfinity, T negativeInfinity, T nan, out T value, out int bytesConsumed) where T : struct
		{
			int num = 0;
			int num2 = source.Length;
			bool flag = false;
			if (num2 >= 4)
			{
				byte b = source[num];
				if (b != 43)
				{
					if (b != 45)
					{
						goto IL_002e;
					}
					flag = true;
				}
				num++;
				num2--;
			}
			goto IL_002e;
			IL_002e:
			if (num2 >= 3)
			{
				if (((source[num] ^ 0x6E) & -33) == 0 && ((source[num + 1] ^ 0x61) & -33) == 0 && ((source[num + 2] ^ 0x6E) & -33) == 0)
				{
					value = nan;
					bytesConsumed = 3 + num;
					return true;
				}
				if (num2 >= 8)
				{
					int num3 = BinaryPrimitives.ReadInt32LittleEndian(source.Slice(num)) ^ 0x69666E69;
					if ((num3 & -538976289) == 0)
					{
						num3 = BinaryPrimitives.ReadInt32LittleEndian(source.Slice(num + 4)) ^ 0x7974696E;
						if ((num3 & -538976289) == 0)
						{
							value = (flag ? negativeInfinity : positiveInfinity);
							bytesConsumed = 8 + num;
							return true;
						}
					}
				}
			}
			value = default(T);
			bytesConsumed = 0;
			return false;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out Guid value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (true)
			{
				switch (standardFormat)
				{
				case '\0':
					return TryParseGuidCore(source, out value, out bytesConsumed, 0);
				case 'D':
					break;
				case 'B':
					return TryParseGuidCore(source, out value, out bytesConsumed, 32123);
				case 'P':
					return TryParseGuidCore(source, out value, out bytesConsumed, 10536);
				case 'N':
					return TryParseGuidN(source, out value, out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<Guid>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
		}

		private static bool TryParseGuidN(ReadOnlySpan<byte> text, out Guid value, out int bytesConsumed)
		{
			if (text.Length < 32)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32X(text.Slice(0, 8), out var value2, out var bytesConsumed2) || bytesConsumed2 != 8)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt16X(text.Slice(8, 4), out var value3, out bytesConsumed2) || bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt16X(text.Slice(12, 4), out var value4, out bytesConsumed2) || bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt16X(text.Slice(16, 4), out var value5, out bytesConsumed2) || bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt64X(text.Slice(20), out var value6, out bytesConsumed2) || bytesConsumed2 != 12)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			bytesConsumed = 32;
			value = new Guid((int)value2, (short)value3, (short)value4, (byte)(value5 >> 8), (byte)value5, (byte)(value6 >> 40), (byte)(value6 >> 32), (byte)(value6 >> 24), (byte)(value6 >> 16), (byte)(value6 >> 8), (byte)value6);
			return true;
		}

		private static bool TryParseGuidCore(ReadOnlySpan<byte> source, out Guid value, out int bytesConsumed, int ends)
		{
			int num = 36 + ((ends != 0) ? 2 : 0);
			if (source.Length < num)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (ends != 0)
			{
				if (source[0] != (byte)ends)
				{
					value = default(Guid);
					bytesConsumed = 0;
					return false;
				}
				source = source.Slice(1);
				ends >>= 8;
			}
			if (!TryParseUInt32X(source, out var value2, out var bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 8)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (source[bytesConsumed2] != 45)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			source = source.Slice(9);
			if (!TryParseUInt16X(source, out var value3, out bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (source[bytesConsumed2] != 45)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			source = source.Slice(5);
			if (!TryParseUInt16X(source, out var value4, out bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (source[bytesConsumed2] != 45)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			source = source.Slice(5);
			if (!TryParseUInt16X(source, out var value5, out bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (source[bytesConsumed2] != 45)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			source = source.Slice(5);
			if (!TryParseUInt64X(source, out var value6, out bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 12)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (ends != 0 && source[bytesConsumed2] != (byte)ends)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			bytesConsumed = num;
			value = new Guid((int)value2, (short)value3, (short)value4, (byte)(value5 >> 8), (byte)value5, (byte)(value6 >> 40), (byte)(value6 >> 32), (byte)(value6 >> 24), (byte)(value6 >> 16), (byte)(value6 >> 8), (byte)value6);
			return true;
		}

		[CLSCompliant(false)]
		public static bool TryParse(ReadOnlySpan<byte> source, out sbyte value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (standardFormat != 0)
			{
				switch (standardFormat | 0x20)
				{
				case 100:
				case 103:
					break;
				case 110:
					return TryParseSByteN(source, out value, out bytesConsumed);
				case 120:
					Unsafe.SkipInit<sbyte>(out value);
					return TryParseByteX(source, out Unsafe.As<sbyte, byte>(ref value), out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<sbyte>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
			return TryParseSByteD(source, out value, out bytesConsumed);
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out short value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (standardFormat != 0)
			{
				switch (standardFormat | 0x20)
				{
				case 100:
				case 103:
					break;
				case 110:
					return TryParseInt16N(source, out value, out bytesConsumed);
				case 120:
					Unsafe.SkipInit<short>(out value);
					return TryParseUInt16X(source, out Unsafe.As<short, ushort>(ref value), out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<short>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
			return TryParseInt16D(source, out value, out bytesConsumed);
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out int value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (standardFormat != 0)
			{
				switch (standardFormat | 0x20)
				{
				case 100:
				case 103:
					break;
				case 110:
					return TryParseInt32N(source, out value, out bytesConsumed);
				case 120:
					Unsafe.SkipInit<int>(out value);
					return TryParseUInt32X(source, out Unsafe.As<int, uint>(ref value), out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<int>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
			return TryParseInt32D(source, out value, out bytesConsumed);
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out long value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (standardFormat != 0)
			{
				switch (standardFormat | 0x20)
				{
				case 100:
				case 103:
					break;
				case 110:
					return TryParseInt64N(source, out value, out bytesConsumed);
				case 120:
					Unsafe.SkipInit<long>(out value);
					return TryParseUInt64X(source, out Unsafe.As<long, ulong>(ref value), out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<long>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
			return TryParseInt64D(source, out value, out bytesConsumed);
		}

		private static bool TryParseSByteD(ReadOnlySpan<byte> source, out sbyte value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0123;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0123;
					}
					num3 = source[num2];
				}
				num4 = 0;
				if (ParserHelpers.IsDigit(num3))
				{
					if (num3 != 48)
					{
						goto IL_009c;
					}
					while (true)
					{
						num2++;
						if ((uint)num2 >= (uint)source.Length)
						{
							break;
						}
						num3 = source[num2];
						if (num3 == 48)
						{
							continue;
						}
						goto IL_0091;
					}
					goto IL_012b;
				}
			}
			goto IL_0123;
			IL_0123:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0091:
			if (ParserHelpers.IsDigit(num3))
			{
				goto IL_009c;
			}
			goto IL_012b;
			IL_012b:
			bytesConsumed = num2;
			value = (sbyte)(num4 * num);
			return true;
			IL_009c:
			num4 = num3 - 48;
			num2++;
			if ((uint)num2 < (uint)source.Length)
			{
				num3 = source[num2];
				if (ParserHelpers.IsDigit(num3))
				{
					num2++;
					num4 = 10 * num4 + num3 - 48;
					if ((uint)num2 < (uint)source.Length)
					{
						num3 = source[num2];
						if (ParserHelpers.IsDigit(num3))
						{
							num2++;
							num4 = num4 * 10 + num3 - 48;
							if ((uint)num4 > 127L + (long)((-1 * num + 1) / 2) || ((uint)num2 < (uint)source.Length && ParserHelpers.IsDigit(source[num2])))
							{
								goto IL_0123;
							}
						}
					}
				}
			}
			goto IL_012b;
		}

		private static bool TryParseInt16D(ReadOnlySpan<byte> source, out short value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0186;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0186;
					}
					num3 = source[num2];
				}
				num4 = 0;
				if (ParserHelpers.IsDigit(num3))
				{
					if (num3 != 48)
					{
						goto IL_009c;
					}
					while (true)
					{
						num2++;
						if ((uint)num2 >= (uint)source.Length)
						{
							break;
						}
						num3 = source[num2];
						if (num3 == 48)
						{
							continue;
						}
						goto IL_0091;
					}
					goto IL_018e;
				}
			}
			goto IL_0186;
			IL_0186:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0091:
			if (ParserHelpers.IsDigit(num3))
			{
				goto IL_009c;
			}
			goto IL_018e;
			IL_018e:
			bytesConsumed = num2;
			value = (short)(num4 * num);
			return true;
			IL_009c:
			num4 = num3 - 48;
			num2++;
			if ((uint)num2 < (uint)source.Length)
			{
				num3 = source[num2];
				if (ParserHelpers.IsDigit(num3))
				{
					num2++;
					num4 = 10 * num4 + num3 - 48;
					if ((uint)num2 < (uint)source.Length)
					{
						num3 = source[num2];
						if (ParserHelpers.IsDigit(num3))
						{
							num2++;
							num4 = 10 * num4 + num3 - 48;
							if ((uint)num2 < (uint)source.Length)
							{
								num3 = source[num2];
								if (ParserHelpers.IsDigit(num3))
								{
									num2++;
									num4 = 10 * num4 + num3 - 48;
									if ((uint)num2 < (uint)source.Length)
									{
										num3 = source[num2];
										if (ParserHelpers.IsDigit(num3))
										{
											num2++;
											num4 = num4 * 10 + num3 - 48;
											if ((uint)num4 > 32767L + (long)((-1 * num + 1) / 2) || ((uint)num2 < (uint)source.Length && ParserHelpers.IsDigit(source[num2])))
											{
												goto IL_0186;
											}
										}
									}
								}
							}
						}
					}
				}
			}
			goto IL_018e;
		}

		private static bool TryParseInt32D(ReadOnlySpan<byte> source, out int value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0281;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0281;
					}
					num3 = source[num2];
				}
				num4 = 0;
				if (ParserHelpers.IsDigit(num3))
				{
					if (num3 != 48)
					{
						goto IL_009c;
					}
					while (true)
					{
						num2++;
						if ((uint)num2 >= (uint)source.Length)
						{
							break;
						}
						num3 = source[num2];
						if (num3 == 48)
						{
							continue;
						}
						goto IL_0091;
					}
					goto IL_0289;
				}
			}
			goto IL_0281;
			IL_0281:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0091:
			if (ParserHelpers.IsDigit(num3))
			{
				goto IL_009c;
			}
			goto IL_0289;
			IL_0289:
			bytesConsumed = num2;
			value = num4 * num;
			return true;
			IL_009c:
			num4 = num3 - 48;
			num2++;
			if ((uint)num2 < (uint)source.Length)
			{
				num3 = source[num2];
				if (ParserHelpers.IsDigit(num3))
				{
					num2++;
					num4 = 10 * num4 + num3 - 48;
					if ((uint)num2 < (uint)source.Length)
					{
						num3 = source[num2];
						if (ParserHelpers.IsDigit(num3))
						{
							num2++;
							num4 = 10 * num4 + num3 - 48;
							if ((uint)num2 < (uint)source.Length)
							{
								num3 = source[num2];
								if (ParserHelpers.IsDigit(num3))
								{
									num2++;
									num4 = 10 * num4 + num3 - 48;
									if ((uint)num2 < (uint)source.Length)
									{
										num3 = source[num2];
										if (ParserHelpers.IsDigit(num3))
										{
											num2++;
											num4 = 10 * num4 + num3 - 48;
											if ((uint)num2 < (uint)source.Length)
											{
												num3 = source[num2];
												if (ParserHelpers.IsDigit(num3))
												{
													num2++;
													num4 = 10 * num4 + num3 - 48;
													if ((uint)num2 < (uint)source.Length)
													{
														num3 = source[num2];
														if (ParserHelpers.IsDigit(num3))
														{
															num2++;
															num4 = 10 * num4 + num3 - 48;
															if ((uint)num2 < (uint)source.Length)
															{
																num3 = source[num2];
																if (ParserHelpers.IsDigit(num3))
																{
																	num2++;
																	num4 = 10 * num4 + num3 - 48;
																	if ((uint)num2 < (uint)source.Length)
																	{
																		num3 = source[num2];
																		if (ParserHelpers.IsDigit(num3))
																		{
																			num2++;
																			num4 = 10 * num4 + num3 - 48;
																			if ((uint)num2 < (uint)source.Length)
																			{
																				num3 = source[num2];
																				if (ParserHelpers.IsDigit(num3))
																				{
																					num2++;
																					if (num4 <= 214748364)
																					{
																						num4 = num4 * 10 + num3 - 48;
																						if ((uint)num4 <= 2147483647L + (long)((-1 * num + 1) / 2) && ((uint)num2 >= (uint)source.Length || !ParserHelpers.IsDigit(source[num2])))
																						{
																							goto IL_0289;
																						}
																					}
																					goto IL_0281;
																				}
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
			goto IL_0289;
		}

		private static bool TryParseInt64D(ReadOnlySpan<byte> source, out long value, out int bytesConsumed)
		{
			long num = 0L;
			int num2 = 0;
			while ((uint)num2 < (uint)source.Length)
			{
				nuint num3 = (uint)(source[num2] - 48);
				if ((uint)num3 > 9)
				{
					if (num2 != 0)
					{
						break;
					}
					num2++;
					if ((int)num3 == -3)
					{
						num--;
					}
					else if ((int)num3 != -5)
					{
						break;
					}
					continue;
				}
				ulong num4 = num3;
				int num5 = 19 + num2;
				num2++;
				if (source.Length < num5)
				{
					for (; (uint)num2 < (uint)source.Length; num2++)
					{
						nuint num6 = (uint)(source[num2] - 48);
						if ((uint)num6 > 9)
						{
							break;
						}
						num4 = num4 * 10 + num6;
					}
				}
				else
				{
					while ((uint)num2 < (uint)source.Length)
					{
						nuint num7 = (uint)(source[num2] - 48);
						if ((uint)num7 > 9)
						{
							break;
						}
						num2++;
						if (num4 < 922337203685477580L)
						{
							num4 = num4 * 10 + num7;
							continue;
						}
						if (num4 != 922337203685477580L || (int)num7 + (int)num > 7)
						{
							goto end_IL_0005;
						}
						num4 = 9223372036854775800uL + (ulong)num7;
					}
				}
				bytesConsumed = num2;
				value = (long)(num4 ^ (ulong)num) - num;
				return true;
				continue;
				end_IL_0005:
				break;
			}
			bytesConsumed = 0;
			value = 0L;
			return false;
		}

		private static bool TryParseSByteN(ReadOnlySpan<byte> source, out sbyte value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_00f9;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_00f9;
					}
					num3 = source[num2];
				}
				if (num3 != 46)
				{
					if (ParserHelpers.IsDigit(num3))
					{
						num4 = num3 - 48;
						while (true)
						{
							num2++;
							if ((uint)num2 >= (uint)source.Length)
							{
								break;
							}
							num3 = source[num2];
							if (num3 == 44)
							{
								continue;
							}
							if (num3 == 46)
							{
								goto IL_00d4;
							}
							if (!ParserHelpers.IsDigit(num3))
							{
								break;
							}
							num4 = num4 * 10 + num3 - 48;
							if (num4 <= 127 + (-1 * num + 1) / 2)
							{
								continue;
							}
							goto IL_00f9;
						}
						goto IL_0101;
					}
				}
				else
				{
					num4 = 0;
					num2++;
					if ((uint)num2 < (uint)source.Length && source[num2] == 48)
					{
						goto IL_00d4;
					}
				}
			}
			goto IL_00f9;
			IL_00f9:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0101:
			bytesConsumed = num2;
			value = (sbyte)(num4 * num);
			return true;
			IL_00d4:
			while (true)
			{
				num2++;
				if ((uint)num2 >= (uint)source.Length)
				{
					break;
				}
				num3 = source[num2];
				if (num3 == 48)
				{
					continue;
				}
				goto IL_00f1;
			}
			goto IL_0101;
			IL_00f1:
			if (ParserHelpers.IsDigit(num3))
			{
				goto IL_00f9;
			}
			goto IL_0101;
		}

		private static bool TryParseInt16N(ReadOnlySpan<byte> source, out short value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_00ff;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_00ff;
					}
					num3 = source[num2];
				}
				if (num3 != 46)
				{
					if (ParserHelpers.IsDigit(num3))
					{
						num4 = num3 - 48;
						while (true)
						{
							num2++;
							if ((uint)num2 >= (uint)source.Length)
							{
								break;
							}
							num3 = source[num2];
							if (num3 == 44)
							{
								continue;
							}
							if (num3 == 46)
							{
								goto IL_00da;
							}
							if (!ParserHelpers.IsDigit(num3))
							{
								break;
							}
							num4 = num4 * 10 + num3 - 48;
							if (num4 <= 32767 + (-1 * num + 1) / 2)
							{
								continue;
							}
							goto IL_00ff;
						}
						goto IL_0107;
					}
				}
				else
				{
					num4 = 0;
					num2++;
					if ((uint)num2 < (uint)source.Length && source[num2] == 48)
					{
						goto IL_00da;
					}
				}
			}
			goto IL_00ff;
			IL_00ff:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0107:
			bytesConsumed = num2;
			value = (short)(num4 * num);
			return true;
			IL_00da:
			while (true)
			{
				num2++;
				if ((uint)num2 >= (uint)source.Length)
				{
					break;
				}
				num3 = source[num2];
				if (num3 == 48)
				{
					continue;
				}
				goto IL_00f7;
			}
			goto IL_0107;
			IL_00f7:
			if (ParserHelpers.IsDigit(num3))
			{
				goto IL_00ff;
			}
			goto IL_0107;
		}

		private static bool TryParseInt32N(ReadOnlySpan<byte> source, out int value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_010a;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_010a;
					}
					num3 = source[num2];
				}
				if (num3 != 46)
				{
					if (ParserHelpers.IsDigit(num3))
					{
						num4 = num3 - 48;
						while (true)
						{
							num2++;
							if ((uint)num2 >= (uint)source.Length)
							{
								break;
							}
							num3 = source[num2];
							if (num3 == 44)
							{
								continue;
							}
							if (num3 == 46)
							{
								goto IL_00e5;
							}
							if (!ParserHelpers.IsDigit(num3))
							{
								break;
							}
							if ((uint)num4 <= 214748364u)
							{
								num4 = num4 * 10 + num3 - 48;
								if ((uint)num4 <= 2147483647L + (long)((-1 * num + 1) / 2))
								{
									continue;
								}
							}
							goto IL_010a;
						}
						goto IL_0112;
					}
				}
				else
				{
					num4 = 0;
					num2++;
					if ((uint)num2 < (uint)source.Length && source[num2] == 48)
					{
						goto IL_00e5;
					}
				}
			}
			goto IL_010a;
			IL_010a:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0112:
			bytesConsumed = num2;
			value = num4 * num;
			return true;
			IL_00e5:
			while (true)
			{
				num2++;
				if ((uint)num2 >= (uint)source.Length)
				{
					break;
				}
				num3 = source[num2];
				if (num3 == 48)
				{
					continue;
				}
				goto IL_0102;
			}
			goto IL_0112;
			IL_0102:
			if (ParserHelpers.IsDigit(num3))
			{
				goto IL_010a;
			}
			goto IL_0112;
		}

		private static bool TryParseInt64N(ReadOnlySpan<byte> source, out long value, out int bytesConsumed)
		{
			int num;
			int num2;
			long num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0115;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0115;
					}
					num3 = source[num2];
				}
				if (num3 != 46)
				{
					if (ParserHelpers.IsDigit(num3))
					{
						num4 = num3 - 48;
						while (true)
						{
							num2++;
							if ((uint)num2 >= (uint)source.Length)
							{
								break;
							}
							num3 = source[num2];
							if (num3 == 44)
							{
								continue;
							}
							if (num3 == 46)
							{
								goto IL_00f0;
							}
							if (!ParserHelpers.IsDigit(num3))
							{
								break;
							}
							if ((ulong)num4 <= 922337203685477580uL)
							{
								num4 = num4 * 10 + num3 - 48;
								if ((ulong)num4 <= (ulong)(long.MaxValue + (-1 * num + 1) / 2))
								{
									continue;
								}
							}
							goto IL_0115;
						}
						goto IL_011e;
					}
				}
				else
				{
					num4 = 0L;
					num2++;
					if ((uint)num2 < (uint)source.Length && source[num2] == 48)
					{
						goto IL_00f0;
					}
				}
			}
			goto IL_0115;
			IL_0115:
			bytesConsumed = 0;
			value = 0L;
			return false;
			IL_011e:
			bytesConsumed = num2;
			value = num4 * num;
			return true;
			IL_00f0:
			while (true)
			{
				num2++;
				if ((uint)num2 >= (uint)source.Length)
				{
					break;
				}
				num3 = source[num2];
				if (num3 == 48)
				{
					continue;
				}
				goto IL_010d;
			}
			goto IL_011e;
			IL_010d:
			if (ParserHelpers.IsDigit(num3))
			{
				goto IL_0115;
			}
			goto IL_011e;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (standardFormat != 0)
			{
				switch (standardFormat | 0x20)
				{
				case 100:
				case 103:
					break;
				case 110:
					return TryParseByteN(source, out value, out bytesConsumed);
				case 120:
					return TryParseByteX(source, out value, out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<byte>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
			return TryParseByteD(source, out value, out bytesConsumed);
		}

		[CLSCompliant(false)]
		public static bool TryParse(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (standardFormat != 0)
			{
				switch (standardFormat | 0x20)
				{
				case 100:
				case 103:
					break;
				case 110:
					return TryParseUInt16N(source, out value, out bytesConsumed);
				case 120:
					return TryParseUInt16X(source, out value, out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<ushort>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
			return TryParseUInt16D(source, out value, out bytesConsumed);
		}

		[CLSCompliant(false)]
		public static bool TryParse(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (standardFormat != 0)
			{
				switch (standardFormat | 0x20)
				{
				case 100:
				case 103:
					break;
				case 110:
					return TryParseUInt32N(source, out value, out bytesConsumed);
				case 120:
					return TryParseUInt32X(source, out value, out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<uint>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
			return TryParseUInt32D(source, out value, out bytesConsumed);
		}

		[CLSCompliant(false)]
		public static bool TryParse(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed, char standardFormat = '\0')
		{
			while (standardFormat != 0)
			{
				switch (standardFormat | 0x20)
				{
				case 100:
				case 103:
					break;
				case 110:
					return TryParseUInt64N(source, out value, out bytesConsumed);
				case 120:
					return TryParseUInt64X(source, out value, out bytesConsumed);
				default:
					return ParserHelpers.TryParseThrowFormatException<ulong>(source, out value, out bytesConsumed);
				}
				standardFormat = '\0';
			}
			return TryParseUInt64D(source, out value, out bytesConsumed);
		}

		private static bool TryParseByteD(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				num3 = 0;
				if (ParserHelpers.IsDigit(num2))
				{
					if (num2 != 48)
					{
						goto IL_0056;
					}
					while (true)
					{
						num++;
						if ((uint)num >= (uint)source.Length)
						{
							break;
						}
						num2 = source[num];
						if (num2 == 48)
						{
							continue;
						}
						goto IL_004b;
					}
					goto IL_00dd;
				}
			}
			goto IL_00d5;
			IL_004b:
			if (ParserHelpers.IsDigit(num2))
			{
				goto IL_0056;
			}
			goto IL_00dd;
			IL_0056:
			num3 = num2 - 48;
			num++;
			if ((uint)num < (uint)source.Length)
			{
				num2 = source[num];
				if (ParserHelpers.IsDigit(num2))
				{
					num++;
					num3 = 10 * num3 + num2 - 48;
					if ((uint)num < (uint)source.Length)
					{
						num2 = source[num];
						if (ParserHelpers.IsDigit(num2))
						{
							num++;
							num3 = num3 * 10 + num2 - 48;
							if ((uint)num3 > 255u || ((uint)num < (uint)source.Length && ParserHelpers.IsDigit(source[num])))
							{
								goto IL_00d5;
							}
						}
					}
				}
			}
			goto IL_00dd;
			IL_00dd:
			bytesConsumed = num;
			value = (byte)num3;
			return true;
			IL_00d5:
			bytesConsumed = 0;
			value = 0;
			return false;
		}

		private static bool TryParseUInt16D(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				num3 = 0;
				if (ParserHelpers.IsDigit(num2))
				{
					if (num2 != 48)
					{
						goto IL_0056;
					}
					while (true)
					{
						num++;
						if ((uint)num >= (uint)source.Length)
						{
							break;
						}
						num2 = source[num];
						if (num2 == 48)
						{
							continue;
						}
						goto IL_004b;
					}
					goto IL_013d;
				}
			}
			goto IL_0135;
			IL_004b:
			if (ParserHelpers.IsDigit(num2))
			{
				goto IL_0056;
			}
			goto IL_013d;
			IL_0056:
			num3 = num2 - 48;
			num++;
			if ((uint)num < (uint)source.Length)
			{
				num2 = source[num];
				if (ParserHelpers.IsDigit(num2))
				{
					num++;
					num3 = 10 * num3 + num2 - 48;
					if ((uint)num < (uint)source.Length)
					{
						num2 = source[num];
						if (ParserHelpers.IsDigit(num2))
						{
							num++;
							num3 = 10 * num3 + num2 - 48;
							if ((uint)num < (uint)source.Length)
							{
								num2 = source[num];
								if (ParserHelpers.IsDigit(num2))
								{
									num++;
									num3 = 10 * num3 + num2 - 48;
									if ((uint)num < (uint)source.Length)
									{
										num2 = source[num];
										if (ParserHelpers.IsDigit(num2))
										{
											num++;
											num3 = num3 * 10 + num2 - 48;
											if ((uint)num3 > 65535u || ((uint)num < (uint)source.Length && ParserHelpers.IsDigit(source[num])))
											{
												goto IL_0135;
											}
										}
									}
								}
							}
						}
					}
				}
			}
			goto IL_013d;
			IL_013d:
			bytesConsumed = num;
			value = (ushort)num3;
			return true;
			IL_0135:
			bytesConsumed = 0;
			value = 0;
			return false;
		}

		private static bool TryParseUInt32D(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				num3 = 0;
				if (ParserHelpers.IsDigit(num2))
				{
					if (num2 != 48)
					{
						goto IL_0056;
					}
					while (true)
					{
						num++;
						if ((uint)num >= (uint)source.Length)
						{
							break;
						}
						num2 = source[num];
						if (num2 == 48)
						{
							continue;
						}
						goto IL_004b;
					}
					goto IL_023d;
				}
			}
			goto IL_0235;
			IL_004b:
			if (ParserHelpers.IsDigit(num2))
			{
				goto IL_0056;
			}
			goto IL_023d;
			IL_0056:
			num3 = num2 - 48;
			num++;
			if ((uint)num < (uint)source.Length)
			{
				num2 = source[num];
				if (ParserHelpers.IsDigit(num2))
				{
					num++;
					num3 = 10 * num3 + num2 - 48;
					if ((uint)num < (uint)source.Length)
					{
						num2 = source[num];
						if (ParserHelpers.IsDigit(num2))
						{
							num++;
							num3 = 10 * num3 + num2 - 48;
							if ((uint)num < (uint)source.Length)
							{
								num2 = source[num];
								if (ParserHelpers.IsDigit(num2))
								{
									num++;
									num3 = 10 * num3 + num2 - 48;
									if ((uint)num < (uint)source.Length)
									{
										num2 = source[num];
										if (ParserHelpers.IsDigit(num2))
										{
											num++;
											num3 = 10 * num3 + num2 - 48;
											if ((uint)num < (uint)source.Length)
											{
												num2 = source[num];
												if (ParserHelpers.IsDigit(num2))
												{
													num++;
													num3 = 10 * num3 + num2 - 48;
													if ((uint)num < (uint)source.Length)
													{
														num2 = source[num];
														if (ParserHelpers.IsDigit(num2))
														{
															num++;
															num3 = 10 * num3 + num2 - 48;
															if ((uint)num < (uint)source.Length)
															{
																num2 = source[num];
																if (ParserHelpers.IsDigit(num2))
																{
																	num++;
																	num3 = 10 * num3 + num2 - 48;
																	if ((uint)num < (uint)source.Length)
																	{
																		num2 = source[num];
																		if (ParserHelpers.IsDigit(num2))
																		{
																			num++;
																			num3 = 10 * num3 + num2 - 48;
																			if ((uint)num < (uint)source.Length)
																			{
																				num2 = source[num];
																				if (ParserHelpers.IsDigit(num2))
																				{
																					num++;
																					if ((uint)num3 <= 429496729u && (num3 != 429496729 || num2 <= 53))
																					{
																						num3 = num3 * 10 + num2 - 48;
																						if ((uint)num >= (uint)source.Length || !ParserHelpers.IsDigit(source[num]))
																						{
																							goto IL_023d;
																						}
																					}
																					goto IL_0235;
																				}
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
			goto IL_023d;
			IL_023d:
			bytesConsumed = num;
			value = (uint)num3;
			return true;
			IL_0235:
			bytesConsumed = 0;
			value = 0u;
			return false;
		}

		private static bool TryParseUInt64D(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed)
		{
			if (!source.IsEmpty)
			{
				nuint num = (uint)(source[0] - 48);
				if ((uint)num <= 9)
				{
					ulong num2 = num;
					int i = 1;
					if (source.Length < 20)
					{
						for (; (uint)i < (uint)source.Length; i++)
						{
							nuint num3 = (uint)(source[i] - 48);
							if ((uint)num3 > 9)
							{
								break;
							}
							num2 = num2 * 10 + num3;
						}
					}
					else
					{
						while ((uint)i < (uint)source.Length)
						{
							nuint num4 = (uint)(source[i] - 48);
							if ((uint)num4 > 9)
							{
								break;
							}
							i++;
							if (num2 < 1844674407370955161L)
							{
								num2 = num2 * 10 + num4;
								continue;
							}
							if (num2 == 1844674407370955161L && (uint)num4 <= 5)
							{
								num2 = 18446744073709551610uL + (ulong)num4;
								continue;
							}
							goto IL_00c0;
						}
					}
					bytesConsumed = i;
					value = num2;
					return true;
				}
			}
			goto IL_00c0;
			IL_00c0:
			bytesConsumed = 0;
			value = 0uL;
			return false;
		}

		private static bool TryParseByteN(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				if (num2 == 43)
				{
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_00ce;
					}
					num2 = source[num];
				}
				if (num2 != 46)
				{
					if (ParserHelpers.IsDigit(num2))
					{
						num3 = num2 - 48;
						while (true)
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								break;
							}
							num2 = source[num];
							if (num2 == 44)
							{
								continue;
							}
							if (num2 == 46)
							{
								goto IL_00a9;
							}
							if (!ParserHelpers.IsDigit(num2))
							{
								break;
							}
							num3 = num3 * 10 + num2 - 48;
							if (num3 <= 255)
							{
								continue;
							}
							goto IL_00ce;
						}
						goto IL_00d6;
					}
				}
				else
				{
					num3 = 0;
					num++;
					if ((uint)num < (uint)source.Length && source[num] == 48)
					{
						goto IL_00a9;
					}
				}
			}
			goto IL_00ce;
			IL_00c6:
			if (ParserHelpers.IsDigit(num2))
			{
				goto IL_00ce;
			}
			goto IL_00d6;
			IL_00ce:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_00d6:
			bytesConsumed = num;
			value = (byte)num3;
			return true;
			IL_00a9:
			while (true)
			{
				num++;
				if ((uint)num >= (uint)source.Length)
				{
					break;
				}
				num2 = source[num];
				if (num2 == 48)
				{
					continue;
				}
				goto IL_00c6;
			}
			goto IL_00d6;
		}

		private static bool TryParseUInt16N(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				if (num2 == 43)
				{
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_00ce;
					}
					num2 = source[num];
				}
				if (num2 != 46)
				{
					if (ParserHelpers.IsDigit(num2))
					{
						num3 = num2 - 48;
						while (true)
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								break;
							}
							num2 = source[num];
							if (num2 == 44)
							{
								continue;
							}
							if (num2 == 46)
							{
								goto IL_00a9;
							}
							if (!ParserHelpers.IsDigit(num2))
							{
								break;
							}
							num3 = num3 * 10 + num2 - 48;
							if (num3 <= 65535)
							{
								continue;
							}
							goto IL_00ce;
						}
						goto IL_00d6;
					}
				}
				else
				{
					num3 = 0;
					num++;
					if ((uint)num < (uint)source.Length && source[num] == 48)
					{
						goto IL_00a9;
					}
				}
			}
			goto IL_00ce;
			IL_00c6:
			if (ParserHelpers.IsDigit(num2))
			{
				goto IL_00ce;
			}
			goto IL_00d6;
			IL_00ce:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_00d6:
			bytesConsumed = num;
			value = (ushort)num3;
			return true;
			IL_00a9:
			while (true)
			{
				num++;
				if ((uint)num >= (uint)source.Length)
				{
					break;
				}
				num2 = source[num];
				if (num2 == 48)
				{
					continue;
				}
				goto IL_00c6;
			}
			goto IL_00d6;
		}

		private static bool TryParseUInt32N(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				if (num2 == 43)
				{
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_00de;
					}
					num2 = source[num];
				}
				if (num2 != 46)
				{
					if (ParserHelpers.IsDigit(num2))
					{
						num3 = num2 - 48;
						while (true)
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								break;
							}
							num2 = source[num];
							if (num2 == 44)
							{
								continue;
							}
							if (num2 == 46)
							{
								goto IL_00b9;
							}
							if (!ParserHelpers.IsDigit(num2))
							{
								break;
							}
							if ((uint)num3 <= 429496729u && (num3 != 429496729 || num2 <= 53))
							{
								num3 = num3 * 10 + num2 - 48;
								continue;
							}
							goto IL_00de;
						}
						goto IL_00e6;
					}
				}
				else
				{
					num3 = 0;
					num++;
					if ((uint)num < (uint)source.Length && source[num] == 48)
					{
						goto IL_00b9;
					}
				}
			}
			goto IL_00de;
			IL_00d6:
			if (ParserHelpers.IsDigit(num2))
			{
				goto IL_00de;
			}
			goto IL_00e6;
			IL_00de:
			bytesConsumed = 0;
			value = 0u;
			return false;
			IL_00e6:
			bytesConsumed = num;
			value = (uint)num3;
			return true;
			IL_00b9:
			while (true)
			{
				num++;
				if ((uint)num >= (uint)source.Length)
				{
					break;
				}
				num2 = source[num];
				if (num2 == 48)
				{
					continue;
				}
				goto IL_00d6;
			}
			goto IL_00e6;
		}

		private static bool TryParseUInt64N(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed)
		{
			int num;
			long num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				if (num2 == 43)
				{
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_00eb;
					}
					num2 = source[num];
				}
				if (num2 != 46)
				{
					if (ParserHelpers.IsDigit(num2))
					{
						num3 = num2 - 48;
						while (true)
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								break;
							}
							num2 = source[num];
							if (num2 == 44)
							{
								continue;
							}
							if (num2 == 46)
							{
								goto IL_00c6;
							}
							if (!ParserHelpers.IsDigit(num2))
							{
								break;
							}
							if ((ulong)num3 <= 1844674407370955161uL && (num3 != 1844674407370955161L || num2 <= 53))
							{
								num3 = num3 * 10 + num2 - 48;
								continue;
							}
							goto IL_00eb;
						}
						goto IL_00f4;
					}
				}
				else
				{
					num3 = 0L;
					num++;
					if ((uint)num < (uint)source.Length && source[num] == 48)
					{
						goto IL_00c6;
					}
				}
			}
			goto IL_00eb;
			IL_00e3:
			if (ParserHelpers.IsDigit(num2))
			{
				goto IL_00eb;
			}
			goto IL_00f4;
			IL_00eb:
			bytesConsumed = 0;
			value = 0uL;
			return false;
			IL_00f4:
			bytesConsumed = num;
			value = (ulong)num3;
			return true;
			IL_00c6:
			while (true)
			{
				num++;
				if ((uint)num >= (uint)source.Length)
				{
					break;
				}
				num2 = source[num];
				if (num2 == 48)
				{
					continue;
				}
				goto IL_00e3;
			}
			goto IL_00f4;
		}

		private static bool TryParseByteX(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0;
				return false;
			}
			ReadOnlySpan<byte> charToHexLookup = HexConverter.CharToHexLookup;
			byte index = source[0];
			byte b = charToHexLookup[index];
			if (b == byte.MaxValue)
			{
				bytesConsumed = 0;
				value = 0;
				return false;
			}
			uint num = b;
			if (source.Length <= 2)
			{
				for (int i = 1; i < source.Length; i++)
				{
					index = source[i];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = i;
						value = (byte)num;
						return true;
					}
					num = (num << 4) + b;
				}
			}
			else
			{
				for (int j = 1; j < 2; j++)
				{
					index = source[j];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = j;
						value = (byte)num;
						return true;
					}
					num = (num << 4) + b;
				}
				for (int k = 2; k < source.Length; k++)
				{
					index = source[k];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = k;
						value = (byte)num;
						return true;
					}
					if (num > 15)
					{
						bytesConsumed = 0;
						value = 0;
						return false;
					}
					num = (num << 4) + b;
				}
			}
			bytesConsumed = source.Length;
			value = (byte)num;
			return true;
		}

		private static bool TryParseUInt16X(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0;
				return false;
			}
			ReadOnlySpan<byte> charToHexLookup = HexConverter.CharToHexLookup;
			byte index = source[0];
			byte b = charToHexLookup[index];
			if (b == byte.MaxValue)
			{
				bytesConsumed = 0;
				value = 0;
				return false;
			}
			uint num = b;
			if (source.Length <= 4)
			{
				for (int i = 1; i < source.Length; i++)
				{
					index = source[i];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = i;
						value = (ushort)num;
						return true;
					}
					num = (num << 4) + b;
				}
			}
			else
			{
				for (int j = 1; j < 4; j++)
				{
					index = source[j];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = j;
						value = (ushort)num;
						return true;
					}
					num = (num << 4) + b;
				}
				for (int k = 4; k < source.Length; k++)
				{
					index = source[k];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = k;
						value = (ushort)num;
						return true;
					}
					if (num > 4095)
					{
						bytesConsumed = 0;
						value = 0;
						return false;
					}
					num = (num << 4) + b;
				}
			}
			bytesConsumed = source.Length;
			value = (ushort)num;
			return true;
		}

		private static bool TryParseUInt32X(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0u;
				return false;
			}
			ReadOnlySpan<byte> charToHexLookup = HexConverter.CharToHexLookup;
			byte index = source[0];
			byte b = charToHexLookup[index];
			if (b == byte.MaxValue)
			{
				bytesConsumed = 0;
				value = 0u;
				return false;
			}
			uint num = b;
			if (source.Length <= 8)
			{
				for (int i = 1; i < source.Length; i++)
				{
					index = source[i];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = i;
						value = num;
						return true;
					}
					num = (num << 4) + b;
				}
			}
			else
			{
				for (int j = 1; j < 8; j++)
				{
					index = source[j];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = j;
						value = num;
						return true;
					}
					num = (num << 4) + b;
				}
				for (int k = 8; k < source.Length; k++)
				{
					index = source[k];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = k;
						value = num;
						return true;
					}
					if (num > 268435455)
					{
						bytesConsumed = 0;
						value = 0u;
						return false;
					}
					num = (num << 4) + b;
				}
			}
			bytesConsumed = source.Length;
			value = num;
			return true;
		}

		private static bool TryParseUInt64X(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0uL;
				return false;
			}
			ReadOnlySpan<byte> charToHexLookup = HexConverter.CharToHexLookup;
			byte index = source[0];
			byte b = charToHexLookup[index];
			if (b == byte.MaxValue)
			{
				bytesConsumed = 0;
				value = 0uL;
				return false;
			}
			ulong num = b;
			if (source.Length <= 16)
			{
				for (int i = 1; i < source.Length; i++)
				{
					index = source[i];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = i;
						value = num;
						return true;
					}
					num = (num << 4) + b;
				}
			}
			else
			{
				for (int j = 1; j < 16; j++)
				{
					index = source[j];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = j;
						value = num;
						return true;
					}
					num = (num << 4) + b;
				}
				for (int k = 16; k < source.Length; k++)
				{
					index = source[k];
					b = charToHexLookup[index];
					if (b == byte.MaxValue)
					{
						bytesConsumed = k;
						value = num;
						return true;
					}
					if (num > 1152921504606846975L)
					{
						bytesConsumed = 0;
						value = 0uL;
						return false;
					}
					num = (num << 4) + b;
				}
			}
			bytesConsumed = source.Length;
			value = num;
			return true;
		}

		private static bool TryParseNumber(ReadOnlySpan<byte> source, ref Number.NumberBuffer number, out int bytesConsumed, ParseNumberOptions options, out bool textUsedExponentNotation)
		{
			textUsedExponentNotation = false;
			if (source.Length == 0)
			{
				bytesConsumed = 0;
				return false;
			}
			Span<byte> digits = number.Digits;
			int i = 0;
			int num = 0;
			byte b = source[i];
			if (b != 43)
			{
				if (b != 45)
				{
					goto IL_0055;
				}
				number.IsNegative = true;
			}
			i++;
			if (i == source.Length)
			{
				bytesConsumed = 0;
				return false;
			}
			b = source[i];
			goto IL_0055;
			IL_0055:
			int num2 = i;
			int num3 = 0;
			int num4 = digits.Length - 1;
			for (; i != source.Length; i++)
			{
				b = source[i];
				if (b != 48)
				{
					break;
				}
			}
			if (i == source.Length)
			{
				bytesConsumed = i;
				return true;
			}
			int num5 = i;
			int num6 = 0;
			while (i != source.Length)
			{
				b = source[i];
				int num7 = (byte)(b - 48);
				if (num7 > 9)
				{
					break;
				}
				i++;
				num3++;
				if (num3 >= num4)
				{
					num6 |= num7;
				}
			}
			number.HasNonZeroTail = num6 != 0;
			int num8 = i - num2;
			int num9 = i - num5;
			int num10 = Math.Min(num9, num4);
			source.Slice(num5, num10).CopyTo(digits);
			num = num10;
			number.Scale = num9;
			if (i == source.Length)
			{
				digits[num] = 0;
				number.DigitsCount = num;
				bytesConsumed = i;
				return true;
			}
			int num11 = 0;
			if (b == 46)
			{
				i++;
				int num12 = i;
				while (i != source.Length)
				{
					b = source[i];
					int num13 = (byte)(b - 48);
					if (num13 > 9)
					{
						break;
					}
					i++;
					num3++;
					if (num3 >= num4)
					{
						num6 |= num13;
					}
				}
				number.HasNonZeroTail = num6 != 0;
				num11 = i - num12;
				int j = num12;
				if (num == 0)
				{
					for (; j < i && source[j] == 48; j++)
					{
						number.Scale--;
					}
				}
				int num14 = Math.Min(i - j, num4 - num);
				source.Slice(j, num14).CopyTo(digits.Slice(num));
				num += num14;
				if (i == source.Length)
				{
					if (num8 == 0 && num11 == 0)
					{
						bytesConsumed = 0;
						return false;
					}
					digits[num] = 0;
					number.DigitsCount = num;
					bytesConsumed = i;
					return true;
				}
			}
			if (num8 == 0 && num11 == 0)
			{
				bytesConsumed = 0;
				return false;
			}
			if ((b & -33) != 69)
			{
				digits[num] = 0;
				number.DigitsCount = num;
				bytesConsumed = i;
				return true;
			}
			textUsedExponentNotation = true;
			i++;
			if ((options & ParseNumberOptions.AllowExponent) == 0)
			{
				bytesConsumed = 0;
				return false;
			}
			if (i == source.Length)
			{
				bytesConsumed = 0;
				return false;
			}
			bool flag = false;
			b = source[i];
			if (b != 43)
			{
				if (b != 45)
				{
					goto IL_02a0;
				}
				flag = true;
			}
			i++;
			if (i == source.Length)
			{
				bytesConsumed = 0;
				return false;
			}
			b = source[i];
			goto IL_02a0;
			IL_02a0:
			if ((byte)(b - 48) > 9)
			{
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32D(source.Slice(i), out var value, out var bytesConsumed2))
			{
				value = uint.MaxValue;
				for (i += 10; i != source.Length; i++)
				{
					b = source[i];
					int num15 = (byte)(b - 48);
					if (num15 > 9)
					{
						break;
					}
				}
			}
			i += bytesConsumed2;
			if (flag)
			{
				if (number.Scale < int.MinValue + value)
				{
					number.Scale = int.MinValue;
				}
				else
				{
					number.Scale -= (int)value;
				}
			}
			else if (number.Scale > 2147483647L - (long)value)
			{
				number.Scale = int.MaxValue;
			}
			else
			{
				number.Scale += (int)value;
			}
			digits[num] = 0;
			number.DigitsCount = num;
			bytesConsumed = i;
			return true;
		}

		private static bool TryParseTimeSpanBigG(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed)
		{
			int i = 0;
			byte b = 0;
			for (; i != source.Length; i++)
			{
				b = source[i];
				if (b != 32 && b != 9)
				{
					break;
				}
			}
			if (i == source.Length)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			bool isNegative = false;
			if (b == 45)
			{
				isNegative = true;
				i++;
				if (i == source.Length)
				{
					value = default(TimeSpan);
					bytesConsumed = 0;
					return false;
				}
			}
			if (!TryParseUInt32D(source.Slice(i), out var value2, out var bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (i == source.Length || source[i++] != 58)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32D(source.Slice(i), out var value3, out bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (i == source.Length || source[i++] != 58)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32D(source.Slice(i), out var value4, out bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (i == source.Length || source[i++] != 58)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32D(source.Slice(i), out var value5, out bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (i == source.Length || source[i++] != 46)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseTimeSpanFraction(source.Slice(i), out var value6, out bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (!TryCreateTimeSpan(isNegative, value2, value3, value4, value5, value6, out value))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (i != source.Length && (source[i] == 46 || source[i] == 58))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			bytesConsumed = i;
			return true;
		}

		private static bool TryParseTimeSpanC(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed)
		{
			TimeSpanSplitter timeSpanSplitter = default(TimeSpanSplitter);
			if (!timeSpanSplitter.TrySplitTimeSpan(source, periodUsedToSeparateDay: true, out bytesConsumed))
			{
				value = default(TimeSpan);
				return false;
			}
			bool isNegative = timeSpanSplitter.IsNegative;
			bool flag;
			switch (timeSpanSplitter.Separators)
			{
			case 0u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, 0u, 0u, 0u, 0u, out value);
				break;
			case 16777216u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, 0u, 0u, out value);
				break;
			case 33619968u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, 0u, 0u, out value);
				break;
			case 16842752u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, 0u, out value);
				break;
			case 33620224u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, 0u, out value);
				break;
			case 16843264u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, out value);
				break;
			case 33620226u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, timeSpanSplitter.V5, out value);
				break;
			default:
				value = default(TimeSpan);
				flag = false;
				break;
			}
			if (!flag)
			{
				bytesConsumed = 0;
				return false;
			}
			return true;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'T':
			case 'c':
			case 't':
				return TryParseTimeSpanC(source, out value, out bytesConsumed);
			case 'G':
				return TryParseTimeSpanBigG(source, out value, out bytesConsumed);
			case 'g':
				return TryParseTimeSpanLittleG(source, out value, out bytesConsumed);
			default:
				return ParserHelpers.TryParseThrowFormatException<TimeSpan>(out value, out bytesConsumed);
			}
		}

		private static bool TryParseTimeSpanFraction(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed)
		{
			int num = 0;
			if (num == source.Length)
			{
				value = 0u;
				bytesConsumed = 0;
				return false;
			}
			uint num2 = (uint)(source[num] - 48);
			if (num2 > 9)
			{
				value = 0u;
				bytesConsumed = 0;
				return false;
			}
			num++;
			uint num3 = num2;
			int num4 = 1;
			while (num != source.Length)
			{
				num2 = (uint)(source[num] - 48);
				if (num2 > 9)
				{
					break;
				}
				num++;
				num4++;
				if (num4 > 7)
				{
					value = 0u;
					bytesConsumed = 0;
					return false;
				}
				num3 = 10 * num3 + num2;
			}
			switch (num4)
			{
			case 6:
				num3 *= 10;
				break;
			case 5:
				num3 *= 100;
				break;
			case 4:
				num3 *= 1000;
				break;
			case 3:
				num3 *= 10000;
				break;
			case 2:
				num3 *= 100000;
				break;
			default:
				num3 *= 1000000;
				break;
			case 7:
				break;
			}
			value = num3;
			bytesConsumed = num;
			return true;
		}

		private static bool TryCreateTimeSpan(bool isNegative, uint days, uint hours, uint minutes, uint seconds, uint fraction, out TimeSpan timeSpan)
		{
			if (hours > 23 || minutes > 59 || seconds > 59)
			{
				timeSpan = default(TimeSpan);
				return false;
			}
			long num = ((long)days * 3600L * 24 + (long)hours * 3600L + (long)minutes * 60L + seconds) * 1000;
			long ticks;
			if (isNegative)
			{
				num = -num;
				if (num < -922337203685477L)
				{
					timeSpan = default(TimeSpan);
					return false;
				}
				long num2 = num * 10000;
				if (num2 < long.MinValue + fraction)
				{
					timeSpan = default(TimeSpan);
					return false;
				}
				ticks = num2 - fraction;
			}
			else
			{
				if (num > 922337203685477L)
				{
					timeSpan = default(TimeSpan);
					return false;
				}
				long num3 = num * 10000;
				if (num3 > long.MaxValue - (long)fraction)
				{
					timeSpan = default(TimeSpan);
					return false;
				}
				ticks = num3 + fraction;
			}
			timeSpan = new TimeSpan(ticks);
			return true;
		}

		private static bool TryParseTimeSpanLittleG(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed)
		{
			TimeSpanSplitter timeSpanSplitter = default(TimeSpanSplitter);
			if (!timeSpanSplitter.TrySplitTimeSpan(source, periodUsedToSeparateDay: false, out bytesConsumed))
			{
				value = default(TimeSpan);
				return false;
			}
			bool isNegative = timeSpanSplitter.IsNegative;
			bool flag;
			switch (timeSpanSplitter.Separators)
			{
			case 0u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, 0u, 0u, 0u, 0u, out value);
				break;
			case 16777216u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, 0u, 0u, out value);
				break;
			case 16842752u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, 0u, out value);
				break;
			case 16843008u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, 0u, out value);
				break;
			case 16843264u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, out value);
				break;
			case 16843010u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, timeSpanSplitter.V5, out value);
				break;
			default:
				value = default(TimeSpan);
				flag = false;
				break;
			}
			if (!flag)
			{
				bytesConsumed = 0;
				return false;
			}
			return true;
		}
	}
}
namespace System.Buffers.Binary
{
	public static class BinaryPrimitives
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static sbyte ReverseEndianness(sbyte value)
		{
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static short ReverseEndianness(short value)
		{
			return (short)ReverseEndianness((ushort)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static int ReverseEndianness(int value)
		{
			return (int)ReverseEndianness((uint)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static long ReverseEndianness(long value)
		{
			return (long)ReverseEndianness((ulong)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte ReverseEndianness(byte value)
		{
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		[Intrinsic]
		public static ushort ReverseEndianness(ushort value)
		{
			return (ushort)((value >> 8) + (value << 8));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		[Intrinsic]
		public static uint ReverseEndianness(uint value)
		{
			return BitOperations.RotateRight(value & 0xFF00FFu, 8) + BitOperations.RotateLeft(value & 0xFF00FF00u, 8);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		[Intrinsic]
		public static ulong ReverseEndianness(ulong value)
		{
			return ((ulong)ReverseEndianness((uint)value) << 32) + ReverseEndianness((uint)(value >> 32));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double ReadDoubleBigEndian(ReadOnlySpan<byte> source)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return BitConverter.Int64BitsToDouble(ReverseEndianness(MemoryMarshal.Read<long>(source)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Half ReadHalfBigEndian(ReadOnlySpan<byte> source)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return BitConverter.Int16BitsToHalf(ReverseEndianness(MemoryMarshal.Read<short>(source)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ReadInt16BigEndian(ReadOnlySpan<byte> source)
		{
			short value = MemoryMarshal.Read<short>(source);
			_ = BitConverter.IsLittleEndian;
			return ReverseEndianness(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ReadInt32BigEndian(ReadOnlySpan<byte> source)
		{
			int value = MemoryMarshal.Read<int>(source);
			_ = BitConverter.IsLittleEndian;
			return ReverseEndianness(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long ReadInt64BigEndian(ReadOnlySpan<byte> source)
		{
			long value = MemoryMarshal.Read<long>(source);
			_ = BitConverter.IsLittleEndian;
			return ReverseEndianness(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ReadSingleBigEndian(ReadOnlySpan<byte> source)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return BitConverter.Int32BitsToSingle(ReverseEndianness(MemoryMarshal.Read<int>(source)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ushort ReadUInt16BigEndian(ReadOnlySpan<byte> source)
		{
			ushort value = MemoryMarshal.Read<ushort>(source);
			_ = BitConverter.IsLittleEndian;
			return ReverseEndianness(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint ReadUInt32BigEndian(ReadOnlySpan<byte> source)
		{
			uint value = MemoryMarshal.Read<uint>(source);
			_ = BitConverter.IsLittleEndian;
			return ReverseEndianness(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong ReadUInt64BigEndian(ReadOnlySpan<byte> source)
		{
			ulong value = MemoryMarshal.Read<ulong>(source);
			_ = BitConverter.IsLittleEndian;
			return ReverseEndianness(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadDoubleBigEndian(ReadOnlySpan<byte> source, out double value)
		{
			_ = BitConverter.IsLittleEndian;
			long value2;
			bool result = MemoryMarshal.TryRead<long>(source, out value2);
			value = BitConverter.Int64BitsToDouble(ReverseEndianness(value2));
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadHalfBigEndian(ReadOnlySpan<byte> source, out Half value)
		{
			_ = BitConverter.IsLittleEndian;
			short value2;
			bool result = MemoryMarshal.TryRead<short>(source, out value2);
			value = BitConverter.Int16BitsToHalf(ReverseEndianness(value2));
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt16BigEndian(ReadOnlySpan<byte> source, out short value)
		{
			_ = BitConverter.IsLittleEndian;
			short value2;
			bool result = MemoryMarshal.TryRead<short>(source, out value2);
			value = ReverseEndianness(value2);
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt32BigEndian(ReadOnlySpan<byte> source, out int value)
		{
			_ = BitConverter.IsLittleEndian;
			int value2;
			bool result = MemoryMarshal.TryRead<int>(source, out value2);
			value = ReverseEndianness(value2);
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt64BigEndian(ReadOnlySpan<byte> source, out long value)
		{
			_ = BitConverter.IsLittleEndian;
			long value2;
			bool result = MemoryMarshal.TryRead<long>(source, out value2);
			value = ReverseEndianness(value2);
			return result;
		}

		public static bool TryReadSingleBigEndian(ReadOnlySpan<byte> source, out float value)
		{
			_ = BitConverter.IsLittleEndian;
			int value2;
			bool result = MemoryMarshal.TryRead<int>(source, out value2);
			value = BitConverter.Int32BitsToSingle(ReverseEndianness(value2));
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt16BigEndian(ReadOnlySpan<byte> source, out ushort value)
		{
			_ = BitConverter.IsLittleEndian;
			ushort value2;
			bool result = MemoryMarshal.TryRead<ushort>(source, out value2);
			value = ReverseEndianness(value2);
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt32BigEndian(ReadOnlySpan<byte> source, out uint value)
		{
			_ = BitConverter.IsLittleEndian;
			uint value2;
			bool result = MemoryMarshal.TryRead<uint>(source, out value2);
			value = ReverseEndianness(value2);
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt64BigEndian(ReadOnlySpan<byte> source, out ulong value)
		{
			_ = BitConverter.IsLittleEndian;
			ulong value2;
			bool result = MemoryMarshal.TryRead<ulong>(source, out value2);
			value = ReverseEndianness(value2);
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double ReadDoubleLittleEndian(ReadOnlySpan<byte> source)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.Read<double>(source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Half ReadHalfLittleEndian(ReadOnlySpan<byte> source)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.Read<Half>(source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ReadInt16LittleEndian(ReadOnlySpan<byte> source)
		{
			short result = MemoryMarshal.Read<short>(source);
			if (!BitConverter.IsLittleEndian)
			{
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ReadInt32LittleEndian(ReadOnlySpan<byte> source)
		{
			int result = MemoryMarshal.Read<int>(source);
			if (!BitConverter.IsLittleEndian)
			{
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long ReadInt64LittleEndian(ReadOnlySpan<byte> source)
		{
			long result = MemoryMarshal.Read<long>(source);
			if (!BitConverter.IsLittleEndian)
			{
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ReadSingleLittleEndian(ReadOnlySpan<byte> source)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.Read<float>(source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ushort ReadUInt16LittleEndian(ReadOnlySpan<byte> source)
		{
			ushort result = MemoryMarshal.Read<ushort>(source);
			if (!BitConverter.IsLittleEndian)
			{
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint ReadUInt32LittleEndian(ReadOnlySpan<byte> source)
		{
			uint result = MemoryMarshal.Read<uint>(source);
			if (!BitConverter.IsLittleEndian)
			{
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong ReadUInt64LittleEndian(ReadOnlySpan<byte> source)
		{
			ulong result = MemoryMarshal.Read<ulong>(source);
			if (!BitConverter.IsLittleEndian)
			{
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadDoubleLittleEndian(ReadOnlySpan<byte> source, out double value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryRead<double>(source, out value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadHalfLittleEndian(ReadOnlySpan<byte> source, out Half value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryRead<Half>(source, out value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt16LittleEndian(ReadOnlySpan<byte> source, out short value)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.TryRead<short>(source, out value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt32LittleEndian(ReadOnlySpan<byte> source, out int value)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.TryRead<int>(source, out value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt64LittleEndian(ReadOnlySpan<byte> source, out long value)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.TryRead<long>(source, out value);
		}

		public static bool TryReadSingleLittleEndian(ReadOnlySpan<byte> source, out float value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryRead<float>(source, out value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt16LittleEndian(ReadOnlySpan<byte> source, out ushort value)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.TryRead<ushort>(source, out value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt32LittleEndian(ReadOnlySpan<byte> source, out uint value)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.TryRead<uint>(source, out value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt64LittleEndian(ReadOnlySpan<byte> source, out ulong value)
		{
			_ = BitConverter.IsLittleEndian;
			return MemoryMarshal.TryRead<ulong>(source, out value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDoubleBigEndian(Span<byte> destination, double value)
		{
			_ = BitConverter.IsLittleEndian;
			long value2 = ReverseEndianness(BitConverter.DoubleToInt64Bits(value));
			MemoryMarshal.Write(destination, ref value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteHalfBigEndian(Span<byte> destination, Half value)
		{
			_ = BitConverter.IsLittleEndian;
			short value2 = ReverseEndianness(BitConverter.HalfToInt16Bits(value));
			MemoryMarshal.Write(destination, ref value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt16BigEndian(Span<byte> destination, short value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt32BigEndian(Span<byte> destination, int value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt64BigEndian(Span<byte> destination, long value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteSingleBigEndian(Span<byte> destination, float value)
		{
			_ = BitConverter.IsLittleEndian;
			int value2 = ReverseEndianness(BitConverter.SingleToInt32Bits(value));
			MemoryMarshal.Write(destination, ref value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt16BigEndian(Span<byte> destination, ushort value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt32BigEndian(Span<byte> destination, uint value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt64BigEndian(Span<byte> destination, ulong value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteDoubleBigEndian(Span<byte> destination, double value)
		{
			_ = BitConverter.IsLittleEndian;
			long value2 = ReverseEndianness(BitConverter.DoubleToInt64Bits(value));
			return MemoryMarshal.TryWrite(destination, ref value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteHalfBigEndian(Span<byte> destination, Half value)
		{
			_ = BitConverter.IsLittleEndian;
			short value2 = ReverseEndianness(BitConverter.HalfToInt16Bits(value));
			return MemoryMarshal.TryWrite(destination, ref value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt16BigEndian(Span<byte> destination, short value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt32BigEndian(Span<byte> destination, int value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt64BigEndian(Span<byte> destination, long value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteSingleBigEndian(Span<byte> destination, float value)
		{
			_ = BitConverter.IsLittleEndian;
			int value2 = ReverseEndianness(BitConverter.SingleToInt32Bits(value));
			return MemoryMarshal.TryWrite(destination, ref value2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt16BigEndian(Span<byte> destination, ushort value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt32BigEndian(Span<byte> destination, uint value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt64BigEndian(Span<byte> destination, ulong value)
		{
			_ = BitConverter.IsLittleEndian;
			value = ReverseEndianness(value);
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDoubleLittleEndian(Span<byte> destination, double value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteHalfLittleEndian(Span<byte> destination, Half value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt16LittleEndian(Span<byte> destination, short value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt32LittleEndian(Span<byte> destination, int value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt64LittleEndian(Span<byte> destination, long value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteSingleLittleEndian(Span<byte> destination, float value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt16LittleEndian(Span<byte> destination, ushort value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt32LittleEndian(Span<byte> destination, uint value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt64LittleEndian(Span<byte> destination, ulong value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteDoubleLittleEndian(Span<byte> destination, double value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteHalfLittleEndian(Span<byte> destination, Half value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt16LittleEndian(Span<byte> destination, short value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt32LittleEndian(Span<byte> destination, int value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt64LittleEndian(Span<byte> destination, long value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteSingleLittleEndian(Span<byte> destination, float value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt16LittleEndian(Span<byte> destination, ushort value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt32LittleEndian(Span<byte> destination, uint value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt64LittleEndian(Span<byte> destination, ulong value)
		{
			if (!BitConverter.IsLittleEndian)
			{
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}
	}
}
namespace System.Threading
{
	public sealed class ThreadPoolBoundHandle : IDisposable
	{
		private readonly SafeHandle _handle;

		private bool _isDisposed;

		public SafeHandle Handle => _handle;

		private ThreadPoolBoundHandle(SafeHandle handle)
		{
			_handle = handle;
		}

		public static ThreadPoolBoundHandle BindHandle(SafeHandle handle)
		{
			if (handle == null)
			{
				throw new ArgumentNullException("handle");
			}
			if (handle.IsClosed || handle.IsInvalid)
			{
				throw new ArgumentException(SR.Argument_InvalidHandle, "handle");
			}
			return BindHandleCore(handle);
		}

		[CLSCompliant(false)]
		public unsafe NativeOverlapped* AllocateNativeOverlapped(IOCompletionCallback callback, object? state, object? pinData)
		{
			return AllocateNativeOverlapped(callback, state, pinData, flowExecutionContext: true);
		}

		[CLSCompliant(false)]
		public unsafe NativeOverlapped* UnsafeAllocateNativeOverlapped(IOCompletionCallback callback, object? state, object? pinData)
		{
			return AllocateNativeOverlapped(callback, state, pinData, flowExecutionContext: false);
		}

		private unsafe NativeOverlapped* AllocateNativeOverlapped(IOCompletionCallback callback, object state, object pinData, bool flowExecutionContext)
		{
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			EnsureNotDisposed();
			ThreadPoolBoundHandleOverlapped threadPoolBoundHandleOverlapped = new ThreadPoolBoundHandleOverlapped(callback, state, pinData, null, flowExecutionContext);
			threadPoolBoundHandleOverlapped._boundHandle = this;
			return threadPoolBoundHandleOverlapped._nativeOverlapped;
		}

		[CLSCompliant(false)]
		public unsafe NativeOverlapped* AllocateNativeOverlapped(PreAllocatedOverlapped preAllocated)
		{
			if (preAllocated == null)
			{
				throw new ArgumentNullException("preAllocated");
			}
			EnsureNotDisposed();
			preAllocated.AddRef();
			try
			{
				ThreadPoolBoundHandleOverlapped overlapped = preAllocated._overlapped;
				if (overlapped._boundHandle != null)
				{
					throw new ArgumentException(SR.Argument_PreAllocatedAlreadyAllocated, "preAllocated");
				}
				overlapped._boundHandle = this;
				return overlapped._nativeOverlapped;
			}
			catch
			{
				preAllocated.Release();
				throw;
			}
		}

		[CLSCompliant(false)]
		public unsafe void FreeNativeOverlapped(NativeOverlapped* overlapped)
		{
			if (overlapped == null)
			{
				throw new ArgumentNullException("overlapped");
			}
			ThreadPoolBoundHandleOverlapped overlappedWrapper = GetOverlappedWrapper(overlapped);
			if (overlappedWrapper._boundHandle != this)
			{
				throw new ArgumentException(SR.Argument_NativeOverlappedWrongBoundHandle, "overlapped");
			}
			if (overlappedWrapper._preAllocated != null)
			{
				overlappedWrapper._preAllocated.Release();
			}
			else
			{
				Overlapped.Free(overlapped);
			}
		}

		[CLSCompliant(false)]
		public unsafe static object? GetNativeOverlappedState(NativeOverlapped* overlapped)
		{
			if (overlapped == null)
			{
				throw new ArgumentNullException("overlapped");
			}
			ThreadPoolBoundHandleOverlapped overlappedWrapper = GetOverlappedWrapper(overlapped);
			return overlappedWrapper._userState;
		}

		private unsafe static ThreadPoolBoundHandleOverlapped GetOverlappedWrapper(NativeOverlapped* overlapped)
		{
			try
			{
				return (ThreadPoolBoundHandleOverlapped)Overlapped.Unpack(overlapped);
			}
			catch (NullReferenceException innerException)
			{
				throw new ArgumentException(SR.Argument_NativeOverlappedAlreadyFree, "overlapped", innerException);
			}
		}

		public void Dispose()
		{
			_isDisposed = true;
		}

		private void EnsureNotDisposed()
		{
			if (_isDisposed)
			{
				throw new ObjectDisposedException(GetType().ToString());
			}
		}

		private static ThreadPoolBoundHandle BindHandleCore(SafeHandle handle)
		{
			try
			{
				bool flag = ThreadPool.BindHandle(handle);
			}
			catch (Exception ex)
			{
				if (ex.HResult == -2147024890)
				{
					throw new ArgumentException(SR.Argument_InvalidHandle, "handle");
				}
				if (ex.HResult == -2147024809)
				{
					throw new ArgumentException(SR.Argument_AlreadyBoundOrSyncHandle, "handle");
				}
				throw;
			}
			return new ThreadPoolBoundHandle(handle);
		}
	}
	internal sealed class ThreadPoolBoundHandleOverlapped : Overlapped
	{
		private unsafe static readonly IOCompletionCallback s_completionCallback = CompletionCallback;

		private readonly IOCompletionCallback _userCallback;

		internal readonly object _userState;

		internal readonly PreAllocatedOverlapped _preAllocated;

		internal unsafe NativeOverlapped* _nativeOverlapped;

		internal ThreadPoolBoundHandle _boundHandle;

		internal bool _completed;

		public unsafe ThreadPoolBoundHandleOverlapped(IOCompletionCallback callback, object state, object pinData, PreAllocatedOverlapped preAllocated, bool flowExecutionContext)
		{
			_userCallback = callback;
			_userState = state;
			_preAllocated = preAllocated;
			_nativeOverlapped = (flowExecutionContext ? Pack(s_completionCallback, pinData) : UnsafePack(s_completionCallback, pinData));
			_nativeOverlapped->OffsetLow = 0;
			_nativeOverlapped->OffsetHigh = 0;
		}

		private unsafe static void CompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* nativeOverlapped)
		{
			ThreadPoolBoundHandleOverlapped threadPoolBoundHandleOverlapped = (ThreadPoolBoundHandleOverlapped)Overlapped.Unpack(nativeOverlapped);
			if (threadPoolBoundHandleOverlapped._completed)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NativeOverlappedReused);
			}
			threadPoolBoundHandleOverlapped._completed = true;
			if (threadPoolBoundHandleOverlapped._boundHandle == null)
			{
				throw new InvalidOperationException(SR.Argument_NativeOverlappedAlreadyFree);
			}
			threadPoolBoundHandleOverlapped._userCallback(errorCode, numBytes, nativeOverlapped);
		}
	}
	public sealed class PreAllocatedOverlapped : IDisposable, IDeferredDisposable
	{
		internal readonly ThreadPoolBoundHandleOverlapped _overlapped;

		private DeferredDisposableLifetime<PreAllocatedOverlapped> _lifetime;

		[CLSCompliant(false)]
		public PreAllocatedOverlapped(IOCompletionCallback callback, object? state, object? pinData)
			: this(callback, state, pinData, flowExecutionContext: true)
		{
		}

		[CLSCompliant(false)]
		public static PreAllocatedOverlapped UnsafeCreate(IOCompletionCallback callback, object? state, object? pinData)
		{
			return new PreAllocatedOverlapped(callback, state, pinData, flowExecutionContext: false);
		}

		private PreAllocatedOverlapped(IOCompletionCallback callback, object state, object pinData, bool flowExecutionContext)
		{
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			_overlapped = new ThreadPoolBoundHandleOverlapped(callback, state, pinData, this, flowExecutionContext);
		}

		internal bool AddRef()
		{
			return _lifetime.AddRef();
		}

		internal void Release()
		{
			_lifetime.Release(this);
		}

		public void Dispose()
		{
			_lifetime.Dispose(this);
			GC.SuppressFinalize(this);
		}

		~PreAllocatedOverlapped()
		{
			Dispose();
		}

		unsafe void IDeferredDisposable.OnFinalRelease(bool disposed)
		{
			if (_overlapped != null)
			{
				if (disposed)
				{
					Overlapped.Free(_overlapped._nativeOverlapped);
					return;
				}
				_overlapped._boundHandle = null;
				_overlapped._completed = false;
				*_overlapped._nativeOverlapped = default(NativeOverlapped);
			}
		}

		internal bool IsUserObject(byte[] buffer)
		{
			return _overlapped.IsUserObject(buffer);
		}
	}
	public static class Interlocked
	{
		public static int Increment(ref int location)
		{
			return Add(ref location, 1);
		}

		public static long Increment(ref long location)
		{
			return Add(ref location, 1L);
		}

		public static int Decrement(ref int location)
		{
			return Add(ref location, -1);
		}

		public static long Decrement(ref long location)
		{
			return Add(ref location, -1L);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern int Exchange(ref int location1, int value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern long Exchange(ref long location1, long value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern float Exchange(ref float location1, float value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern double Exchange(ref double location1, double value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[return: NotNullIfNotNull("location1")]
		public static extern object? Exchange([NotNullIfNotNull("value")] ref object? location1, object? value);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[return: NotNullIfNotNull("location1")]
		public static T Exchange<T>([NotNullIfNotNull("value")] ref T location1, T value) where T : class?
		{
			return Unsafe.As<T>(Exchange(ref Unsafe.As<T, object>(ref location1), value));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern int CompareExchange(ref int location1, int value, int comparand);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern long CompareExchange(ref long location1, long value, long comparand);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern float CompareExchange(ref float location1, float value, float comparand);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern double CompareExchange(ref double location1, double value, double comparand);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[return: NotNullIfNotNull("location1")]
		public static extern object? CompareExchange(ref object? location1, object? value, object? comparand);

		[Intrinsic]
		[return: NotNullIfNotNull("location1")]
		public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class?
		{
			return Unsafe.As<T>(CompareExchange(ref Unsafe.As<T, object>(ref location1), value, comparand));
		}

		public static int Add(ref int location1, int value)
		{
			return ExchangeAdd(ref location1, value) + value;
		}

		public static long Add(ref long location1, long value)
		{
			return ExchangeAdd(ref location1, value) + value;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		private static extern int ExchangeAdd(ref int location1, int value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern long ExchangeAdd(ref long location1, long value);

		public static long Read(ref long location)
		{
			return CompareExchange(ref location, 0L, 0L);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern void MemoryBarrier();

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		internal static extern void ReadMemoryBarrier();

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void _MemoryBarrierProcessWide();

		public static void MemoryBarrierProcessWide()
		{
			_MemoryBarrierProcessWide();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint Increment(ref uint location)
		{
			return Add(ref location, 1u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong Increment(ref ulong location)
		{
			return Add(ref location, 1uL);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint Decrement(ref uint location)
		{
			return (uint)Add(ref Unsafe.As<uint, int>(ref location), -1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong Decrement(ref ulong location)
		{
			return (ulong)Add(ref Unsafe.As<ulong, long>(ref location), -1L);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint Exchange(ref uint location1, uint value)
		{
			return (uint)Exchange(ref Unsafe.As<uint, int>(ref location1), (int)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong Exchange(ref ulong location1, ulong value)
		{
			return (ulong)Exchange(ref Unsafe.As<ulong, long>(ref location1), (long)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static IntPtr Exchange(ref IntPtr location1, IntPtr value)
		{
			return (IntPtr)Exchange(ref Unsafe.As<IntPtr, int>(ref location1), (int)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint CompareExchange(ref uint location1, uint value, uint comparand)
		{
			return (uint)CompareExchange(ref Unsafe.As<uint, int>(ref location1), (int)value, (int)comparand);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong CompareExchange(ref ulong location1, ulong value, ulong comparand)
		{
			return (ulong)CompareExchange(ref Unsafe.As<ulong, long>(ref location1), (long)value, (long)comparand);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static IntPtr CompareExchange(ref IntPtr location1, IntPtr value, IntPtr comparand)
		{
			return (IntPtr)CompareExchange(ref Unsafe.As<IntPtr, int>(ref location1), (int)value, (int)comparand);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint Add(ref uint location1, uint value)
		{
			return (uint)Add(ref Unsafe.As<uint, int>(ref location1), (int)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong Add(ref ulong location1, ulong value)
		{
			return (ulong)Add(ref Unsafe.As<ulong, long>(ref location1), (long)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong Read(ref ulong location)
		{
			return CompareExchange(ref location, 0uL, 0uL);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static int And(ref int location1, int value)
		{
			int num = location1;
			int num2;
			while (true)
			{
				int value2 = num & value;
				num2 = CompareExchange(ref location1, value2, num);
				if (num2 == num)
				{
					break;
				}
				num = num2;
			}
			return num2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint And(ref uint location1, uint value)
		{
			return (uint)And(ref Unsafe.As<uint, int>(ref location1), (int)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static long And(ref long location1, long value)
		{
			long num = location1;
			long num2;
			while (true)
			{
				long value2 = num & value;
				num2 = CompareExchange(ref location1, value2, num);
				if (num2 == num)
				{
					break;
				}
				num = num2;
			}
			return num2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong And(ref ulong location1, ulong value)
		{
			return (ulong)And(ref Unsafe.As<ulong, long>(ref location1), (long)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static int Or(ref int location1, int value)
		{
			int num = location1;
			int num2;
			while (true)
			{
				int value2 = num | value;
				num2 = CompareExchange(ref location1, value2, num);
				if (num2 == num)
				{
					break;
				}
				num = num2;
			}
			return num2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint Or(ref uint location1, uint value)
		{
			return (uint)Or(ref Unsafe.As<uint, int>(ref location1), (int)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static long Or(ref long location1, long value)
		{
			long num = location1;
			long num2;
			while (true)
			{
				long value2 = num | value;
				num2 = CompareExchange(ref location1, value2, num);
				if (num2 == num)
				{
					break;
				}
				num = num2;
			}
			return num2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong Or(ref ulong location1, ulong value)
		{
			return (ulong)Or(ref Unsafe.As<ulong, long>(ref location1), (long)value);
		}
	}
	public static class Monitor
	{
		public static long LockContentionCount => GetLockContentionCount();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern void Enter(object obj);

		public static void Enter(object obj, ref bool lockTaken)
		{
			if (lockTaken)
			{
				ThrowLockTakenException();
			}
			ReliableEnter(obj, ref lockTaken);
		}

		[DoesNotReturn]
		private static void ThrowLockTakenException()
		{
			throw new ArgumentException(SR.Argument_MustBeFalse, "lockTaken");
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void ReliableEnter(object obj, ref bool lockTaken);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern void Exit(object obj);

		public static bool TryEnter(object obj)
		{
			bool lockTaken = false;
			TryEnter(obj, 0, ref lockTaken);
			return lockTaken;
		}

		public static void TryEnter(object obj, ref bool lockTaken)
		{
			if (lockTaken)
			{
				ThrowLockTakenException();
			}
			ReliableEnterTimeout(obj, 0, ref lockTaken);
		}

		public static bool TryEnter(object obj, int millisecondsTimeout)
		{
			bool lockTaken = false;
			TryEnter(obj, millisecondsTimeout, ref lockTaken);
			return lockTaken;
		}

		public static void TryEnter(object obj, int millisecondsTimeout, ref bool lockTaken)
		{
			if (lockTaken)
			{
				ThrowLockTakenException();
			}
			ReliableEnterTimeout(obj, millisecondsTimeout, ref lockTaken);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void ReliableEnterTimeout(object obj, int timeout, ref bool lockTaken);

		public static bool IsEntered(object obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			return IsEnteredNative(obj);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool IsEnteredNative(object obj);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool ObjWait(int millisecondsTimeout, object obj);

		[UnsupportedOSPlatform("browser")]
		public static bool Wait(object obj, int millisecondsTimeout)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			return ObjWait(millisecondsTimeout, obj);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void ObjPulse(object obj);

		public static void Pulse(object obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			ObjPulse(obj);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void ObjPulseAll(object obj);

		public static void PulseAll(object obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			ObjPulseAll(obj);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern long GetLockContentionCount();

		public static bool TryEnter(object obj, TimeSpan timeout)
		{
			return TryEnter(obj, WaitHandle.ToTimeoutMilliseconds(timeout));
		}

		public static void TryEnter(object obj, TimeSpan timeout, ref bool lockTaken)
		{
			TryEnter(obj, WaitHandle.ToTimeoutMilliseconds(timeout), ref lockTaken);
		}

		[UnsupportedOSPlatform("browser")]
		public static bool Wait(object obj, TimeSpan timeout)
		{
			return Wait(obj, WaitHandle.ToTimeoutMilliseconds(timeout));
		}

		[UnsupportedOSPlatform("browser")]
		public static bool Wait(object obj)
		{
			return Wait(obj, -1);
		}

		[UnsupportedOSPlatform("browser")]
		public static bool Wait(object obj, int millisecondsTimeout, bool exitContext)
		{
			return Wait(obj, millisecondsTimeout);
		}

		[UnsupportedOSPlatform("browser")]
		public static bool Wait(object obj, TimeSpan timeout, bool exitContext)
		{
			return Wait(obj, WaitHandle.ToTimeoutMilliseconds(timeout));
		}
	}
	internal class _IOCompletionCallback
	{
		private readonly IOCompletionCallback _ioCompletionCallback;

		private readonly ExecutionContext _executionContext;

		private uint _errorCode;

		private uint _numBytes;

		private unsafe NativeOverlapped* _pNativeOverlapped;

		internal static ContextCallback _ccb = IOCompletionCallback_Context;

		internal _IOCompletionCallback(IOCompletionCallback ioCompletionCallback, ExecutionContext executionContext)
		{
			_ioCompletionCallback = ioCompletionCallback;
			_executionContext = executionContext;
		}

		internal unsafe static void IOCompletionCallback_Context(object state)
		{
			_IOCompletionCallback iOCompletionCallback = (_IOCompletionCallback)state;
			iOCompletionCallback._ioCompletionCallback(iOCompletionCallback._errorCode, iOCompletionCallback._numBytes, iOCompletionCallback._pNativeOverlapped);
		}

		internal unsafe static void PerformIOCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* pNativeOverlapped)
		{
			do
			{
				OverlappedData overlappedFromNative = OverlappedData.GetOverlappedFromNative(pNativeOverlapped);
				if (overlappedFromNative._callback is IOCompletionCallback iOCompletionCallback)
				{
					iOCompletionCallback(errorCode, numBytes, pNativeOverlapped);
				}
				else
				{
					_IOCompletionCallback iOCompletionCallback2 = (_IOCompletionCallback)overlappedFromNative._callback;
					iOCompletionCallback2._errorCode = errorCode;
					iOCompletionCallback2._numBytes = numBytes;
					iOCompletionCallback2._pNativeOverlapped = pNativeOverlapped;
					ExecutionContext.RunInternal(iOCompletionCallback2._executionContext, _ccb, iOCompletionCallback2);
				}
				OverlappedData.CheckVMForIOPacket(out pNativeOverlapped, out errorCode, out numBytes);
			}
			while (pNativeOverlapped != null);
		}
	}
	internal sealed class OverlappedData
	{
		internal IAsyncResult _asyncResult;

		internal object _callback;

		internal readonly Overlapped _overlapped;

		private object _userObject;

		private unsafe readonly NativeOverlapped* _pNativeOverlapped;

		private IntPtr _eventHandle;

		private int _offsetLow;

		private int _offsetHigh;

		internal unsafe ref int OffsetLow
		{
			get
			{
				if (_pNativeOverlapped == null)
				{
					return ref _offsetLow;
				}
				return ref _pNativeOverlapped->OffsetLow;
			}
		}

		internal unsafe ref int OffsetHigh
		{
			get
			{
				if (_pNativeOverlapped == null)
				{
					return ref _offsetHigh;
				}
				return ref _pNativeOverlapped->OffsetHigh;
			}
		}

		internal unsafe ref IntPtr EventHandle
		{
			get
			{
				if (_pNativeOverlapped == null)
				{
					return ref _eventHandle;
				}
				return ref _pNativeOverlapped->EventHandle;
			}
		}

		internal OverlappedData(Overlapped overlapped)
		{
			_overlapped = overlapped;
		}

		internal unsafe NativeOverlapped* Pack(IOCompletionCallback iocb, object userData)
		{
			if (_pNativeOverlapped != null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_Overlapped_Pack);
			}
			if (iocb != null)
			{
				ExecutionContext executionContext = ExecutionContext.Capture();
				_callback = ((executionContext != null && !executionContext.IsDefault) ? ((object)new _IOCompletionCallback(iocb, executionContext)) : ((object)iocb));
			}
			else
			{
				_callback = null;
			}
			_userObject = userData;
			return AllocateNativeOverlapped();
		}

		internal unsafe NativeOverlapped* UnsafePack(IOCompletionCallback iocb, object userData)
		{
			if (_pNativeOverlapped != null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_Overlapped_Pack);
			}
			_userObject = userData;
			_callback = iocb;
			return AllocateNativeOverlapped();
		}

		internal bool IsUserObject(byte[] buffer)
		{
			return _userObject == buffer;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe extern NativeOverlapped* AllocateNativeOverlapped();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern void FreeNativeOverlapped(NativeOverlapped* nativeOverlappedPtr);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern OverlappedData GetOverlappedFromNative(NativeOverlapped* nativeOverlappedPtr);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern void CheckVMForIOPacket(out NativeOverlapped* pNativeOverlapped, out uint errorCode, out uint numBytes);
	}
	public class Overlapped
	{
		private OverlappedData _overlappedData;

		public IAsyncResult? AsyncResult
		{
			get
			{
				return _overlappedData._asyncResult;
			}
			set
			{
				_overlappedData._asyncResult = value;
			}
		}

		public int OffsetLow
		{
			get
			{
				return _overlappedData.OffsetLow;
			}
			set
			{
				_overlappedData.OffsetLow = value;
			}
		}

		public int OffsetHigh
		{
			get
			{
				return _overlappedData.OffsetHigh;
			}
			set
			{
				_overlappedData.OffsetHigh = value;
			}
		}

		[Obsolete("Overlapped.EventHandle is not 64-bit compatible and has been deprecated. Use EventHandleIntPtr instead.")]
		public int EventHandle
		{
			get
			{
				return EventHandleIntPtr.ToInt32();
			}
			set
			{
				EventHandleIntPtr = new IntPtr(value);
			}
		}

		public IntPtr EventHandleIntPtr
		{
			get
			{
				return _overlappedData.EventHandle;
			}
			set
			{
				_overlappedData.EventHandle = value;
			}
		}

		public Overlapped()
		{
			_overlappedData = new OverlappedData(this);
		}

		public Overlapped(int offsetLo, int offsetHi, IntPtr hEvent, IAsyncResult? ar)
			: this()
		{
			_overlappedData.OffsetLow = offsetLo;
			_overlappedData.OffsetHigh = offsetHi;
			_overlappedData.EventHandle = hEvent;
			_overlappedData._asyncResult = ar;
		}

		[Obsolete("This constructor is not 64-bit compatible and has been deprecated. Use the constructor that accepts an IntPtr for the event handle instead.")]
		public Overlapped(int offsetLo, int offsetHi, int hEvent, IAsyncResult? ar)
			: this(offsetLo, offsetHi, new IntPtr(hEvent), ar)
		{
		}

		[Obsolete("This overload is not safe and has been deprecated. Use Pack(IOCompletionCallback?, object?) instead.")]
		[CLSCompliant(false)]
		public unsafe NativeOverlapped* Pack(IOCompletionCallback? iocb)
		{
			return Pack(iocb, null);
		}

		[CLSCompliant(false)]
		public unsafe NativeOverlapped* Pack(IOCompletionCallback? iocb, object? userData)
		{
			return _overlappedData.Pack(iocb, userData);
		}

		[Obsolete("This overload is not safe and has been deprecated. Use UnsafePack(IOCompletionCallback?, object?) instead.")]
		[CLSCompliant(false)]
		public unsafe NativeOverlapped* UnsafePack(IOCompletionCallback? iocb)
		{
			return UnsafePack(iocb, null);
		}

		[CLSCompliant(false)]
		public unsafe NativeOverlapped* UnsafePack(IOCompletionCallback? iocb, object? userData)
		{
			return _overlappedData.UnsafePack(iocb, userData);
		}

		[CLSCompliant(false)]
		public unsafe static Overlapped Unpack(NativeOverlapped* nativeOverlappedPtr)
		{
			if (nativeOverlappedPtr == null)
			{
				throw new ArgumentNullException("nativeOverlappedPtr");
			}
			return OverlappedData.GetOverlappedFromNative(nativeOverlappedPtr)._overlapped;
		}

		[CLSCompliant(false)]
		public unsafe static void Free(NativeOverlapped* nativeOverlappedPtr)
		{
			if (nativeOverlappedPtr == null)
			{
				throw new ArgumentNullException("nativeOverlappedPtr");
			}
			OverlappedData.GetOverlappedFromNative(nativeOverlappedPtr)._overlapped._overlappedData = null;
			OverlappedData.FreeNativeOverlapped(nativeOverlappedPtr);
		}

		internal bool IsUserObject(byte[] buffer)
		{
			return _overlappedData.IsUserObject(buffer);
		}
	}
	public class SynchronizationContext
	{
		private bool _requireWaitNotification;

		public static SynchronizationContext? Current => Thread.CurrentThread._synchronizationContext;

		private static int InvokeWaitMethodHelper(SynchronizationContext syncContext, IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout)
		{
			return syncContext.Wait(waitHandles, waitAll, millisecondsTimeout);
		}

		protected void SetWaitNotificationRequired()
		{
			_requireWaitNotification = true;
		}

		public bool IsWaitNotificationRequired()
		{
			return _requireWaitNotification;
		}

		public virtual void Send(SendOrPostCallback d, object? state)
		{
			d(state);
		}

		public virtual void Post(SendOrPostCallback d, object? state)
		{
			ThreadPool.QueueUserWorkItem(delegate((SendOrPostCallback d, object state) s)
			{
				s.d(s.state);
			}, (d, state), preferLocal: false);
		}

		public virtual void OperationStarted()
		{
		}

		public virtual void OperationCompleted()
		{
		}

		[CLSCompliant(false)]
		public virtual int Wait(IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout)
		{
			return WaitHelper(waitHandles, waitAll, millisecondsTimeout);
		}

		[CLSCompliant(false)]
		protected static int WaitHelper(IntPtr[] waitHandles, bool waitAll, int millisecondsTimeout)
		{
			if (waitHandles == null)
			{
				throw new ArgumentNullException("waitHandles");
			}
			return WaitHandle.WaitMultipleIgnoringSyncContext(waitHandles, waitAll, millisecondsTimeout);
		}

		public static void SetSynchronizationContext(SynchronizationContext? syncContext)
		{
			Thread.CurrentThread._synchronizationContext = syncContext;
		}

		public virtual SynchronizationContext CreateCopy()
		{
			return new SynchronizationContext();
		}
	}
	internal readonly struct ThreadHandle
	{
		private readonly IntPtr _ptr;

		internal ThreadHandle(IntPtr pThread)
		{
			_ptr = pThread;
		}
	}
	public sealed class Thread : CriticalFinalizerObject
	{
		private sealed class StartHelper
		{
			internal int _maxStackSize;

			internal Delegate _start;

			internal object _startArg;

			internal CultureInfo _culture;

			internal CultureInfo _uiCulture;

			internal ExecutionContext _executionContext;

			internal static readonly ContextCallback s_threadStartContextCallback = Callback;

			internal StartHelper(Delegate start)
			{
				_start = start;
			}

			private static void Callback(object state)
			{
				((StartHelper)state).RunWorker();
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal void Run()
			{
				if (_executionContext != null && !_executionContext.IsDefault)
				{
					System.Threading.ExecutionContext.RunInternal(_executionContext, s_threadStartContextCallback, this);
				}
				else
				{
					RunWorker();
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private void RunWorker()
			{
				InitializeCulture();
				Delegate start = _start;
				_start = null;
				if (start is ThreadStart threadStart)
				{
					threadStart();
					return;
				}
				ParameterizedThreadStart parameterizedThreadStart = (ParameterizedThreadStart)start;
				object startArg = _startArg;
				_startArg = null;
				parameterizedThreadStart(startArg);
			}

			private void InitializeCulture()
			{
				if (_culture != null)
				{
					CultureInfo.CurrentCulture = _culture;
					_culture = null;
				}
				if (_uiCulture != null)
				{
					CultureInfo.CurrentUICulture = _uiCulture;
					_uiCulture = null;
				}
			}
		}

		private static class LocalDataStore
		{
			private static Dictionary<string, LocalDataStoreSlot> s_nameToSlotMap;

			public static LocalDataStoreSlot AllocateSlot()
			{
				return new LocalDataStoreSlot(new ThreadLocal<object>());
			}

			private static Dictionary<string, LocalDataStoreSlot> EnsureNameToSlotMap()
			{
				Dictionary<string, LocalDataStoreSlot> dictionary = s_nameToSlotMap;
				if (dictionary != null)
				{
					return dictionary;
				}
				dictionary = new Dictionary<string, LocalDataStoreSlot>();
				return Interlocked.CompareExchange(ref s_nameToSlotMap, dictionary, null) ?? dictionary;
			}

			public static LocalDataStoreSlot AllocateNamedSlot(string name)
			{
				LocalDataStoreSlot localDataStoreSlot = AllocateSlot();
				Dictionary<string, LocalDataStoreSlot> dictionary = EnsureNameToSlotMap();
				lock (dictionary)
				{
					dictionary.Add(name, localDataStoreSlot);
					return localDataStoreSlot;
				}
			}

			public static LocalDataStoreSlot GetNamedSlot(string name)
			{
				Dictionary<string, LocalDataStoreSlot> dictionary = EnsureNameToSlotMap();
				lock (dictionary)
				{
					if (!dictionary.TryGetValue(name, out var value))
					{
						value = (dictionary[name] = AllocateSlot());
					}
					return value;
				}
			}

			public static void FreeNamedSlot(string name)
			{
				Dictionary<string, LocalDataStoreSlot> dictionary = EnsureNameToSlotMap();
				lock (dictionary)
				{
					dictionary.Remove(name);
				}
			}

			private static ThreadLocal<object> GetThreadLocal(LocalDataStoreSlot slot)
			{
				if (slot == null)
				{
					throw new ArgumentNullException("slot");
				}
				return slot.Data;
			}

			public static object GetData(LocalDataStoreSlot slot)
			{
				return GetThreadLocal(slot).Value;
			}

			public static void SetData(LocalDataStoreSlot slot, object value)
			{
				GetThreadLocal(slot).Value = value;
			}
		}

		internal ExecutionContext _executionContext;

		internal SynchronizationContext _synchronizationContext;

		private string _name;

		private StartHelper _startHelper;

		private IntPtr _DONT_USE_InternalThread;

		private int _priority;

		private int _managedThreadId;

		private bool _mayNeedResetForThreadPool;

		private static readonly bool s_isProcessorNumberReallyFast = ProcessorIdCache.ProcessorNumberSpeedCheck();

		private static AsyncLocal<IPrincipal> s_asyncLocalPrincipal;

		[ThreadStatic]
		private static Thread t_currentThread;

		public extern int ManagedThreadId
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[Intrinsic]
			get;
		}

		public extern bool IsAlive
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		public bool IsBackground
		{
			get
			{
				return IsBackgroundNative();
			}
			set
			{
				SetBackgroundNative(value);
				if (!value)
				{
					_mayNeedResetForThreadPool = true;
				}
			}
		}

		public extern bool IsThreadPoolThread
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
			[MethodImpl(MethodImplOptions.InternalCall)]
			internal set;
		}

		public ThreadPriority Priority
		{
			get
			{
				return (ThreadPriority)GetPriorityNative();
			}
			set
			{
				SetPriorityNative((int)value);
				if (value != ThreadPriority.Normal)
				{
					_mayNeedResetForThreadPool = true;
				}
			}
		}

		public ThreadState ThreadState => (ThreadState)GetThreadStateNative();

		internal static extern int OptimalMaxSpinWaitsPerSpinIteration
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			[CompilerGenerated]
			get;
		}

		[UnsupportedOSPlatformGuard("browser")]
		internal static bool IsThreadStartSupported => true;

		public CultureInfo CurrentCulture
		{
			get
			{
				RequireCurrentThread();
				return CultureInfo.CurrentCulture;
			}
			set
			{
				if (this != CurrentThread)
				{
					SetCultureOnUnstartedThread(value, uiCulture: false);
				}
				else
				{
					CultureInfo.CurrentCulture = value;
				}
			}
		}

		public CultureInfo CurrentUICulture
		{
			get
			{
				RequireCurrentThread();
				return CultureInfo.CurrentUICulture;
			}
			set
			{
				if (this != CurrentThread)
				{
					SetCultureOnUnstartedThread(value, uiCulture: true);
				}
				else
				{
					CultureInfo.CurrentUICulture = value;
				}
			}
		}

		public static IPrincipal? CurrentPrincipal
		{
			get
			{
				IPrincipal principal = s_asyncLocalPrincipal?.Value;
				if (principal == null)
				{
					principal = (CurrentPrincipal = AppDomain.CurrentDomain.GetThreadPrincipal());
				}
				return principal;
			}
			set
			{
				if (s_asyncLocalPrincipal == null)
				{
					if (value == null)
					{
						return;
					}
					Interlocked.CompareExchange(ref s_asyncLocalPrincipal, new AsyncLocal<IPrincipal>(), null);
				}
				s_asyncLocalPrincipal.Value = value;
			}
		}

		public static Thread CurrentThread
		{
			[Intrinsic]
			get
			{
				return t_currentThread ?? InitializeCurrentThread();
			}
		}

		internal static ulong CurrentOSThreadId => GetCurrentOSThreadId();

		public ExecutionContext? ExecutionContext => System.Threading.ExecutionContext.Capture();

		public string? Name
		{
			get
			{
				return _name;
			}
			set
			{
				lock (this)
				{
					if (_name != value)
					{
						_name = value;
						ThreadNameChanged(value);
						_mayNeedResetForThreadPool = true;
					}
				}
			}
		}

		[Obsolete("The ApartmentState property has been deprecated. Use GetApartmentState, SetApartmentState or TrySetApartmentState.")]
		public ApartmentState ApartmentState
		{
			get
			{
				return GetApartmentState();
			}
			set
			{
				TrySetApartmentState(value);
			}
		}

		private Thread()
		{
		}

		internal ThreadHandle GetNativeHandle()
		{
			IntPtr dONT_USE_InternalThread = _DONT_USE_InternalThread;
			if (dONT_USE_InternalThread == IntPtr.Zero)
			{
				throw new ArgumentException(null, SR.Argument_InvalidHandle);
			}
			return new ThreadHandle(dONT_USE_InternalThread);
		}

		private unsafe void StartCore()
		{
			lock (this)
			{
				fixed (char* pThreadName = _name)
				{
					StartInternal(GetNativeHandle(), _startHelper?._maxStackSize ?? 0, _priority, pThreadName);
				}
			}
		}

		[DllImport("QCall")]
		private unsafe static extern void StartInternal(ThreadHandle t, int stackSize, int priority, char* pThreadName);

		private void StartCallback()
		{
			StartHelper startHelper = _startHelper;
			_startHelper = null;
			startHelper.Run();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr InternalGetCurrentThread();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void SleepInternal(int millisecondsTimeout);

		[DllImport("QCall")]
		internal static extern void UninterruptibleSleep0();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void SpinWaitInternal(int iterations);

		public static void SpinWait(int iterations)
		{
			SpinWaitInternal(iterations);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern Interop.BOOL YieldInternal();

		public static bool Yield()
		{
			return YieldInternal() != Interop.BOOL.FALSE;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Thread InitializeCurrentThread()
		{
			return t_currentThread = GetCurrentThreadNative();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern Thread GetCurrentThreadNative();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void Initialize();

		~Thread()
		{
			InternalFinalize();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void InternalFinalize();

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void InformThreadNameChange(ThreadHandle t, string name, int len);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern bool IsBackgroundNative();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetBackgroundNative(bool isBackground);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern int GetPriorityNative();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern void SetPriorityNative(int priority);

		[DllImport("QCall")]
		private static extern ulong GetCurrentOSThreadId();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern int GetThreadStateNative();

		public ApartmentState GetApartmentState()
		{
			return (ApartmentState)GetApartmentStateNative();
		}

		private bool SetApartmentStateUnchecked(ApartmentState state, bool throwOnError)
		{
			ApartmentState apartmentState = (ApartmentState)SetApartmentStateNative((int)state);
			if (state == ApartmentState.Unknown && apartmentState == ApartmentState.MTA)
			{
				return true;
			}
			if (apartmentState != state)
			{
				if (throwOnError)
				{
					string message = SR.Format(SR.Thread_ApartmentState_ChangeFailed, apartmentState);
					throw new InvalidOperationException(message);
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern int GetApartmentStateNative();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern int SetApartmentStateNative(int state);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void DisableComObjectEagerCleanup();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern void Interrupt();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public extern bool Join(int millisecondsTimeout);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetCurrentProcessorNumber();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetCurrentProcessorId()
		{
			if (s_isProcessorNumberReallyFast)
			{
				return GetCurrentProcessorNumber();
			}
			return ProcessorIdCache.GetCurrentProcessorId();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ResetThreadPoolThread()
		{
			if (ThreadPool.UsePortableThreadPool && _mayNeedResetForThreadPool)
			{
				ResetThreadPoolThreadSlow();
			}
		}

		public Thread(ThreadStart start)
		{
			if (start == null)
			{
				throw new ArgumentNullException("start");
			}
			_startHelper = new StartHelper(start);
			Initialize();
		}

		public Thread(ThreadStart start, int maxStackSize)
		{
			if (start == null)
			{
				throw new ArgumentNullException("start");
			}
			if (maxStackSize < 0)
			{
				throw new ArgumentOutOfRangeException("maxStackSize", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_startHelper = new StartHelper(start)
			{
				_maxStackSize = maxStackSize
			};
			Initialize();
		}

		public Thread(ParameterizedThreadStart start)
		{
			if (start == null)
			{
				throw new ArgumentNullException("start");
			}
			_startHelper = new StartHelper(start);
			Initialize();
		}

		public Thread(ParameterizedThreadStart start, int maxStackSize)
		{
			if (start == null)
			{
				throw new ArgumentNullException("start");
			}
			if (maxStackSize < 0)
			{
				throw new ArgumentOutOfRangeException("maxStackSize", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_startHelper = new StartHelper(start)
			{
				_maxStackSize = maxStackSize
			};
			Initialize();
		}

		[UnsupportedOSPlatform("browser")]
		public void Start(object? parameter)
		{
			Start(parameter, captureContext: true);
		}

		[UnsupportedOSPlatform("browser")]
		public void UnsafeStart(object? parameter)
		{
			Start(parameter, captureContext: false);
		}

		private void Start(object parameter, bool captureContext)
		{
			StartHelper startHelper = _startHelper;
			if (startHelper != null)
			{
				if (startHelper._start is ThreadStart)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ThreadWrongThreadStart);
				}
				startHelper._startArg = parameter;
				startHelper._executionContext = (captureContext ? System.Threading.ExecutionContext.Capture() : null);
			}
			StartCore();
		}

		[UnsupportedOSPlatform("browser")]
		public void Start()
		{
			Start(captureContext: true);
		}

		[UnsupportedOSPlatform("browser")]
		public void UnsafeStart()
		{
			Start(captureContext: false);
		}

		private void Start(bool captureContext)
		{
			StartHelper startHelper = _startHelper;
			if (startHelper != null)
			{
				startHelper._startArg = null;
				startHelper._executionContext = (captureContext ? System.Threading.ExecutionContext.Capture() : null);
			}
			StartCore();
		}

		private void RequireCurrentThread()
		{
			if (this != CurrentThread)
			{
				throw new InvalidOperationException(SR.Thread_Operation_RequiresCurrentThread);
			}
		}

		private void SetCultureOnUnstartedThread(CultureInfo value, bool uiCulture)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			StartHelper startHelper = _startHelper;
			if ((ThreadState & ThreadState.Unstarted) == 0)
			{
				throw new InvalidOperationException(SR.Thread_Operation_RequiresCurrentThread);
			}
			if (uiCulture)
			{
				startHelper._uiCulture = value;
			}
			else
			{
				startHelper._culture = value;
			}
		}

		private void ThreadNameChanged(string value)
		{
			InformThreadNameChange(GetNativeHandle(), value, value?.Length ?? 0);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void Sleep(int millisecondsTimeout)
		{
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", millisecondsTimeout, SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			SleepInternal(millisecondsTimeout);
		}

		internal void SetThreadPoolWorkerThreadName()
		{
			lock (this)
			{
				_name = ".NET ThreadPool Worker";
				ThreadNameChanged(".NET ThreadPool Worker");
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void ResetThreadPoolThreadSlow()
		{
			_mayNeedResetForThreadPool = false;
			if (_name != ".NET ThreadPool Worker")
			{
				SetThreadPoolWorkerThreadName();
			}
			if (!IsBackground)
			{
				IsBackground = true;
			}
			if (Priority != ThreadPriority.Normal)
			{
				Priority = ThreadPriority.Normal;
			}
		}

		[Obsolete("Thread.Abort is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0006", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public void Abort()
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadAbort);
		}

		[Obsolete("Thread.Abort is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0006", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public void Abort(object? stateInfo)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadAbort);
		}

		[Obsolete("Thread.Abort is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0006", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static void ResetAbort()
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadAbort);
		}

		[Obsolete("Thread.Suspend has been deprecated. Use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources.")]
		public void Suspend()
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadSuspend);
		}

		[Obsolete("Thread.Resume has been deprecated. Use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources.")]
		public void Resume()
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadSuspend);
		}

		public static void BeginCriticalRegion()
		{
		}

		public static void EndCriticalRegion()
		{
		}

		public static void BeginThreadAffinity()
		{
		}

		public static void EndThreadAffinity()
		{
		}

		public static LocalDataStoreSlot AllocateDataSlot()
		{
			return LocalDataStore.AllocateSlot();
		}

		public static LocalDataStoreSlot AllocateNamedDataSlot(string name)
		{
			return LocalDataStore.AllocateNamedSlot(name);
		}

		public static LocalDataStoreSlot GetNamedDataSlot(string name)
		{
			return LocalDataStore.GetNamedSlot(name);
		}

		public static void FreeNamedDataSlot(string name)
		{
			LocalDataStore.FreeNamedSlot(name);
		}

		public static object? GetData(LocalDataStoreSlot slot)
		{
			return LocalDataStore.GetData(slot);
		}

		public static void SetData(LocalDataStoreSlot slot, object? data)
		{
			LocalDataStore.SetData(slot, data);
		}

		[SupportedOSPlatform("windows")]
		public void SetApartmentState(ApartmentState state)
		{
			SetApartmentState(state, throwOnError: true);
		}

		public bool TrySetApartmentState(ApartmentState state)
		{
			return SetApartmentState(state, throwOnError: false);
		}

		private bool SetApartmentState(ApartmentState state, bool throwOnError)
		{
			if ((uint)state > 2u)
			{
				throw new ArgumentOutOfRangeException("state", SR.ArgumentOutOfRange_Enum);
			}
			return SetApartmentStateUnchecked(state, throwOnError);
		}

		[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public CompressedStack GetCompressedStack()
		{
			throw new InvalidOperationException(SR.Thread_GetSetCompressedStack_NotSupported);
		}

		[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public void SetCompressedStack(CompressedStack stack)
		{
			throw new InvalidOperationException(SR.Thread_GetSetCompressedStack_NotSupported);
		}

		public static AppDomain GetDomain()
		{
			return AppDomain.CurrentDomain;
		}

		public static int GetDomainID()
		{
			return 1;
		}

		public override int GetHashCode()
		{
			return ManagedThreadId;
		}

		public void Join()
		{
			Join(-1);
		}

		public bool Join(TimeSpan timeout)
		{
			return Join(WaitHandle.ToTimeoutMilliseconds(timeout));
		}

		public static void MemoryBarrier()
		{
			Interlocked.MemoryBarrier();
		}

		public static void Sleep(TimeSpan timeout)
		{
			Sleep(WaitHandle.ToTimeoutMilliseconds(timeout));
		}

		public static byte VolatileRead(ref byte address)
		{
			return Volatile.Read(ref address);
		}

		public static double VolatileRead(ref double address)
		{
			return Volatile.Read(ref address);
		}

		public static short VolatileRead(ref short address)
		{
			return Volatile.Read(ref address);
		}

		public static int VolatileRead(ref int address)
		{
			return Volatile.Read(ref address);
		}

		public static long VolatileRead(ref long address)
		{
			return Volatile.Read(ref address);
		}

		public static IntPtr VolatileRead(ref IntPtr address)
		{
			return Volatile.Read(ref address);
		}

		[return: NotNullIfNotNull("address")]
		public static object? VolatileRead([NotNullIfNotNull("address")] ref object? address)
		{
			return Volatile.Read(ref address);
		}

		[CLSCompliant(false)]
		public static sbyte VolatileRead(ref sbyte address)
		{
			return Volatile.Read(ref address);
		}

		public static float VolatileRead(ref float address)
		{
			return Volatile.Read(ref address);
		}

		[CLSCompliant(false)]
		public static ushort VolatileRead(ref ushort address)
		{
			return Volatile.Read(ref address);
		}

		[CLSCompliant(false)]
		public static uint VolatileRead(ref uint address)
		{
			return Volatile.Read(ref address);
		}

		[CLSCompliant(false)]
		public static ulong VolatileRead(ref ulong address)
		{
			return Volatile.Read(ref address);
		}

		[CLSCompliant(false)]
		public static UIntPtr VolatileRead(ref UIntPtr address)
		{
			return Volatile.Read(ref address);
		}

		public static void VolatileWrite(ref byte address, byte value)
		{
			Volatile.Write(ref address, value);
		}

		public static void VolatileWrite(ref double address, double value)
		{
			Volatile.Write(ref address, value);
		}

		public static void VolatileWrite(ref short address, short value)
		{
			Volatile.Write(ref address, value);
		}

		public static void VolatileWrite(ref int address, int value)
		{
			Volatile.Write(ref address, value);
		}

		public static void VolatileWrite(ref long address, long value)
		{
			Volatile.Write(ref address, value);
		}

		public static void VolatileWrite(ref IntPtr address, IntPtr value)
		{
			Volatile.Write(ref address, value);
		}

		public static void VolatileWrite([NotNullIfNotNull("value")] ref object? address, object? value)
		{
			Volatile.Write(ref address, value);
		}

		[CLSCompliant(false)]
		public static void VolatileWrite(ref sbyte address, sbyte value)
		{
			Volatile.Write(ref address, value);
		}

		public static void VolatileWrite(ref float address, float value)
		{
			Volatile.Write(ref address, value);
		}

		[CLSCompliant(false)]
		public static void VolatileWrite(ref ushort address, ushort value)
		{
			Volatile.Write(ref address, value);
		}

		[CLSCompliant(false)]
		public static void VolatileWrite(ref uint address, uint value)
		{
			Volatile.Write(ref address, value);
		}

		[CLSCompliant(false)]
		public static void VolatileWrite(ref ulong address, ulong value)
		{
			Volatile.Write(ref address, value);
		}

		[CLSCompliant(false)]
		public static void VolatileWrite(ref UIntPtr address, UIntPtr value)
		{
			Volatile.Write(ref address, value);
		}
	}
	internal static class ProcessorIdCache
	{
		[ThreadStatic]
		private static int t_currentProcessorIdCache;

		private static int s_processorIdRefreshRate;

		private static int RefreshCurrentProcessorId()
		{
			int num = Thread.GetCurrentProcessorNumber();
			if (num < 0)
			{
				num = Environment.CurrentManagedThreadId;
			}
			t_currentProcessorIdCache = ((num << 16) & 0x7FFFFFFF) | s_processorIdRefreshRate;
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetCurrentProcessorId()
		{
			int num = t_currentProcessorIdCache--;
			if ((num & 0xFFFF) == 0)
			{
				return RefreshCurrentProcessorId();
			}
			return num >> 16;
		}

		internal static bool ProcessorNumberSpeedCheck()
		{
			double num = double.MaxValue;
			double num2 = double.MaxValue;
			UninlinedThreadStatic();
			if (Thread.GetCurrentProcessorNumber() < 0)
			{
				s_processorIdRefreshRate = 65535;
				return false;
			}
			long num3 = Stopwatch.Frequency / 1000000 + 1;
			for (int i = 0; i < 10; i++)
			{
				int num4 = 8;
				long timestamp;
				do
				{
					num4 *= 2;
					timestamp = Stopwatch.GetTimestamp();
					for (int j = 0; j < num4; j++)
					{
						Thread.GetCurrentProcessorNumber();
					}
					timestamp = Stopwatch.GetTimestamp() - timestamp;
				}
				while (timestamp < num3);
				num = Math.Min(num, (double)timestamp / (double)num4);
				num4 /= 4;
				do
				{
					num4 *= 2;
					timestamp = Stopwatch.GetTimestamp();
					for (int k = 0; k < num4; k++)
					{
						UninlinedThreadStatic();
					}
					timestamp = Stopwatch.GetTimestamp() - timestamp;
				}
				while (timestamp < num3);
				num2 = Math.Min(num2, (double)timestamp / (double)num4);
			}
			s_processorIdRefreshRate = Math.Min((int)(num * 5.0 / num2), 5000);
			return s_processorIdRefreshRate <= 5;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static int UninlinedThreadStatic()
		{
			return t_currentProcessorIdCache;
		}
	}
	internal static class _ThreadPoolWaitCallback
	{
		internal static bool PerformWaitCallback()
		{
			return ThreadPoolWorkQueue.Dispatch();
		}
	}
	[UnsupportedOSPlatform("browser")]
	public sealed class RegisteredWaitHandle : MarshalByRefObject
	{
		private IntPtr _nativeRegisteredWaitHandle = InvalidHandleValue;

		private bool _releaseHandle;

		private static AutoResetEvent s_cachedEvent;

		private static readonly LowLevelLock s_callbackLock = new LowLevelLock();

		private int _numRequestedCallbacks;

		private bool _signalAfterCallbacksComplete;

		private bool _unregisterCalled;

		private bool _unregistered;

		private AutoResetEvent _callbacksComplete;

		private AutoResetEvent _removed;

		internal _ThreadPoolWaitOrTimerCallback Callback { get; }

		internal SafeWaitHandle Handle { get; }

		internal int TimeoutTimeMs { get; private set; }

		internal int TimeoutDurationMs { get; }

		internal bool IsInfiniteTimeout => TimeoutDurationMs == -1;

		internal bool Repeating { get; }

		private SafeWaitHandle? UserUnregisterWaitHandle { get; set; }

		private IntPtr UserUnregisterWaitHandleValue { get; set; }

		private static IntPtr InvalidHandleValue => new IntPtr(-1);

		internal bool IsBlocking => UserUnregisterWaitHandleValue == InvalidHandleValue;

		internal PortableThreadPool.WaitThread? WaitThread { get; set; }

		private static bool IsValidHandle(IntPtr handle)
		{
			if (handle != InvalidHandleValue)
			{
				return handle != IntPtr.Zero;
			}
			return false;
		}

		internal void SetNativeRegisteredWaitHandle(IntPtr nativeRegisteredWaitHandle)
		{
			_nativeRegisteredWaitHandle = nativeRegisteredWaitHandle;
		}

		internal void OnBeforeRegister()
		{
			if (ThreadPool.UsePortableThreadPool)
			{
				GC.SuppressFinalize(this);
			}
			else
			{
				Handle.DangerousAddRef(ref _releaseHandle);
			}
		}

		public bool Unregister(WaitHandle waitObject)
		{
			if (ThreadPool.UsePortableThreadPool)
			{
				return UnregisterPortable(waitObject);
			}
			s_callbackLock.Acquire();
			try
			{
				if (!IsValidHandle(_nativeRegisteredWaitHandle) || !UnregisterWaitNative(_nativeRegisteredWaitHandle, waitObject?.SafeWaitHandle))
				{
					return false;
				}
				_nativeRegisteredWaitHandle = InvalidHandleValue;
				if (_releaseHandle)
				{
					Handle.DangerousRelease();
					_releaseHandle = false;
				}
			}
			finally
			{
				s_callbackLock.Release();
			}
			GC.SuppressFinalize(this);
			return true;
		}

		~RegisteredWaitHandle()
		{
			if (ThreadPool.UsePortableThreadPool)
			{
				return;
			}
			s_callbackLock.Acquire();
			try
			{
				if (IsValidHandle(_nativeRegisteredWaitHandle))
				{
					WaitHandleCleanupNative(_nativeRegisteredWaitHandle);
					_nativeRegisteredWaitHandle = InvalidHandleValue;
					if (_releaseHandle)
					{
						Handle.DangerousRelease();
						_releaseHandle = false;
					}
				}
			}
			finally
			{
				s_callbackLock.Release();
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void WaitHandleCleanupNative(IntPtr handle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool UnregisterWaitNative(IntPtr handle, SafeHandle waitObject);

		internal RegisteredWaitHandle(WaitHandle waitHandle, _ThreadPoolWaitOrTimerCallback callbackHelper, int millisecondsTimeout, bool repeating)
		{
			Handle = waitHandle.SafeWaitHandle;
			Callback = callbackHelper;
			TimeoutDurationMs = millisecondsTimeout;
			Repeating = repeating;
			if (!IsInfiniteTimeout)
			{
				RestartTimeout();
			}
		}

		private static AutoResetEvent RentEvent()
		{
			return Interlocked.Exchange(ref s_cachedEvent, null) ?? new AutoResetEvent(initialState: false);
		}

		private static void ReturnEvent(AutoResetEvent resetEvent)
		{
			if (Interlocked.CompareExchange(ref s_cachedEvent, resetEvent, null) != null)
			{
				resetEvent.Dispose();
			}
		}

		internal void RestartTimeout()
		{
			TimeoutTimeMs = Environment.TickCount + TimeoutDurationMs;
		}

		private bool UnregisterPortable(WaitHandle waitObject)
		{
			s_callbackLock.Acquire();
			bool success = false;
			try
			{
				if (_unregisterCalled)
				{
					return false;
				}
				UserUnregisterWaitHandle = waitObject?.SafeWaitHandle;
				UserUnregisterWaitHandle?.DangerousAddRef(ref success);
				UserUnregisterWaitHandleValue = UserUnregisterWaitHandle?.DangerousGetHandle() ?? IntPtr.Zero;
				if (_unregistered)
				{
					SignalUserWaitHandle();
					return true;
				}
				if (IsBlocking)
				{
					_callbacksComplete = RentEvent();
				}
				else
				{
					_removed = RentEvent();
				}
			}
			catch (Exception)
			{
				if (_removed != null)
				{
					ReturnEvent(_removed);
					_removed = null;
				}
				else if (_callbacksComplete != null)
				{
					ReturnEvent(_callbacksComplete);
					_callbacksComplete = null;
				}
				UserUnregisterWaitHandleValue = IntPtr.Zero;
				if (success)
				{
					UserUnregisterWaitHandle?.DangerousRelease();
				}
				UserUnregisterWaitHandle = null;
				throw;
			}
			finally
			{
				_unregisterCalled = true;
				s_callbackLock.Release();
			}
			WaitThread.UnregisterWait(this);
			return true;
		}

		private void SignalUserWaitHandle()
		{
			SafeWaitHandle userUnregisterWaitHandle = UserUnregisterWaitHandle;
			IntPtr userUnregisterWaitHandleValue = UserUnregisterWaitHandleValue;
			try
			{
				if (userUnregisterWaitHandleValue != IntPtr.Zero && userUnregisterWaitHandleValue != InvalidHandleValue)
				{
					EventWaitHandle.Set(userUnregisterWaitHandle);
				}
			}
			finally
			{
				userUnregisterWaitHandle?.DangerousRelease();
				_callbacksComplete?.Set();
				_unregistered = true;
			}
		}

		internal void PerformCallback(bool timedOut)
		{
			_ThreadPoolWaitOrTimerCallback.PerformWaitOrTimerCallback(Callback, timedOut);
			CompleteCallbackRequest();
		}

		internal void RequestCallback()
		{
			s_callbackLock.Acquire();
			try
			{
				_numRequestedCallbacks++;
			}
			finally
			{
				s_callbackLock.Release();
			}
		}

		internal void OnRemoveWait()
		{
			s_callbackLock.Acquire();
			try
			{
				_removed?.Set();
				if (_numRequestedCallbacks == 0)
				{
					SignalUserWaitHandle();
				}
				else
				{
					_signalAfterCallbacksComplete = true;
				}
			}
			finally
			{
				s_callbackLock.Release();
			}
		}

		private void CompleteCallbackRequest()
		{
			s_callbackLock.Acquire();
			try
			{
				_numRequestedCallbacks--;
				if (_numRequestedCallbacks == 0 && _signalAfterCallbacksComplete)
				{
					SignalUserWaitHandle();
				}
			}
			finally
			{
				s_callbackLock.Release();
			}
		}

		internal void WaitForCallbacks()
		{
			_callbacksComplete.WaitOne();
			ReturnEvent(_callbacksComplete);
			_callbacksComplete = null;
		}

		internal void WaitForRemoval()
		{
			_removed.WaitOne();
			ReturnEvent(_removed);
			_removed = null;
		}
	}
	internal sealed class CompleteWaitThreadPoolWorkItem : IThreadPoolWorkItem
	{
		private RegisteredWaitHandle _registeredWaitHandle;

		private bool _timedOut;

		void IThreadPoolWorkItem.Execute()
		{
			CompleteWait();
		}

		private void CompleteWait()
		{
			PortableThreadPool.CompleteWait(_registeredWaitHandle, _timedOut);
		}

		public CompleteWaitThreadPoolWorkItem(RegisteredWaitHandle registeredWaitHandle, bool timedOut)
		{
			_registeredWaitHandle = registeredWaitHandle;
			_timedOut = timedOut;
		}
	}
	internal sealed class UnmanagedThreadPoolWorkItem : IThreadPoolWorkItem
	{
		private readonly IntPtr _callback;

		private readonly IntPtr _state;

		public UnmanagedThreadPoolWorkItem(IntPtr callback, IntPtr state)
		{
			_callback = callback;
			_state = state;
		}

		void IThreadPoolWorkItem.Execute()
		{
			ExecuteUnmanagedThreadPoolWorkItem(_callback, _state);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void ExecuteUnmanagedThreadPoolWorkItem(IntPtr callback, IntPtr state);
	}
	public static class ThreadPool
	{
		internal static readonly bool UsePortableThreadPool = InitializeConfigAndDetermineUsePortableThreadPool();

		private static readonly bool IsWorkerTrackingEnabledInConfig = GetEnableWorkerTracking();

		internal static readonly ThreadPoolWorkQueue s_workQueue = new ThreadPoolWorkQueue();

		internal static readonly Action<object> s_invokeAsyncStateMachineBox = delegate(object state)
		{
			if (!(state is IAsyncStateMachineBox asyncStateMachineBox))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.state);
			}
			else
			{
				asyncStateMachineBox.MoveNext();
			}
		};

		internal static bool SupportsTimeSensitiveWorkItems => UsePortableThreadPool;

		public static int ThreadCount => (UsePortableThreadPool ? PortableThreadPool.ThreadPoolInstance.ThreadCount : 0) + GetThreadCount();

		public static long CompletedWorkItemCount
		{
			get
			{
				long num = GetCompletedWorkItemCount();
				if (UsePortableThreadPool)
				{
					num += PortableThreadPool.ThreadPoolInstance.CompletedWorkItemCount;
				}
				return num;
			}
		}

		private static long PendingUnmanagedWorkItemCount
		{
			get
			{
				if (!UsePortableThreadPool)
				{
					return GetPendingUnmanagedWorkItemCount();
				}
				return 0L;
			}
		}

		internal static bool EnableWorkerTracking
		{
			get
			{
				if (IsWorkerTrackingEnabledInConfig)
				{
					return EventSource.IsSupported;
				}
				return false;
			}
		}

		public static long PendingWorkItemCount
		{
			get
			{
				ThreadPoolWorkQueue threadPoolWorkQueue = s_workQueue;
				return ThreadPoolWorkQueue.LocalCount + threadPoolWorkQueue.GlobalCount + PendingUnmanagedWorkItemCount;
			}
		}

		private unsafe static bool InitializeConfigAndDetermineUsePortableThreadPool()
		{
			bool result = false;
			int configVariableIndex = 0;
			while (true)
			{
				uint configValue;
				bool isBoolean;
				char* appContextConfigName;
				int nextConfigUInt32Value = GetNextConfigUInt32Value(configVariableIndex, out configValue, out isBoolean, out appContextConfigName);
				if (nextConfigUInt32Value < 0)
				{
					break;
				}
				configVariableIndex = nextConfigUInt32Value;
				if (appContextConfigName == null)
				{
					result = true;
					continue;
				}
				string text = new string(appContextConfigName);
				if (isBoolean)
				{
					AppContext.SetSwitch(text, configValue != 0);
				}
				else
				{
					AppContext.SetData(text, configValue);
				}
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern int GetNextConfigUInt32Value(int configVariableIndex, out uint configValue, out bool isBoolean, out char* appContextConfigName);

		private static bool GetEnableWorkerTracking()
		{
			if (!UsePortableThreadPool)
			{
				return GetEnableWorkerTrackingNative();
			}
			return AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.EnableWorkerTracking", defaultValue: false);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool CanSetMinIOCompletionThreads(int ioCompletionThreads);

		internal static void SetMinIOCompletionThreads(int ioCompletionThreads)
		{
			bool flag = SetMinThreadsNative(1, ioCompletionThreads);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool CanSetMaxIOCompletionThreads(int ioCompletionThreads);

		internal static void SetMaxIOCompletionThreads(int ioCompletionThreads)
		{
			bool flag = SetMaxThreadsNative(1, ioCompletionThreads);
		}

		public static bool SetMaxThreads(int workerThreads, int completionPortThreads)
		{
			if (UsePortableThreadPool)
			{
				return PortableThreadPool.ThreadPoolInstance.SetMaxThreads(workerThreads, completionPortThreads);
			}
			if (workerThreads >= 0 && completionPortThreads >= 0)
			{
				return SetMaxThreadsNative(workerThreads, completionPortThreads);
			}
			return false;
		}

		public static void GetMaxThreads(out int workerThreads, out int completionPortThreads)
		{
			GetMaxThreadsNative(out workerThreads, out completionPortThreads);
			if (UsePortableThreadPool)
			{
				workerThreads = PortableThreadPool.ThreadPoolInstance.GetMaxThreads();
			}
		}

		public static bool SetMinThreads(int workerThreads, int completionPortThreads)
		{
			if (UsePortableThreadPool)
			{
				return PortableThreadPool.ThreadPoolInstance.SetMinThreads(workerThreads, completionPortThreads);
			}
			if (workerThreads >= 0 && completionPortThreads >= 0)
			{
				return SetMinThreadsNative(workerThreads, completionPortThreads);
			}
			return false;
		}

		public static void GetMinThreads(out int workerThreads, out int completionPortThreads)
		{
			GetMinThreadsNative(out workerThreads, out completionPortThreads);
			if (UsePortableThreadPool)
			{
				workerThreads = PortableThreadPool.ThreadPoolInstance.GetMinThreads();
			}
		}

		public static void GetAvailableThreads(out int workerThreads, out int completionPortThreads)
		{
			GetAvailableThreadsNative(out workerThreads, out completionPortThreads);
			if (UsePortableThreadPool)
			{
				workerThreads = PortableThreadPool.ThreadPoolInstance.GetAvailableThreads();
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int GetThreadCount();

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern long GetCompletedWorkItemCount();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern long GetPendingUnmanagedWorkItemCount();

		private static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce, bool flowExecutionContext)
		{
			if (waitObject == null)
			{
				throw new ArgumentNullException("waitObject");
			}
			if (callBack == null)
			{
				throw new ArgumentNullException("callBack");
			}
			RegisteredWaitHandle registeredWaitHandle = new RegisteredWaitHandle(waitObject, new _ThreadPoolWaitOrTimerCallback(callBack, state, flowExecutionContext), (int)millisecondsTimeOutInterval, !executeOnlyOnce);
			registeredWaitHandle.OnBeforeRegister();
			if (UsePortableThreadPool)
			{
				PortableThreadPool.ThreadPoolInstance.RegisterWaitHandle(registeredWaitHandle);
			}
			else
			{
				IntPtr nativeRegisteredWaitHandle = RegisterWaitForSingleObjectNative(waitObject, registeredWaitHandle.Callback, (uint)registeredWaitHandle.TimeoutDurationMs, !registeredWaitHandle.Repeating, registeredWaitHandle);
				registeredWaitHandle.SetNativeRegisteredWaitHandle(nativeRegisteredWaitHandle);
			}
			return registeredWaitHandle;
		}

		internal static void UnsafeQueueWaitCompletion(CompleteWaitThreadPoolWorkItem completeWaitWorkItem)
		{
			QueueWaitCompletionNative(completeWaitWorkItem);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void QueueWaitCompletionNative(CompleteWaitThreadPoolWorkItem completeWaitWorkItem);

		internal static void RequestWorkerThread()
		{
			if (UsePortableThreadPool)
			{
				PortableThreadPool.ThreadPoolInstance.RequestWorker();
			}
			else
			{
				RequestWorkerThreadNative();
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern Interop.BOOL RequestWorkerThreadNative();

		private static void EnsureGateThreadRunning()
		{
			PortableThreadPool.EnsureGateThreadRunning();
		}

		internal static bool PerformRuntimeSpecificGateActivities(int cpuUtilization)
		{
			return PerformRuntimeSpecificGateActivitiesNative(cpuUtilization) != Interop.BOOL.FALSE;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern Interop.BOOL PerformRuntimeSpecificGateActivitiesNative(int cpuUtilization);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern bool PostQueuedCompletionStatus(NativeOverlapped* overlapped);

		[CLSCompliant(false)]
		[SupportedOSPlatform("windows")]
		public unsafe static bool UnsafeQueueNativeOverlapped(NativeOverlapped* overlapped)
		{
			return PostQueuedCompletionStatus(overlapped);
		}

		private static void UnsafeQueueUnmanagedWorkItem(IntPtr callback, IntPtr state)
		{
			UnsafeQueueTimeSensitiveWorkItemInternal(new UnmanagedThreadPoolWorkItem(callback, state));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool SetMinThreadsNative(int workerThreads, int completionPortThreads);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool SetMaxThreadsNative(int workerThreads, int completionPortThreads);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetMinThreadsNative(out int workerThreads, out int completionPortThreads);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetMaxThreadsNative(out int workerThreads, out int completionPortThreads);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetAvailableThreadsNative(out int workerThreads, out int completionPortThreads);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool NotifyWorkItemComplete(object threadLocalCompletionCountObject, int currentTimeMs)
		{
			if (UsePortableThreadPool)
			{
				return PortableThreadPool.ThreadPoolInstance.NotifyWorkItemComplete(threadLocalCompletionCountObject, currentTimeMs);
			}
			return NotifyWorkItemCompleteNative();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool NotifyWorkItemCompleteNative();

		internal static void ReportThreadStatus(bool isWorking)
		{
			if (UsePortableThreadPool)
			{
				PortableThreadPool.ThreadPoolInstance.ReportThreadStatus(isWorking);
			}
			else
			{
				ReportThreadStatusNative(isWorking);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void ReportThreadStatusNative(bool isWorking);

		internal static void NotifyWorkItemProgress()
		{
			if (UsePortableThreadPool)
			{
				PortableThreadPool.ThreadPoolInstance.NotifyWorkItemProgress();
			}
			else
			{
				NotifyWorkItemProgressNative();
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void NotifyWorkItemProgressNative();

		internal static bool NotifyThreadBlocked()
		{
			if (UsePortableThreadPool)
			{
				return PortableThreadPool.ThreadPoolInstance.NotifyThreadBlocked();
			}
			return false;
		}

		internal static void NotifyThreadUnblocked()
		{
			PortableThreadPool.ThreadPoolInstance.NotifyThreadUnblocked();
		}

		internal static object GetOrCreateThreadLocalCompletionCountObject()
		{
			if (!UsePortableThreadPool)
			{
				return null;
			}
			return PortableThreadPool.ThreadPoolInstance.GetOrCreateThreadLocalCompletionCountObject();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool GetEnableWorkerTrackingNative();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr RegisterWaitForSingleObjectNative(WaitHandle waitHandle, object state, uint timeOutInterval, bool executeOnlyOnce, RegisteredWaitHandle registeredWaitHandle);

		[Obsolete("ThreadPool.BindHandle(IntPtr) has been deprecated. Use ThreadPool.BindHandle(SafeHandle) instead.")]
		[SupportedOSPlatform("windows")]
		public static bool BindHandle(IntPtr osHandle)
		{
			return BindIOCompletionCallbackNative(osHandle);
		}

		[SupportedOSPlatform("windows")]
		public static bool BindHandle(SafeHandle osHandle)
		{
			if (osHandle == null)
			{
				throw new ArgumentNullException("osHandle");
			}
			bool flag = false;
			bool success = false;
			try
			{
				osHandle.DangerousAddRef(ref success);
				return BindIOCompletionCallbackNative(osHandle.DangerousGetHandle());
			}
			finally
			{
				if (success)
				{
					osHandle.DangerousRelease();
				}
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool BindIOCompletionCallbackNative(IntPtr fileHandle);

		[CLSCompliant(false)]
		[UnsupportedOSPlatform("browser")]
		public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object? state, uint millisecondsTimeOutInterval, bool executeOnlyOnce)
		{
			if (millisecondsTimeOutInterval > int.MaxValue && millisecondsTimeOutInterval != uint.MaxValue)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
			}
			return RegisterWaitForSingleObject(waitObject, callBack, state, millisecondsTimeOutInterval, executeOnlyOnce, flowExecutionContext: true);
		}

		[CLSCompliant(false)]
		[UnsupportedOSPlatform("browser")]
		public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object? state, uint millisecondsTimeOutInterval, bool executeOnlyOnce)
		{
			if (millisecondsTimeOutInterval > int.MaxValue && millisecondsTimeOutInterval != uint.MaxValue)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			return RegisterWaitForSingleObject(waitObject, callBack, state, millisecondsTimeOutInterval, executeOnlyOnce, flowExecutionContext: false);
		}

		[UnsupportedOSPlatform("browser")]
		public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object? state, int millisecondsTimeOutInterval, bool executeOnlyOnce)
		{
			if (millisecondsTimeOutInterval < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, flowExecutionContext: true);
		}

		[UnsupportedOSPlatform("browser")]
		public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object? state, int millisecondsTimeOutInterval, bool executeOnlyOnce)
		{
			if (millisecondsTimeOutInterval < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, flowExecutionContext: false);
		}

		[UnsupportedOSPlatform("browser")]
		public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object? state, long millisecondsTimeOutInterval, bool executeOnlyOnce)
		{
			if (millisecondsTimeOutInterval < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (millisecondsTimeOutInterval > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
			}
			return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, flowExecutionContext: true);
		}

		[UnsupportedOSPlatform("browser")]
		public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object? state, long millisecondsTimeOutInterval, bool executeOnlyOnce)
		{
			if (millisecondsTimeOutInterval < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (millisecondsTimeOutInterval > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeOutInterval", SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
			}
			return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, flowExecutionContext: false);
		}

		[UnsupportedOSPlatform("browser")]
		public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object? state, TimeSpan timeout, bool executeOnlyOnce)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1)
			{
				throw new ArgumentOutOfRangeException("timeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout", SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
			}
			return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)num, executeOnlyOnce, flowExecutionContext: true);
		}

		[UnsupportedOSPlatform("browser")]
		public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object? state, TimeSpan timeout, bool executeOnlyOnce)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1)
			{
				throw new ArgumentOutOfRangeException("timeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout", SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
			}
			return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)num, executeOnlyOnce, flowExecutionContext: false);
		}

		public static bool QueueUserWorkItem(WaitCallback callBack)
		{
			return QueueUserWorkItem(callBack, null);
		}

		public static bool QueueUserWorkItem(WaitCallback callBack, object? state)
		{
			if (callBack == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.callBack);
			}
			ExecutionContext executionContext = ExecutionContext.Capture();
			object callback = ((executionContext == null || executionContext.IsDefault) ? ((QueueUserWorkItemCallbackBase)new QueueUserWorkItemCallbackDefaultContext(callBack, state)) : ((QueueUserWorkItemCallbackBase)new QueueUserWorkItemCallback(callBack, state, executionContext)));
			s_workQueue.Enqueue(callback, forceGlobal: true);
			return true;
		}

		public static bool QueueUserWorkItem<TState>(Action<TState> callBack, TState state, bool preferLocal)
		{
			if (callBack == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.callBack);
			}
			ExecutionContext executionContext = ExecutionContext.Capture();
			object callback = ((executionContext == null || executionContext.IsDefault) ? ((QueueUserWorkItemCallbackBase)new QueueUserWorkItemCallbackDefaultContext<TState>(callBack, state)) : ((QueueUserWorkItemCallbackBase)new QueueUserWorkItemCallback<TState>(callBack, state, executionContext)));
			s_workQueue.Enqueue(callback, !preferLocal);
			return true;
		}

		public static bool UnsafeQueueUserWorkItem<TState>(Action<TState> callBack, TState state, bool preferLocal)
		{
			if (callBack == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.callBack);
			}
			if ((object)callBack == s_invokeAsyncStateMachineBox)
			{
				if (!(state is IAsyncStateMachineBox))
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.state);
				}
				UnsafeQueueUserWorkItemInternal(state, preferLocal);
				return true;
			}
			s_workQueue.Enqueue(new QueueUserWorkItemCallbackDefaultContext<TState>(callBack, state), !preferLocal);
			return true;
		}

		public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object? state)
		{
			if (callBack == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.callBack);
			}
			object callback = new QueueUserWorkItemCallbackDefaultContext(callBack, state);
			s_workQueue.Enqueue(callback, forceGlobal: true);
			return true;
		}

		public static bool UnsafeQueueUserWorkItem(IThreadPoolWorkItem callBack, bool preferLocal)
		{
			if (callBack == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.callBack);
			}
			if (callBack is Task)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.callBack);
			}
			UnsafeQueueUserWorkItemInternal(callBack, preferLocal);
			return true;
		}

		internal static void UnsafeQueueUserWorkItemInternal(object callBack, bool preferLocal)
		{
			s_workQueue.Enqueue(callBack, !preferLocal);
		}

		internal static void UnsafeQueueTimeSensitiveWorkItemInternal(IThreadPoolWorkItem timeSensitiveWorkItem)
		{
			s_workQueue.EnqueueTimeSensitiveWorkItem(timeSensitiveWorkItem);
		}

		internal static bool TryPopCustomWorkItem(object workItem)
		{
			return ThreadPoolWorkQueue.LocalFindAndPop(workItem);
		}

		internal static IEnumerable<object> GetQueuedWorkItems()
		{
			if (SupportsTimeSensitiveWorkItems)
			{
				foreach (IThreadPoolWorkItem item in s_workQueue.timeSensitiveWorkQueue)
				{
					yield return item;
				}
			}
			foreach (object workItem in s_workQueue.workItems)
			{
				yield return workItem;
			}
			ThreadPoolWorkQueue.WorkStealingQueue[] queues = ThreadPoolWorkQueue.WorkStealingQueueList.Queues;
			foreach (ThreadPoolWorkQueue.WorkStealingQueue workStealingQueue in queues)
			{
				if (workStealingQueue == null || workStealingQueue.m_array == null)
				{
					continue;
				}
				object[] items = workStealingQueue.m_array;
				foreach (object obj in items)
				{
					if (obj != null)
					{
						yield return obj;
					}
				}
			}
		}

		internal static IEnumerable<object> GetLocallyQueuedWorkItems()
		{
			ThreadPoolWorkQueue.WorkStealingQueue workStealingQueue = ThreadPoolWorkQueueThreadLocals.threadLocals?.workStealingQueue;
			if (workStealingQueue == null || workStealingQueue.m_array == null)
			{
				yield break;
			}
			object[] items = workStealingQueue.m_array;
			foreach (object obj in items)
			{
				if (obj != null)
				{
					yield return obj;
				}
			}
		}

		internal static IEnumerable<object> GetGloballyQueuedWorkItems()
		{
			if (SupportsTimeSensitiveWorkItems)
			{
				foreach (IThreadPoolWorkItem item in s_workQueue.timeSensitiveWorkQueue)
				{
					yield return item;
				}
			}
			foreach (object workItem in s_workQueue.workItems)
			{
				yield return workItem;
			}
		}

		private static object[] ToObjectArray(IEnumerable<object> workitems)
		{
			int num = 0;
			foreach (object workitem in workitems)
			{
				num++;
			}
			object[] array = new object[num];
			num = 0;
			foreach (object workitem2 in workitems)
			{
				if (num < array.Length)
				{
					array[num] = workitem2;
				}
				num++;
			}
			return array;
		}

		internal static object[] GetQueuedWorkItemsForDebugger()
		{
			return ToObjectArray(GetQueuedWorkItems());
		}

		internal static object[] GetGloballyQueuedWorkItemsForDebugger()
		{
			return ToObjectArray(GetGloballyQueuedWorkItems());
		}

		internal static object[] GetLocallyQueuedWorkItemsForDebugger()
		{
			return ToObjectArray(GetLocallyQueuedWorkItems());
		}
	}
	[DebuggerDisplay("Count = {CountForDebugger}")]
	[DebuggerTypeProxy(typeof(TimerQueueDebuggerTypeProxy))]
	internal sealed class TimerQueue
	{
		private sealed class AppDomainTimerSafeHandle : SafeHandleZeroOrMinusOneIsInvalid
		{
			public AppDomainTimerSafeHandle()
				: base(ownsHandle: true)
			{
			}

			protected override bool ReleaseHandle()
			{
				return DeleteAppDomainTimer(handle);
			}
		}

		private sealed class TimerQueueDebuggerTypeProxy
		{
			private readonly TimerQueue _queue;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public TimerQueueTimer[] Items => new List<TimerQueueTimer>(_queue.GetTimersForDebugger()).ToArray();

			public TimerQueueDebuggerTypeProxy(TimerQueue queue)
			{
				_queue = queue ?? throw new ArgumentNullException("queue");
			}
		}

		private readonly int _id;

		private AppDomainTimerSafeHandle m_appDomainTimer;

		internal static readonly (long TickCount, DateTime Time) s_tickCountToTimeMap = (TickCount64, DateTime.UtcNow);

		private bool _isTimerScheduled;

		private long _currentTimerStartTicks;

		private uint _currentTimerDuration;

		private TimerQueueTimer _shortTimers;

		private TimerQueueTimer _longTimers;

		private long _currentAbsoluteThreshold = TickCount64 + 333;

		public static TimerQueue[] Instances { get; } = CreateTimerQueues();


		private int CountForDebugger
		{
			get
			{
				int num = 0;
				foreach (TimerQueueTimer item in GetTimersForDebugger())
				{
					num++;
				}
				return num;
			}
		}

		public long ActiveCount { get; private set; }

		private static long TickCount64
		{
			get
			{
				if (Environment.IsWindows8OrAbove)
				{
					ulong UnbiasedTime;
					bool flag = Interop.Kernel32.QueryUnbiasedInterruptTime(out UnbiasedTime);
					return (long)(UnbiasedTime / 10000);
				}
				return Environment.TickCount64;
			}
		}

		private TimerQueue(int id)
		{
			_id = id;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool SetTimer(uint actualDuration)
		{
			if (m_appDomainTimer == null || m_appDomainTimer.IsInvalid)
			{
				m_appDomainTimer = CreateAppDomainTimer(actualDuration, _id);
				return !m_appDomainTimer.IsInvalid;
			}
			return ChangeAppDomainTimer(m_appDomainTimer, actualDuration);
		}

		internal static void AppDomainTimerCallback(int id)
		{
			Instances[id].FireNextTimers();
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern AppDomainTimerSafeHandle CreateAppDomainTimer(uint dueTime, int id);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern bool ChangeAppDomainTimer(AppDomainTimerSafeHandle handle, uint dueTime);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern bool DeleteAppDomainTimer(IntPtr handle);

		private static TimerQueue[] CreateTimerQueues()
		{
			TimerQueue[] array = new TimerQueue[Environment.ProcessorCount];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new TimerQueue(i);
			}
			return array;
		}

		internal IEnumerable<TimerQueueTimer> GetTimersForDebugger()
		{
			for (TimerQueueTimer timer2 = _shortTimers; timer2 != null; timer2 = timer2._next)
			{
				yield return timer2;
			}
			for (TimerQueueTimer timer2 = _longTimers; timer2 != null; timer2 = timer2._next)
			{
				yield return timer2;
			}
		}

		private bool EnsureTimerFiresBy(uint requestedDuration)
		{
			uint num = Math.Min(requestedDuration, 268435455u);
			if (_isTimerScheduled)
			{
				long num2 = TickCount64 - _currentTimerStartTicks;
				if (num2 >= _currentTimerDuration)
				{
					return true;
				}
				uint num3 = _currentTimerDuration - (uint)(int)num2;
				if (num >= num3)
				{
					return true;
				}
			}
			if (SetTimer(num))
			{
				_isTimerScheduled = true;
				_currentTimerStartTicks = TickCount64;
				_currentTimerDuration = num;
				return true;
			}
			return false;
		}

		private void FireNextTimers()
		{
			TimerQueueTimer timerQueueTimer = null;
			lock (this)
			{
				_isTimerScheduled = false;
				bool flag = false;
				uint num = uint.MaxValue;
				long tickCount = TickCount64;
				TimerQueueTimer timerQueueTimer2 = _shortTimers;
				for (int i = 0; i < 2; i++)
				{
					while (timerQueueTimer2 != null)
					{
						TimerQueueTimer next = timerQueueTimer2._next;
						long num2 = tickCount - timerQueueTimer2._startTicks;
						long num3 = timerQueueTimer2._dueTime - num2;
						if (num3 <= 0)
						{
							timerQueueTimer2._everQueued = true;
							if (timerQueueTimer2._period != uint.MaxValue)
							{
								timerQueueTimer2._startTicks = tickCount;
								long num4 = num2 - timerQueueTimer2._dueTime;
								timerQueueTimer2._dueTime = ((num4 >= timerQueueTimer2._period) ? 1u : (timerQueueTimer2._period - (uint)(int)num4));
								if (timerQueueTimer2._dueTime < num)
								{
									flag = true;
									num = timerQueueTimer2._dueTime;
								}
								bool flag2 = tickCount + timerQueueTimer2._dueTime - _currentAbsoluteThreshold <= 0;
								if (timerQueueTimer2._short != flag2)
								{
									MoveTimerToCorrectList(timerQueueTimer2, flag2);
								}
							}
							else
							{
								DeleteTimer(timerQueueTimer2);
							}
							if (timerQueueTimer == null)
							{
								timerQueueTimer = timerQueueTimer2;
							}
							else
							{
								ThreadPool.UnsafeQueueUserWorkItemInternal(timerQueueTimer2, preferLocal: false);
							}
						}
						else
						{
							if (num3 < num)
							{
								flag = true;
								num = (uint)num3;
							}
							if (!timerQueueTimer2._short && num3 <= 333)
							{
								MoveTimerToCorrectList(timerQueueTimer2, shortList: true);
							}
						}
						timerQueueTimer2 = next;
					}
					if (i != 0)
					{
						continue;
					}
					long num5 = _currentAbsoluteThreshold - tickCount;
					if (num5 > 0)
					{
						if (_shortTimers == null && _longTimers != null)
						{
							num = (uint)((int)num5 + 1);
							flag = true;
						}
						break;
					}
					timerQueueTimer2 = _longTimers;
					_currentAbsoluteThreshold = tickCount + 333;
				}
				if (flag)
				{
					EnsureTimerFiresBy(num);
				}
			}
			timerQueueTimer?.Fire();
		}

		public bool UpdateTimer(TimerQueueTimer timer, uint dueTime, uint period)
		{
			long tickCount = TickCount64;
			long num = tickCount + dueTime;
			bool flag = _currentAbsoluteThreshold - num >= 0;
			if (timer._dueTime == uint.MaxValue)
			{
				timer._short = flag;
				LinkTimer(timer);
				long activeCount = ActiveCount + 1;
				ActiveCount = activeCount;
			}
			else if (timer._short != flag)
			{
				UnlinkTimer(timer);
				timer._short = flag;
				LinkTimer(timer);
			}
			timer._dueTime = dueTime;
			timer._period = ((period == 0) ? uint.MaxValue : period);
			timer._startTicks = tickCount;
			return EnsureTimerFiresBy(dueTime);
		}

		public void MoveTimerToCorrectList(TimerQueueTimer timer, bool shortList)
		{
			UnlinkTimer(timer);
			timer._short = shortList;
			LinkTimer(timer);
		}

		private void LinkTimer(TimerQueueTimer timer)
		{
			ref TimerQueueTimer reference = ref timer._short ? ref _shortTimers : ref _longTimers;
			timer._next = reference;
			if (timer._next != null)
			{
				timer._next._prev = timer;
			}
			timer._prev = null;
			reference = timer;
		}

		private void UnlinkTimer(TimerQueueTimer timer)
		{
			TimerQueueTimer next = timer._next;
			if (next != null)
			{
				next._prev = timer._prev;
			}
			if (_shortTimers == timer)
			{
				_shortTimers = next;
			}
			else if (_longTimers == timer)
			{
				_longTimers = next;
			}
			next = timer._prev;
			if (next != null)
			{
				next._next = timer._next;
			}
		}

		public void DeleteTimer(TimerQueueTimer timer)
		{
			if (timer._dueTime != uint.MaxValue)
			{
				long activeCount = ActiveCount - 1;
				ActiveCount = activeCount;
				UnlinkTimer(timer);
				timer._prev = null;
				timer._next = null;
				timer._dueTime = uint.MaxValue;
				timer._period = uint.MaxValue;
				timer._startTicks = 0L;
				timer._short = false;
			}
		}
	}
	public abstract class WaitHandle : MarshalByRefObject, IDisposable
	{
		internal const int MaxWaitHandles = 64;

		protected static readonly IntPtr InvalidHandle = new IntPtr(-1);

		private SafeWaitHandle _waitHandle;

		[ThreadStatic]
		private static SafeWaitHandle[] t_safeWaitHandlesForRent;

		internal const int WaitSuccess = 0;

		internal const int WaitAbandoned = 128;

		public const int WaitTimeout = 258;

		[Obsolete("WaitHandleHandle has been deprecated. Use the SafeWaitHandle property instead.")]
		public virtual IntPtr Handle
		{
			get
			{
				if (_waitHandle != null)
				{
					return _waitHandle.DangerousGetHandle();
				}
				return InvalidHandle;
			}
			set
			{
				if (value == InvalidHandle)
				{
					if (_waitHandle != null)
					{
						_waitHandle.SetHandleAsInvalid();
						_waitHandle = null;
					}
				}
				else
				{
					_waitHandle = new SafeWaitHandle(value, ownsHandle: true);
				}
			}
		}

		public SafeWaitHandle SafeWaitHandle
		{
			get
			{
				return _waitHandle ?? (_waitHandle = new SafeWaitHandle(InvalidHandle, ownsHandle: false));
			}
			[param: AllowNull]
			set
			{
				_waitHandle = value;
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int WaitOneCore(IntPtr waitHandle, int millisecondsTimeout);

		internal unsafe static int WaitMultipleIgnoringSyncContext(Span<IntPtr> waitHandles, bool waitAll, int millisecondsTimeout)
		{
			fixed (IntPtr* waitHandles2 = &MemoryMarshal.GetReference(waitHandles))
			{
				return WaitMultipleIgnoringSyncContext(waitHandles2, waitHandles.Length, waitAll, millisecondsTimeout);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern int WaitMultipleIgnoringSyncContext(IntPtr* waitHandles, int numHandles, bool waitAll, int millisecondsTimeout);

		private static int SignalAndWaitCore(IntPtr waitHandleToSignal, IntPtr waitHandleToWaitOn, int millisecondsTimeout)
		{
			int num = SignalAndWaitNative(waitHandleToSignal, waitHandleToWaitOn, millisecondsTimeout);
			if (num == 298)
			{
				throw new InvalidOperationException(SR.Threading_WaitHandleTooManyPosts);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern int SignalAndWaitNative(IntPtr waitHandleToSignal, IntPtr waitHandleToWaitOn, int millisecondsTimeout);

		internal static int ToTimeoutMilliseconds(TimeSpan timeout)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1)
			{
				throw new ArgumentOutOfRangeException("timeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout", SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
			}
			return (int)num;
		}

		public virtual void Close()
		{
			Dispose();
		}

		protected virtual void Dispose(bool explicitDisposing)
		{
			_waitHandle?.Close();
		}

		public void Dispose()
		{
			Dispose(explicitDisposing: true);
			GC.SuppressFinalize(this);
		}

		public virtual bool WaitOne(int millisecondsTimeout)
		{
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			return WaitOneNoCheck(millisecondsTimeout);
		}

		private bool WaitOneNoCheck(int millisecondsTimeout)
		{
			SafeWaitHandle safeWaitHandle = _waitHandle ?? throw new ObjectDisposedException(null, SR.ObjectDisposed_Generic);
			bool success = false;
			try
			{
				safeWaitHandle.DangerousAddRef(ref success);
				SynchronizationContext current = SynchronizationContext.Current;
				int num = ((current == null || !current.IsWaitNotificationRequired()) ? WaitOneCore(safeWaitHandle.DangerousGetHandle(), millisecondsTimeout) : current.Wait(new IntPtr[1] { safeWaitHandle.DangerousGetHandle() }, waitAll: false, millisecondsTimeout));
				if (num == 128)
				{
					throw new AbandonedMutexException();
				}
				return num != 258;
			}
			finally
			{
				if (success)
				{
					safeWaitHandle.DangerousRelease();
				}
			}
		}

		private static SafeWaitHandle[] RentSafeWaitHandleArray(int capacity)
		{
			SafeWaitHandle[] array = t_safeWaitHandlesForRent;
			t_safeWaitHandlesForRent = null;
			int num = ((array != null) ? array.Length : 0);
			if (num < capacity)
			{
				array = new SafeWaitHandle[Math.Max(capacity, Math.Min(64, 2 * num))];
			}
			return array;
		}

		private static void ReturnSafeWaitHandleArray(SafeWaitHandle[] safeWaitHandles)
		{
			t_safeWaitHandlesForRent = safeWaitHandles;
		}

		private static void ObtainSafeWaitHandles(ReadOnlySpan<WaitHandle> waitHandles, Span<SafeWaitHandle> safeWaitHandles, Span<IntPtr> unsafeWaitHandles)
		{
			bool success = true;
			SafeWaitHandle safeWaitHandle = null;
			try
			{
				for (int i = 0; i < waitHandles.Length; i++)
				{
					WaitHandle waitHandle = waitHandles[i];
					if (waitHandle == null)
					{
						throw new ArgumentNullException("waitHandles[" + i + "]", SR.ArgumentNull_ArrayElement);
					}
					SafeWaitHandle safeWaitHandle2 = waitHandle._waitHandle ?? throw new ObjectDisposedException(null, SR.ObjectDisposed_Generic);
					safeWaitHandle = safeWaitHandle2;
					success = false;
					safeWaitHandle2.DangerousAddRef(ref success);
					safeWaitHandles[i] = safeWaitHandle2;
					unsafeWaitHandles[i] = safeWaitHandle2.DangerousGetHandle();
				}
			}
			catch
			{
				for (int j = 0; j < waitHandles.Length; j++)
				{
					SafeWaitHandle safeWaitHandle3 = safeWaitHandles[j];
					if (safeWaitHandle3 == null)
					{
						break;
					}
					safeWaitHandle3.DangerousRelease();
					safeWaitHandles[j] = null;
					if (safeWaitHandle3 == safeWaitHandle)
					{
						safeWaitHandle = null;
						success = true;
					}
				}
				if (!success)
				{
					safeWaitHandle.DangerousRelease();
				}
				throw;
			}
		}

		private static int WaitMultiple(WaitHandle[] waitHandles, bool waitAll, int millisecondsTimeout)
		{
			if (waitHandles == null)
			{
				throw new ArgumentNullException("waitHandles", SR.ArgumentNull_Waithandles);
			}
			return WaitMultiple(new ReadOnlySpan<WaitHandle>(waitHandles), waitAll, millisecondsTimeout);
		}

		private static int WaitMultiple(ReadOnlySpan<WaitHandle> waitHandles, bool waitAll, int millisecondsTimeout)
		{
			if (waitHandles.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyWaithandleArray, "waitHandles");
			}
			if (waitHandles.Length > 64)
			{
				throw new NotSupportedException(SR.NotSupported_MaxWaitHandles);
			}
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			SynchronizationContext current = SynchronizationContext.Current;
			bool flag = current?.IsWaitNotificationRequired() ?? false;
			SafeWaitHandle[] array = RentSafeWaitHandleArray(waitHandles.Length);
			try
			{
				int num;
				if (flag)
				{
					IntPtr[] array2 = new IntPtr[waitHandles.Length];
					ObtainSafeWaitHandles(waitHandles, array, array2);
					num = current.Wait(array2, waitAll, millisecondsTimeout);
				}
				else
				{
					Span<IntPtr> span = stackalloc IntPtr[waitHandles.Length];
					ObtainSafeWaitHandles(waitHandles, array, span);
					num = WaitMultipleIgnoringSyncContext(span, waitAll, millisecondsTimeout);
				}
				if (num >= 128 && num < 128 + waitHandles.Length)
				{
					if (waitAll)
					{
						throw new AbandonedMutexException();
					}
					num -= 128;
					throw new AbandonedMutexException(num, waitHandles[num]);
				}
				return num;
			}
			finally
			{
				for (int i = 0; i < waitHandles.Length; i++)
				{
					SafeWaitHandle safeWaitHandle = array[i];
					if (safeWaitHandle != null)
					{
						safeWaitHandle.DangerousRelease();
						array[i] = null;
					}
				}
				ReturnSafeWaitHandleArray(array);
			}
		}

		private static int WaitAnyMultiple(ReadOnlySpan<SafeWaitHandle> safeWaitHandles, int millisecondsTimeout)
		{
			SynchronizationContext current = SynchronizationContext.Current;
			if (current != null && current.IsWaitNotificationRequired())
			{
				IntPtr[] array = new IntPtr[safeWaitHandles.Length];
				for (int i = 0; i < safeWaitHandles.Length; i++)
				{
					array[i] = safeWaitHandles[i].DangerousGetHandle();
				}
				return current.Wait(array, waitAll: false, millisecondsTimeout);
			}
			Span<IntPtr> waitHandles = stackalloc IntPtr[safeWaitHandles.Length];
			for (int j = 0; j < safeWaitHandles.Length; j++)
			{
				waitHandles[j] = safeWaitHandles[j].DangerousGetHandle();
			}
			return WaitMultipleIgnoringSyncContext(waitHandles, waitAll: false, millisecondsTimeout);
		}

		private static bool SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn, int millisecondsTimeout)
		{
			if (toSignal == null)
			{
				throw new ArgumentNullException("toSignal");
			}
			if (toWaitOn == null)
			{
				throw new ArgumentNullException("toWaitOn");
			}
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			SafeWaitHandle waitHandle = toSignal._waitHandle;
			SafeWaitHandle waitHandle2 = toWaitOn._waitHandle;
			if (waitHandle == null || waitHandle2 == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_Generic);
			}
			bool success = false;
			bool success2 = false;
			try
			{
				waitHandle.DangerousAddRef(ref success);
				waitHandle2.DangerousAddRef(ref success2);
				int num = SignalAndWaitCore(waitHandle.DangerousGetHandle(), waitHandle2.DangerousGetHandle(), millisecondsTimeout);
				if (num == 128)
				{
					throw new AbandonedMutexException();
				}
				return num != 258;
			}
			finally
			{
				if (success2)
				{
					waitHandle2.DangerousRelease();
				}
				if (success)
				{
					waitHandle.DangerousRelease();
				}
			}
		}

		public virtual bool WaitOne(TimeSpan timeout)
		{
			return WaitOneNoCheck(ToTimeoutMilliseconds(timeout));
		}

		public virtual bool WaitOne()
		{
			return WaitOneNoCheck(-1);
		}

		public virtual bool WaitOne(int millisecondsTimeout, bool exitContext)
		{
			return WaitOne(millisecondsTimeout);
		}

		public virtual bool WaitOne(TimeSpan timeout, bool exitContext)
		{
			return WaitOneNoCheck(ToTimeoutMilliseconds(timeout));
		}

		public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout)
		{
			return WaitMultiple(waitHandles, waitAll: true, millisecondsTimeout) != 258;
		}

		public static bool WaitAll(WaitHandle[] waitHandles, TimeSpan timeout)
		{
			return WaitMultiple(waitHandles, waitAll: true, ToTimeoutMilliseconds(timeout)) != 258;
		}

		public static bool WaitAll(WaitHandle[] waitHandles)
		{
			return WaitMultiple(waitHandles, waitAll: true, -1) != 258;
		}

		public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
		{
			return WaitMultiple(waitHandles, waitAll: true, millisecondsTimeout) != 258;
		}

		public static bool WaitAll(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext)
		{
			return WaitMultiple(waitHandles, waitAll: true, ToTimeoutMilliseconds(timeout)) != 258;
		}

		public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout)
		{
			return WaitMultiple(waitHandles, waitAll: false, millisecondsTimeout);
		}

		internal static int WaitAny(ReadOnlySpan<SafeWaitHandle> safeWaitHandles, int millisecondsTimeout)
		{
			return WaitAnyMultiple(safeWaitHandles, millisecondsTimeout);
		}

		public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout)
		{
			return WaitMultiple(waitHandles, waitAll: false, ToTimeoutMilliseconds(timeout));
		}

		public static int WaitAny(WaitHandle[] waitHandles)
		{
			return WaitMultiple(waitHandles, waitAll: false, -1);
		}

		public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext)
		{
			return WaitMultiple(waitHandles, waitAll: false, millisecondsTimeout);
		}

		public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext)
		{
			return WaitMultiple(waitHandles, waitAll: false, ToTimeoutMilliseconds(timeout));
		}

		public static bool SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn)
		{
			return SignalAndWait(toSignal, toWaitOn, -1);
		}

		public static bool SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn, TimeSpan timeout, bool exitContext)
		{
			return SignalAndWait(toSignal, toWaitOn, ToTimeoutMilliseconds(timeout));
		}

		public static bool SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn, int millisecondsTimeout, bool exitContext)
		{
			return SignalAndWait(toSignal, toWaitOn, millisecondsTimeout);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class AbandonedMutexException : SystemException
	{
		private int _mutexIndex = -1;

		private Mutex _mutex;

		public Mutex? Mutex => _mutex;

		public int MutexIndex => _mutexIndex;

		public AbandonedMutexException()
			: base(SR.Threading_AbandonedMutexException)
		{
			base.HResult = -2146233043;
		}

		public AbandonedMutexException(string? message)
			: base(message)
		{
			base.HResult = -2146233043;
		}

		public AbandonedMutexException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233043;
		}

		public AbandonedMutexException(int location, WaitHandle? handle)
			: base(SR.Threading_AbandonedMutexException)
		{
			base.HResult = -2146233043;
			SetupException(location, handle);
		}

		public AbandonedMutexException(string? message, int location, WaitHandle? handle)
			: base(message)
		{
			base.HResult = -2146233043;
			SetupException(location, handle);
		}

		public AbandonedMutexException(string? message, Exception? inner, int location, WaitHandle? handle)
			: base(message, inner)
		{
			base.HResult = -2146233043;
			SetupException(location, handle);
		}

		protected AbandonedMutexException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		private void SetupException(int location, WaitHandle handle)
		{
			_mutexIndex = location;
			_mutex = handle as Mutex;
		}
	}
	public enum ApartmentState
	{
		STA,
		MTA,
		Unknown
	}
	public sealed class AsyncLocal<T> : IAsyncLocal
	{
		private readonly Action<AsyncLocalValueChangedArgs<T>> m_valueChangedHandler;

		public T Value
		{
			[return: MaybeNull]
			get
			{
				object localValue = ExecutionContext.GetLocalValue(this);
				if (localValue != null)
				{
					return (T)localValue;
				}
				return default(T);
			}
			set
			{
				ExecutionContext.SetLocalValue(this, value, m_valueChangedHandler != null);
			}
		}

		public AsyncLocal()
		{
		}

		public AsyncLocal(Action<AsyncLocalValueChangedArgs<T>>? valueChangedHandler)
		{
			m_valueChangedHandler = valueChangedHandler;
		}

		void IAsyncLocal.OnValueChanged(object previousValueObj, object currentValueObj, bool contextChanged)
		{
			T previousValue = ((previousValueObj == null) ? default(T) : ((T)previousValueObj));
			T currentValue = ((currentValueObj == null) ? default(T) : ((T)currentValueObj));
			m_valueChangedHandler(new AsyncLocalValueChangedArgs<T>(previousValue, currentValue, contextChanged));
		}
	}
	internal interface IAsyncLocal
	{
		void OnValueChanged(object previousValue, object currentValue, bool contextChanged);
	}
	public readonly struct AsyncLocalValueChangedArgs<T>
	{
		public T? PreviousValue { get; }

		public T? CurrentValue { get; }

		public bool ThreadContextChanged { get; }

		internal AsyncLocalValueChangedArgs(T previousValue, T currentValue, bool contextChanged)
		{
			PreviousValue = previousValue;
			CurrentValue = currentValue;
			ThreadContextChanged = contextChanged;
		}
	}
	internal interface IAsyncLocalValueMap
	{
		bool TryGetValue(IAsyncLocal key, out object value);

		IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent);
	}
	internal static class AsyncLocalValueMap
	{
		private sealed class EmptyAsyncLocalValueMap : IAsyncLocalValueMap
		{
			public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent)
			{
				if (value == null && treatNullValueAsNonexistent)
				{
					return this;
				}
				return new OneElementAsyncLocalValueMap(key, value);
			}

			public bool TryGetValue(IAsyncLocal key, out object value)
			{
				value = null;
				return false;
			}
		}

		private sealed class OneElementAsyncLocalValueMap : IAsyncLocalValueMap
		{
			private readonly IAsyncLocal _key1;

			private readonly object _value1;

			public OneElementAsyncLocalValueMap(IAsyncLocal key, object value)
			{
				_key1 = key;
				_value1 = value;
			}

			public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent)
			{
				if (value != null || !treatNullValueAsNonexistent)
				{
					if (key != _key1)
					{
						return new TwoElementAsyncLocalValueMap(_key1, _value1, key, value);
					}
					return new OneElementAsyncLocalValueMap(key, value);
				}
				if (key != _key1)
				{
					return this;
				}
				return Empty;
			}

			public bool TryGetValue(IAsyncLocal key, out object value)
			{
				if (key == _key1)
				{
					value = _value1;
					return true;
				}
				value = null;
				return false;
			}
		}

		private sealed class TwoElementAsyncLocalValueMap : IAsyncLocalValueMap
		{
			private readonly IAsyncLocal _key1;

			private readonly IAsyncLocal _key2;

			private readonly object _value1;

			private readonly object _value2;

			public TwoElementAsyncLocalValueMap(IAsyncLocal key1, object value1, IAsyncLocal key2, object value2)
			{
				_key1 = key1;
				_value1 = value1;
				_key2 = key2;
				_value2 = value2;
			}

			public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent)
			{
				if (value != null || !treatNullValueAsNonexistent)
				{
					if (key != _key1)
					{
						if (key != _key2)
						{
							return new ThreeElementAsyncLocalValueMap(_key1, _value1, _key2, _value2, key, value);
						}
						return new TwoElementAsyncLocalValueMap(_key1, _value1, key, value);
					}
					return new TwoElementAsyncLocalValueMap(key, value, _key2, _value2);
				}
				if (key != _key1)
				{
					if (key != _key2)
					{
						return this;
					}
					return new OneElementAsyncLocalValueMap(_key1, _value1);
				}
				return new OneElementAsyncLocalValueMap(_key2, _value2);
			}

			public bool TryGetValue(IAsyncLocal key, out object value)
			{
				if (key == _key1)
				{
					value = _value1;
					return true;
				}
				if (key == _key2)
				{
					value = _value2;
					return true;
				}
				value = null;
				return false;
			}
		}

		private sealed class ThreeElementAsyncLocalValueMap : IAsyncLocalValueMap
		{
			private readonly IAsyncLocal _key1;

			private readonly IAsyncLocal _key2;

			private readonly IAsyncLocal _key3;

			private readonly object _value1;

			private readonly object _value2;

			private readonly object _value3;

			public ThreeElementAsyncLocalValueMap(IAsyncLocal key1, object value1, IAsyncLocal key2, object value2, IAsyncLocal key3, object value3)
			{
				_key1 = key1;
				_value1 = value1;
				_key2 = key2;
				_value2 = value2;
				_key3 = key3;
				_value3 = value3;
			}

			public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent)
			{
				if (value != null || !treatNullValueAsNonexistent)
				{
					if (key == _key1)
					{
						return new ThreeElementAsyncLocalValueMap(key, value, _key2, _value2, _key3, _value3);
					}
					if (key == _key2)
					{
						return new ThreeElementAsyncLocalValueMap(_key1, _value1, key, value, _key3, _value3);
					}
					if (key == _key3)
					{
						return new ThreeElementAsyncLocalValueMap(_key1, _value1, _key2, _value2, key, value);
					}
					MultiElementAsyncLocalValueMap multiElementAsyncLocalValueMap = new MultiElementAsyncLocalValueMap(4);
					multiElementAsyncLocalValueMap.UnsafeStore(0, _key1, _value1);
					multiElementAsyncLocalValueMap.UnsafeStore(1, _key2, _value2);
					multiElementAsyncLocalValueMap.UnsafeStore(2, _key3, _value3);
					multiElementAsyncLocalValueMap.UnsafeStore(3, key, value);
					return multiElementAsyncLocalValueMap;
				}
				if (key != _key1)
				{
					if (key != _key2)
					{
						if (key != _key3)
						{
							return this;
						}
						return new TwoElementAsyncLocalValueMap(_key1, _value1, _key2, _value2);
					}
					return new TwoElementAsyncLocalValueMap(_key1, _value1, _key3, _value3);
				}
				return new TwoElementAsyncLocalValueMap(_key2, _value2, _key3, _value3);
			}

			public bool TryGetValue(IAsyncLocal key, out object value)
			{
				if (key == _key1)
				{
					value = _value1;
					return true;
				}
				if (key == _key2)
				{
					value = _value2;
					return true;
				}
				if (key == _key3)
				{
					value = _value3;
					return true;
				}
				value = null;
				return false;
			}
		}

		private sealed class MultiElementAsyncLocalValueMap : IAsyncLocalValueMap
		{
			private readonly KeyValuePair<IAsyncLocal, object>[] _keyValues;

			internal MultiElementAsyncLocalValueMap(int count)
			{
				_keyValues = new KeyValuePair<IAsyncLocal, object>[count];
			}

			internal void UnsafeStore(int index, IAsyncLocal key, object value)
			{
				_keyValues[index] = new KeyValuePair<IAsyncLocal, object>(key, value);
			}

			public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent)
			{
				for (int i = 0; i < _keyValues.Length; i++)
				{
					if (key == _keyValues[i].Key)
					{
						if (value != null || !treatNullValueAsNonexistent)
						{
							MultiElementAsyncLocalValueMap multiElementAsyncLocalValueMap = new MultiElementAsyncLocalValueMap(_keyValues.Length);
							Array.Copy(_keyValues, multiElementAsyncLocalValueMap._keyValues, _keyValues.Length);
							multiElementAsyncLocalValueMap._keyValues[i] = new KeyValuePair<IAsyncLocal, object>(key, value);
							return multiElementAsyncLocalValueMap;
						}
						if (_keyValues.Length == 4)
						{
							return i switch
							{
								2 => new ThreeElementAsyncLocalValueMap(_keyValues[0].Key, _keyValues[0].Value, _keyValues[1].Key, _keyValues[1].Value, _keyValues[3].Key, _keyValues[3].Value), 
								1 => new ThreeElementAsyncLocalValueMap(_keyValues[0].Key, _keyValues[0].Value, _keyValues[2].Key, _keyValues[2].Value, _keyValues[3].Key, _keyValues[3].Value), 
								0 => new ThreeElementAsyncLocalValueMap(_keyValues[1].Key, _keyValues[1].Value, _keyValues[2].Key, _keyValues[2].Value, _keyValues[3].Key, _keyValues[3].Value), 
								_ => new ThreeElementAsyncLocalValueMap(_keyValues[0].Key, _keyValues[0].Value, _keyValues[1].Key, _keyValues[1].Value, _keyValues[2].Key, _keyValues[2].Value), 
							};
						}
						MultiElementAsyncLocalValueMap multiElementAsyncLocalValueMap2 = new MultiElementAsyncLocalValueMap(_keyValues.Length - 1);
						if (i != 0)
						{
							Array.Copy(_keyValues, multiElementAsyncLocalValueMap2._keyValues, i);
						}
						if (i != _keyValues.Length - 1)
						{
							Array.Copy(_keyValues, i + 1, multiElementAsyncLocalValueMap2._keyValues, i, _keyValues.Length - i - 1);
						}
						return multiElementAsyncLocalValueMap2;
					}
				}
				if (value == null && treatNullValueAsNonexistent)
				{
					return this;
				}
				if (_keyValues.Length < 16)
				{
					MultiElementAsyncLocalValueMap multiElementAsyncLocalValueMap3 = new MultiElementAsyncLocalValueMap(_keyValues.Length + 1);
					Array.Copy(_keyValues, multiElementAsyncLocalValueMap3._keyValues, _keyValues.Length);
					multiElementAsyncLocalValueMap3._keyValues[_keyValues.Length] = new KeyValuePair<IAsyncLocal, object>(key, value);
					return multiElementAsyncLocalValueMap3;
				}
				ManyElementAsyncLocalValueMap manyElementAsyncLocalValueMap = new ManyElementAsyncLocalValueMap(17);
				KeyValuePair<IAsyncLocal, object>[] keyValues = _keyValues;
				for (int j = 0; j < keyValues.Length; j++)
				{
					KeyValuePair<IAsyncLocal, object> keyValuePair = keyValues[j];
					manyElementAsyncLocalValueMap[keyValuePair.Key] = keyValuePair.Value;
				}
				manyElementAsyncLocalValueMap[key] = value;
				return manyElementAsyncLocalValueMap;
			}

			public bool TryGetValue(IAsyncLocal key, out object value)
			{
				KeyValuePair<IAsyncLocal, object>[] keyValues = _keyValues;
				for (int i = 0; i < keyValues.Length; i++)
				{
					KeyValuePair<IAsyncLocal, object> keyValuePair = keyValues[i];
					if (key == keyValuePair.Key)
					{
						value = keyValuePair.Value;
						return true;
					}
				}
				value = null;
				return false;
			}
		}

		private sealed class ManyElementAsyncLocalValueMap : Dictionary<IAsyncLocal, object>, IAsyncLocalValueMap
		{
			public ManyElementAsyncLocalValueMap(int capacity)
				: base(capacity)
			{
			}

			public IAsyncLocalValueMap Set(IAsyncLocal key, object value, bool treatNullValueAsNonexistent)
			{
				int count = base.Count;
				bool flag = ContainsKey(key);
				if (value != null || !treatNullValueAsNonexistent)
				{
					ManyElementAsyncLocalValueMap manyElementAsyncLocalValueMap = new ManyElementAsyncLocalValueMap(count + ((!flag) ? 1 : 0));
					using (Enumerator enumerator = GetEnumerator())
					{
						while (enumerator.MoveNext())
						{
							KeyValuePair<IAsyncLocal, object> current = enumerator.Current;
							manyElementAsyncLocalValueMap[current.Key] = current.Value;
						}
					}
					manyElementAsyncLocalValueMap[key] = value;
					return manyElementAsyncLocalValueMap;
				}
				if (flag)
				{
					if (count == 17)
					{
						MultiElementAsyncLocalValueMap multiElementAsyncLocalValueMap = new MultiElementAsyncLocalValueMap(16);
						int num = 0;
						using Enumerator enumerator2 = GetEnumerator();
						while (enumerator2.MoveNext())
						{
							KeyValuePair<IAsyncLocal, object> current2 = enumerator2.Current;
							if (key != current2.Key)
							{
								multiElementAsyncLocalValueMap.UnsafeStore(num++, current2.Key, current2.Value);
							}
						}
						return multiElementAsyncLocalValueMap;
					}
					ManyElementAsyncLocalValueMap manyElementAsyncLocalValueMap2 = new ManyElementAsyncLocalValueMap(count - 1);
					using Enumerator enumerator3 = GetEnumerator();
					while (enumerator3.MoveNext())
					{
						KeyValuePair<IAsyncLocal, object> current3 = enumerator3.Current;
						if (key != current3.Key)
						{
							manyElementAsyncLocalValueMap2[current3.Key] = current3.Value;
						}
					}
					return manyElementAsyncLocalValueMap2;
				}
				return this;
			}
		}

		public static IAsyncLocalValueMap Empty { get; } = new EmptyAsyncLocalValueMap();


		public static bool IsEmpty(IAsyncLocalValueMap asyncLocalValueMap)
		{
			return asyncLocalValueMap == Empty;
		}

		public static IAsyncLocalValueMap Create(IAsyncLocal key, object value, bool treatNullValueAsNonexistent)
		{
			if (value == null && treatNullValueAsNonexistent)
			{
				return Empty;
			}
			return new OneElementAsyncLocalValueMap(key, value);
		}
	}
	public sealed class AutoResetEvent : EventWaitHandle
	{
		public AutoResetEvent(bool initialState)
			: base(initialState, EventResetMode.AutoReset)
		{
		}
	}
	[DebuggerDisplay("IsCancellationRequested = {IsCancellationRequested}")]
	public readonly struct CancellationToken
	{
		private readonly CancellationTokenSource _source;

		public static CancellationToken None => default(CancellationToken);

		public bool IsCancellationRequested
		{
			get
			{
				if (_source != null)
				{
					return _source.IsCancellationRequested;
				}
				return false;
			}
		}

		public bool CanBeCanceled => _source != null;

		public WaitHandle WaitHandle => (_source ?? CancellationTokenSource.s_neverCanceledSource).WaitHandle;

		internal CancellationToken(CancellationTokenSource source)
		{
			_source = source;
		}

		public CancellationToken(bool canceled)
			: this(canceled ? CancellationTokenSource.s_canceledSource : null)
		{
		}

		public CancellationTokenRegistration Register(Action callback)
		{
			return Register(callback, useSynchronizationContext: false);
		}

		public CancellationTokenRegistration Register(Action callback, bool useSynchronizationContext)
		{
			return Register((Action<object>)delegate(object obj)
			{
				((Action)obj)();
			}, callback ?? throw new ArgumentNullException("callback"), useSynchronizationContext, useExecutionContext: true);
		}

		public CancellationTokenRegistration Register(Action<object?> callback, object? state)
		{
			return Register(callback, state, useSynchronizationContext: false, useExecutionContext: true);
		}

		public CancellationTokenRegistration Register(Action<object?, CancellationToken> callback, object? state)
		{
			return Register(callback, state, useSynchronizationContext: false, useExecutionContext: true);
		}

		public CancellationTokenRegistration Register(Action<object?> callback, object? state, bool useSynchronizationContext)
		{
			return Register(callback, state, useSynchronizationContext, useExecutionContext: true);
		}

		public CancellationTokenRegistration UnsafeRegister(Action<object?> callback, object? state)
		{
			return Register(callback, state, useSynchronizationContext: false, useExecutionContext: false);
		}

		public CancellationTokenRegistration UnsafeRegister(Action<object?, CancellationToken> callback, object? state)
		{
			return Register(callback, state, useSynchronizationContext: false, useExecutionContext: false);
		}

		private CancellationTokenRegistration Register(Delegate callback, object state, bool useSynchronizationContext, bool useExecutionContext)
		{
			if ((object)callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			return _source?.Register(callback, state, useSynchronizationContext ? SynchronizationContext.Current : null, useExecutionContext ? ExecutionContext.Capture() : null) ?? default(CancellationTokenRegistration);
		}

		public bool Equals(CancellationToken other)
		{
			return _source == other._source;
		}

		public override bool Equals([NotNullWhen(true)] object? other)
		{
			if (other is CancellationToken)
			{
				return Equals((CancellationToken)other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (_source ?? CancellationTokenSource.s_neverCanceledSource).GetHashCode();
		}

		public static bool operator ==(CancellationToken left, CancellationToken right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(CancellationToken left, CancellationToken right)
		{
			return !left.Equals(right);
		}

		public void ThrowIfCancellationRequested()
		{
			if (IsCancellationRequested)
			{
				ThrowOperationCanceledException();
			}
		}

		[DoesNotReturn]
		private void ThrowOperationCanceledException()
		{
			throw new OperationCanceledException(SR.OperationCanceled, this);
		}
	}
	public readonly struct CancellationTokenRegistration : IEquatable<CancellationTokenRegistration>, IDisposable, IAsyncDisposable
	{
		private readonly long _id;

		private readonly CancellationTokenSource.CallbackNode _node;

		public CancellationToken Token
		{
			get
			{
				CancellationTokenSource.CallbackNode node = _node;
				if (node == null)
				{
					return default(CancellationToken);
				}
				return new CancellationToken(node.Registrations.Source);
			}
		}

		internal CancellationTokenRegistration(long id, CancellationTokenSource.CallbackNode node)
		{
			_id = id;
			_node = node;
		}

		public void Dispose()
		{
			CancellationTokenSource.CallbackNode node2 = _node;
			if (node2 != null && !node2.Registrations.Unregister(_id, node2))
			{
				WaitForCallbackIfNecessary(_id, node2);
			}
			static void WaitForCallbackIfNecessary(long id, CancellationTokenSource.CallbackNode node)
			{
				CancellationTokenSource source = node.Registrations.Source;
				if (source.IsCancellationRequested && !source.IsCancellationCompleted && node.Registrations.ThreadIDExecutingCallbacks != Environment.CurrentManagedThreadId)
				{
					node.Registrations.WaitForCallbackToComplete(id);
				}
			}
		}

		public ValueTask DisposeAsync()
		{
			CancellationTokenSource.CallbackNode node2 = _node;
			if (node2 == null || node2.Registrations.Unregister(_id, node2))
			{
				return default(ValueTask);
			}
			return WaitForCallbackIfNecessaryAsync(_id, node2);
			static ValueTask WaitForCallbackIfNecessaryAsync(long id, CancellationTokenSource.CallbackNode node)
			{
				CancellationTokenSource source = node.Registrations.Source;
				if (source.IsCancellationRequested && !source.IsCancellationCompleted && node.Registrations.ThreadIDExecutingCallbacks != Environment.CurrentManagedThreadId)
				{
					return node.Registrations.WaitForCallbackToCompleteAsync(id);
				}
				return default(ValueTask);
			}
		}

		public bool Unregister()
		{
			CancellationTokenSource.CallbackNode node = _node;
			return node?.Registrations.Unregister(_id, node) ?? false;
		}

		public static bool operator ==(CancellationTokenRegistration left, CancellationTokenRegistration right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(CancellationTokenRegistration left, CancellationTokenRegistration right)
		{
			return !left.Equals(right);
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is CancellationTokenRegistration other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(CancellationTokenRegistration other)
		{
			if (_node == other._node)
			{
				return _id == other._id;
			}
			return false;
		}

		public override int GetHashCode()
		{
			if (_node == null)
			{
				return _id.GetHashCode();
			}
			return _node.GetHashCode() ^ _id.GetHashCode();
		}
	}
	public class CancellationTokenSource : IDisposable
	{
		private sealed class Linked1CancellationTokenSource : CancellationTokenSource
		{
			private readonly CancellationTokenRegistration _reg1;

			internal Linked1CancellationTokenSource(CancellationToken token1)
			{
				_reg1 = token1.UnsafeRegister(LinkedNCancellationTokenSource.s_linkedTokenCancelDelegate, this);
			}

			protected override void Dispose(bool disposing)
			{
				if (disposing && !_disposed)
				{
					_reg1.Dispose();
					base.Dispose(disposing);
				}
			}
		}

		private sealed class Linked2CancellationTokenSource : CancellationTokenSource
		{
			private readonly CancellationTokenRegistration _reg1;

			private readonly CancellationTokenRegistration _reg2;

			internal Linked2CancellationTokenSource(CancellationToken token1, CancellationToken token2)
			{
				_reg1 = token1.UnsafeRegister(LinkedNCancellationTokenSource.s_linkedTokenCancelDelegate, this);
				_reg2 = token2.UnsafeRegister(LinkedNCancellationTokenSource.s_linkedTokenCancelDelegate, this);
			}

			protected override void Dispose(bool disposing)
			{
				if (disposing && !_disposed)
				{
					_reg1.Dispose();
					_reg2.Dispose();
					base.Dispose(disposing);
				}
			}
		}

		private sealed class LinkedNCancellationTokenSource : CancellationTokenSource
		{
			internal static readonly Action<object> s_linkedTokenCancelDelegate = delegate(object s)
			{
				((CancellationTokenSource)s).NotifyCancellation(throwOnFirstException: false);
			};

			private CancellationTokenRegistration[] _linkingRegistrations;

			internal LinkedNCancellationTokenSource(CancellationToken[] tokens)
			{
				_linkingRegistrations = new CancellationTokenRegistration[tokens.Length];
				for (int i = 0; i < tokens.Length; i++)
				{
					if (tokens[i].CanBeCanceled)
					{
						_linkingRegistrations[i] = tokens[i].UnsafeRegister(s_linkedTokenCancelDelegate, this);
					}
				}
			}

			protected override void Dispose(bool disposing)
			{
				if (!disposing || _disposed)
				{
					return;
				}
				CancellationTokenRegistration[] linkingRegistrations = _linkingRegistrations;
				if (linkingRegistrations != null)
				{
					_linkingRegistrations = null;
					for (int i = 0; i < linkingRegistrations.Length; i++)
					{
						linkingRegistrations[i].Dispose();
					}
				}
				base.Dispose(disposing);
			}
		}

		internal sealed class Registrations
		{
			public readonly CancellationTokenSource Source;

			public CallbackNode Callbacks;

			public CallbackNode FreeNodeList;

			public long NextAvailableId = 1L;

			public long ExecutingCallbackId;

			public volatile int ThreadIDExecutingCallbacks = -1;

			private int _lock;

			public Registrations(CancellationTokenSource source)
			{
				Source = source;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private void Recycle(CallbackNode node)
			{
				node.Id = 0L;
				node.Callback = null;
				node.CallbackState = null;
				node.ExecutionContext = null;
				node.SynchronizationContext = null;
				node.Prev = null;
				node.Next = FreeNodeList;
				FreeNodeList = node;
			}

			public bool Unregister(long id, CallbackNode node)
			{
				if (id == 0L)
				{
					return false;
				}
				EnterLock();
				try
				{
					if (node.Id != id)
					{
						return false;
					}
					if (Callbacks == node)
					{
						Callbacks = node.Next;
					}
					else
					{
						node.Prev.Next = node.Next;
					}
					if (node.Next != null)
					{
						node.Next.Prev = node.Prev;
					}
					Recycle(node);
					return true;
				}
				finally
				{
					ExitLock();
				}
			}

			public void UnregisterAll()
			{
				EnterLock();
				try
				{
					CallbackNode callbackNode = Callbacks;
					Callbacks = null;
					while (callbackNode != null)
					{
						CallbackNode next = callbackNode.Next;
						Recycle(callbackNode);
						callbackNode = next;
					}
				}
				finally
				{
					ExitLock();
				}
			}

			public void WaitForCallbackToComplete(long id)
			{
				SpinWait spinWait = default(SpinWait);
				while (Volatile.Read(ref ExecutingCallbackId) == id)
				{
					spinWait.SpinOnce();
				}
			}

			public ValueTask WaitForCallbackToCompleteAsync(long id)
			{
				if (Volatile.Read(ref ExecutingCallbackId) != id)
				{
					return default(ValueTask);
				}
				return new ValueTask(Task.Factory.StartNew((Func<object?, Task>)async delegate(object s)
				{
					TupleSlim<Registrations, long> state = (TupleSlim<Registrations, long>)s;
					while (Volatile.Read(ref state.Item1.ExecutingCallbackId) == state.Item2)
					{
						await Task.Yield();
					}
				}, (object?)new TupleSlim<Registrations, long>(this, id), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap());
			}

			public void EnterLock()
			{
				ref int @lock = ref _lock;
				if (Interlocked.Exchange(ref @lock, 1) != 0)
				{
					Contention(ref @lock);
				}
				[MethodImpl(MethodImplOptions.NoInlining)]
				static void Contention(ref int value)
				{
					SpinWait spinWait = default(SpinWait);
					do
					{
						spinWait.SpinOnce();
					}
					while (Interlocked.Exchange(ref value, 1) == 1);
				}
			}

			public void ExitLock()
			{
				Volatile.Write(ref _lock, 0);
			}
		}

		internal sealed class CallbackNode
		{
			public readonly Registrations Registrations;

			public CallbackNode Prev;

			public CallbackNode Next;

			public long Id;

			public Delegate Callback;

			public object CallbackState;

			public ExecutionContext ExecutionContext;

			public SynchronizationContext SynchronizationContext;

			public CallbackNode(Registrations registrations)
			{
				Registrations = registrations;
			}

			public void ExecuteCallback()
			{
				ExecutionContext executionContext = ExecutionContext;
				if (executionContext == null)
				{
					Invoke(Callback, CallbackState, Registrations.Source);
					return;
				}
				ExecutionContext.RunInternal(executionContext, delegate(object s)
				{
					CallbackNode callbackNode = (CallbackNode)s;
					Invoke(callbackNode.Callback, callbackNode.CallbackState, callbackNode.Registrations.Source);
				}, this);
			}
		}

		internal static readonly CancellationTokenSource s_canceledSource = new CancellationTokenSource
		{
			_state = 2
		};

		internal static readonly CancellationTokenSource s_neverCanceledSource = new CancellationTokenSource();

		private static readonly TimerCallback s_timerCallback = TimerCallback;

		private volatile int _state;

		private bool _disposed;

		private volatile TimerQueueTimer _timer;

		private volatile ManualResetEvent _kernelEvent;

		private Registrations _registrations;

		public bool IsCancellationRequested => _state != 0;

		internal bool IsCancellationCompleted => _state == 2;

		public CancellationToken Token
		{
			get
			{
				ThrowIfDisposed();
				return new CancellationToken(this);
			}
		}

		internal WaitHandle WaitHandle
		{
			get
			{
				ThrowIfDisposed();
				if (_kernelEvent != null)
				{
					return _kernelEvent;
				}
				ManualResetEvent manualResetEvent = new ManualResetEvent(initialState: false);
				if (Interlocked.CompareExchange(ref _kernelEvent, manualResetEvent, null) != null)
				{
					manualResetEvent.Dispose();
				}
				if (IsCancellationRequested)
				{
					_kernelEvent.Set();
				}
				return _kernelEvent;
			}
		}

		private static void TimerCallback(object state)
		{
			((CancellationTokenSource)state).NotifyCancellation(throwOnFirstException: false);
		}

		public CancellationTokenSource()
		{
		}

		public CancellationTokenSource(TimeSpan delay)
		{
			long num = (long)delay.TotalMilliseconds;
			if (num < -1 || num > 4294967294u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.delay);
			}
			InitializeWithTimer((uint)num);
		}

		public CancellationTokenSource(int millisecondsDelay)
		{
			if (millisecondsDelay < -1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.millisecondsDelay);
			}
			InitializeWithTimer((uint)millisecondsDelay);
		}

		private void InitializeWithTimer(uint millisecondsDelay)
		{
			if (millisecondsDelay == 0)
			{
				_state = 2;
			}
			else
			{
				_timer = new TimerQueueTimer(s_timerCallback, this, millisecondsDelay, uint.MaxValue, flowExecutionContext: false);
			}
		}

		public void Cancel()
		{
			Cancel(throwOnFirstException: false);
		}

		public void Cancel(bool throwOnFirstException)
		{
			ThrowIfDisposed();
			NotifyCancellation(throwOnFirstException);
		}

		public void CancelAfter(TimeSpan delay)
		{
			long num = (long)delay.TotalMilliseconds;
			if (num < -1 || num > 4294967294u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.delay);
			}
			CancelAfter((uint)num);
		}

		public void CancelAfter(int millisecondsDelay)
		{
			if (millisecondsDelay < -1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.millisecondsDelay);
			}
			CancelAfter((uint)millisecondsDelay);
		}

		private void CancelAfter(uint millisecondsDelay)
		{
			ThrowIfDisposed();
			if (IsCancellationRequested)
			{
				return;
			}
			TimerQueueTimer timerQueueTimer = _timer;
			if (timerQueueTimer == null)
			{
				timerQueueTimer = new TimerQueueTimer(s_timerCallback, this, uint.MaxValue, uint.MaxValue, flowExecutionContext: false);
				TimerQueueTimer timerQueueTimer2 = Interlocked.CompareExchange(ref _timer, timerQueueTimer, null);
				if (timerQueueTimer2 != null)
				{
					timerQueueTimer.Close();
					timerQueueTimer = timerQueueTimer2;
				}
			}
			try
			{
				timerQueueTimer.Change(millisecondsDelay, uint.MaxValue);
			}
			catch (ObjectDisposedException)
			{
			}
		}

		public bool TryReset()
		{
			ThrowIfDisposed();
			if (_state == 0)
			{
				bool flag = false;
				try
				{
					TimerQueueTimer timer = _timer;
					flag = timer == null || (timer.Change(uint.MaxValue, uint.MaxValue) && !timer._everQueued);
				}
				catch (ObjectDisposedException)
				{
				}
				if (flag)
				{
					Volatile.Read(ref _registrations)?.UnregisterAll();
					return true;
				}
			}
			return false;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!disposing || _disposed)
			{
				return;
			}
			TimerQueueTimer timer = _timer;
			if (timer != null)
			{
				_timer = null;
				timer.Close();
			}
			_registrations = null;
			if (_kernelEvent != null)
			{
				ManualResetEvent manualResetEvent = Interlocked.Exchange(ref _kernelEvent, null);
				if (manualResetEvent != null && _state != 1)
				{
					manualResetEvent.Dispose();
				}
			}
			_disposed = true;
		}

		private void ThrowIfDisposed()
		{
			if (_disposed)
			{
				ThrowHelper.ThrowObjectDisposedException(ExceptionResource.CancellationTokenSource_Disposed);
			}
		}

		internal CancellationTokenRegistration Register(Delegate callback, object stateForCallback, SynchronizationContext syncContext, ExecutionContext executionContext)
		{
			if (!IsCancellationRequested)
			{
				if (_disposed)
				{
					return default(CancellationTokenRegistration);
				}
				Registrations registrations = Volatile.Read(ref _registrations);
				if (registrations == null)
				{
					registrations = new Registrations(this);
					registrations = Interlocked.CompareExchange(ref _registrations, registrations, null) ?? registrations;
				}
				CallbackNode callbackNode = null;
				long id = 0L;
				if (registrations.FreeNodeList != null)
				{
					registrations.EnterLock();
					try
					{
						callbackNode = registrations.FreeNodeList;
						if (callbackNode != null)
						{
							registrations.FreeNodeList = callbackNode.Next;
							id = (callbackNode.Id = registrations.NextAvailableId++);
							callbackNode.Callback = callback;
							callbackNode.CallbackState = stateForCallback;
							callbackNode.ExecutionContext = executionContext;
							callbackNode.SynchronizationContext = syncContext;
							callbackNode.Next = registrations.Callbacks;
							registrations.Callbacks = callbackNode;
							if (callbackNode.Next != null)
							{
								callbackNode.Next.Prev = callbackNode;
							}
						}
					}
					finally
					{
						registrations.ExitLock();
					}
				}
				if (callbackNode == null)
				{
					callbackNode = new CallbackNode(registrations);
					callbackNode.Callback = callback;
					callbackNode.CallbackState = stateForCallback;
					callbackNode.ExecutionContext = executionContext;
					callbackNode.SynchronizationContext = syncContext;
					registrations.EnterLock();
					try
					{
						id = (callbackNode.Id = registrations.NextAvailableId++);
						callbackNode.Next = registrations.Callbacks;
						if (callbackNode.Next != null)
						{
							callbackNode.Next.Prev = callbackNode;
						}
						registrations.Callbacks = callbackNode;
					}
					finally
					{
						registrations.ExitLock();
					}
				}
				if (!IsCancellationRequested || !registrations.Unregister(id, callbackNode))
				{
					return new CancellationTokenRegistration(id, callbackNode);
				}
			}
			Invoke(callback, stateForCallback, this);
			return default(CancellationTokenRegistration);
		}

		private void NotifyCancellation(bool throwOnFirstException)
		{
			if (!IsCancellationRequested && Interlocked.CompareExchange(ref _state, 1, 0) == 0)
			{
				TimerQueueTimer timer = _timer;
				if (timer != null)
				{
					_timer = null;
					timer.Close();
				}
				_kernelEvent?.Set();
				ExecuteCallbackHandlers(throwOnFirstException);
			}
		}

		private void ExecuteCallbackHandlers(bool throwOnFirstException)
		{
			Registrations registrations = Interlocked.Exchange(ref _registrations, null);
			if (registrations == null)
			{
				Interlocked.Exchange(ref _state, 2);
				return;
			}
			registrations.ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId;
			List<Exception> list = null;
			try
			{
				while (true)
				{
					registrations.EnterLock();
					CallbackNode callbacks;
					try
					{
						callbacks = registrations.Callbacks;
						if (callbacks == null)
						{
							break;
						}
						if (callbacks.Next != null)
						{
							callbacks.Next.Prev = null;
						}
						registrations.Callbacks = callbacks.Next;
						registrations.ExecutingCallbackId = callbacks.Id;
						callbacks.Id = 0L;
						goto IL_0080;
					}
					finally
					{
						registrations.ExitLock();
					}
					IL_0080:
					try
					{
						if (callbacks.SynchronizationContext != null)
						{
							callbacks.SynchronizationContext.Send(delegate(object s)
							{
								CallbackNode callbackNode = (CallbackNode)s;
								callbackNode.Registrations.ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId;
								callbackNode.ExecuteCallback();
							}, callbacks);
							registrations.ThreadIDExecutingCallbacks = Environment.CurrentManagedThreadId;
						}
						else
						{
							callbacks.ExecuteCallback();
						}
					}
					catch (Exception item) when (!throwOnFirstException)
					{
						(list ?? (list = new List<Exception>())).Add(item);
					}
				}
			}
			finally
			{
				_state = 2;
				Interlocked.Exchange(ref registrations.ExecutingCallbackId, 0L);
			}
			if (list == null)
			{
				return;
			}
			throw new AggregateException(list);
		}

		public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken token1, CancellationToken token2)
		{
			if (token1.CanBeCanceled)
			{
				if (!token2.CanBeCanceled)
				{
					return new Linked1CancellationTokenSource(token1);
				}
				return new Linked2CancellationTokenSource(token1, token2);
			}
			return CreateLinkedTokenSource(token2);
		}

		public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken token)
		{
			if (!token.CanBeCanceled)
			{
				return new CancellationTokenSource();
			}
			return new Linked1CancellationTokenSource(token);
		}

		public static CancellationTokenSource CreateLinkedTokenSource(params CancellationToken[] tokens)
		{
			if (tokens == null)
			{
				throw new ArgumentNullException("tokens");
			}
			return tokens.Length switch
			{
				0 => throw new ArgumentException(SR.CancellationToken_CreateLinkedToken_TokensIsEmpty), 
				1 => CreateLinkedTokenSource(tokens[0]), 
				2 => CreateLinkedTokenSource(tokens[0], tokens[1]), 
				_ => new LinkedNCancellationTokenSource(tokens), 
			};
		}

		private static void Invoke(Delegate d, object state, CancellationTokenSource source)
		{
			if (d is Action<object> action)
			{
				action(state);
			}
			else
			{
				((Action<object, CancellationToken>)d)(state, new CancellationToken(source));
			}
		}
	}
	public sealed class CompressedStack : ISerializable
	{
		private CompressedStack()
		{
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public static CompressedStack Capture()
		{
			return GetCompressedStack();
		}

		public CompressedStack CreateCopy()
		{
			return this;
		}

		public static CompressedStack GetCompressedStack()
		{
			return new CompressedStack();
		}

		public static void Run(CompressedStack compressedStack, ContextCallback callback, object? state)
		{
			if (compressedStack == null)
			{
				throw new ArgumentNullException("compressedStack");
			}
			callback(state);
		}
	}
	internal enum StackCrawlMark
	{
		LookForMe,
		LookForMyCaller,
		LookForMyCallersCaller,
		LookForThread
	}
	internal interface IDeferredDisposable
	{
		void OnFinalRelease(bool disposed);
	}
	internal struct DeferredDisposableLifetime<T> where T : class, IDeferredDisposable
	{
		private int _count;

		public bool AddRef()
		{
			int num;
			int value;
			do
			{
				num = Volatile.Read(ref _count);
				if (num < 0)
				{
					throw new ObjectDisposedException(typeof(T).ToString());
				}
				value = checked(num + 1);
			}
			while (Interlocked.CompareExchange(ref _count, value, num) != num);
			return true;
		}

		public void Release(T obj)
		{
			int num3;
			while (true)
			{
				int num = Volatile.Read(ref _count);
				if (num > 0)
				{
					int num2 = num - 1;
					if (Interlocked.CompareExchange(ref _count, num2, num) == num)
					{
						if (num2 == 0)
						{
							obj.OnFinalRelease(disposed: false);
						}
						return;
					}
				}
				else
				{
					num3 = num + 1;
					if (Interlocked.CompareExchange(ref _count, num3, num) == num)
					{
						break;
					}
				}
			}
			if (num3 == -1)
			{
				obj.OnFinalRelease(disposed: true);
			}
		}

		public void Dispose(T obj)
		{
			int num;
			int num2;
			do
			{
				num = Volatile.Read(ref _count);
				if (num < 0)
				{
					return;
				}
				num2 = -1 - num;
			}
			while (Interlocked.CompareExchange(ref _count, num2, num) != num);
			if (num2 == -1)
			{
				obj.OnFinalRelease(disposed: true);
			}
		}
	}
	public enum EventResetMode
	{
		AutoReset,
		ManualReset
	}
	public class EventWaitHandle : WaitHandle
	{
		public EventWaitHandle(bool initialState, EventResetMode mode)
			: this(initialState, mode, null, out var _)
		{
		}

		public EventWaitHandle(bool initialState, EventResetMode mode, string? name)
			: this(initialState, mode, name, out var _)
		{
		}

		public EventWaitHandle(bool initialState, EventResetMode mode, string? name, out bool createdNew)
		{
			if (mode != 0 && mode != EventResetMode.ManualReset)
			{
				throw new ArgumentException(SR.Argument_InvalidFlag, "mode");
			}
			CreateEventCore(initialState, mode, name, out createdNew);
		}

		[SupportedOSPlatform("windows")]
		public static EventWaitHandle OpenExisting(string name)
		{
			EventWaitHandle result;
			return OpenExistingWorker(name, out result) switch
			{
				OpenExistingResult.NameNotFound => throw new WaitHandleCannotBeOpenedException(), 
				OpenExistingResult.NameInvalid => throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name)), 
				OpenExistingResult.PathNotFound => throw new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, name)), 
				_ => result, 
			};
		}

		[SupportedOSPlatform("windows")]
		public static bool TryOpenExisting(string name, [NotNullWhen(true)] out EventWaitHandle? result)
		{
			return OpenExistingWorker(name, out result) == OpenExistingResult.Success;
		}

		private EventWaitHandle(SafeWaitHandle handle)
		{
			base.SafeWaitHandle = handle;
		}

		private void CreateEventCore(bool initialState, EventResetMode mode, string name, out bool createdNew)
		{
			uint num = (initialState ? 2u : 0u);
			if (mode == EventResetMode.ManualReset)
			{
				num |= 1u;
			}
			SafeWaitHandle safeWaitHandle = Interop.Kernel32.CreateEventEx(IntPtr.Zero, name, num, 34603010u);
			int lastPInvokeError = Marshal.GetLastPInvokeError();
			if (safeWaitHandle.IsInvalid)
			{
				safeWaitHandle.SetHandleAsInvalid();
				if (!string.IsNullOrEmpty(name) && lastPInvokeError == 6)
				{
					throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name));
				}
				throw Win32Marshal.GetExceptionForWin32Error(lastPInvokeError, name);
			}
			createdNew = lastPInvokeError != 183;
			base.SafeWaitHandle = safeWaitHandle;
		}

		private static OpenExistingResult OpenExistingWorker(string name, out EventWaitHandle result)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			result = null;
			SafeWaitHandle safeWaitHandle = Interop.Kernel32.OpenEvent(34603010u, inheritHandle: false, name);
			if (safeWaitHandle.IsInvalid)
			{
				int lastPInvokeError = Marshal.GetLastPInvokeError();
				switch (lastPInvokeError)
				{
				case 2:
				case 123:
					return OpenExistingResult.NameNotFound;
				case 3:
					return OpenExistingResult.PathNotFound;
				case 6:
					return OpenExistingResult.NameInvalid;
				default:
					throw Win32Marshal.GetExceptionForWin32Error(lastPInvokeError, name);
				}
			}
			result = new EventWaitHandle(safeWaitHandle);
			return OpenExistingResult.Success;
		}

		public bool Reset()
		{
			bool flag = Interop.Kernel32.ResetEvent(base.SafeWaitHandle);
			if (!flag)
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
			return flag;
		}

		public bool Set()
		{
			bool flag = Interop.Kernel32.SetEvent(base.SafeWaitHandle);
			if (!flag)
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
			return flag;
		}

		internal static bool Set(SafeWaitHandle waitHandle)
		{
			return Interop.Kernel32.SetEvent(waitHandle);
		}
	}
	public delegate void ContextCallback(object? state);
	public sealed class ExecutionContext : IDisposable, ISerializable
	{
		internal static readonly ExecutionContext Default = new ExecutionContext();

		private static volatile ExecutionContext s_defaultFlowSuppressed;

		private readonly IAsyncLocalValueMap m_localValues;

		private readonly IAsyncLocal[] m_localChangeNotifications;

		private readonly bool m_isFlowSuppressed;

		private readonly bool m_isDefault;

		internal bool HasChangeNotifications => m_localChangeNotifications != null;

		internal bool IsDefault => m_isDefault;

		private ExecutionContext()
		{
			m_isDefault = true;
		}

		private ExecutionContext(IAsyncLocalValueMap localValues, IAsyncLocal[] localChangeNotifications, bool isFlowSuppressed)
		{
			m_localValues = localValues;
			m_localChangeNotifications = localChangeNotifications;
			m_isFlowSuppressed = isFlowSuppressed;
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public static ExecutionContext? Capture()
		{
			ExecutionContext executionContext = Thread.CurrentThread._executionContext;
			if (executionContext == null)
			{
				executionContext = Default;
			}
			else if (executionContext.m_isFlowSuppressed)
			{
				executionContext = null;
			}
			return executionContext;
		}

		internal static ExecutionContext CaptureForRestore()
		{
			return Thread.CurrentThread._executionContext;
		}

		private ExecutionContext ShallowClone(bool isFlowSuppressed)
		{
			if (m_localValues == null || AsyncLocalValueMap.IsEmpty(m_localValues))
			{
				if (!isFlowSuppressed)
				{
					return null;
				}
				return s_defaultFlowSuppressed ?? (s_defaultFlowSuppressed = new ExecutionContext(AsyncLocalValueMap.Empty, new IAsyncLocal[0], isFlowSuppressed: true));
			}
			return new ExecutionContext(m_localValues, m_localChangeNotifications, isFlowSuppressed);
		}

		public static AsyncFlowControl SuppressFlow()
		{
			Thread currentThread = Thread.CurrentThread;
			ExecutionContext executionContext = currentThread._executionContext ?? Default;
			if (executionContext.m_isFlowSuppressed)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CannotSupressFlowMultipleTimes);
			}
			executionContext = executionContext.ShallowClone(isFlowSuppressed: true);
			AsyncFlowControl result = default(AsyncFlowControl);
			currentThread._executionContext = executionContext;
			result.Initialize(currentThread);
			return result;
		}

		public static void RestoreFlow()
		{
			Thread currentThread = Thread.CurrentThread;
			ExecutionContext executionContext = currentThread._executionContext;
			if (executionContext == null || !executionContext.m_isFlowSuppressed)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CannotRestoreUnsupressedFlow);
			}
			currentThread._executionContext = executionContext.ShallowClone(isFlowSuppressed: false);
		}

		public static bool IsFlowSuppressed()
		{
			return Thread.CurrentThread._executionContext?.m_isFlowSuppressed ?? false;
		}

		public static void Run(ExecutionContext executionContext, ContextCallback callback, object? state)
		{
			if (executionContext == null)
			{
				ThrowNullContext();
			}
			RunInternal(executionContext, callback, state);
		}

		internal static void RunInternal(ExecutionContext executionContext, ContextCallback callback, object state)
		{
			Thread currentThread = Thread.CurrentThread;
			ExecutionContext executionContext2 = currentThread._executionContext;
			if (executionContext2 != null && executionContext2.m_isDefault)
			{
				executionContext2 = null;
			}
			ExecutionContext executionContext3 = executionContext2;
			SynchronizationContext synchronizationContext = currentThread._synchronizationContext;
			if (executionContext != null && executionContext.m_isDefault)
			{
				executionContext = null;
			}
			if (executionContext3 != executionContext)
			{
				RestoreChangedContextToThread(currentThread, executionContext, executionContext3);
			}
			ExceptionDispatchInfo exceptionDispatchInfo = null;
			try
			{
				callback(state);
			}
			catch (Exception source)
			{
				exceptionDispatchInfo = ExceptionDispatchInfo.Capture(source);
			}
			if (currentThread._synchronizationContext != synchronizationContext)
			{
				currentThread._synchronizationContext = synchronizationContext;
			}
			ExecutionContext executionContext4 = currentThread._executionContext;
			if (executionContext4 != executionContext3)
			{
				RestoreChangedContextToThread(currentThread, executionContext3, executionContext4);
			}
			exceptionDispatchInfo?.Throw();
		}

		public static void Restore(ExecutionContext executionContext)
		{
			if (executionContext == null)
			{
				ThrowNullContext();
			}
			RestoreInternal(executionContext);
		}

		internal static void RestoreInternal(ExecutionContext executionContext)
		{
			Thread currentThread = Thread.CurrentThread;
			ExecutionContext executionContext2 = currentThread._executionContext;
			if (executionContext2 != null && executionContext2.m_isDefault)
			{
				executionContext2 = null;
			}
			if (executionContext != null && executionContext.m_isDefault)
			{
				executionContext = null;
			}
			if (executionContext2 != executionContext)
			{
				RestoreChangedContextToThread(currentThread, executionContext, executionContext2);
			}
		}

		internal static void RunFromThreadPoolDispatchLoop(Thread threadPoolThread, ExecutionContext executionContext, ContextCallback callback, object state)
		{
			if (executionContext != null && !executionContext.m_isDefault)
			{
				RestoreChangedContextToThread(threadPoolThread, executionContext, null);
			}
			ExceptionDispatchInfo exceptionDispatchInfo = null;
			try
			{
				callback(state);
			}
			catch (Exception source)
			{
				exceptionDispatchInfo = ExceptionDispatchInfo.Capture(source);
			}
			ExecutionContext executionContext2 = threadPoolThread._executionContext;
			threadPoolThread._synchronizationContext = null;
			if (executionContext2 != null)
			{
				RestoreChangedContextToThread(threadPoolThread, null, executionContext2);
			}
			exceptionDispatchInfo?.Throw();
		}

		internal static void RunForThreadPoolUnsafe<TState>(ExecutionContext executionContext, Action<TState> callback, in TState state)
		{
			Thread.CurrentThread._executionContext = executionContext;
			if (executionContext.HasChangeNotifications)
			{
				OnValuesChanged(null, executionContext);
			}
			callback(state);
		}

		internal static void RestoreChangedContextToThread(Thread currentThread, ExecutionContext contextToRestore, ExecutionContext currentContext)
		{
			currentThread._executionContext = contextToRestore;
			if ((currentContext != null && currentContext.HasChangeNotifications) || (contextToRestore != null && contextToRestore.HasChangeNotifications))
			{
				OnValuesChanged(currentContext, contextToRestore);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ResetThreadPoolThread(Thread currentThread)
		{
			ExecutionContext executionContext = currentThread._executionContext;
			currentThread._synchronizationContext = null;
			currentThread._executionContext = null;
			if (executionContext != null && executionContext.HasChangeNotifications)
			{
				OnValuesChanged(executionContext, null);
				currentThread._synchronizationContext = null;
				currentThread._executionContext = null;
			}
		}

		internal static void OnValuesChanged(ExecutionContext previousExecutionCtx, ExecutionContext nextExecutionCtx)
		{
			IAsyncLocal[] array = previousExecutionCtx?.m_localChangeNotifications;
			IAsyncLocal[] array2 = nextExecutionCtx?.m_localChangeNotifications;
			try
			{
				if (array != null && array2 != null)
				{
					IAsyncLocal[] array3 = array;
					foreach (IAsyncLocal asyncLocal in array3)
					{
						previousExecutionCtx.m_localValues.TryGetValue(asyncLocal, out var value);
						nextExecutionCtx.m_localValues.TryGetValue(asyncLocal, out var value2);
						if (value != value2)
						{
							asyncLocal.OnValueChanged(value, value2, contextChanged: true);
						}
					}
					if (array2 == array)
					{
						return;
					}
					IAsyncLocal[] array4 = array2;
					foreach (IAsyncLocal asyncLocal2 in array4)
					{
						if (!previousExecutionCtx.m_localValues.TryGetValue(asyncLocal2, out var value3))
						{
							nextExecutionCtx.m_localValues.TryGetValue(asyncLocal2, out var value4);
							if (value3 != value4)
							{
								asyncLocal2.OnValueChanged(value3, value4, contextChanged: true);
							}
						}
					}
					return;
				}
				if (array != null)
				{
					IAsyncLocal[] array5 = array;
					foreach (IAsyncLocal asyncLocal3 in array5)
					{
						previousExecutionCtx.m_localValues.TryGetValue(asyncLocal3, out var value5);
						if (value5 != null)
						{
							asyncLocal3.OnValueChanged(value5, null, contextChanged: true);
						}
					}
					return;
				}
				IAsyncLocal[] array6 = array2;
				foreach (IAsyncLocal asyncLocal4 in array6)
				{
					nextExecutionCtx.m_localValues.TryGetValue(asyncLocal4, out var value6);
					if (value6 != null)
					{
						asyncLocal4.OnValueChanged(null, value6, contextChanged: true);
					}
				}
			}
			catch (Exception exception)
			{
				Environment.FailFast(SR.ExecutionContext_ExceptionInAsyncLocalNotification, exception);
			}
		}

		[DoesNotReturn]
		[StackTraceHidden]
		private static void ThrowNullContext()
		{
			throw new InvalidOperationException(SR.InvalidOperation_NullContext);
		}

		internal static object GetLocalValue(IAsyncLocal local)
		{
			ExecutionContext executionContext = Thread.CurrentThread._executionContext;
			if (executionContext == null)
			{
				return null;
			}
			executionContext.m_localValues.TryGetValue(local, out var value);
			return value;
		}

		internal static void SetLocalValue(IAsyncLocal local, object newValue, bool needChangeNotifications)
		{
			ExecutionContext executionContext = Thread.CurrentThread._executionContext;
			object value = null;
			bool flag = false;
			if (executionContext != null)
			{
				flag = executionContext.m_localValues.TryGetValue(local, out value);
			}
			if (value == newValue)
			{
				return;
			}
			IAsyncLocal[] array = null;
			bool flag2 = false;
			IAsyncLocalValueMap asyncLocalValueMap;
			if (executionContext != null)
			{
				flag2 = executionContext.m_isFlowSuppressed;
				asyncLocalValueMap = executionContext.m_localValues.Set(local, newValue, !needChangeNotifications);
				array = executionContext.m_localChangeNotifications;
			}
			else
			{
				asyncLocalValueMap = AsyncLocalValueMap.Create(local, newValue, !needChangeNotifications);
			}
			if (needChangeNotifications && !flag)
			{
				if (array == null)
				{
					array = new IAsyncLocal[1] { local };
				}
				else
				{
					int num = array.Length;
					Array.Resize(ref array, num + 1);
					array[num] = local;
				}
			}
			Thread.CurrentThread._executionContext = ((!flag2 && AsyncLocalValueMap.IsEmpty(asyncLocalValueMap)) ? null : new ExecutionContext(asyncLocalValueMap, array, flag2));
			if (needChangeNotifications)
			{
				local.OnValueChanged(value, newValue, contextChanged: false);
			}
		}

		public ExecutionContext CreateCopy()
		{
			return this;
		}

		public void Dispose()
		{
		}
	}
	public struct AsyncFlowControl : IEquatable<AsyncFlowControl>, IDisposable
	{
		private Thread _thread;

		internal void Initialize(Thread currentThread)
		{
			_thread = currentThread;
		}

		public void Undo()
		{
			if (_thread == null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CannotUseAFCMultiple);
			}
			if (Thread.CurrentThread != _thread)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CannotUseAFCOtherThread);
			}
			if (!ExecutionContext.IsFlowSuppressed())
			{
				throw new InvalidOperationException(SR.InvalidOperation_AsyncFlowCtrlCtxMismatch);
			}
			_thread = null;
			ExecutionContext.RestoreFlow();
		}

		public void Dispose()
		{
			Undo();
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is AsyncFlowControl obj2)
			{
				return Equals(obj2);
			}
			return false;
		}

		public bool Equals(AsyncFlowControl obj)
		{
			return _thread == obj._thread;
		}

		public override int GetHashCode()
		{
			return _thread?.GetHashCode() ?? 0;
		}

		public static bool operator ==(AsyncFlowControl a, AsyncFlowControl b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(AsyncFlowControl a, AsyncFlowControl b)
		{
			return !(a == b);
		}
	}
	[CLSCompliant(false)]
	public unsafe delegate void IOCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* pOVERLAP);
	public interface IThreadPoolWorkItem
	{
		void Execute();
	}
	public static class LazyInitializer
	{
		public static T EnsureInitialized<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>([NotNull] ref T? target) where T : class
		{
			return Volatile.Read(ref target) ?? EnsureInitializedCore(ref target);
		}

		private static T EnsureInitializedCore<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>([NotNull] ref T target) where T : class
		{
			try
			{
				Interlocked.CompareExchange(ref target, Activator.CreateInstance<T>(), null);
			}
			catch (MissingMethodException)
			{
				throw new MissingMemberException(SR.Lazy_CreateValue_NoParameterlessCtorForT);
			}
			return target;
		}

		public static T EnsureInitialized<T>([NotNull] ref T? target, Func<T> valueFactory) where T : class
		{
			return Volatile.Read(ref target) ?? EnsureInitializedCore(ref target, valueFactory);
		}

		private static T EnsureInitializedCore<T>([NotNull] ref T target, Func<T> valueFactory) where T : class
		{
			T val = valueFactory();
			if (val == null)
			{
				throw new InvalidOperationException(SR.Lazy_StaticInit_InvalidOperation);
			}
			Interlocked.CompareExchange(ref target, val, null);
			return target;
		}

		public static T EnsureInitialized<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>([AllowNull] ref T target, ref bool initialized, [NotNullIfNotNull("syncLock")] ref object? syncLock)
		{
			if (Volatile.Read(ref initialized))
			{
				return target;
			}
			return EnsureInitializedCore(ref target, ref initialized, ref syncLock);
		}

		private static T EnsureInitializedCore<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>([AllowNull] ref T target, ref bool initialized, [NotNull] ref object syncLock)
		{
			lock (EnsureLockInitialized(ref syncLock))
			{
				if (!Volatile.Read(ref initialized))
				{
					try
					{
						target = Activator.CreateInstance<T>();
					}
					catch (MissingMethodException)
					{
						throw new MissingMemberException(SR.Lazy_CreateValue_NoParameterlessCtorForT);
					}
					Volatile.Write(ref initialized, value: true);
				}
			}
			return target;
		}

		public static T EnsureInitialized<T>([AllowNull] ref T target, ref bool initialized, [NotNullIfNotNull("syncLock")] ref object? syncLock, Func<T> valueFactory)
		{
			if (Volatile.Read(ref initialized))
			{
				return target;
			}
			return EnsureInitializedCore(ref target, ref initialized, ref syncLock, valueFactory);
		}

		private static T EnsureInitializedCore<T>([AllowNull] ref T target, ref bool initialized, [NotNull] ref object syncLock, Func<T> valueFactory)
		{
			lock (EnsureLockInitialized(ref syncLock))
			{
				if (!Volatile.Read(ref initialized))
				{
					target = valueFactory();
					Volatile.Write(ref initialized, value: true);
				}
			}
			return target;
		}

		public static T EnsureInitialized<T>([NotNull] ref T? target, [NotNullIfNotNull("syncLock")] ref object? syncLock, Func<T> valueFactory) where T : class
		{
			return Volatile.Read(ref target) ?? EnsureInitializedCore(ref target, ref syncLock, valueFactory);
		}

		private static T EnsureInitializedCore<T>([NotNull] ref T target, [NotNull] ref object syncLock, Func<T> valueFactory) where T : class
		{
			lock (EnsureLockInitialized(ref syncLock))
			{
				if (Volatile.Read(ref target) == null)
				{
					Volatile.Write(ref target, valueFactory());
					if (target == null)
					{
						throw new InvalidOperationException(SR.Lazy_StaticInit_InvalidOperation);
					}
				}
			}
			return target;
		}

		private static object EnsureLockInitialized([NotNull] ref object syncLock)
		{
			return syncLock ?? Interlocked.CompareExchange(ref syncLock, new object(), null) ?? syncLock;
		}
	}
	public enum LazyThreadSafetyMode
	{
		None,
		PublicationOnly,
		ExecutionAndPublication
	}
	[Serializable]
	[TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class LockRecursionException : Exception
	{
		public LockRecursionException()
		{
		}

		public LockRecursionException(string? message)
			: base(message)
		{
		}

		public LockRecursionException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		protected LockRecursionException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal sealed class LowLevelLock : IDisposable
	{
		private int _state;

		private bool _isAnyWaitingThreadSignaled;

		private LowLevelSpinWaiter _spinWaiter;

		private readonly Func<bool> _spinWaitTryAcquireCallback;

		private LowLevelMonitor _monitor;

		public LowLevelLock()
		{
			_spinWaiter = default(LowLevelSpinWaiter);
			_spinWaitTryAcquireCallback = SpinWaitTryAcquireCallback;
			_monitor.Initialize();
		}

		~LowLevelLock()
		{
			Dispose();
		}

		public void Dispose()
		{
			_monitor.Dispose();
			GC.SuppressFinalize(this);
		}

		public bool TryAcquire()
		{
			int num = Interlocked.CompareExchange(ref _state, 1, 0);
			if (num == 0 || TryAcquire_NoFastPath(num))
			{
				return true;
			}
			return false;
		}

		private bool TryAcquire_NoFastPath(int state)
		{
			if ((state & 1) == 0)
			{
				return Interlocked.CompareExchange(ref _state, state + 1, state) == state;
			}
			return false;
		}

		private bool SpinWaitTryAcquireCallback()
		{
			return TryAcquire_NoFastPath(_state);
		}

		public void Acquire()
		{
			if (!TryAcquire())
			{
				WaitAndAcquire();
			}
		}

		private void WaitAndAcquire()
		{
			if (!_spinWaiter.SpinWaitForCondition(_spinWaitTryAcquireCallback, 8, 4))
			{
				_monitor.Acquire();
				int num = Interlocked.Add(ref _state, 2);
				while (((uint)num & (true ? 1u : 0u)) != 0 || Interlocked.CompareExchange(ref _state, num + -1, num) != num)
				{
					_monitor.Wait();
					_isAnyWaitingThreadSignaled = false;
					num = _state;
				}
				_monitor.Release();
			}
		}

		public void Release()
		{
			if (Interlocked.Decrement(ref _state) != 0)
			{
				SignalWaiter();
			}
		}

		private void SignalWaiter()
		{
			_monitor.Acquire();
			if ((uint)_state >= 2u && !_isAnyWaitingThreadSignaled)
			{
				_isAnyWaitingThreadSignaled = true;
				_monitor.Signal_Release();
			}
			else
			{
				_monitor.Release();
			}
		}
	}
	internal struct LowLevelSpinWaiter
	{
		private int _spinningThreadCount;

		public bool SpinWaitForCondition(Func<bool> condition, int spinCount, int sleep0Threshold)
		{
			int processorCount = Environment.ProcessorCount;
			int num = Interlocked.Increment(ref _spinningThreadCount);
			try
			{
				if (num <= processorCount)
				{
					for (int i = ((processorCount <= 1) ? sleep0Threshold : 0); i < spinCount; i++)
					{
						Wait(i, sleep0Threshold, processorCount);
						if (condition())
						{
							return true;
						}
					}
				}
			}
			finally
			{
				Interlocked.Decrement(ref _spinningThreadCount);
			}
			return false;
		}

		public static void Wait(int spinIndex, int sleep0Threshold, int processorCount)
		{
			if (processorCount > 1 && (spinIndex < sleep0Threshold || (spinIndex - sleep0Threshold) % 2 != 0))
			{
				int num = Thread.OptimalMaxSpinWaitsPerSpinIteration;
				if (spinIndex <= 30 && 1 << spinIndex < num)
				{
					num = 1 << spinIndex;
				}
				Thread.SpinWait(num);
			}
			else
			{
				Thread.UninterruptibleSleep0();
			}
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal struct LowLevelMonitor
	{
		internal struct Monitor
		{
			public Interop.Kernel32.CRITICAL_SECTION _criticalSection;

			public Interop.Kernel32.CONDITION_VARIABLE _conditionVariable;
		}

		private unsafe Monitor* _pMonitor;

		public void Dispose()
		{
			DisposeCore();
		}

		public void Acquire()
		{
			AcquireCore();
		}

		public void Release()
		{
			ReleaseCore();
		}

		public void Wait()
		{
			WaitCore();
		}

		public void Signal_Release()
		{
			Signal_ReleaseCore();
		}

		public unsafe void Initialize()
		{
			_pMonitor = (Monitor*)(void*)Marshal.AllocHGlobal(sizeof(Monitor));
			Interop.Kernel32.InitializeCriticalSection(&_pMonitor->_criticalSection);
			Interop.Kernel32.InitializeConditionVariable(&_pMonitor->_conditionVariable);
		}

		private unsafe void DisposeCore()
		{
			if (_pMonitor != null)
			{
				Interop.Kernel32.DeleteCriticalSection(&_pMonitor->_criticalSection);
				Marshal.FreeHGlobal((IntPtr)_pMonitor);
				_pMonitor = null;
			}
		}

		private unsafe void AcquireCore()
		{
			Interop.Kernel32.EnterCriticalSection(&_pMonitor->_criticalSection);
		}

		private unsafe void ReleaseCore()
		{
			Interop.Kernel32.LeaveCriticalSection(&_pMonitor->_criticalSection);
		}

		private void WaitCore()
		{
			WaitCore(-1);
		}

		private unsafe bool WaitCore(int timeoutMilliseconds)
		{
			return Interop.Kernel32.SleepConditionVariableCS(&_pMonitor->_conditionVariable, &_pMonitor->_criticalSection, timeoutMilliseconds);
		}

		private unsafe void Signal_ReleaseCore()
		{
			Interop.Kernel32.WakeConditionVariable(&_pMonitor->_conditionVariable);
			Interop.Kernel32.LeaveCriticalSection(&_pMonitor->_criticalSection);
		}
	}
	public sealed class ManualResetEvent : EventWaitHandle
	{
		public ManualResetEvent(bool initialState)
			: base(initialState, EventResetMode.ManualReset)
		{
		}
	}
	[DebuggerDisplay("Set = {IsSet}")]
	public class ManualResetEventSlim : IDisposable
	{
		private volatile object m_lock;

		private volatile ManualResetEvent m_eventObj;

		private volatile int m_combinedState;

		private static readonly Action<object> s_cancellationTokenCallback = CancellationTokenCallback;

		public WaitHandle WaitHandle
		{
			get
			{
				ThrowIfDisposed();
				if (m_eventObj == null)
				{
					LazyInitializeEvent();
				}
				return m_eventObj;
			}
		}

		public bool IsSet
		{
			get
			{
				return ExtractStatePortion(m_combinedState, int.MinValue) != 0;
			}
			private set
			{
				UpdateStateAtomically((value ? 1 : 0) << 31, int.MinValue);
			}
		}

		public int SpinCount
		{
			get
			{
				return ExtractStatePortionAndShiftRight(m_combinedState, 1073217536, 19);
			}
			private set
			{
				m_combinedState = (m_combinedState & -1073217537) | (value << 19);
			}
		}

		private int Waiters
		{
			get
			{
				return ExtractStatePortionAndShiftRight(m_combinedState, 524287, 0);
			}
			set
			{
				if (value >= 524287)
				{
					throw new InvalidOperationException(SR.Format(SR.ManualResetEventSlim_ctor_TooManyWaiters, 524287));
				}
				UpdateStateAtomically(value, 524287);
			}
		}

		public ManualResetEventSlim()
			: this(initialState: false)
		{
		}

		public ManualResetEventSlim(bool initialState)
		{
			Initialize(initialState, SpinWait.SpinCountforSpinBeforeWait);
		}

		public ManualResetEventSlim(bool initialState, int spinCount)
		{
			if (spinCount < 0)
			{
				throw new ArgumentOutOfRangeException("spinCount");
			}
			if (spinCount > 2047)
			{
				throw new ArgumentOutOfRangeException("spinCount", SR.Format(SR.ManualResetEventSlim_ctor_SpinCountOutOfRange, 2047));
			}
			Initialize(initialState, spinCount);
		}

		private void Initialize(bool initialState, int spinCount)
		{
			m_combinedState = (initialState ? int.MinValue : 0);
			SpinCount = (Environment.IsSingleProcessor ? 1 : spinCount);
		}

		private void EnsureLockObjectCreated()
		{
			if (m_lock == null)
			{
				object value = new object();
				Interlocked.CompareExchange(ref m_lock, value, null);
			}
		}

		private void LazyInitializeEvent()
		{
			bool isSet = IsSet;
			ManualResetEvent manualResetEvent = new ManualResetEvent(isSet);
			if (Interlocked.CompareExchange(ref m_eventObj, manualResetEvent, null) != null)
			{
				manualResetEvent.Dispose();
				return;
			}
			bool isSet2 = IsSet;
			if (isSet2 == isSet)
			{
				return;
			}
			lock (manualResetEvent)
			{
				if (m_eventObj == manualResetEvent)
				{
					manualResetEvent.Set();
				}
			}
		}

		public void Set()
		{
			Set(duringCancellation: false);
		}

		private void Set(bool duringCancellation)
		{
			IsSet = true;
			if (Waiters > 0)
			{
				lock (m_lock)
				{
					Monitor.PulseAll(m_lock);
				}
			}
			ManualResetEvent eventObj = m_eventObj;
			if (eventObj == null || duringCancellation)
			{
				return;
			}
			lock (eventObj)
			{
				if (m_eventObj != null)
				{
					m_eventObj.Set();
				}
			}
		}

		public void Reset()
		{
			ThrowIfDisposed();
			if (m_eventObj != null)
			{
				m_eventObj.Reset();
			}
			IsSet = false;
		}

		[UnsupportedOSPlatform("browser")]
		public void Wait()
		{
			Wait(-1, CancellationToken.None);
		}

		[UnsupportedOSPlatform("browser")]
		public void Wait(CancellationToken cancellationToken)
		{
			Wait(-1, cancellationToken);
		}

		[UnsupportedOSPlatform("browser")]
		public bool Wait(TimeSpan timeout)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout");
			}
			return Wait((int)num, CancellationToken.None);
		}

		[UnsupportedOSPlatform("browser")]
		public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout");
			}
			return Wait((int)num, cancellationToken);
		}

		[UnsupportedOSPlatform("browser")]
		public bool Wait(int millisecondsTimeout)
		{
			return Wait(millisecondsTimeout, CancellationToken.None);
		}

		[UnsupportedOSPlatform("browser")]
		public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
		{
			ThrowIfDisposed();
			cancellationToken.ThrowIfCancellationRequested();
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout");
			}
			if (!IsSet)
			{
				if (millisecondsTimeout == 0)
				{
					return false;
				}
				uint startTime = 0u;
				bool flag = false;
				int num = millisecondsTimeout;
				if (millisecondsTimeout != -1)
				{
					startTime = TimeoutHelper.GetTime();
					flag = true;
				}
				int spinCount = SpinCount;
				SpinWait spinWait = default(SpinWait);
				while (spinWait.Count < spinCount)
				{
					spinWait.SpinOnce(-1);
					if (IsSet)
					{
						return true;
					}
					if (spinWait.Count >= 100 && spinWait.Count % 10 == 0)
					{
						cancellationToken.ThrowIfCancellationRequested();
					}
				}
				EnsureLockObjectCreated();
				using (cancellationToken.UnsafeRegister(s_cancellationTokenCallback, this))
				{
					lock (m_lock)
					{
						while (!IsSet)
						{
							cancellationToken.ThrowIfCancellationRequested();
							if (flag)
							{
								num = TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout);
								if (num <= 0)
								{
									return false;
								}
							}
							Waiters++;
							if (IsSet)
							{
								Waiters--;
								return true;
							}
							try
							{
								if (!Monitor.Wait(m_lock, num))
								{
									return false;
								}
							}
							finally
							{
								Waiters--;
							}
						}
					}
				}
			}
			return true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (((uint)m_combinedState & 0x40000000u) != 0)
			{
				return;
			}
			m_combinedState |= 1073741824;
			if (!disposing)
			{
				return;
			}
			ManualResetEvent eventObj = m_eventObj;
			if (eventObj == null)
			{
				return;
			}
			lock (eventObj)
			{
				eventObj.Dispose();
				m_eventObj = null;
			}
		}

		private void ThrowIfDisposed()
		{
			if (((uint)m_combinedState & 0x40000000u) != 0)
			{
				throw new ObjectDisposedException(SR.ManualResetEventSlim_Disposed);
			}
		}

		private static void CancellationTokenCallback(object obj)
		{
			ManualResetEventSlim manualResetEventSlim = (ManualResetEventSlim)obj;
			lock (manualResetEventSlim.m_lock)
			{
				Monitor.PulseAll(manualResetEventSlim.m_lock);
			}
		}

		private void UpdateStateAtomically(int newBits, int updateBitsMask)
		{
			SpinWait spinWait = default(SpinWait);
			while (true)
			{
				int combinedState = m_combinedState;
				int value = (combinedState & ~updateBitsMask) | newBits;
				if (Interlocked.CompareExchange(ref m_combinedState, value, combinedState) == combinedState)
				{
					break;
				}
				spinWait.SpinOnce(-1);
			}
		}

		private static int ExtractStatePortionAndShiftRight(int state, int mask, int rightBitShiftCount)
		{
			return (state & mask) >>> rightBitShiftCount;
		}

		private static int ExtractStatePortion(int state, int mask)
		{
			return state & mask;
		}
	}
	public sealed class Mutex : WaitHandle
	{
		public Mutex(bool initiallyOwned, string? name, out bool createdNew)
		{
			CreateMutexCore(initiallyOwned, name, out createdNew);
		}

		public Mutex(bool initiallyOwned, string? name)
		{
			CreateMutexCore(initiallyOwned, name, out var _);
		}

		public Mutex(bool initiallyOwned)
		{
			CreateMutexCore(initiallyOwned, null, out var _);
		}

		public Mutex()
		{
			CreateMutexCore(initiallyOwned: false, null, out var _);
		}

		private Mutex(SafeWaitHandle handle)
		{
			base.SafeWaitHandle = handle;
		}

		public static Mutex OpenExisting(string name)
		{
			Mutex result;
			return OpenExistingWorker(name, out result) switch
			{
				OpenExistingResult.NameNotFound => throw new WaitHandleCannotBeOpenedException(), 
				OpenExistingResult.NameInvalid => throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name)), 
				OpenExistingResult.PathNotFound => throw new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, name)), 
				_ => result, 
			};
		}

		public static bool TryOpenExisting(string name, [NotNullWhen(true)] out Mutex? result)
		{
			return OpenExistingWorker(name, out result) == OpenExistingResult.Success;
		}

		private void CreateMutexCore(bool initiallyOwned, string name, out bool createdNew)
		{
			uint flags = (initiallyOwned ? 1u : 0u);
			SafeWaitHandle safeWaitHandle = Interop.Kernel32.CreateMutexEx(IntPtr.Zero, name, flags, 34603009u);
			int lastPInvokeError = Marshal.GetLastPInvokeError();
			if (safeWaitHandle.IsInvalid)
			{
				safeWaitHandle.SetHandleAsInvalid();
				if (lastPInvokeError == 6)
				{
					throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name));
				}
				throw Win32Marshal.GetExceptionForWin32Error(lastPInvokeError, name);
			}
			createdNew = lastPInvokeError != 183;
			base.SafeWaitHandle = safeWaitHandle;
		}

		private static OpenExistingResult OpenExistingWorker(string name, out Mutex result)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			result = null;
			SafeWaitHandle safeWaitHandle = Interop.Kernel32.OpenMutex(34603009u, inheritHandle: false, name);
			if (safeWaitHandle.IsInvalid)
			{
				int lastPInvokeError = Marshal.GetLastPInvokeError();
				if (2 == lastPInvokeError || 123 == lastPInvokeError)
				{
					return OpenExistingResult.NameNotFound;
				}
				if (3 == lastPInvokeError)
				{
					return OpenExistingResult.PathNotFound;
				}
				if (6 == lastPInvokeError)
				{
					return OpenExistingResult.NameInvalid;
				}
				throw Win32Marshal.GetExceptionForWin32Error(lastPInvokeError, name);
			}
			result = new Mutex(safeWaitHandle);
			return OpenExistingResult.Success;
		}

		public void ReleaseMutex()
		{
			if (!Interop.Kernel32.ReleaseMutex(base.SafeWaitHandle))
			{
				throw new ApplicationException(SR.Arg_SynchronizationLockException);
			}
		}
	}
	public struct NativeOverlapped
	{
		public IntPtr InternalLow;

		public IntPtr InternalHigh;

		public int OffsetLow;

		public int OffsetHigh;

		public IntPtr EventHandle;
	}
	public delegate void ParameterizedThreadStart(object? obj);
	public enum LockRecursionPolicy
	{
		NoRecursion,
		SupportsRecursion
	}
	internal sealed class ReaderWriterCount
	{
		public long lockID;

		public int readercount;

		public int writercount;

		public int upgradecount;

		public ReaderWriterCount next;
	}
	public class ReaderWriterLockSlim : IDisposable
	{
		private struct TimeoutTracker
		{
			private readonly int _total;

			private readonly int _start;

			public int RemainingMilliseconds
			{
				get
				{
					if (_total == -1 || _total == 0)
					{
						return _total;
					}
					int num = Environment.TickCount - _start;
					if (num < 0 || num >= _total)
					{
						return 0;
					}
					return _total - num;
				}
			}

			public bool IsExpired => RemainingMilliseconds == 0;

			public TimeoutTracker(TimeSpan timeout)
			{
				long num = (long)timeout.TotalMilliseconds;
				if (num < -1 || num > int.MaxValue)
				{
					throw new ArgumentOutOfRangeException("timeout");
				}
				_total = (int)num;
				if (_total != -1 && _total != 0)
				{
					_start = Environment.TickCount;
				}
				else
				{
					_start = 0;
				}
			}

			public TimeoutTracker(int millisecondsTimeout)
			{
				if (millisecondsTimeout < -1)
				{
					throw new ArgumentOutOfRangeException("millisecondsTimeout");
				}
				_total = millisecondsTimeout;
				if (_total != -1 && _total != 0)
				{
					_start = Environment.TickCount;
				}
				else
				{
					_start = 0;
				}
			}
		}

		private struct SpinLock
		{
			private int _isLocked;

			private int _enterDeprioritizationState;

			private ushort EnterForEnterAnyReadDeprioritizedCount => (ushort)((uint)_enterDeprioritizationState >> 16);

			private ushort EnterForEnterAnyWriteDeprioritizedCount => (ushort)_enterDeprioritizationState;

			private static int GetEnterDeprioritizationStateChange(EnterSpinLockReason reason)
			{
				return (reason & EnterSpinLockReason.OperationMask) switch
				{
					EnterSpinLockReason.EnterAnyRead => 0, 
					EnterSpinLockReason.ExitAnyRead => 1, 
					EnterSpinLockReason.EnterWrite => 65536, 
					_ => 65537, 
				};
			}

			private bool IsEnterDeprioritized(EnterSpinLockReason reason)
			{
				return reason switch
				{
					EnterSpinLockReason.EnterAnyRead => EnterForEnterAnyReadDeprioritizedCount != 0, 
					EnterSpinLockReason.EnterWrite => EnterForEnterAnyWriteDeprioritizedCount != 0, 
					EnterSpinLockReason.UpgradeToWrite => EnterForEnterAnyWriteDeprioritizedCount > 1, 
					_ => false, 
				};
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private bool TryEnter()
			{
				return Interlocked.CompareExchange(ref _isLocked, 1, 0) == 0;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Enter(EnterSpinLockReason reason)
			{
				if (!TryEnter())
				{
					EnterSpin(reason);
				}
			}

			private void EnterSpin(EnterSpinLockReason reason)
			{
				int enterDeprioritizationStateChange = GetEnterDeprioritizationStateChange(reason);
				if (enterDeprioritizationStateChange != 0)
				{
					Interlocked.Add(ref _enterDeprioritizationState, enterDeprioritizationStateChange);
				}
				int processorCount = Environment.ProcessorCount;
				int num = 0;
				while (true)
				{
					if (num < 10 && processorCount > 1)
					{
						Thread.SpinWait(20 * (num + 1));
					}
					else if (num < 15)
					{
						Thread.Sleep(0);
					}
					else
					{
						Thread.Sleep(1);
					}
					if (!IsEnterDeprioritized(reason))
					{
						if (_isLocked == 0 && TryEnter())
						{
							break;
						}
					}
					else if (num >= 20)
					{
						reason |= EnterSpinLockReason.Wait;
						num = -1;
					}
					num++;
				}
				if (enterDeprioritizationStateChange != 0)
				{
					Interlocked.Add(ref _enterDeprioritizationState, -enterDeprioritizationStateChange);
				}
			}

			public void Exit()
			{
				Volatile.Write(ref _isLocked, 0);
			}
		}

		[Flags]
		private enum WaiterStates : byte
		{
			None = 0,
			NoWaiters = 1,
			WriteWaiterSignaled = 2,
			UpgradeableReadWaiterSignaled = 4
		}

		private enum EnterSpinLockReason
		{
			EnterAnyRead = 0,
			ExitAnyRead = 1,
			EnterWrite = 2,
			UpgradeToWrite = 3,
			EnterRecursiveWrite = 4,
			ExitAnyWrite = 5,
			OperationMask = 7,
			Wait = 8
		}

		private enum EnterLockType
		{
			Read,
			UpgradeableRead,
			Write,
			UpgradeToWrite
		}

		private readonly bool _fIsReentrant;

		private SpinLock _spinLock;

		private uint _numWriteWaiters;

		private uint _numReadWaiters;

		private uint _numWriteUpgradeWaiters;

		private uint _numUpgradeWaiters;

		private WaiterStates _waiterStates;

		private int _upgradeLockOwnerId;

		private int _writeLockOwnerId;

		private EventWaitHandle _writeEvent;

		private EventWaitHandle _readEvent;

		private EventWaitHandle _upgradeEvent;

		private EventWaitHandle _waitUpgradeEvent;

		private static long s_nextLockID;

		private readonly long _lockID;

		[ThreadStatic]
		private static ReaderWriterCount t_rwc;

		private bool _fUpgradeThreadHoldingRead;

		private uint _owners;

		private bool _fDisposed;

		private bool HasNoWaiters
		{
			get
			{
				return (_waiterStates & WaiterStates.NoWaiters) != 0;
			}
			set
			{
				if (value)
				{
					_waiterStates |= WaiterStates.NoWaiters;
				}
				else
				{
					_waiterStates &= ~WaiterStates.NoWaiters;
				}
			}
		}

		public bool IsReadLockHeld
		{
			get
			{
				if (RecursiveReadCount > 0)
				{
					return true;
				}
				return false;
			}
		}

		public bool IsUpgradeableReadLockHeld
		{
			get
			{
				if (RecursiveUpgradeCount > 0)
				{
					return true;
				}
				return false;
			}
		}

		public bool IsWriteLockHeld
		{
			get
			{
				if (RecursiveWriteCount > 0)
				{
					return true;
				}
				return false;
			}
		}

		public LockRecursionPolicy RecursionPolicy
		{
			get
			{
				if (_fIsReentrant)
				{
					return LockRecursionPolicy.SupportsRecursion;
				}
				return LockRecursionPolicy.NoRecursion;
			}
		}

		public int CurrentReadCount
		{
			get
			{
				int numReaders = (int)GetNumReaders();
				if (_upgradeLockOwnerId != -1)
				{
					return numReaders - 1;
				}
				return numReaders;
			}
		}

		public int RecursiveReadCount
		{
			get
			{
				int result = 0;
				ReaderWriterCount threadRWCount = GetThreadRWCount(dontAllocate: true);
				if (threadRWCount != null)
				{
					result = threadRWCount.readercount;
				}
				return result;
			}
		}

		public int RecursiveUpgradeCount
		{
			get
			{
				if (_fIsReentrant)
				{
					int result = 0;
					ReaderWriterCount threadRWCount = GetThreadRWCount(dontAllocate: true);
					if (threadRWCount != null)
					{
						result = threadRWCount.upgradecount;
					}
					return result;
				}
				if (Environment.CurrentManagedThreadId == _upgradeLockOwnerId)
				{
					return 1;
				}
				return 0;
			}
		}

		public int RecursiveWriteCount
		{
			get
			{
				if (_fIsReentrant)
				{
					int result = 0;
					ReaderWriterCount threadRWCount = GetThreadRWCount(dontAllocate: true);
					if (threadRWCount != null)
					{
						result = threadRWCount.writercount;
					}
					return result;
				}
				if (Environment.CurrentManagedThreadId == _writeLockOwnerId)
				{
					return 1;
				}
				return 0;
			}
		}

		public int WaitingReadCount => (int)_numReadWaiters;

		public int WaitingUpgradeCount => (int)_numUpgradeWaiters;

		public int WaitingWriteCount => (int)_numWriteWaiters;

		private void InitializeThreadCounts()
		{
			_upgradeLockOwnerId = -1;
			_writeLockOwnerId = -1;
		}

		public ReaderWriterLockSlim()
			: this(LockRecursionPolicy.NoRecursion)
		{
		}

		public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy)
		{
			if (recursionPolicy == LockRecursionPolicy.SupportsRecursion)
			{
				_fIsReentrant = true;
			}
			InitializeThreadCounts();
			_waiterStates = WaiterStates.NoWaiters;
			_lockID = Interlocked.Increment(ref s_nextLockID);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsRWEntryEmpty(ReaderWriterCount rwc)
		{
			if (rwc.lockID == 0L)
			{
				return true;
			}
			if (rwc.readercount == 0 && rwc.writercount == 0 && rwc.upgradecount == 0)
			{
				return true;
			}
			return false;
		}

		private bool IsRwHashEntryChanged(ReaderWriterCount lrwc)
		{
			return lrwc.lockID != _lockID;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ReaderWriterCount GetThreadRWCount(bool dontAllocate)
		{
			ReaderWriterCount next = t_rwc;
			ReaderWriterCount readerWriterCount = null;
			while (next != null)
			{
				if (next.lockID == _lockID)
				{
					return next;
				}
				if (!dontAllocate && readerWriterCount == null && IsRWEntryEmpty(next))
				{
					readerWriterCount = next;
				}
				next = next.next;
			}
			if (dontAllocate)
			{
				return null;
			}
			if (readerWriterCount == null)
			{
				readerWriterCount = new ReaderWriterCount();
				readerWriterCount.next = t_rwc;
				t_rwc = readerWriterCount;
			}
			readerWriterCount.lockID = _lockID;
			return readerWriterCount;
		}

		public void EnterReadLock()
		{
			TryEnterReadLock(-1);
		}

		public bool TryEnterReadLock(TimeSpan timeout)
		{
			return TryEnterReadLock(new TimeoutTracker(timeout));
		}

		public bool TryEnterReadLock(int millisecondsTimeout)
		{
			return TryEnterReadLock(new TimeoutTracker(millisecondsTimeout));
		}

		private bool TryEnterReadLock(TimeoutTracker timeout)
		{
			return TryEnterReadLockCore(timeout);
		}

		private bool TryEnterReadLockCore(TimeoutTracker timeout)
		{
			if (_fDisposed)
			{
				throw new ObjectDisposedException(null);
			}
			int currentManagedThreadId = Environment.CurrentManagedThreadId;
			ReaderWriterCount threadRWCount;
			if (!_fIsReentrant)
			{
				if (currentManagedThreadId == _writeLockOwnerId)
				{
					throw new LockRecursionException(SR.LockRecursionException_ReadAfterWriteNotAllowed);
				}
				_spinLock.Enter(EnterSpinLockReason.EnterAnyRead);
				threadRWCount = GetThreadRWCount(dontAllocate: false);
				if (threadRWCount.readercount > 0)
				{
					_spinLock.Exit();
					throw new LockRecursionException(SR.LockRecursionException_RecursiveReadNotAllowed);
				}
				if (currentManagedThreadId == _upgradeLockOwnerId)
				{
					threadRWCount.readercount++;
					_owners++;
					_spinLock.Exit();
					return true;
				}
			}
			else
			{
				_spinLock.Enter(EnterSpinLockReason.EnterAnyRead);
				threadRWCount = GetThreadRWCount(dontAllocate: false);
				if (threadRWCount.readercount > 0)
				{
					threadRWCount.readercount++;
					_spinLock.Exit();
					return true;
				}
				if (currentManagedThreadId == _upgradeLockOwnerId)
				{
					threadRWCount.readercount++;
					_owners++;
					_spinLock.Exit();
					_fUpgradeThreadHoldingRead = true;
					return true;
				}
				if (currentManagedThreadId == _writeLockOwnerId)
				{
					threadRWCount.readercount++;
					_owners++;
					_spinLock.Exit();
					return true;
				}
			}
			bool flag = true;
			int num = 0;
			while (true)
			{
				if (_owners < 268435454)
				{
					_owners++;
					threadRWCount.readercount++;
					_spinLock.Exit();
					return flag;
				}
				if (timeout.IsExpired)
				{
					_spinLock.Exit();
					return false;
				}
				if (num < 20 && ShouldSpinForEnterAnyRead())
				{
					_spinLock.Exit();
					num++;
					SpinWait(num);
					_spinLock.Enter(EnterSpinLockReason.EnterAnyRead);
					if (IsRwHashEntryChanged(threadRWCount))
					{
						threadRWCount = GetThreadRWCount(dontAllocate: false);
					}
				}
				else if (_readEvent == null)
				{
					LazyCreateEvent(ref _readEvent, EnterLockType.Read);
					if (IsRwHashEntryChanged(threadRWCount))
					{
						threadRWCount = GetThreadRWCount(dontAllocate: false);
					}
				}
				else
				{
					flag = WaitOnEvent(_readEvent, ref _numReadWaiters, timeout, EnterLockType.Read);
					if (!flag)
					{
						break;
					}
					if (IsRwHashEntryChanged(threadRWCount))
					{
						threadRWCount = GetThreadRWCount(dontAllocate: false);
					}
				}
			}
			return false;
		}

		public void EnterWriteLock()
		{
			TryEnterWriteLock(-1);
		}

		public bool TryEnterWriteLock(TimeSpan timeout)
		{
			return TryEnterWriteLock(new TimeoutTracker(timeout));
		}

		public bool TryEnterWriteLock(int millisecondsTimeout)
		{
			return TryEnterWriteLock(new TimeoutTracker(millisecondsTimeout));
		}

		private bool TryEnterWriteLock(TimeoutTracker timeout)
		{
			return TryEnterWriteLockCore(timeout);
		}

		private bool TryEnterWriteLockCore(TimeoutTracker timeout)
		{
			if (_fDisposed)
			{
				throw new ObjectDisposedException(null);
			}
			int currentManagedThreadId = Environment.CurrentManagedThreadId;
			bool flag = false;
			ReaderWriterCount threadRWCount;
			if (!_fIsReentrant)
			{
				if (currentManagedThreadId == _writeLockOwnerId)
				{
					throw new LockRecursionException(SR.LockRecursionException_RecursiveWriteNotAllowed);
				}
				EnterSpinLockReason reason;
				if (currentManagedThreadId == _upgradeLockOwnerId)
				{
					flag = true;
					reason = EnterSpinLockReason.UpgradeToWrite;
				}
				else
				{
					reason = EnterSpinLockReason.EnterWrite;
				}
				_spinLock.Enter(reason);
				threadRWCount = GetThreadRWCount(dontAllocate: true);
				if (threadRWCount != null && threadRWCount.readercount > 0)
				{
					_spinLock.Exit();
					throw new LockRecursionException(SR.LockRecursionException_WriteAfterReadNotAllowed);
				}
			}
			else
			{
				EnterSpinLockReason reason2 = ((currentManagedThreadId == _writeLockOwnerId) ? EnterSpinLockReason.EnterRecursiveWrite : ((currentManagedThreadId != _upgradeLockOwnerId) ? EnterSpinLockReason.EnterWrite : EnterSpinLockReason.UpgradeToWrite));
				_spinLock.Enter(reason2);
				threadRWCount = GetThreadRWCount(dontAllocate: false);
				if (currentManagedThreadId == _writeLockOwnerId)
				{
					threadRWCount.writercount++;
					_spinLock.Exit();
					return true;
				}
				if (currentManagedThreadId == _upgradeLockOwnerId)
				{
					flag = true;
				}
				else if (threadRWCount.readercount > 0)
				{
					_spinLock.Exit();
					throw new LockRecursionException(SR.LockRecursionException_WriteAfterReadNotAllowed);
				}
			}
			bool flag2 = true;
			int num = 0;
			while (true)
			{
				if (IsWriterAcquired())
				{
					SetWriterAcquired();
					break;
				}
				if (flag)
				{
					uint numReaders = GetNumReaders();
					if (numReaders == 1)
					{
						SetWriterAcquired();
						break;
					}
					if (numReaders == 2 && threadRWCount != null)
					{
						if (IsRwHashEntryChanged(threadRWCount))
						{
							threadRWCount = GetThreadRWCount(dontAllocate: false);
						}
						if (threadRWCount.readercount > 0)
						{
							SetWriterAcquired();
							break;
						}
					}
				}
				if (timeout.IsExpired)
				{
					_spinLock.Exit();
					return false;
				}
				if (num < 20 && ShouldSpinForEnterAnyWrite(flag))
				{
					_spinLock.Exit();
					num++;
					SpinWait(num);
					_spinLock.Enter(flag ? EnterSpinLockReason.UpgradeToWrite : EnterSpinLockReason.EnterWrite);
				}
				else if (flag)
				{
					if (_waitUpgradeEvent == null)
					{
						LazyCreateEvent(ref _waitUpgradeEvent, EnterLockType.UpgradeToWrite);
					}
					else if (!WaitOnEvent(_waitUpgradeEvent, ref _numWriteUpgradeWaiters, timeout, EnterLockType.UpgradeToWrite))
					{
						return false;
					}
				}
				else if (_writeEvent == null)
				{
					LazyCreateEvent(ref _writeEvent, EnterLockType.Write);
				}
				else if (!WaitOnEvent(_writeEvent, ref _numWriteWaiters, timeout, EnterLockType.Write))
				{
					return false;
				}
			}
			if (_fIsReentrant)
			{
				if (IsRwHashEntryChanged(threadRWCount))
				{
					threadRWCount = GetThreadRWCount(dontAllocate: false);
				}
				threadRWCount.writercount++;
			}
			_spinLock.Exit();
			_writeLockOwnerId = currentManagedThreadId;
			return true;
		}

		public void EnterUpgradeableReadLock()
		{
			TryEnterUpgradeableReadLock(-1);
		}

		public bool TryEnterUpgradeableReadLock(TimeSpan timeout)
		{
			return TryEnterUpgradeableReadLock(new TimeoutTracker(timeout));
		}

		public bool TryEnterUpgradeableReadLock(int millisecondsTimeout)
		{
			return TryEnterUpgradeableReadLock(new TimeoutTracker(millisecondsTimeout));
		}

		private bool TryEnterUpgradeableReadLock(TimeoutTracker timeout)
		{
			return TryEnterUpgradeableReadLockCore(timeout);
		}

		private bool TryEnterUpgradeableReadLockCore(TimeoutTracker timeout)
		{
			if (_fDisposed)
			{
				throw new ObjectDisposedException(null);
			}
			int currentManagedThreadId = Environment.CurrentManagedThreadId;
			ReaderWriterCount threadRWCount;
			if (!_fIsReentrant)
			{
				if (currentManagedThreadId == _upgradeLockOwnerId)
				{
					throw new LockRecursionException(SR.LockRecursionException_RecursiveUpgradeNotAllowed);
				}
				if (currentManagedThreadId == _writeLockOwnerId)
				{
					throw new LockRecursionException(SR.LockRecursionException_UpgradeAfterWriteNotAllowed);
				}
				_spinLock.Enter(EnterSpinLockReason.EnterAnyRead);
				threadRWCount = GetThreadRWCount(dontAllocate: true);
				if (threadRWCount != null && threadRWCount.readercount > 0)
				{
					_spinLock.Exit();
					throw new LockRecursionException(SR.LockRecursionException_UpgradeAfterReadNotAllowed);
				}
			}
			else
			{
				_spinLock.Enter(EnterSpinLockReason.EnterAnyRead);
				threadRWCount = GetThreadRWCount(dontAllocate: false);
				if (currentManagedThreadId == _upgradeLockOwnerId)
				{
					threadRWCount.upgradecount++;
					_spinLock.Exit();
					return true;
				}
				if (currentManagedThreadId == _writeLockOwnerId)
				{
					_owners++;
					_upgradeLockOwnerId = currentManagedThreadId;
					threadRWCount.upgradecount++;
					if (threadRWCount.readercount > 0)
					{
						_fUpgradeThreadHoldingRead = true;
					}
					_spinLock.Exit();
					return true;
				}
				if (threadRWCount.readercount > 0)
				{
					_spinLock.Exit();
					throw new LockRecursionException(SR.LockRecursionException_UpgradeAfterReadNotAllowed);
				}
			}
			bool flag = true;
			int num = 0;
			while (true)
			{
				if (_upgradeLockOwnerId == -1 && _owners < 268435454)
				{
					_owners++;
					_upgradeLockOwnerId = currentManagedThreadId;
					if (_fIsReentrant)
					{
						if (IsRwHashEntryChanged(threadRWCount))
						{
							threadRWCount = GetThreadRWCount(dontAllocate: false);
						}
						threadRWCount.upgradecount++;
					}
					break;
				}
				if (timeout.IsExpired)
				{
					_spinLock.Exit();
					return false;
				}
				if (num < 20 && ShouldSpinForEnterAnyRead())
				{
					_spinLock.Exit();
					num++;
					SpinWait(num);
					_spinLock.Enter(EnterSpinLockReason.EnterAnyRead);
				}
				else if (_upgradeEvent == null)
				{
					LazyCreateEvent(ref _upgradeEvent, EnterLockType.UpgradeableRead);
				}
				else if (!WaitOnEvent(_upgradeEvent, ref _numUpgradeWaiters, timeout, EnterLockType.UpgradeableRead))
				{
					return false;
				}
			}
			_spinLock.Exit();
			return true;
		}

		public void ExitReadLock()
		{
			_spinLock.Enter(EnterSpinLockReason.ExitAnyRead);
			ReaderWriterCount threadRWCount = GetThreadRWCount(dontAllocate: true);
			if (threadRWCount == null || threadRWCount.readercount < 1)
			{
				_spinLock.Exit();
				throw new SynchronizationLockException(SR.SynchronizationLockException_MisMatchedRead);
			}
			if (_fIsReentrant)
			{
				if (threadRWCount.readercount > 1)
				{
					threadRWCount.readercount--;
					_spinLock.Exit();
					return;
				}
				if (Environment.CurrentManagedThreadId == _upgradeLockOwnerId)
				{
					_fUpgradeThreadHoldingRead = false;
				}
			}
			_owners--;
			threadRWCount.readercount--;
			ExitAndWakeUpAppropriateWaiters();
		}

		public void ExitWriteLock()
		{
			if (!_fIsReentrant)
			{
				if (Environment.CurrentManagedThreadId != _writeLockOwnerId)
				{
					throw new SynchronizationLockException(SR.SynchronizationLockException_MisMatchedWrite);
				}
				_spinLock.Enter(EnterSpinLockReason.ExitAnyWrite);
			}
			else
			{
				_spinLock.Enter(EnterSpinLockReason.ExitAnyWrite);
				ReaderWriterCount threadRWCount = GetThreadRWCount(dontAllocate: false);
				if (threadRWCount == null)
				{
					_spinLock.Exit();
					throw new SynchronizationLockException(SR.SynchronizationLockException_MisMatchedWrite);
				}
				if (threadRWCount.writercount < 1)
				{
					_spinLock.Exit();
					throw new SynchronizationLockException(SR.SynchronizationLockException_MisMatchedWrite);
				}
				threadRWCount.writercount--;
				if (threadRWCount.writercount > 0)
				{
					_spinLock.Exit();
					return;
				}
			}
			ClearWriterAcquired();
			_writeLockOwnerId = -1;
			ExitAndWakeUpAppropriateWaiters();
		}

		public void ExitUpgradeableReadLock()
		{
			if (!_fIsReentrant)
			{
				if (Environment.CurrentManagedThreadId != _upgradeLockOwnerId)
				{
					throw new SynchronizationLockException(SR.SynchronizationLockException_MisMatchedUpgrade);
				}
				_spinLock.Enter(EnterSpinLockReason.ExitAnyRead);
			}
			else
			{
				_spinLock.Enter(EnterSpinLockReason.ExitAnyRead);
				ReaderWriterCount threadRWCount = GetThreadRWCount(dontAllocate: true);
				if (threadRWCount == null)
				{
					_spinLock.Exit();
					throw new SynchronizationLockException(SR.SynchronizationLockException_MisMatchedUpgrade);
				}
				if (threadRWCount.upgradecount < 1)
				{
					_spinLock.Exit();
					throw new SynchronizationLockException(SR.SynchronizationLockException_MisMatchedUpgrade);
				}
				threadRWCount.upgradecount--;
				if (threadRWCount.upgradecount > 0)
				{
					_spinLock.Exit();
					return;
				}
				_fUpgradeThreadHoldingRead = false;
			}
			_owners--;
			_upgradeLockOwnerId = -1;
			ExitAndWakeUpAppropriateWaiters();
		}

		private void LazyCreateEvent([NotNull] ref EventWaitHandle waitEvent, EnterLockType enterLockType)
		{
			_spinLock.Exit();
			EventWaitHandle eventWaitHandle = new EventWaitHandle(initialState: false, (enterLockType == EnterLockType.Read) ? EventResetMode.ManualReset : EventResetMode.AutoReset);
			EnterSpinLockReason reason;
			switch (enterLockType)
			{
			case EnterLockType.Read:
			case EnterLockType.UpgradeableRead:
				reason = EnterSpinLockReason.Wait;
				break;
			case EnterLockType.Write:
				reason = (EnterSpinLockReason)10;
				break;
			default:
				reason = (EnterSpinLockReason)11;
				break;
			}
			_spinLock.Enter(reason);
			if (waitEvent == null)
			{
				waitEvent = eventWaitHandle;
			}
			else
			{
				eventWaitHandle.Dispose();
			}
		}

		private bool WaitOnEvent(EventWaitHandle waitEvent, ref uint numWaiters, TimeoutTracker timeout, EnterLockType enterLockType)
		{
			WaiterStates waiterStates = WaiterStates.None;
			EnterSpinLockReason reason;
			switch (enterLockType)
			{
			case EnterLockType.UpgradeableRead:
				waiterStates = WaiterStates.UpgradeableReadWaiterSignaled;
				goto case EnterLockType.Read;
			case EnterLockType.Read:
				reason = EnterSpinLockReason.EnterAnyRead;
				break;
			case EnterLockType.Write:
				waiterStates = WaiterStates.WriteWaiterSignaled;
				reason = EnterSpinLockReason.EnterWrite;
				break;
			default:
				reason = EnterSpinLockReason.UpgradeToWrite;
				break;
			}
			if (waiterStates != 0 && (_waiterStates & waiterStates) != 0)
			{
				_waiterStates &= (WaiterStates)(byte)(~(int)waiterStates);
			}
			waitEvent.Reset();
			numWaiters++;
			HasNoWaiters = false;
			if (_numWriteWaiters == 1)
			{
				SetWritersWaiting();
			}
			if (_numWriteUpgradeWaiters == 1)
			{
				SetUpgraderWaiting();
			}
			bool flag = false;
			_spinLock.Exit();
			try
			{
				flag = waitEvent.WaitOne(timeout.RemainingMilliseconds);
			}
			finally
			{
				_spinLock.Enter(reason);
				numWaiters--;
				if (flag && waiterStates != 0 && (_waiterStates & waiterStates) != 0)
				{
					_waiterStates &= (WaiterStates)(byte)(~(int)waiterStates);
				}
				if (_numWriteWaiters == 0 && _numWriteUpgradeWaiters == 0 && _numUpgradeWaiters == 0 && _numReadWaiters == 0)
				{
					HasNoWaiters = true;
				}
				if (_numWriteWaiters == 0)
				{
					ClearWritersWaiting();
				}
				if (_numWriteUpgradeWaiters == 0)
				{
					ClearUpgraderWaiting();
				}
				if (!flag)
				{
					if (enterLockType >= EnterLockType.Write)
					{
						ExitAndWakeUpAppropriateReadWaiters();
					}
					else
					{
						_spinLock.Exit();
					}
				}
			}
			return flag;
		}

		private void ExitAndWakeUpAppropriateWaiters()
		{
			if (HasNoWaiters)
			{
				_spinLock.Exit();
			}
			else
			{
				ExitAndWakeUpAppropriateWaitersPreferringWriters();
			}
		}

		private void ExitAndWakeUpAppropriateWaitersPreferringWriters()
		{
			uint numReaders = GetNumReaders();
			if (_fIsReentrant && _numWriteUpgradeWaiters != 0 && _fUpgradeThreadHoldingRead && numReaders == 2)
			{
				_spinLock.Exit();
				_waitUpgradeEvent.Set();
			}
			else if (numReaders == 1 && _numWriteUpgradeWaiters != 0)
			{
				_spinLock.Exit();
				_waitUpgradeEvent.Set();
			}
			else if (numReaders == 0 && _numWriteWaiters != 0)
			{
				WaiterStates waiterStates = _waiterStates & WaiterStates.WriteWaiterSignaled;
				if (waiterStates == WaiterStates.None)
				{
					_waiterStates |= WaiterStates.WriteWaiterSignaled;
				}
				_spinLock.Exit();
				if (waiterStates == WaiterStates.None)
				{
					_writeEvent.Set();
				}
			}
			else
			{
				ExitAndWakeUpAppropriateReadWaiters();
			}
		}

		private void ExitAndWakeUpAppropriateReadWaiters()
		{
			if (_numWriteWaiters != 0 || _numWriteUpgradeWaiters != 0 || HasNoWaiters)
			{
				_spinLock.Exit();
				return;
			}
			bool flag = _numReadWaiters != 0;
			bool flag2 = _numUpgradeWaiters != 0 && _upgradeLockOwnerId == -1;
			if (flag2)
			{
				if ((_waiterStates & WaiterStates.UpgradeableReadWaiterSignaled) == 0)
				{
					_waiterStates |= WaiterStates.UpgradeableReadWaiterSignaled;
				}
				else
				{
					flag2 = false;
				}
			}
			_spinLock.Exit();
			if (flag)
			{
				_readEvent.Set();
			}
			if (flag2)
			{
				_upgradeEvent.Set();
			}
		}

		private bool IsWriterAcquired()
		{
			return (_owners & 0xBFFFFFFFu) == 0;
		}

		private void SetWriterAcquired()
		{
			_owners |= 2147483648u;
		}

		private void ClearWriterAcquired()
		{
			_owners &= 2147483647u;
		}

		private void SetWritersWaiting()
		{
			_owners |= 1073741824u;
		}

		private void ClearWritersWaiting()
		{
			_owners &= 3221225471u;
		}

		private void SetUpgraderWaiting()
		{
			_owners |= 536870912u;
		}

		private void ClearUpgraderWaiting()
		{
			_owners &= 3758096383u;
		}

		private uint GetNumReaders()
		{
			return _owners & 0xFFFFFFFu;
		}

		private bool ShouldSpinForEnterAnyRead()
		{
			if (!HasNoWaiters)
			{
				if (_numWriteWaiters == 0)
				{
					return _numWriteUpgradeWaiters == 0;
				}
				return false;
			}
			return true;
		}

		private bool ShouldSpinForEnterAnyWrite(bool isUpgradeToWrite)
		{
			if (!isUpgradeToWrite)
			{
				return _numWriteUpgradeWaiters == 0;
			}
			return true;
		}

		private static void SpinWait(int spinCount)
		{
			if (spinCount < 5 && Environment.ProcessorCount > 1)
			{
				Thread.SpinWait(20 * spinCount);
			}
			else
			{
				Thread.Sleep(0);
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
		}

		private void Dispose(bool disposing)
		{
			if (disposing && !_fDisposed)
			{
				if (WaitingReadCount > 0 || WaitingUpgradeCount > 0 || WaitingWriteCount > 0)
				{
					throw new SynchronizationLockException(SR.SynchronizationLockException_IncorrectDispose);
				}
				if (IsReadLockHeld || IsUpgradeableReadLockHeld || IsWriteLockHeld)
				{
					throw new SynchronizationLockException(SR.SynchronizationLockException_IncorrectDispose);
				}
				if (_writeEvent != null)
				{
					_writeEvent.Dispose();
					_writeEvent = null;
				}
				if (_readEvent != null)
				{
					_readEvent.Dispose();
					_readEvent = null;
				}
				if (_upgradeEvent != null)
				{
					_upgradeEvent.Dispose();
					_upgradeEvent = null;
				}
				if (_waitUpgradeEvent != null)
				{
					_waitUpgradeEvent.Dispose();
					_waitUpgradeEvent = null;
				}
				_fDisposed = true;
			}
		}
	}
	public sealed class Semaphore : WaitHandle
	{
		public Semaphore(int initialCount, int maximumCount)
			: this(initialCount, maximumCount, null)
		{
		}

		public Semaphore(int initialCount, int maximumCount, string? name)
			: this(initialCount, maximumCount, name, out var _)
		{
		}

		public Semaphore(int initialCount, int maximumCount, string? name, out bool createdNew)
		{
			if (initialCount < 0)
			{
				throw new ArgumentOutOfRangeException("initialCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (maximumCount < 1)
			{
				throw new ArgumentOutOfRangeException("maximumCount", SR.ArgumentOutOfRange_NeedPosNum);
			}
			if (initialCount > maximumCount)
			{
				throw new ArgumentException(SR.Argument_SemaphoreInitialMaximum);
			}
			CreateSemaphoreCore(initialCount, maximumCount, name, out createdNew);
		}

		[SupportedOSPlatform("windows")]
		public static Semaphore OpenExisting(string name)
		{
			Semaphore result;
			return OpenExistingWorker(name, out result) switch
			{
				OpenExistingResult.NameNotFound => throw new WaitHandleCannotBeOpenedException(), 
				OpenExistingResult.NameInvalid => throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name)), 
				OpenExistingResult.PathNotFound => throw new IOException(SR.Format(SR.IO_PathNotFound_Path, name)), 
				_ => result, 
			};
		}

		[SupportedOSPlatform("windows")]
		public static bool TryOpenExisting(string name, [NotNullWhen(true)] out Semaphore? result)
		{
			return OpenExistingWorker(name, out result) == OpenExistingResult.Success;
		}

		public int Release()
		{
			return ReleaseCore(1);
		}

		public int Release(int releaseCount)
		{
			if (releaseCount < 1)
			{
				throw new ArgumentOutOfRangeException("releaseCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return ReleaseCore(releaseCount);
		}

		private Semaphore(SafeWaitHandle handle)
		{
			base.SafeWaitHandle = handle;
		}

		private void CreateSemaphoreCore(int initialCount, int maximumCount, string name, out bool createdNew)
		{
			SafeWaitHandle safeWaitHandle = Interop.Kernel32.CreateSemaphoreEx(IntPtr.Zero, initialCount, maximumCount, name, 0u, 34603010u);
			int lastPInvokeError = Marshal.GetLastPInvokeError();
			if (safeWaitHandle.IsInvalid)
			{
				if (!string.IsNullOrEmpty(name) && lastPInvokeError == 6)
				{
					throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name));
				}
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
			createdNew = lastPInvokeError != 183;
			base.SafeWaitHandle = safeWaitHandle;
		}

		private static OpenExistingResult OpenExistingWorker(string name, out Semaphore result)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			SafeWaitHandle safeWaitHandle = Interop.Kernel32.OpenSemaphore(34603010u, inheritHandle: false, name);
			if (safeWaitHandle.IsInvalid)
			{
				result = null;
				switch (Marshal.GetLastPInvokeError())
				{
				case 2:
				case 123:
					return OpenExistingResult.NameNotFound;
				case 3:
					return OpenExistingResult.PathNotFound;
				case 6:
					return OpenExistingResult.NameInvalid;
				default:
					throw Win32Marshal.GetExceptionForLastWin32Error();
				}
			}
			result = new Semaphore(safeWaitHandle);
			return OpenExistingResult.Success;
		}

		private int ReleaseCore(int releaseCount)
		{
			if (!Interop.Kernel32.ReleaseSemaphore(base.SafeWaitHandle, releaseCount, out var previousCount))
			{
				throw new SemaphoreFullException();
			}
			return previousCount;
		}
	}
	[Serializable]
	[TypeForwardedFrom("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class SemaphoreFullException : SystemException
	{
		public SemaphoreFullException()
			: base(SR.Threading_SemaphoreFullException)
		{
		}

		public SemaphoreFullException(string? message)
			: base(message)
		{
		}

		public SemaphoreFullException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		protected SemaphoreFullException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[DebuggerDisplay("Current Count = {m_currentCount}")]
	public class SemaphoreSlim : IDisposable
	{
		private sealed class TaskNode : Task<bool>
		{
			internal TaskNode Prev;

			internal TaskNode Next;

			internal TaskNode()
				: base((object)null, TaskCreationOptions.RunContinuationsAsynchronously)
			{
			}
		}

		private readonly struct ConfiguredNoThrowAwaiter<T> : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly Task<T> _task;

			public bool IsCompleted => _task.IsCompleted;

			public ConfiguredNoThrowAwaiter(Task<T> task)
			{
				_task = task;
			}

			public ConfiguredNoThrowAwaiter<T> GetAwaiter()
			{
				return this;
			}

			public void GetResult()
			{
				_task.MarkExceptionsAsHandled();
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				_task.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter().UnsafeOnCompleted(continuation);
			}

			public void OnCompleted(Action continuation)
			{
				_task.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter().OnCompleted(continuation);
			}
		}

		private volatile int m_currentCount;

		private readonly int m_maxCount;

		private int m_waitCount;

		private int m_countOfWaitersPulsedToWake;

		private readonly StrongBox<bool> m_lockObjAndDisposed;

		private volatile ManualResetEvent m_waitHandle;

		private TaskNode m_asyncHead;

		private TaskNode m_asyncTail;

		private static readonly Action<object> s_cancellationTokenCanceledEventHandler = CancellationTokenCanceledEventHandler;

		public int CurrentCount => m_currentCount;

		public WaitHandle AvailableWaitHandle
		{
			get
			{
				CheckDispose();
				if (m_waitHandle != null)
				{
					return m_waitHandle;
				}
				lock (m_lockObjAndDisposed)
				{
					if (m_waitHandle == null)
					{
						m_waitHandle = new ManualResetEvent(m_currentCount != 0);
					}
				}
				return m_waitHandle;
			}
		}

		public SemaphoreSlim(int initialCount)
			: this(initialCount, int.MaxValue)
		{
		}

		public SemaphoreSlim(int initialCount, int maxCount)
		{
			if (initialCount < 0 || initialCount > maxCount)
			{
				throw new ArgumentOutOfRangeException("initialCount", initialCount, SR.SemaphoreSlim_ctor_InitialCountWrong);
			}
			if (maxCount <= 0)
			{
				throw new ArgumentOutOfRangeException("maxCount", maxCount, SR.SemaphoreSlim_ctor_MaxCountWrong);
			}
			m_maxCount = maxCount;
			m_currentCount = initialCount;
			m_lockObjAndDisposed = new StrongBox<bool>();
		}

		[UnsupportedOSPlatform("browser")]
		public void Wait()
		{
			Wait(-1, CancellationToken.None);
		}

		[UnsupportedOSPlatform("browser")]
		public void Wait(CancellationToken cancellationToken)
		{
			Wait(-1, cancellationToken);
		}

		[UnsupportedOSPlatform("browser")]
		public bool Wait(TimeSpan timeout)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout", timeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
			}
			return Wait((int)timeout.TotalMilliseconds, CancellationToken.None);
		}

		[UnsupportedOSPlatform("browser")]
		public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout", timeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
			}
			return Wait((int)timeout.TotalMilliseconds, cancellationToken);
		}

		[UnsupportedOSPlatform("browser")]
		public bool Wait(int millisecondsTimeout)
		{
			return Wait(millisecondsTimeout, CancellationToken.None);
		}

		[UnsupportedOSPlatform("browser")]
		public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
		{
			CheckDispose();
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", millisecondsTimeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
			}
			cancellationToken.ThrowIfCancellationRequested();
			if (millisecondsTimeout == 0 && m_currentCount == 0)
			{
				return false;
			}
			uint startTime = 0u;
			if (millisecondsTimeout != -1 && millisecondsTimeout > 0)
			{
				startTime = TimeoutHelper.GetTime();
			}
			bool flag = false;
			Task<bool> task = null;
			bool lockTaken = false;
			CancellationTokenRegistration cancellationTokenRegistration = cancellationToken.UnsafeRegister(s_cancellationTokenCanceledEventHandler, this);
			try
			{
				if (m_currentCount == 0)
				{
					int num = SpinWait.SpinCountforSpinBeforeWait * 4;
					SpinWait spinWait = default(SpinWait);
					while (spinWait.Count < num)
					{
						spinWait.SpinOnce(-1);
						if (m_currentCount != 0)
						{
							break;
						}
					}
				}
				Monitor.Enter(m_lockObjAndDisposed, ref lockTaken);
				m_waitCount++;
				if (m_asyncHead != null)
				{
					task = WaitAsync(millisecondsTimeout, cancellationToken);
				}
				else
				{
					OperationCanceledException ex = null;
					if (m_currentCount == 0)
					{
						if (millisecondsTimeout == 0)
						{
							return false;
						}
						try
						{
							flag = WaitUntilCountOrTimeout(millisecondsTimeout, startTime, cancellationToken);
						}
						catch (OperationCanceledException ex2)
						{
							ex = ex2;
						}
					}
					if (m_currentCount > 0)
					{
						flag = true;
						m_currentCount--;
					}
					else if (ex != null)
					{
						throw ex;
					}
					if (m_waitHandle != null && m_currentCount == 0)
					{
						m_waitHandle.Reset();
					}
				}
			}
			finally
			{
				if (lockTaken)
				{
					m_waitCount--;
					Monitor.Exit(m_lockObjAndDisposed);
				}
				cancellationTokenRegistration.Dispose();
			}
			return task?.GetAwaiter().GetResult() ?? flag;
		}

		[UnsupportedOSPlatform("browser")]
		private bool WaitUntilCountOrTimeout(int millisecondsTimeout, uint startTime, CancellationToken cancellationToken)
		{
			int num = -1;
			while (m_currentCount == 0)
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (millisecondsTimeout != -1)
				{
					num = TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout);
					if (num <= 0)
					{
						return false;
					}
				}
				bool flag = Monitor.Wait(m_lockObjAndDisposed, num);
				if (m_countOfWaitersPulsedToWake != 0)
				{
					m_countOfWaitersPulsedToWake--;
				}
				if (!flag)
				{
					return false;
				}
			}
			return true;
		}

		public Task WaitAsync()
		{
			return WaitAsync(-1, default(CancellationToken));
		}

		public Task WaitAsync(CancellationToken cancellationToken)
		{
			return WaitAsync(-1, cancellationToken);
		}

		public Task<bool> WaitAsync(int millisecondsTimeout)
		{
			return WaitAsync(millisecondsTimeout, default(CancellationToken));
		}

		public Task<bool> WaitAsync(TimeSpan timeout)
		{
			return WaitAsync(timeout, default(CancellationToken));
		}

		public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken cancellationToken)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout", timeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
			}
			return WaitAsync((int)timeout.TotalMilliseconds, cancellationToken);
		}

		public Task<bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellationToken)
		{
			CheckDispose();
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", millisecondsTimeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<bool>(cancellationToken);
			}
			lock (m_lockObjAndDisposed)
			{
				if (m_currentCount > 0)
				{
					m_currentCount--;
					if (m_waitHandle != null && m_currentCount == 0)
					{
						m_waitHandle.Reset();
					}
					return Task.FromResult(result: true);
				}
				if (millisecondsTimeout == 0)
				{
					return Task.FromResult(result: false);
				}
				TaskNode taskNode = CreateAndAddAsyncWaiter();
				return (millisecondsTimeout == -1 && !cancellationToken.CanBeCanceled) ? taskNode : WaitUntilCountOrTimeoutAsync(taskNode, millisecondsTimeout, cancellationToken);
			}
		}

		private TaskNode CreateAndAddAsyncWaiter()
		{
			TaskNode taskNode = new TaskNode();
			if (m_asyncHead == null)
			{
				m_asyncHead = taskNode;
				m_asyncTail = taskNode;
			}
			else
			{
				m_asyncTail.Next = taskNode;
				taskNode.Prev = m_asyncTail;
				m_asyncTail = taskNode;
			}
			return taskNode;
		}

		private bool RemoveAsyncWaiter(TaskNode task)
		{
			bool result = m_asyncHead == task || task.Prev != null;
			if (task.Next != null)
			{
				task.Next.Prev = task.Prev;
			}
			if (task.Prev != null)
			{
				task.Prev.Next = task.Next;
			}
			if (m_asyncHead == task)
			{
				m_asyncHead = task.Next;
			}
			if (m_asyncTail == task)
			{
				m_asyncTail = task.Prev;
			}
			task.Next = (task.Prev = null);
			return result;
		}

		private async Task<bool> WaitUntilCountOrTimeoutAsync(TaskNode asyncWaiter, int millisecondsTimeout, CancellationToken cancellationToken)
		{
			await new ConfiguredNoThrowAwaiter<bool>(asyncWaiter.WaitAsync(TimeSpan.FromMilliseconds(millisecondsTimeout), cancellationToken));
			if (cancellationToken.IsCancellationRequested)
			{
				await TaskScheduler.Default;
			}
			if (asyncWaiter.IsCompleted)
			{
				return true;
			}
			lock (m_lockObjAndDisposed)
			{
				if (RemoveAsyncWaiter(asyncWaiter))
				{
					cancellationToken.ThrowIfCancellationRequested();
					return false;
				}
			}
			return await asyncWaiter.ConfigureAwait(continueOnCapturedContext: false);
		}

		public int Release()
		{
			return Release(1);
		}

		public int Release(int releaseCount)
		{
			CheckDispose();
			if (releaseCount < 1)
			{
				throw new ArgumentOutOfRangeException("releaseCount", releaseCount, SR.SemaphoreSlim_Release_CountWrong);
			}
			int num;
			lock (m_lockObjAndDisposed)
			{
				int currentCount = m_currentCount;
				num = currentCount;
				if (m_maxCount - currentCount < releaseCount)
				{
					throw new SemaphoreFullException();
				}
				currentCount += releaseCount;
				int waitCount = m_waitCount;
				int num2 = Math.Min(currentCount, waitCount) - m_countOfWaitersPulsedToWake;
				if (num2 > 0)
				{
					if (num2 > releaseCount)
					{
						num2 = releaseCount;
					}
					m_countOfWaitersPulsedToWake += num2;
					for (int i = 0; i < num2; i++)
					{
						Monitor.Pulse(m_lockObjAndDisposed);
					}
				}
				if (m_asyncHead != null)
				{
					int num3 = currentCount - waitCount;
					while (num3 > 0 && m_asyncHead != null)
					{
						currentCount--;
						num3--;
						TaskNode asyncHead = m_asyncHead;
						RemoveAsyncWaiter(asyncHead);
						asyncHead.TrySetResult(result: true);
					}
				}
				m_currentCount = currentCount;
				if (m_waitHandle != null && num == 0 && currentCount > 0)
				{
					m_waitHandle.Set();
				}
			}
			return num;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				WaitHandle waitHandle = m_waitHandle;
				if (waitHandle != null)
				{
					waitHandle.Dispose();
					m_waitHandle = null;
				}
				m_lockObjAndDisposed.Value = true;
				m_asyncHead = null;
				m_asyncTail = null;
			}
		}

		private static void CancellationTokenCanceledEventHandler(object obj)
		{
			SemaphoreSlim semaphoreSlim = (SemaphoreSlim)obj;
			lock (semaphoreSlim.m_lockObjAndDisposed)
			{
				Monitor.PulseAll(semaphoreSlim.m_lockObjAndDisposed);
			}
		}

		private void CheckDispose()
		{
			if (m_lockObjAndDisposed.Value)
			{
				throw new ObjectDisposedException(null, SR.SemaphoreSlim_Disposed);
			}
		}
	}
	public delegate void SendOrPostCallback(object? state);
	[DebuggerTypeProxy(typeof(SystemThreading_SpinLockDebugView))]
	[DebuggerDisplay("IsHeld = {IsHeld}")]
	public struct SpinLock
	{
		internal sealed class SystemThreading_SpinLockDebugView
		{
			private SpinLock _spinLock;

			public bool? IsHeldByCurrentThread
			{
				get
				{
					try
					{
						return _spinLock.IsHeldByCurrentThread;
					}
					catch (InvalidOperationException)
					{
						return null;
					}
				}
			}

			public int? OwnerThreadID
			{
				get
				{
					if (_spinLock.IsThreadOwnerTrackingEnabled)
					{
						return _spinLock._owner;
					}
					return null;
				}
			}

			public bool IsHeld => _spinLock.IsHeld;

			public SystemThreading_SpinLockDebugView(SpinLock spinLock)
			{
				_spinLock = spinLock;
			}
		}

		private volatile int _owner;

		public bool IsHeld
		{
			get
			{
				if (IsThreadOwnerTrackingEnabled)
				{
					return _owner != 0;
				}
				return (_owner & 1) != 0;
			}
		}

		public bool IsHeldByCurrentThread
		{
			get
			{
				if (!IsThreadOwnerTrackingEnabled)
				{
					throw new InvalidOperationException(SR.SpinLock_IsHeldByCurrentThread);
				}
				return (_owner & 0x7FFFFFFF) == Environment.CurrentManagedThreadId;
			}
		}

		public bool IsThreadOwnerTrackingEnabled => (_owner & int.MinValue) == 0;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int CompareExchange(ref int location, int value, int comparand, ref bool success)
		{
			int num = Interlocked.CompareExchange(ref location, value, comparand);
			success = num == comparand;
			return num;
		}

		public SpinLock(bool enableThreadOwnerTracking)
		{
			_owner = 0;
			if (!enableThreadOwnerTracking)
			{
				_owner |= int.MinValue;
			}
		}

		public void Enter(ref bool lockTaken)
		{
			int owner = _owner;
			if (lockTaken || (owner & -2147483647) != int.MinValue || CompareExchange(ref _owner, owner | 1, owner, ref lockTaken) != owner)
			{
				ContinueTryEnter(-1, ref lockTaken);
			}
		}

		public void TryEnter(ref bool lockTaken)
		{
			int owner = _owner;
			if (((owner & int.MinValue) == 0) | lockTaken)
			{
				ContinueTryEnter(0, ref lockTaken);
			}
			else if (((uint)owner & (true ? 1u : 0u)) != 0)
			{
				lockTaken = false;
			}
			else
			{
				CompareExchange(ref _owner, owner | 1, owner, ref lockTaken);
			}
		}

		public void TryEnter(TimeSpan timeout, ref bool lockTaken)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout", timeout, SR.SpinLock_TryEnter_ArgumentOutOfRange);
			}
			TryEnter((int)timeout.TotalMilliseconds, ref lockTaken);
		}

		public void TryEnter(int millisecondsTimeout, ref bool lockTaken)
		{
			int owner = _owner;
			if (((millisecondsTimeout < -1) | lockTaken) || (owner & -2147483647) != int.MinValue || CompareExchange(ref _owner, owner | 1, owner, ref lockTaken) != owner)
			{
				ContinueTryEnter(millisecondsTimeout, ref lockTaken);
			}
		}

		private void ContinueTryEnter(int millisecondsTimeout, ref bool lockTaken)
		{
			if (lockTaken)
			{
				lockTaken = false;
				throw new ArgumentException(SR.SpinLock_TryReliableEnter_ArgumentException);
			}
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", millisecondsTimeout, SR.SpinLock_TryEnter_ArgumentOutOfRange);
			}
			uint startTime = 0u;
			if (millisecondsTimeout != -1 && millisecondsTimeout != 0)
			{
				startTime = TimeoutHelper.GetTime();
			}
			if (IsThreadOwnerTrackingEnabled)
			{
				ContinueTryEnterWithThreadTracking(millisecondsTimeout, startTime, ref lockTaken);
				return;
			}
			int num = int.MaxValue;
			int owner = _owner;
			if ((owner & 1) == 0)
			{
				if (CompareExchange(ref _owner, owner | 1, owner, ref lockTaken) == owner || millisecondsTimeout == 0)
				{
					return;
				}
			}
			else
			{
				if (millisecondsTimeout == 0)
				{
					return;
				}
				if ((owner & 0x7FFFFFFE) != 2147483646)
				{
					num = (Interlocked.Add(ref _owner, 2) & 0x7FFFFFFE) >> 1;
				}
			}
			SpinWait spinWait = default(SpinWait);
			if (num > Environment.ProcessorCount)
			{
				spinWait.Count = 10;
			}
			do
			{
				spinWait.SpinOnce(40);
				owner = _owner;
				if ((owner & 1) == 0)
				{
					int value = (((owner & 0x7FFFFFFE) == 0) ? (owner | 1) : ((owner - 2) | 1));
					if (CompareExchange(ref _owner, value, owner, ref lockTaken) == owner)
					{
						return;
					}
				}
			}
			while (spinWait.Count % 10 != 0 || millisecondsTimeout == -1 || TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout) > 0);
			DecrementWaiters();
		}

		private void DecrementWaiters()
		{
			SpinWait spinWait = default(SpinWait);
			while (true)
			{
				int owner = _owner;
				if (((uint)owner & 0x7FFFFFFEu) != 0 && Interlocked.CompareExchange(ref _owner, owner - 2, owner) != owner)
				{
					spinWait.SpinOnce();
					continue;
				}
				break;
			}
		}

		private void ContinueTryEnterWithThreadTracking(int millisecondsTimeout, uint startTime, ref bool lockTaken)
		{
			int currentManagedThreadId = Environment.CurrentManagedThreadId;
			if (_owner == currentManagedThreadId)
			{
				throw new LockRecursionException(SR.SpinLock_TryEnter_LockRecursionException);
			}
			SpinWait spinWait = default(SpinWait);
			while (true)
			{
				spinWait.SpinOnce();
				if (_owner == 0 && CompareExchange(ref _owner, currentManagedThreadId, 0, ref lockTaken) == 0)
				{
					break;
				}
				switch (millisecondsTimeout)
				{
				case -1:
					continue;
				case 0:
					return;
				}
				if (spinWait.NextSpinWillYield && TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout) <= 0)
				{
					return;
				}
			}
		}

		public void Exit()
		{
			if ((_owner & int.MinValue) == 0)
			{
				ExitSlowPath(useMemoryBarrier: true);
			}
			else
			{
				Interlocked.Decrement(ref _owner);
			}
		}

		public void Exit(bool useMemoryBarrier)
		{
			int owner = _owner;
			if ((owner & int.MinValue) != 0 && !useMemoryBarrier)
			{
				_owner = owner & -2;
			}
			else
			{
				ExitSlowPath(useMemoryBarrier);
			}
		}

		private void ExitSlowPath(bool useMemoryBarrier)
		{
			bool flag = (_owner & int.MinValue) == 0;
			if (flag && !IsHeldByCurrentThread)
			{
				throw new SynchronizationLockException(SR.SpinLock_Exit_SynchronizationLockException);
			}
			if (useMemoryBarrier)
			{
				if (flag)
				{
					Interlocked.Exchange(ref _owner, 0);
				}
				else
				{
					Interlocked.Decrement(ref _owner);
				}
			}
			else if (flag)
			{
				_owner = 0;
			}
			else
			{
				int owner = _owner;
				_owner = owner & -2;
			}
		}
	}
	public struct SpinWait
	{
		internal static readonly int SpinCountforSpinBeforeWait = (Environment.IsSingleProcessor ? 1 : 35);

		private int _count;

		public int Count
		{
			get
			{
				return _count;
			}
			internal set
			{
				_count = value;
			}
		}

		public bool NextSpinWillYield
		{
			get
			{
				if (_count < 10)
				{
					return Environment.IsSingleProcessor;
				}
				return true;
			}
		}

		public void SpinOnce()
		{
			SpinOnceCore(20);
		}

		public void SpinOnce(int sleep1Threshold)
		{
			if (sleep1Threshold < -1)
			{
				throw new ArgumentOutOfRangeException("sleep1Threshold", sleep1Threshold, SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (sleep1Threshold >= 0 && sleep1Threshold < 10)
			{
				sleep1Threshold = 10;
			}
			SpinOnceCore(sleep1Threshold);
		}

		private void SpinOnceCore(int sleep1Threshold)
		{
			if ((_count >= 10 && ((_count >= sleep1Threshold && sleep1Threshold >= 0) || (_count - 10) % 2 == 0)) || Environment.IsSingleProcessor)
			{
				if (_count >= sleep1Threshold && sleep1Threshold >= 0)
				{
					Thread.Sleep(1);
				}
				else
				{
					int num = ((_count >= 10) ? ((_count - 10) / 2) : _count);
					if (num % 5 == 4)
					{
						Thread.Sleep(0);
					}
					else
					{
						Thread.Yield();
					}
				}
			}
			else
			{
				int num2 = Thread.OptimalMaxSpinWaitsPerSpinIteration;
				if (_count <= 30 && 1 << _count < num2)
				{
					num2 = 1 << _count;
				}
				Thread.SpinWait(num2);
			}
			_count = ((_count == int.MaxValue) ? 10 : (_count + 1));
		}

		public void Reset()
		{
			_count = 0;
		}

		public static void SpinUntil(Func<bool> condition)
		{
			SpinUntil(condition, -1);
		}

		public static bool SpinUntil(Func<bool> condition, TimeSpan timeout)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("timeout", timeout, SR.SpinWait_SpinUntil_TimeoutWrong);
			}
			return SpinUntil(condition, (int)num);
		}

		public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout)
		{
			if (millisecondsTimeout < -1)
			{
				throw new ArgumentOutOfRangeException("millisecondsTimeout", millisecondsTimeout, SR.SpinWait_SpinUntil_TimeoutWrong);
			}
			if (condition == null)
			{
				throw new ArgumentNullException("condition", SR.SpinWait_SpinUntil_ArgumentNull);
			}
			uint num = 0u;
			if (millisecondsTimeout != 0 && millisecondsTimeout != -1)
			{
				num = TimeoutHelper.GetTime();
			}
			SpinWait spinWait = default(SpinWait);
			while (!condition())
			{
				if (millisecondsTimeout == 0)
				{
					return false;
				}
				spinWait.SpinOnce();
				if (millisecondsTimeout != -1 && spinWait.NextSpinWillYield && millisecondsTimeout <= TimeoutHelper.GetTime() - num)
				{
					return false;
				}
			}
			return true;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class SynchronizationLockException : SystemException
	{
		public SynchronizationLockException()
			: base(SR.Arg_SynchronizationLockException)
		{
			base.HResult = -2146233064;
		}

		public SynchronizationLockException(string? message)
			: base(message)
		{
			base.HResult = -2146233064;
		}

		public SynchronizationLockException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233064;
		}

		protected SynchronizationLockException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class ThreadAbortException : SystemException
	{
		public object? ExceptionState => null;

		internal ThreadAbortException()
		{
			base.HResult = -2146233040;
		}

		private ThreadAbortException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public class ThreadExceptionEventArgs : EventArgs
	{
		private readonly Exception m_exception;

		public Exception Exception => m_exception;

		public ThreadExceptionEventArgs(Exception t)
		{
			m_exception = t;
		}
	}
	public delegate void ThreadExceptionEventHandler(object sender, ThreadExceptionEventArgs e);
	internal sealed class ThreadInt64PersistentCounter
	{
		private sealed class ThreadLocalNode
		{
			private uint _count;

			private readonly ThreadInt64PersistentCounter _counter;

			public uint Count => _count;

			public ThreadLocalNode(ThreadInt64PersistentCounter counter)
			{
				_counter = counter;
			}

			public void Dispose()
			{
				ThreadInt64PersistentCounter counter = _counter;
				s_lock.Acquire();
				try
				{
					counter._overflowCount += _count;
					counter._nodes.Remove(this);
				}
				finally
				{
					s_lock.Release();
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Increment()
			{
				uint num = _count + 1;
				if (num != 0)
				{
					_count = num;
				}
				else
				{
					OnIncrementOverflow();
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private void OnIncrementOverflow()
			{
				ThreadInt64PersistentCounter counter = _counter;
				s_lock.Acquire();
				try
				{
					_count = 0u;
					counter._overflowCount += 4294967296L;
				}
				finally
				{
					s_lock.Release();
				}
			}
		}

		private sealed class ThreadLocalNodeFinalizationHelper
		{
			private readonly ThreadLocalNode _node;

			public ThreadLocalNodeFinalizationHelper(ThreadLocalNode node)
			{
				_node = node;
			}

			~ThreadLocalNodeFinalizationHelper()
			{
				_node.Dispose();
			}
		}

		private static readonly LowLevelLock s_lock = new LowLevelLock();

		[ThreadStatic]
		private static List<ThreadLocalNodeFinalizationHelper> t_nodeFinalizationHelpers;

		private long _overflowCount;

		private HashSet<ThreadLocalNode> _nodes = new HashSet<ThreadLocalNode>();

		public long Count
		{
			get
			{
				s_lock.Acquire();
				long num = _overflowCount;
				try
				{
					foreach (ThreadLocalNode node in _nodes)
					{
						num += node.Count;
					}
				}
				catch (OutOfMemoryException)
				{
				}
				finally
				{
					s_lock.Release();
				}
				return num;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Increment(object threadLocalCountObject)
		{
			Unsafe.As<ThreadLocalNode>(threadLocalCountObject).Increment();
		}

		public object CreateThreadLocalCountObject()
		{
			ThreadLocalNode threadLocalNode = new ThreadLocalNode(this);
			List<ThreadLocalNodeFinalizationHelper> list = t_nodeFinalizationHelpers ?? (t_nodeFinalizationHelpers = new List<ThreadLocalNodeFinalizationHelper>(1));
			list.Add(new ThreadLocalNodeFinalizationHelper(threadLocalNode));
			s_lock.Acquire();
			try
			{
				_nodes.Add(threadLocalNode);
				return threadLocalNode;
			}
			finally
			{
				s_lock.Release();
			}
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ThreadInterruptedException : SystemException
	{
		public ThreadInterruptedException()
			: base(Exception.GetMessageFromNativeResources(ExceptionMessageKind.ThreadInterrupted))
		{
			base.HResult = -2146233063;
		}

		public ThreadInterruptedException(string? message)
			: base(message)
		{
			base.HResult = -2146233063;
		}

		public ThreadInterruptedException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233063;
		}

		protected ThreadInterruptedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[DebuggerTypeProxy(typeof(SystemThreading_ThreadLocalDebugView<>))]
	[DebuggerDisplay("IsValueCreated={IsValueCreated}, Value={ValueForDebugDisplay}, Count={ValuesCountForDebugDisplay}")]
	public class ThreadLocal<T> : IDisposable
	{
		private struct LinkedSlotVolatile
		{
			internal volatile LinkedSlot Value;
		}

		private sealed class LinkedSlot
		{
			internal volatile LinkedSlot _next;

			internal volatile LinkedSlot _previous;

			internal volatile LinkedSlotVolatile[] _slotArray;

			internal T _value;

			internal LinkedSlot(LinkedSlotVolatile[] slotArray)
			{
				_slotArray = slotArray;
			}
		}

		private sealed class IdManager
		{
			private int _nextIdToTry;

			private volatile int _idsThatDoNotTrackAllValues;

			private readonly List<byte> _ids = new List<byte>();

			internal int IdsThatDoNotTrackValuesCount => _idsThatDoNotTrackAllValues;

			internal int GetId(bool trackAllValues)
			{
				lock (_ids)
				{
					int i;
					for (i = _nextIdToTry; i < _ids.Count && _ids[i] != 0; i++)
					{
					}
					byte b = (byte)(trackAllValues ? 1 : 2);
					if (i == _ids.Count)
					{
						_ids.Add(b);
					}
					else
					{
						_ids[i] = b;
					}
					if (!trackAllValues)
					{
						_idsThatDoNotTrackAllValues++;
					}
					_nextIdToTry = i + 1;
					return i;
				}
			}

			internal bool IdTracksAllValues(int id)
			{
				lock (_ids)
				{
					return _ids[id] == 1;
				}
			}

			internal void ReturnId(int id, bool idTracksAllValues)
			{
				lock (_ids)
				{
					if (!idTracksAllValues)
					{
						_idsThatDoNotTrackAllValues--;
					}
					_ids[id] = 0;
					if (id < _nextIdToTry)
					{
						_nextIdToTry = id;
					}
				}
			}
		}

		private sealed class FinalizationHelper
		{
			internal LinkedSlotVolatile[] SlotArray;

			internal FinalizationHelper(LinkedSlotVolatile[] slotArray)
			{
				SlotArray = slotArray;
			}

			~FinalizationHelper()
			{
				LinkedSlotVolatile[] slotArray = SlotArray;
				int num = ThreadLocal<T>.s_idManager.IdsThatDoNotTrackValuesCount;
				int i = 0;
				for (; i < slotArray.Length; i++)
				{
					LinkedSlot value = slotArray[i].Value;
					if (value == null)
					{
						continue;
					}
					if (num == 0 || ThreadLocal<T>.s_idManager.IdTracksAllValues(i))
					{
						value._slotArray = null;
						continue;
					}
					lock (ThreadLocal<T>.s_idManager)
					{
						if (slotArray[i].Value != null)
						{
							num--;
						}
						if (value._next != null)
						{
							value._next._previous = value._previous;
						}
						value._previous._next = value._next;
					}
				}
			}
		}

		private Func<T> _valueFactory;

		[ThreadStatic]
		private static LinkedSlotVolatile[] ts_slotArray;

		[ThreadStatic]
		private static FinalizationHelper ts_finalizationHelper;

		private int _idComplement;

		private volatile bool _initialized;

		private static readonly IdManager s_idManager = new IdManager();

		private LinkedSlot _linkedSlot = new LinkedSlot(null);

		private bool _trackAllValues;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public T Value
		{
			[return: MaybeNull]
			get
			{
				LinkedSlotVolatile[] array = ts_slotArray;
				int num = ~_idComplement;
				LinkedSlot value;
				if (array != null && num >= 0 && num < array.Length && (value = array[num].Value) != null && _initialized)
				{
					return value._value;
				}
				return GetValueSlow();
			}
			set
			{
				LinkedSlotVolatile[] array = ts_slotArray;
				int num = ~_idComplement;
				LinkedSlot value2;
				if (array != null && num >= 0 && num < array.Length && (value2 = array[num].Value) != null && _initialized)
				{
					value2._value = value;
				}
				else
				{
					SetValueSlow(value, array);
				}
			}
		}

		public IList<T> Values
		{
			get
			{
				if (!_trackAllValues)
				{
					throw new InvalidOperationException(SR.ThreadLocal_ValuesNotAvailable);
				}
				List<T> valuesAsList = GetValuesAsList();
				if (valuesAsList == null)
				{
					throw new ObjectDisposedException(SR.ThreadLocal_Disposed);
				}
				return valuesAsList;
			}
		}

		private int ValuesCountForDebugDisplay
		{
			get
			{
				int num = 0;
				LinkedSlot linkedSlot = _linkedSlot;
				for (LinkedSlot linkedSlot2 = ((linkedSlot != null) ? linkedSlot._next : null); linkedSlot2 != null; linkedSlot2 = linkedSlot2._next)
				{
					num++;
				}
				return num;
			}
		}

		public bool IsValueCreated
		{
			get
			{
				int num = ~_idComplement;
				if (num < 0)
				{
					throw new ObjectDisposedException(SR.ThreadLocal_Disposed);
				}
				LinkedSlotVolatile[] array = ts_slotArray;
				if (array != null && num < array.Length)
				{
					return array[num].Value != null;
				}
				return false;
			}
		}

		internal T? ValueForDebugDisplay
		{
			get
			{
				LinkedSlotVolatile[] array = ts_slotArray;
				int num = ~_idComplement;
				LinkedSlot value;
				if (array == null || num >= array.Length || (value = array[num].Value) == null || !_initialized)
				{
					return default(T);
				}
				return value._value;
			}
		}

		internal List<T>? ValuesForDebugDisplay => GetValuesAsList();

		public ThreadLocal()
		{
			Initialize(null, trackAllValues: false);
		}

		public ThreadLocal(bool trackAllValues)
		{
			Initialize(null, trackAllValues);
		}

		public ThreadLocal(Func<T> valueFactory)
		{
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			Initialize(valueFactory, trackAllValues: false);
		}

		public ThreadLocal(Func<T> valueFactory, bool trackAllValues)
		{
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			Initialize(valueFactory, trackAllValues);
		}

		private void Initialize(Func<T> valueFactory, bool trackAllValues)
		{
			_valueFactory = valueFactory;
			_trackAllValues = trackAllValues;
			_idComplement = ~s_idManager.GetId(trackAllValues);
			_initialized = true;
		}

		~ThreadLocal()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			int num;
			lock (s_idManager)
			{
				num = ~_idComplement;
				_idComplement = 0;
				if (num < 0 || !_initialized)
				{
					return;
				}
				_initialized = false;
				for (LinkedSlot next = _linkedSlot._next; next != null; next = next._next)
				{
					LinkedSlotVolatile[] slotArray = next._slotArray;
					if (slotArray != null)
					{
						next._slotArray = null;
						slotArray[num].Value._value = default(T);
						slotArray[num].Value = null;
					}
				}
			}
			_linkedSlot = null;
			s_idManager.ReturnId(num, _trackAllValues);
		}

		public override string? ToString()
		{
			return Value.ToString();
		}

		private T GetValueSlow()
		{
			int num = ~_idComplement;
			if (num < 0)
			{
				throw new ObjectDisposedException(SR.ThreadLocal_Disposed);
			}
			Debugger.NotifyOfCrossThreadDependency();
			T val;
			if (_valueFactory == null)
			{
				val = default(T);
			}
			else
			{
				val = _valueFactory();
				if (IsValueCreated)
				{
					throw new InvalidOperationException(SR.ThreadLocal_Value_RecursiveCallsToValue);
				}
			}
			Value = val;
			return val;
		}

		private void SetValueSlow(T value, LinkedSlotVolatile[] slotArray)
		{
			int num = ~_idComplement;
			if (num < 0)
			{
				throw new ObjectDisposedException(SR.ThreadLocal_Disposed);
			}
			if (slotArray == null)
			{
				slotArray = new LinkedSlotVolatile[GetNewTableSize(num + 1)];
				ts_finalizationHelper = new FinalizationHelper(slotArray);
				ts_slotArray = slotArray;
			}
			if (num >= slotArray.Length)
			{
				GrowTable(ref slotArray, num + 1);
				ts_finalizationHelper.SlotArray = slotArray;
				ts_slotArray = slotArray;
			}
			if (slotArray[num].Value == null)
			{
				CreateLinkedSlot(slotArray, num, value);
				return;
			}
			LinkedSlot value2 = slotArray[num].Value;
			if (!_initialized)
			{
				throw new ObjectDisposedException(SR.ThreadLocal_Disposed);
			}
			value2._value = value;
		}

		private void CreateLinkedSlot(LinkedSlotVolatile[] slotArray, int id, T value)
		{
			LinkedSlot linkedSlot = new LinkedSlot(slotArray);
			lock (s_idManager)
			{
				if (!_initialized)
				{
					throw new ObjectDisposedException(SR.ThreadLocal_Disposed);
				}
				LinkedSlot linkedSlot2 = (linkedSlot._next = _linkedSlot._next);
				linkedSlot._previous = _linkedSlot;
				linkedSlot._value = value;
				if (linkedSlot2 != null)
				{
					linkedSlot2._previous = linkedSlot;
				}
				_linkedSlot._next = linkedSlot;
				slotArray[id].Value = linkedSlot;
			}
		}

		private List<T> GetValuesAsList()
		{
			LinkedSlot linkedSlot = _linkedSlot;
			int num = ~_idComplement;
			if (num == -1 || linkedSlot == null)
			{
				return null;
			}
			List<T> list = new List<T>();
			for (linkedSlot = linkedSlot._next; linkedSlot != null; linkedSlot = linkedSlot._next)
			{
				list.Add(linkedSlot._value);
			}
			return list;
		}

		private static void GrowTable(ref LinkedSlotVolatile[] table, int minLength)
		{
			int newTableSize = GetNewTableSize(minLength);
			LinkedSlotVolatile[] array = new LinkedSlotVolatile[newTableSize];
			lock (s_idManager)
			{
				for (int i = 0; i < table.Length; i++)
				{
					LinkedSlot value = table[i].Value;
					if (value != null && value._slotArray != null)
					{
						value._slotArray = array;
						array[i] = table[i];
					}
				}
			}
			table = array;
		}

		private static int GetNewTableSize(int minSize)
		{
			if ((uint)minSize > Array.MaxLength)
			{
				return int.MaxValue;
			}
			int num = minSize;
			num--;
			num |= num >> 1;
			num |= num >> 2;
			num |= num >> 4;
			num |= num >> 8;
			num |= num >> 16;
			num++;
			if ((uint)num > Array.MaxLength)
			{
				num = Array.MaxLength;
			}
			return num;
		}
	}
	internal sealed class SystemThreading_ThreadLocalDebugView<T>
	{
		private readonly ThreadLocal<T> _tlocal;

		public bool IsValueCreated => _tlocal.IsValueCreated;

		public T Value => _tlocal.ValueForDebugDisplay;

		public List<T> Values => _tlocal.ValuesForDebugDisplay;

		public SystemThreading_ThreadLocalDebugView(ThreadLocal<T> tlocal)
		{
			_tlocal = tlocal;
		}
	}
	internal sealed class ThreadPoolWorkQueue
	{
		internal static class WorkStealingQueueList
		{
			private static volatile WorkStealingQueue[] _queues = new WorkStealingQueue[0];

			public static WorkStealingQueue[] Queues => _queues;

			public static void Add(WorkStealingQueue queue)
			{
				WorkStealingQueue[] queues;
				WorkStealingQueue[] array;
				do
				{
					queues = _queues;
					array = new WorkStealingQueue[queues.Length + 1];
					Array.Copy(queues, array, queues.Length);
					array[^1] = queue;
				}
				while (Interlocked.CompareExchange(ref _queues, array, queues) != queues);
			}

			public static void Remove(WorkStealingQueue queue)
			{
				WorkStealingQueue[] queues;
				WorkStealingQueue[] array;
				do
				{
					queues = _queues;
					if (queues.Length == 0)
					{
						break;
					}
					int num = Array.IndexOf(queues, queue);
					if (num == -1)
					{
						break;
					}
					array = new WorkStealingQueue[queues.Length - 1];
					if (num == 0)
					{
						Array.Copy(queues, 1, array, 0, array.Length);
						continue;
					}
					if (num == queues.Length - 1)
					{
						Array.Copy(queues, array, array.Length);
						continue;
					}
					Array.Copy(queues, array, num);
					Array.Copy(queues, num + 1, array, num, array.Length - num);
				}
				while (Interlocked.CompareExchange(ref _queues, array, queues) != queues);
			}
		}

		internal sealed class WorkStealingQueue
		{
			internal volatile object[] m_array = new object[32];

			private volatile int m_mask = 31;

			private volatile int m_headIndex;

			private volatile int m_tailIndex;

			private SpinLock m_foreignLock = new SpinLock(enableThreadOwnerTracking: false);

			public bool CanSteal => m_headIndex < m_tailIndex;

			public int Count
			{
				get
				{
					bool lockTaken = false;
					try
					{
						m_foreignLock.Enter(ref lockTaken);
						return Math.Max(0, m_tailIndex - m_headIndex);
					}
					finally
					{
						if (lockTaken)
						{
							m_foreignLock.Exit(useMemoryBarrier: false);
						}
					}
				}
			}

			public void LocalPush(object obj)
			{
				int num = m_tailIndex;
				if (num == int.MaxValue)
				{
					num = LocalPush_HandleTailOverflow();
				}
				if (num < m_headIndex + m_mask)
				{
					Volatile.Write(ref m_array[num & m_mask], obj);
					m_tailIndex = num + 1;
					return;
				}
				bool lockTaken = false;
				try
				{
					m_foreignLock.Enter(ref lockTaken);
					int headIndex = m_headIndex;
					int num2 = m_tailIndex - m_headIndex;
					if (num2 >= m_mask)
					{
						object[] array = new object[m_array.Length << 1];
						for (int i = 0; i < m_array.Length; i++)
						{
							array[i] = m_array[(i + headIndex) & m_mask];
						}
						m_array = array;
						m_headIndex = 0;
						num = (m_tailIndex = num2);
						m_mask = (m_mask << 1) | 1;
					}
					Volatile.Write(ref m_array[num & m_mask], obj);
					m_tailIndex = num + 1;
				}
				finally
				{
					if (lockTaken)
					{
						m_foreignLock.Exit(useMemoryBarrier: false);
					}
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private int LocalPush_HandleTailOverflow()
			{
				bool lockTaken = false;
				try
				{
					m_foreignLock.Enter(ref lockTaken);
					int num = m_tailIndex;
					if (num == int.MaxValue)
					{
						m_headIndex &= m_mask;
						num = (m_tailIndex &= m_mask);
					}
					return num;
				}
				finally
				{
					if (lockTaken)
					{
						m_foreignLock.Exit(useMemoryBarrier: true);
					}
				}
			}

			public bool LocalFindAndPop(object obj)
			{
				if (m_array[(m_tailIndex - 1) & m_mask] == obj)
				{
					object obj2 = LocalPop();
					return obj2 != null;
				}
				for (int num = m_tailIndex - 2; num >= m_headIndex; num--)
				{
					if (m_array[num & m_mask] == obj)
					{
						bool lockTaken = false;
						try
						{
							m_foreignLock.Enter(ref lockTaken);
							if (m_array[num & m_mask] == null)
							{
								return false;
							}
							Volatile.Write(ref m_array[num & m_mask], null);
							if (num == m_tailIndex)
							{
								m_tailIndex--;
							}
							else if (num == m_headIndex)
							{
								m_headIndex++;
							}
							return true;
						}
						finally
						{
							if (lockTaken)
							{
								m_foreignLock.Exit(useMemoryBarrier: false);
							}
						}
					}
				}
				return false;
			}

			public object LocalPop()
			{
				if (m_headIndex >= m_tailIndex)
				{
					return null;
				}
				return LocalPopCore();
			}

			private object LocalPopCore()
			{
				int num;
				object obj;
				while (true)
				{
					int tailIndex = m_tailIndex;
					if (m_headIndex >= tailIndex)
					{
						return null;
					}
					tailIndex--;
					Interlocked.Exchange(ref m_tailIndex, tailIndex);
					if (m_headIndex <= tailIndex)
					{
						num = tailIndex & m_mask;
						obj = Volatile.Read(ref m_array[num]);
						if (obj != null)
						{
							break;
						}
						continue;
					}
					bool lockTaken = false;
					try
					{
						m_foreignLock.Enter(ref lockTaken);
						if (m_headIndex <= tailIndex)
						{
							int num2 = tailIndex & m_mask;
							object obj2 = Volatile.Read(ref m_array[num2]);
							if (obj2 != null)
							{
								m_array[num2] = null;
								return obj2;
							}
							continue;
						}
						m_tailIndex = tailIndex + 1;
						return null;
					}
					finally
					{
						if (lockTaken)
						{
							m_foreignLock.Exit(useMemoryBarrier: false);
						}
					}
				}
				m_array[num] = null;
				return obj;
			}

			public object TrySteal(ref bool missedSteal)
			{
				while (CanSteal)
				{
					bool lockTaken = false;
					try
					{
						m_foreignLock.TryEnter(ref lockTaken);
						if (lockTaken)
						{
							int headIndex = m_headIndex;
							Interlocked.Exchange(ref m_headIndex, headIndex + 1);
							if (headIndex < m_tailIndex)
							{
								int num = headIndex & m_mask;
								object obj = Volatile.Read(ref m_array[num]);
								if (obj == null)
								{
									continue;
								}
								m_array[num] = null;
								return obj;
							}
							m_headIndex = headIndex;
						}
					}
					finally
					{
						if (lockTaken)
						{
							m_foreignLock.Exit(useMemoryBarrier: false);
						}
					}
					missedSteal = true;
					break;
				}
				return null;
			}
		}

		private struct CacheLineSeparated
		{
			private readonly PaddingFor32 pad1;

			public volatile int numOutstandingThreadRequests;

			private readonly PaddingFor32 pad2;
		}

		internal bool loggingEnabled;

		private bool _dispatchTimeSensitiveWorkFirst;

		internal readonly ConcurrentQueue<object> workItems = new ConcurrentQueue<object>();

		internal readonly ConcurrentQueue<IThreadPoolWorkItem> timeSensitiveWorkQueue = (ThreadPool.SupportsTimeSensitiveWorkItems ? new ConcurrentQueue<IThreadPoolWorkItem>() : null);

		private CacheLineSeparated _separated;

		public static long LocalCount
		{
			get
			{
				long num = 0L;
				WorkStealingQueue[] queues = WorkStealingQueueList.Queues;
				foreach (WorkStealingQueue workStealingQueue in queues)
				{
					num += workStealingQueue.Count;
				}
				return num;
			}
		}

		public long GlobalCount => (ThreadPool.SupportsTimeSensitiveWorkItems ? timeSensitiveWorkQueue.Count : 0) + workItems.Count;

		public ThreadPoolWorkQueue()
		{
			RefreshLoggingEnabled();
		}

		public ThreadPoolWorkQueueThreadLocals GetOrCreateThreadLocals()
		{
			return ThreadPoolWorkQueueThreadLocals.threadLocals ?? CreateThreadLocals();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private ThreadPoolWorkQueueThreadLocals CreateThreadLocals()
		{
			return ThreadPoolWorkQueueThreadLocals.threadLocals = new ThreadPoolWorkQueueThreadLocals(this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void RefreshLoggingEnabled()
		{
			if (!FrameworkEventSource.Log.IsEnabled())
			{
				if (loggingEnabled)
				{
					loggingEnabled = false;
				}
			}
			else
			{
				RefreshLoggingEnabledFull();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void RefreshLoggingEnabledFull()
		{
			loggingEnabled = FrameworkEventSource.Log.IsEnabled(EventLevel.Verbose, (EventKeywords)18L);
		}

		internal void EnsureThreadRequested()
		{
			int num = _separated.numOutstandingThreadRequests;
			while (num < Environment.ProcessorCount)
			{
				int num2 = Interlocked.CompareExchange(ref _separated.numOutstandingThreadRequests, num + 1, num);
				if (num2 == num)
				{
					ThreadPool.RequestWorkerThread();
					break;
				}
				num = num2;
			}
		}

		internal void MarkThreadRequestSatisfied()
		{
			int num = _separated.numOutstandingThreadRequests;
			while (num > 0)
			{
				int num2 = Interlocked.CompareExchange(ref _separated.numOutstandingThreadRequests, num - 1, num);
				if (num2 != num)
				{
					num = num2;
					continue;
				}
				break;
			}
		}

		public void EnqueueTimeSensitiveWorkItem(IThreadPoolWorkItem timeSensitiveWorkItem)
		{
			if (loggingEnabled && FrameworkEventSource.Log.IsEnabled())
			{
				FrameworkEventSource.Log.ThreadPoolEnqueueWorkObject(timeSensitiveWorkItem);
			}
			timeSensitiveWorkQueue.Enqueue(timeSensitiveWorkItem);
			EnsureThreadRequested();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public IThreadPoolWorkItem TryDequeueTimeSensitiveWorkItem()
		{
			IThreadPoolWorkItem result;
			bool flag = timeSensitiveWorkQueue.TryDequeue(out result);
			return result;
		}

		public void Enqueue(object callback, bool forceGlobal)
		{
			if (loggingEnabled && FrameworkEventSource.Log.IsEnabled())
			{
				FrameworkEventSource.Log.ThreadPoolEnqueueWorkObject(callback);
			}
			ThreadPoolWorkQueueThreadLocals threadPoolWorkQueueThreadLocals = null;
			if (!forceGlobal)
			{
				threadPoolWorkQueueThreadLocals = ThreadPoolWorkQueueThreadLocals.threadLocals;
			}
			if (threadPoolWorkQueueThreadLocals != null)
			{
				threadPoolWorkQueueThreadLocals.workStealingQueue.LocalPush(callback);
			}
			else
			{
				workItems.Enqueue(callback);
			}
			EnsureThreadRequested();
		}

		internal static bool LocalFindAndPop(object callback)
		{
			return ThreadPoolWorkQueueThreadLocals.threadLocals?.workStealingQueue.LocalFindAndPop(callback) ?? false;
		}

		public object Dequeue(ThreadPoolWorkQueueThreadLocals tl, ref bool missedSteal)
		{
			WorkStealingQueue workStealingQueue = tl.workStealingQueue;
			object result;
			if ((result = workStealingQueue.LocalPop()) == null && !workItems.TryDequeue(out result))
			{
				WorkStealingQueue[] queues = WorkStealingQueueList.Queues;
				int num = queues.Length;
				int num2 = num - 1;
				uint num3 = tl.random.NextUInt32() % (uint)num;
				while (num > 0)
				{
					num3 = ((num3 < num2) ? (num3 + 1) : 0u);
					WorkStealingQueue workStealingQueue2 = queues[num3];
					if (workStealingQueue2 != workStealingQueue && workStealingQueue2.CanSteal)
					{
						result = workStealingQueue2.TrySteal(ref missedSteal);
						if (result != null)
						{
							return result;
						}
					}
					num--;
				}
				if (ThreadPool.SupportsTimeSensitiveWorkItems)
				{
					result = TryDequeueTimeSensitiveWorkItem();
				}
			}
			return result;
		}

		internal static bool Dispatch()
		{
			ThreadPoolWorkQueue s_workQueue = ThreadPool.s_workQueue;
			s_workQueue.MarkThreadRequestSatisfied();
			s_workQueue.RefreshLoggingEnabled();
			bool flag = true;
			try
			{
				ThreadPoolWorkQueue threadPoolWorkQueue = s_workQueue;
				ThreadPoolWorkQueueThreadLocals orCreateThreadLocals = threadPoolWorkQueue.GetOrCreateThreadLocals();
				object threadLocalCompletionCountObject = orCreateThreadLocals.threadLocalCompletionCountObject;
				Thread currentThread = orCreateThreadLocals.currentThread;
				currentThread._executionContext = null;
				currentThread._synchronizationContext = null;
				int num = Environment.TickCount;
				object obj = null;
				if (ThreadPool.SupportsTimeSensitiveWorkItems)
				{
					bool dispatchTimeSensitiveWorkFirst = threadPoolWorkQueue._dispatchTimeSensitiveWorkFirst;
					threadPoolWorkQueue._dispatchTimeSensitiveWorkFirst = !dispatchTimeSensitiveWorkFirst;
					if (dispatchTimeSensitiveWorkFirst)
					{
						obj = threadPoolWorkQueue.TryDequeueTimeSensitiveWorkItem();
					}
				}
				while (true)
				{
					if (obj == null)
					{
						bool missedSteal = false;
						obj = threadPoolWorkQueue.Dequeue(orCreateThreadLocals, ref missedSteal);
						if (obj == null)
						{
							flag = missedSteal;
							return true;
						}
					}
					if (threadPoolWorkQueue.loggingEnabled && FrameworkEventSource.Log.IsEnabled())
					{
						FrameworkEventSource.Log.ThreadPoolDequeueWorkObject(obj);
					}
					threadPoolWorkQueue.EnsureThreadRequested();
					if (ThreadPool.EnableWorkerTracking)
					{
						DispatchWorkItemWithWorkerTracking(obj, currentThread);
					}
					else
					{
						DispatchWorkItem(obj, currentThread);
					}
					obj = null;
					ExecutionContext.ResetThreadPoolThread(currentThread);
					currentThread.ResetThreadPoolThread();
					int tickCount = Environment.TickCount;
					if (!ThreadPool.NotifyWorkItemComplete(threadLocalCompletionCountObject, tickCount))
					{
						orCreateThreadLocals.TransferLocalWork();
						return false;
					}
					if ((uint)(tickCount - num) >= 30u)
					{
						if (!ThreadPool.SupportsTimeSensitiveWorkItems)
						{
							break;
						}
						num = tickCount;
						threadPoolWorkQueue.RefreshLoggingEnabled();
						obj = threadPoolWorkQueue.TryDequeueTimeSensitiveWorkItem();
					}
				}
				return true;
			}
			finally
			{
				if (flag)
				{
					s_workQueue.EnsureThreadRequested();
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void DispatchWorkItemWithWorkerTracking(object workItem, Thread currentThread)
		{
			bool flag = false;
			try
			{
				ThreadPool.ReportThreadStatus(isWorking: true);
				flag = true;
				DispatchWorkItem(workItem, currentThread);
			}
			finally
			{
				if (flag)
				{
					ThreadPool.ReportThreadStatus(isWorking: false);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void DispatchWorkItem(object workItem, Thread currentThread)
		{
			if (workItem is Task task)
			{
				task.ExecuteFromThreadPool(currentThread);
			}
			else
			{
				Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
			}
		}
	}
	internal sealed class ThreadPoolWorkQueueThreadLocals
	{
		[ThreadStatic]
		public static ThreadPoolWorkQueueThreadLocals threadLocals;

		public readonly ThreadPoolWorkQueue workQueue;

		public readonly ThreadPoolWorkQueue.WorkStealingQueue workStealingQueue;

		public readonly Thread currentThread;

		public readonly object threadLocalCompletionCountObject;

		public readonly Random.XoshiroImpl random = new Random.XoshiroImpl();

		public ThreadPoolWorkQueueThreadLocals(ThreadPoolWorkQueue tpq)
		{
			workQueue = tpq;
			workStealingQueue = new ThreadPoolWorkQueue.WorkStealingQueue();
			ThreadPoolWorkQueue.WorkStealingQueueList.Add(workStealingQueue);
			currentThread = Thread.CurrentThread;
			threadLocalCompletionCountObject = ThreadPool.GetOrCreateThreadLocalCompletionCountObject();
		}

		public void TransferLocalWork()
		{
			while (true)
			{
				object obj = workStealingQueue.LocalPop();
				if (obj != null)
				{
					workQueue.Enqueue(obj, forceGlobal: true);
					continue;
				}
				break;
			}
		}

		~ThreadPoolWorkQueueThreadLocals()
		{
			if (workStealingQueue != null)
			{
				TransferLocalWork();
				ThreadPoolWorkQueue.WorkStealingQueueList.Remove(workStealingQueue);
			}
		}
	}
	public delegate void WaitCallback(object? state);
	public delegate void WaitOrTimerCallback(object? state, bool timedOut);
	internal abstract class QueueUserWorkItemCallbackBase : IThreadPoolWorkItem
	{
		public virtual void Execute()
		{
		}
	}
	internal sealed class QueueUserWorkItemCallback : QueueUserWorkItemCallbackBase
	{
		private WaitCallback _callback;

		private readonly object _state;

		private readonly ExecutionContext _context;

		private static readonly Action<QueueUserWorkItemCallback> s_executionContextShim = delegate(QueueUserWorkItemCallback quwi)
		{
			WaitCallback callback = quwi._callback;
			quwi._callback = null;
			callback(quwi._state);
		};

		internal QueueUserWorkItemCallback(WaitCallback callback, object state, ExecutionContext context)
		{
			_callback = callback;
			_state = state;
			_context = context;
		}

		public override void Execute()
		{
			base.Execute();
			ExecutionContext.RunForThreadPoolUnsafe(_context, s_executionContextShim, in this);
		}
	}
	internal sealed class QueueUserWorkItemCallback<TState> : QueueUserWorkItemCallbackBase
	{
		private Action<TState> _callback;

		private readonly TState _state;

		private readonly ExecutionContext _context;

		internal QueueUserWorkItemCallback(Action<TState> callback, TState state, ExecutionContext context)
		{
			_callback = callback;
			_state = state;
			_context = context;
		}

		public override void Execute()
		{
			base.Execute();
			Action<TState> callback = _callback;
			_callback = null;
			ExecutionContext.RunForThreadPoolUnsafe(_context, callback, in _state);
		}
	}
	internal sealed class QueueUserWorkItemCallbackDefaultContext : QueueUserWorkItemCallbackBase
	{
		private WaitCallback _callback;

		private readonly object _state;

		internal QueueUserWorkItemCallbackDefaultContext(WaitCallback callback, object state)
		{
			_callback = callback;
			_state = state;
		}

		public override void Execute()
		{
			base.Execute();
			WaitCallback callback = _callback;
			_callback = null;
			callback(_state);
		}
	}
	internal sealed class QueueUserWorkItemCallbackDefaultContext<TState> : QueueUserWorkItemCallbackBase
	{
		private Action<TState> _callback;

		private readonly TState _state;

		internal QueueUserWorkItemCallbackDefaultContext(Action<TState> callback, TState state)
		{
			_callback = callback;
			_state = state;
		}

		public override void Execute()
		{
			base.Execute();
			Action<TState> callback = _callback;
			_callback = null;
			callback(_state);
		}
	}
	internal sealed class _ThreadPoolWaitOrTimerCallback
	{
		private readonly WaitOrTimerCallback _waitOrTimerCallback;

		private readonly ExecutionContext _executionContext;

		private readonly object _state;

		private static readonly ContextCallback _ccbt = WaitOrTimerCallback_Context_t;

		private static readonly ContextCallback _ccbf = WaitOrTimerCallback_Context_f;

		internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, object state, bool flowExecutionContext)
		{
			_waitOrTimerCallback = waitOrTimerCallback;
			_state = state;
			if (flowExecutionContext)
			{
				_executionContext = ExecutionContext.Capture();
			}
		}

		private static void WaitOrTimerCallback_Context_t(object state)
		{
			WaitOrTimerCallback_Context(state, timedOut: true);
		}

		private static void WaitOrTimerCallback_Context_f(object state)
		{
			WaitOrTimerCallback_Context(state, timedOut: false);
		}

		private static void WaitOrTimerCallback_Context(object state, bool timedOut)
		{
			_ThreadPoolWaitOrTimerCallback threadPoolWaitOrTimerCallback = (_ThreadPoolWaitOrTimerCallback)state;
			threadPoolWaitOrTimerCallback._waitOrTimerCallback(threadPoolWaitOrTimerCallback._state, timedOut);
		}

		internal static void PerformWaitOrTimerCallback(_ThreadPoolWaitOrTimerCallback helper, bool timedOut)
		{
			ExecutionContext executionContext = helper._executionContext;
			if (executionContext == null)
			{
				WaitOrTimerCallback waitOrTimerCallback = helper._waitOrTimerCallback;
				waitOrTimerCallback(helper._state, timedOut);
			}
			else
			{
				ExecutionContext.Run(executionContext, timedOut ? _ccbt : _ccbf, helper);
			}
		}
	}
	public enum ThreadPriority
	{
		Lowest,
		BelowNormal,
		Normal,
		AboveNormal,
		Highest
	}
	public delegate void ThreadStart();
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class ThreadStartException : SystemException
	{
		internal ThreadStartException()
			: base(SR.Arg_ThreadStartException)
		{
			base.HResult = -2146233051;
		}

		internal ThreadStartException(Exception reason)
			: base(SR.Arg_ThreadStartException, reason)
		{
			base.HResult = -2146233051;
		}

		private ThreadStartException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Flags]
	public enum ThreadState
	{
		Running = 0,
		StopRequested = 1,
		SuspendRequested = 2,
		Background = 4,
		Unstarted = 8,
		Stopped = 0x10,
		WaitSleepJoin = 0x20,
		Suspended = 0x40,
		AbortRequested = 0x80,
		Aborted = 0x100
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ThreadStateException : SystemException
	{
		public ThreadStateException()
			: base(SR.Arg_ThreadStateException)
		{
			base.HResult = -2146233056;
		}

		public ThreadStateException(string? message)
			: base(message)
		{
			base.HResult = -2146233056;
		}

		public ThreadStateException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233056;
		}

		protected ThreadStateException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public static class Timeout
	{
		public static readonly TimeSpan InfiniteTimeSpan = new TimeSpan(0, 0, 0, 0, -1);

		public const int Infinite = -1;
	}
	internal static class TimeoutHelper
	{
		public static uint GetTime()
		{
			return (uint)Environment.TickCount;
		}

		public static int UpdateTimeOut(uint startTime, int originalWaitMillisecondsTimeout)
		{
			uint num = GetTime() - startTime;
			if (num > int.MaxValue)
			{
				return 0;
			}
			int num2 = originalWaitMillisecondsTimeout - (int)num;
			if (num2 <= 0)
			{
				return 0;
			}
			return num2;
		}
	}
	public sealed class PeriodicTimer : IDisposable
	{
		private sealed class State : IValueTaskSource<bool>
		{
			private PeriodicTimer _owner;

			private ManualResetValueTaskSourceCore<bool> _mrvtsc;

			private CancellationTokenRegistration _ctr;

			private bool _stopped;

			private bool _signaled;

			private bool _activeWait;

			public ValueTask<bool> WaitForNextTickAsync(PeriodicTimer owner, CancellationToken cancellationToken)
			{
				lock (this)
				{
					if (_activeWait)
					{
						ThrowHelper.ThrowInvalidOperationException();
					}
					if (cancellationToken.IsCancellationRequested)
					{
						return ValueTask.FromCanceled<bool>(cancellationToken);
					}
					if (_signaled)
					{
						if (!_stopped)
						{
							_signaled = false;
						}
						return new ValueTask<bool>(!_stopped);
					}
					_owner = owner;
					_activeWait = true;
					_ctr = cancellationToken.UnsafeRegister(delegate(object state, CancellationToken cancellationToken)
					{
						((State)state).Signal(stopping: false, cancellationToken);
					}, this);
					return new ValueTask<bool>(this, _mrvtsc.Version);
				}
			}

			public void Signal(bool stopping = false, CancellationToken cancellationToken = default(CancellationToken))
			{
				bool flag = false;
				lock (this)
				{
					_stopped |= stopping;
					if (!_signaled)
					{
						_signaled = true;
						flag = _activeWait;
					}
				}
				if (flag)
				{
					if (cancellationToken.IsCancellationRequested)
					{
						_mrvtsc.SetException(ExceptionDispatchInfo.SetCurrentStackTrace(new OperationCanceledException(cancellationToken)));
					}
					else
					{
						_mrvtsc.SetResult(result: true);
					}
				}
			}

			bool IValueTaskSource<bool>.GetResult(short token)
			{
				_ctr.Dispose();
				lock (this)
				{
					try
					{
						_mrvtsc.GetResult(token);
					}
					finally
					{
						_mrvtsc.Reset();
						_ctr = default(CancellationTokenRegistration);
						_activeWait = false;
						_owner = null;
						if (!_stopped)
						{
							_signaled = false;
						}
					}
					return !_stopped;
				}
			}

			ValueTaskSourceStatus IValueTaskSource<bool>.GetStatus(short token)
			{
				return _mrvtsc.GetStatus(token);
			}

			void IValueTaskSource<bool>.OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				_mrvtsc.OnCompleted(continuation, state, token, flags);
			}
		}

		private readonly TimerQueueTimer _timer;

		private readonly State _state;

		public PeriodicTimer(TimeSpan period)
		{
			long num = (long)period.TotalMilliseconds;
			if (num < 1 || num > 4294967294u)
			{
				GC.SuppressFinalize(this);
				throw new ArgumentOutOfRangeException("period");
			}
			_state = new State();
			_timer = new TimerQueueTimer(delegate(object s)
			{
				((State)s).Signal();
			}, _state, (uint)num, (uint)num, flowExecutionContext: false);
		}

		public ValueTask<bool> WaitForNextTickAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return _state.WaitForNextTickAsync(this, cancellationToken);
		}

		public void Dispose()
		{
			GC.SuppressFinalize(this);
			_timer.Close();
			_state.Signal(stopping: true);
		}

		~PeriodicTimer()
		{
			Dispose();
		}
	}
	public delegate void TimerCallback(object? state);
	[DebuggerDisplay("{DisplayString,nq}")]
	[DebuggerTypeProxy(typeof(TimerDebuggerTypeProxy))]
	internal sealed class TimerQueueTimer : IThreadPoolWorkItem
	{
		internal sealed class TimerDebuggerTypeProxy
		{
			private readonly TimerQueueTimer _timer;

			public DateTime? EstimatedNextTimeUtc
			{
				get
				{
					if (_timer._dueTime != uint.MaxValue)
					{
						long num = _timer._startTicks - TimerQueue.s_tickCountToTimeMap.TickCount + _timer._dueTime;
						return TimerQueue.s_tickCountToTimeMap.Time + TimeSpan.FromMilliseconds(num);
					}
					return null;
				}
			}

			public TimeSpan? DueTime
			{
				get
				{
					if (_timer._dueTime != uint.MaxValue)
					{
						return TimeSpan.FromMilliseconds(_timer._dueTime);
					}
					return null;
				}
			}

			public TimeSpan? Period
			{
				get
				{
					if (_timer._period != uint.MaxValue)
					{
						return TimeSpan.FromMilliseconds(_timer._period);
					}
					return null;
				}
			}

			public TimerCallback Callback => _timer._timerCallback;

			public object State => _timer._state;

			public TimerDebuggerTypeProxy(Timer timer)
			{
				_timer = timer._timer._timer;
			}

			public TimerDebuggerTypeProxy(TimerQueueTimer timer)
			{
				_timer = timer;
			}
		}

		private readonly TimerQueue _associatedTimerQueue;

		internal TimerQueueTimer _next;

		internal TimerQueueTimer _prev;

		internal bool _short;

		internal long _startTicks;

		internal uint _dueTime;

		internal uint _period;

		private readonly TimerCallback _timerCallback;

		private readonly object _state;

		private readonly ExecutionContext _executionContext;

		private int _callbacksRunning;

		private bool _canceled;

		internal bool _everQueued;

		private object _notifyWhenNoCallbacksRunning;

		private static readonly ContextCallback s_callCallbackInContext = delegate(object state)
		{
			TimerQueueTimer timerQueueTimer = (TimerQueueTimer)state;
			timerQueueTimer._timerCallback(timerQueueTimer._state);
		};

		internal string DisplayString
		{
			get
			{
				string text = _timerCallback.Method.DeclaringType?.FullName;
				if (text != null)
				{
					text += ".";
				}
				return "DueTime = " + ((_dueTime == uint.MaxValue) ? "(not set)" : ((object)TimeSpan.FromMilliseconds(_dueTime)))?.ToString() + ", Period = " + ((_period == uint.MaxValue) ? "(not set)" : ((object)TimeSpan.FromMilliseconds(_period)))?.ToString() + ", " + text + _timerCallback.Method.Name + "(" + (_state?.ToString() ?? "null") + ")";
			}
		}

		internal TimerQueueTimer(TimerCallback timerCallback, object state, uint dueTime, uint period, bool flowExecutionContext)
		{
			_timerCallback = timerCallback;
			_state = state;
			_dueTime = uint.MaxValue;
			_period = uint.MaxValue;
			if (flowExecutionContext)
			{
				_executionContext = ExecutionContext.Capture();
			}
			_associatedTimerQueue = TimerQueue.Instances[Thread.GetCurrentProcessorId() % TimerQueue.Instances.Length];
			if (dueTime != uint.MaxValue)
			{
				Change(dueTime, period);
			}
		}

		internal bool Change(uint dueTime, uint period)
		{
			lock (_associatedTimerQueue)
			{
				if (_canceled)
				{
					throw new ObjectDisposedException(null, SR.ObjectDisposed_Generic);
				}
				_period = period;
				if (dueTime == uint.MaxValue)
				{
					_associatedTimerQueue.DeleteTimer(this);
					return true;
				}
				if (FrameworkEventSource.Log.IsEnabled(EventLevel.Informational, (EventKeywords)16L))
				{
					FrameworkEventSource.Log.ThreadTransferSendObj(this, 1, string.Empty, multiDequeues: true, (int)dueTime, (int)period);
				}
				return _associatedTimerQueue.UpdateTimer(this, dueTime, period);
			}
		}

		public void Close()
		{
			lock (_associatedTimerQueue)
			{
				if (!_canceled)
				{
					_canceled = true;
					_associatedTimerQueue.DeleteTimer(this);
				}
			}
		}

		public bool Close(WaitHandle toSignal)
		{
			bool flag = false;
			bool result;
			lock (_associatedTimerQueue)
			{
				if (_canceled)
				{
					result = false;
				}
				else
				{
					_canceled = true;
					_notifyWhenNoCallbacksRunning = toSignal;
					_associatedTimerQueue.DeleteTimer(this);
					flag = _callbacksRunning == 0;
					result = true;
				}
			}
			if (flag)
			{
				SignalNoCallbacksRunning();
			}
			return result;
		}

		public ValueTask CloseAsync()
		{
			lock (_associatedTimerQueue)
			{
				object notifyWhenNoCallbacksRunning = _notifyWhenNoCallbacksRunning;
				if (_canceled)
				{
					if (notifyWhenNoCallbacksRunning is WaitHandle)
					{
						InvalidOperationException ex = new InvalidOperationException(SR.InvalidOperation_TimerAlreadyClosed);
						ex.SetCurrentStackTrace();
						return ValueTask.FromException(ex);
					}
				}
				else
				{
					_canceled = true;
					_associatedTimerQueue.DeleteTimer(this);
				}
				if (_callbacksRunning == 0)
				{
					return default(ValueTask);
				}
				if (notifyWhenNoCallbacksRunning == null)
				{
					return new ValueTask((Task)(_notifyWhenNoCallbacksRunning = new Task(null, TaskCreationOptions.RunContinuationsAsynchronously, promiseStyle: true)));
				}
				return new ValueTask((Task)notifyWhenNoCallbacksRunning);
			}
		}

		void IThreadPoolWorkItem.Execute()
		{
			Fire(isThreadPool: true);
		}

		internal void Fire(bool isThreadPool = false)
		{
			bool flag = false;
			lock (_associatedTimerQueue)
			{
				flag = _canceled;
				if (!flag)
				{
					_callbacksRunning++;
				}
			}
			if (!flag)
			{
				CallCallback(isThreadPool);
				bool flag2;
				lock (_associatedTimerQueue)
				{
					_callbacksRunning--;
					flag2 = _canceled && _callbacksRunning == 0 && _notifyWhenNoCallbacksRunning != null;
				}
				if (flag2)
				{
					SignalNoCallbacksRunning();
				}
			}
		}

		internal void SignalNoCallbacksRunning()
		{
			object notifyWhenNoCallbacksRunning = _notifyWhenNoCallbacksRunning;
			if (notifyWhenNoCallbacksRunning is WaitHandle waitHandle)
			{
				EventWaitHandle.Set(waitHandle.SafeWaitHandle);
			}
			else
			{
				((Task)notifyWhenNoCallbacksRunning).TrySetResult();
			}
		}

		internal void CallCallback(bool isThreadPool)
		{
			if (FrameworkEventSource.Log.IsEnabled(EventLevel.Informational, (EventKeywords)16L))
			{
				FrameworkEventSource.Log.ThreadTransferReceiveObj(this, 1, string.Empty);
			}
			ExecutionContext executionContext = _executionContext;
			if (executionContext == null)
			{
				_timerCallback(_state);
			}
			else if (isThreadPool)
			{
				ExecutionContext.RunFromThreadPoolDispatchLoop(Thread.CurrentThread, executionContext, s_callCallbackInContext, this);
			}
			else
			{
				ExecutionContext.RunInternal(executionContext, s_callCallbackInContext, this);
			}
		}
	}
	internal sealed class TimerHolder
	{
		internal readonly TimerQueueTimer _timer;

		public TimerHolder(TimerQueueTimer timer)
		{
			_timer = timer;
		}

		~TimerHolder()
		{
			_timer.Close();
		}

		public void Close()
		{
			_timer.Close();
			GC.SuppressFinalize(this);
		}

		public bool Close(WaitHandle notifyObject)
		{
			bool result = _timer.Close(notifyObject);
			GC.SuppressFinalize(this);
			return result;
		}

		public ValueTask CloseAsync()
		{
			ValueTask result = _timer.CloseAsync();
			GC.SuppressFinalize(this);
			return result;
		}
	}
	[DebuggerDisplay("{DisplayString,nq}")]
	[DebuggerTypeProxy(typeof(TimerQueueTimer.TimerDebuggerTypeProxy))]
	public sealed class Timer : MarshalByRefObject, IDisposable, IAsyncDisposable
	{
		internal TimerHolder _timer;

		public static long ActiveCount
		{
			get
			{
				long num = 0L;
				TimerQueue[] instances = TimerQueue.Instances;
				foreach (TimerQueue timerQueue in instances)
				{
					lock (timerQueue)
					{
						num += timerQueue.ActiveCount;
					}
				}
				return num;
			}
		}

		private string DisplayString => _timer._timer.DisplayString;

		private static IEnumerable<TimerQueueTimer> AllTimers
		{
			get
			{
				List<TimerQueueTimer> list = new List<TimerQueueTimer>();
				TimerQueue[] instances = TimerQueue.Instances;
				foreach (TimerQueue timerQueue in instances)
				{
					list.AddRange(timerQueue.GetTimersForDebugger());
				}
				list.Sort((TimerQueueTimer t1, TimerQueueTimer t2) => t1._dueTime.CompareTo(t2._dueTime));
				return list;
			}
		}

		public Timer(TimerCallback callback, object? state, int dueTime, int period)
			: this(callback, state, dueTime, period, flowExecutionContext: true)
		{
		}

		internal Timer(TimerCallback callback, object state, int dueTime, int period, bool flowExecutionContext)
		{
			if (dueTime < -1)
			{
				throw new ArgumentOutOfRangeException("dueTime", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (period < -1)
			{
				throw new ArgumentOutOfRangeException("period", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			TimerSetup(callback, state, (uint)dueTime, (uint)period, flowExecutionContext);
		}

		public Timer(TimerCallback callback, object? state, TimeSpan dueTime, TimeSpan period)
		{
			long num = (long)dueTime.TotalMilliseconds;
			if (num < -1)
			{
				throw new ArgumentOutOfRangeException("dueTime", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (num > 4294967294u)
			{
				throw new ArgumentOutOfRangeException("dueTime", SR.ArgumentOutOfRange_TimeoutTooLarge);
			}
			long num2 = (long)period.TotalMilliseconds;
			if (num2 < -1)
			{
				throw new ArgumentOutOfRangeException("period", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (num2 > 4294967294u)
			{
				throw new ArgumentOutOfRangeException("period", SR.ArgumentOutOfRange_PeriodTooLarge);
			}
			TimerSetup(callback, state, (uint)num, (uint)num2);
		}

		[CLSCompliant(false)]
		public Timer(TimerCallback callback, object? state, uint dueTime, uint period)
		{
			TimerSetup(callback, state, dueTime, period);
		}

		public Timer(TimerCallback callback, object? state, long dueTime, long period)
		{
			if (dueTime < -1)
			{
				throw new ArgumentOutOfRangeException("dueTime", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (period < -1)
			{
				throw new ArgumentOutOfRangeException("period", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (dueTime > 4294967294u)
			{
				throw new ArgumentOutOfRangeException("dueTime", SR.ArgumentOutOfRange_TimeoutTooLarge);
			}
			if (period > 4294967294u)
			{
				throw new ArgumentOutOfRangeException("period", SR.ArgumentOutOfRange_PeriodTooLarge);
			}
			TimerSetup(callback, state, (uint)dueTime, (uint)period);
		}

		public Timer(TimerCallback callback)
		{
			TimerSetup(callback, this, uint.MaxValue, uint.MaxValue);
		}

		[MemberNotNull("_timer")]
		private void TimerSetup(TimerCallback callback, object state, uint dueTime, uint period, bool flowExecutionContext = true)
		{
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			_timer = new TimerHolder(new TimerQueueTimer(callback, state, dueTime, period, flowExecutionContext));
		}

		public bool Change(int dueTime, int period)
		{
			if (dueTime < -1)
			{
				throw new ArgumentOutOfRangeException("dueTime", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (period < -1)
			{
				throw new ArgumentOutOfRangeException("period", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			return _timer._timer.Change((uint)dueTime, (uint)period);
		}

		public bool Change(TimeSpan dueTime, TimeSpan period)
		{
			return Change((long)dueTime.TotalMilliseconds, (long)period.TotalMilliseconds);
		}

		[CLSCompliant(false)]
		public bool Change(uint dueTime, uint period)
		{
			return _timer._timer.Change(dueTime, period);
		}

		public bool Change(long dueTime, long period)
		{
			if (dueTime < -1)
			{
				throw new ArgumentOutOfRangeException("dueTime", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (period < -1)
			{
				throw new ArgumentOutOfRangeException("period", SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
			}
			if (dueTime > 4294967294u)
			{
				throw new ArgumentOutOfRangeException("dueTime", SR.ArgumentOutOfRange_TimeoutTooLarge);
			}
			if (period > 4294967294u)
			{
				throw new ArgumentOutOfRangeException("period", SR.ArgumentOutOfRange_PeriodTooLarge);
			}
			return _timer._timer.Change((uint)dueTime, (uint)period);
		}

		public bool Dispose(WaitHandle notifyObject)
		{
			if (notifyObject == null)
			{
				throw new ArgumentNullException("notifyObject");
			}
			return _timer.Close(notifyObject);
		}

		public void Dispose()
		{
			_timer.Close();
		}

		public ValueTask DisposeAsync()
		{
			return _timer.CloseAsync();
		}
	}
	public static class Volatile
	{
		private struct VolatileBoolean
		{
			public volatile bool Value;
		}

		private struct VolatileByte
		{
			public volatile byte Value;
		}

		private struct VolatileInt16
		{
			public volatile short Value;
		}

		private struct VolatileInt32
		{
			public volatile int Value;
		}

		private struct VolatileIntPtr
		{
			public volatile IntPtr Value;
		}

		private struct VolatileSByte
		{
			public volatile sbyte Value;
		}

		private struct VolatileSingle
		{
			public volatile float Value;
		}

		private struct VolatileUInt16
		{
			public volatile ushort Value;
		}

		private struct VolatileUInt32
		{
			public volatile uint Value;
		}

		private struct VolatileUIntPtr
		{
			public volatile UIntPtr Value;
		}

		private struct VolatileObject
		{
			public volatile object Value;
		}

		[Intrinsic]
		[NonVersionable]
		public static bool Read(ref bool location)
		{
			return Unsafe.As<bool, VolatileBoolean>(ref location).Value;
		}

		[Intrinsic]
		[NonVersionable]
		public static void Write(ref bool location, bool value)
		{
			Unsafe.As<bool, VolatileBoolean>(ref location).Value = value;
		}

		[Intrinsic]
		[NonVersionable]
		public static byte Read(ref byte location)
		{
			return Unsafe.As<byte, VolatileByte>(ref location).Value;
		}

		[Intrinsic]
		[NonVersionable]
		public static void Write(ref byte location, byte value)
		{
			Unsafe.As<byte, VolatileByte>(ref location).Value = value;
		}

		[Intrinsic]
		[NonVersionable]
		public unsafe static double Read(ref double location)
		{
			long num = Read(ref Unsafe.As<double, long>(ref location));
			return *(double*)(&num);
		}

		[Intrinsic]
		[NonVersionable]
		public unsafe static void Write(ref double location, double value)
		{
			Write(ref Unsafe.As<double, long>(ref location), *(long*)(&value));
		}

		[Intrinsic]
		[NonVersionable]
		public static short Read(ref short location)
		{
			return Unsafe.As<short, VolatileInt16>(ref location).Value;
		}

		[Intrinsic]
		[NonVersionable]
		public static void Write(ref short location, short value)
		{
			Unsafe.As<short, VolatileInt16>(ref location).Value = value;
		}

		[Intrinsic]
		[NonVersionable]
		public static int Read(ref int location)
		{
			return Unsafe.As<int, VolatileInt32>(ref location).Value;
		}

		[Intrinsic]
		[NonVersionable]
		public static void Write(ref int location, int value)
		{
			Unsafe.As<int, VolatileInt32>(ref location).Value = value;
		}

		[Intrinsic]
		[NonVersionable]
		public static long Read(ref long location)
		{
			return Interlocked.CompareExchange(ref location, 0L, 0L);
		}

		[Intrinsic]
		[NonVersionable]
		public static void Write(ref long location, long value)
		{
			Interlocked.Exchange(ref location, value);
		}

		[Intrinsic]
		[NonVersionable]
		public static IntPtr Read(ref IntPtr location)
		{
			return Unsafe.As<IntPtr, VolatileIntPtr>(ref location).Value;
		}

		[Intrinsic]
		[NonVersionable]
		public static void Write(ref IntPtr location, IntPtr value)
		{
			Unsafe.As<IntPtr, VolatileIntPtr>(ref location).Value = value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static sbyte Read(ref sbyte location)
		{
			return Unsafe.As<sbyte, VolatileSByte>(ref location).Value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static void Write(ref sbyte location, sbyte value)
		{
			Unsafe.As<sbyte, VolatileSByte>(ref location).Value = value;
		}

		[Intrinsic]
		[NonVersionable]
		public static float Read(ref float location)
		{
			return Unsafe.As<float, VolatileSingle>(ref location).Value;
		}

		[Intrinsic]
		[NonVersionable]
		public static void Write(ref float location, float value)
		{
			Unsafe.As<float, VolatileSingle>(ref location).Value = value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static ushort Read(ref ushort location)
		{
			return Unsafe.As<ushort, VolatileUInt16>(ref location).Value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static void Write(ref ushort location, ushort value)
		{
			Unsafe.As<ushort, VolatileUInt16>(ref location).Value = value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static uint Read(ref uint location)
		{
			return Unsafe.As<uint, VolatileUInt32>(ref location).Value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static void Write(ref uint location, uint value)
		{
			Unsafe.As<uint, VolatileUInt32>(ref location).Value = value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static ulong Read(ref ulong location)
		{
			return (ulong)Read(ref Unsafe.As<ulong, long>(ref location));
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static void Write(ref ulong location, ulong value)
		{
			Write(ref Unsafe.As<ulong, long>(ref location), (long)value);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static UIntPtr Read(ref UIntPtr location)
		{
			return Unsafe.As<UIntPtr, VolatileUIntPtr>(ref location).Value;
		}

		[CLSCompliant(false)]
		[Intrinsic]
		[NonVersionable]
		public static void Write(ref UIntPtr location, UIntPtr value)
		{
			Unsafe.As<UIntPtr, VolatileUIntPtr>(ref location).Value = value;
		}

		[Intrinsic]
		[NonVersionable]
		[return: NotNullIfNotNull("location")]
		public static T Read<T>([NotNullIfNotNull("location")] ref T location) where T : class?
		{
			return Unsafe.As<T>(Unsafe.As<T, VolatileObject>(ref location).Value);
		}

		[Intrinsic]
		[NonVersionable]
		public static void Write<T>([NotNullIfNotNull("value")] ref T location, T value) where T : class?
		{
			Unsafe.As<T, VolatileObject>(ref location).Value = value;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class WaitHandleCannotBeOpenedException : ApplicationException
	{
		public WaitHandleCannotBeOpenedException()
			: base(SR.Threading_WaitHandleCannotBeOpenedException)
		{
			base.HResult = -2146233044;
		}

		public WaitHandleCannotBeOpenedException(string? message)
			: base(message)
		{
			base.HResult = -2146233044;
		}

		public WaitHandleCannotBeOpenedException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233044;
		}

		protected WaitHandleCannotBeOpenedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public static class WaitHandleExtensions
	{
		public static SafeWaitHandle GetSafeWaitHandle(this WaitHandle waitHandle)
		{
			if (waitHandle == null)
			{
				throw new ArgumentNullException("waitHandle");
			}
			return waitHandle.SafeWaitHandle;
		}

		public static void SetSafeWaitHandle(this WaitHandle waitHandle, SafeWaitHandle? value)
		{
			if (waitHandle == null)
			{
				throw new ArgumentNullException("waitHandle");
			}
			waitHandle.SafeWaitHandle = value;
		}
	}
	internal enum OpenExistingResult
	{
		Success,
		NameNotFound,
		PathNotFound,
		NameInvalid
	}
	internal sealed class PortableThreadPool
	{
		[StructLayout(LayoutKind.Explicit, Size = 384)]
		private struct CacheLineSeparated
		{
			[FieldOffset(64)]
			public ThreadCounts counts;

			[FieldOffset(128)]
			public int lastDequeueTime;

			[FieldOffset(192)]
			public int priorCompletionCount;

			[FieldOffset(196)]
			public int priorCompletedWorkRequestsTime;

			[FieldOffset(200)]
			public int nextCompletedWorkRequestsTime;

			[FieldOffset(256)]
			public volatile int numRequestedWorkers;

			[FieldOffset(260)]
			public int gateThreadRunningState;
		}

		private enum PendingBlockingAdjustment : byte
		{
			None,
			Immediately,
			WithDelayIfNecessary
		}

		private static class BlockingConfig
		{
			public static readonly bool IsCooperativeBlockingEnabled;

			public static readonly short ThreadsToAddWithoutDelay;

			public static readonly short ThreadsPerDelayStep;

			public static readonly uint DelayStepMs;

			public static readonly uint MaxDelayMs;

			static BlockingConfig()
			{
				IsCooperativeBlockingEnabled = AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.Blocking.CooperativeBlocking", defaultValue: true);
				int int32Config = AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.Blocking.ThreadsToAddWithoutDelay_ProcCountFactor", 1, allowNegative: false);
				int int32Config2 = AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.Blocking.ThreadsPerDelayStep_ProcCountFactor", 1, allowNegative: false);
				DelayStepMs = (uint)AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.Blocking.DelayStepMs", 25, allowNegative: false);
				MaxDelayMs = (uint)AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.Blocking.MaxDelayMs", 250, allowNegative: false);
				int processorCount = Environment.ProcessorCount;
				ThreadsToAddWithoutDelay = (short)(processorCount * int32Config);
				if (ThreadsToAddWithoutDelay > short.MaxValue || ThreadsToAddWithoutDelay / processorCount != int32Config)
				{
					ThreadsToAddWithoutDelay = short.MaxValue;
				}
				int32Config2 = Math.Max(1, int32Config2);
				short num = (short)(32767 - ThreadsToAddWithoutDelay);
				ThreadsPerDelayStep = (short)(processorCount * int32Config2);
				if (ThreadsPerDelayStep > num || ThreadsPerDelayStep / processorCount != int32Config2)
				{
					ThreadsPerDelayStep = num;
				}
				MaxDelayMs = Math.Max(1u, Math.Min(MaxDelayMs, 500u));
				DelayStepMs = Math.Max(1u, Math.Min(DelayStepMs, MaxDelayMs));
			}
		}

		private static class GateThread
		{
			private struct DelayHelper
			{
				private int _previousGateActivitiesTimeMs;

				private int _previousBlockingAdjustmentDelayStartTimeMs;

				private uint _previousBlockingAdjustmentDelayMs;

				private bool _runGateActivitiesAfterNextDelay;

				private bool _adjustForBlockingAfterNextDelay;

				public bool HasBlockingAdjustmentDelay => _previousBlockingAdjustmentDelayMs != 0;

				public void SetGateActivitiesTime(int currentTimeMs)
				{
					_previousGateActivitiesTimeMs = currentTimeMs;
				}

				public void SetBlockingAdjustmentTimeAndDelay(int currentTimeMs, uint delayMs)
				{
					_previousBlockingAdjustmentDelayStartTimeMs = currentTimeMs;
					_previousBlockingAdjustmentDelayMs = delayMs;
				}

				public void ClearBlockingAdjustmentDelay()
				{
					_previousBlockingAdjustmentDelayMs = 0u;
				}

				public uint GetNextDelay(int currentTimeMs)
				{
					uint num = (uint)(currentTimeMs - _previousGateActivitiesTimeMs);
					uint num2 = ((num >= 500) ? 1u : (500 - num));
					if (_previousBlockingAdjustmentDelayMs == 0)
					{
						_runGateActivitiesAfterNextDelay = true;
						_adjustForBlockingAfterNextDelay = false;
						return num2;
					}
					uint num3 = (uint)(currentTimeMs - _previousBlockingAdjustmentDelayStartTimeMs);
					uint num4 = ((num3 >= _previousBlockingAdjustmentDelayMs) ? 1u : (_previousBlockingAdjustmentDelayMs - num3));
					uint num5 = Math.Min(num2, num4);
					_runGateActivitiesAfterNextDelay = num5 == num2;
					_adjustForBlockingAfterNextDelay = num5 == num4;
					return num5;
				}

				public bool ShouldPerformGateActivities(int currentTimeMs, bool wasSignaledToWake)
				{
					bool flag = (!wasSignaledToWake && _runGateActivitiesAfterNextDelay) || (uint)(currentTimeMs - _previousGateActivitiesTimeMs) >= 500u;
					if (flag)
					{
						SetGateActivitiesTime(currentTimeMs);
					}
					return flag;
				}

				public bool HasBlockingAdjustmentDelayElapsed(int currentTimeMs, bool wasSignaledToWake)
				{
					if (!wasSignaledToWake && _adjustForBlockingAfterNextDelay)
					{
						return true;
					}
					uint num = (uint)(currentTimeMs - _previousBlockingAdjustmentDelayStartTimeMs);
					return num >= _previousBlockingAdjustmentDelayMs;
				}
			}

			private static readonly AutoResetEvent RunGateThreadEvent = new AutoResetEvent(initialState: true);

			private static readonly AutoResetEvent DelayEvent = new AutoResetEvent(initialState: false);

			private static void GateThreadStart()
			{
				bool booleanConfig = AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.DisableStarvationDetection", defaultValue: false);
				bool booleanConfig2 = AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.DebugBreakOnWorkerStarvation", defaultValue: false);
				CpuUtilizationReader cpuUtilizationReader = default(CpuUtilizationReader);
				_ = cpuUtilizationReader.CurrentUtilization;
				PortableThreadPool threadPoolInstance = ThreadPoolInstance;
				LowLevelLock threadAdjustmentLock = threadPoolInstance._threadAdjustmentLock;
				DelayHelper delayHelper = default(DelayHelper);
				if (BlockingConfig.IsCooperativeBlockingEnabled)
				{
					threadPoolInstance.OnGen2GCCallback();
					Gen2GcCallback.Register(threadPoolInstance.OnGen2GCCallback);
				}
				while (true)
				{
					RunGateThreadEvent.WaitOne();
					int tickCount = Environment.TickCount;
					delayHelper.SetGateActivitiesTime(tickCount);
					while (true)
					{
						bool wasSignaledToWake = DelayEvent.WaitOne((int)delayHelper.GetNextDelay(tickCount));
						tickCount = Environment.TickCount;
						PendingBlockingAdjustment pendingBlockingAdjustment = threadPoolInstance._pendingBlockingAdjustment;
						if (pendingBlockingAdjustment == PendingBlockingAdjustment.None)
						{
							delayHelper.ClearBlockingAdjustmentDelay();
						}
						else
						{
							bool flag = false;
							if (delayHelper.HasBlockingAdjustmentDelay)
							{
								flag = delayHelper.HasBlockingAdjustmentDelayElapsed(tickCount, wasSignaledToWake);
								if (pendingBlockingAdjustment == PendingBlockingAdjustment.WithDelayIfNecessary && !flag)
								{
									goto IL_00ee;
								}
							}
							uint num = threadPoolInstance.PerformBlockingAdjustment(flag);
							if (num == 0)
							{
								delayHelper.ClearBlockingAdjustmentDelay();
							}
							else
							{
								delayHelper.SetBlockingAdjustmentTimeAndDelay(tickCount, num);
							}
						}
						goto IL_00ee;
						IL_00ee:
						if (!delayHelper.ShouldPerformGateActivities(tickCount, wasSignaledToWake))
						{
							continue;
						}
						if (ThreadPool.EnableWorkerTracking && NativeRuntimeEventSource.Log.IsEnabled())
						{
							NativeRuntimeEventSource.Log.ThreadPoolWorkingThreadCount((uint)threadPoolInstance.GetAndResetHighWatermarkCountOfThreadsProcessingUserCallbacks(), 0);
						}
						bool flag2 = ThreadPool.PerformRuntimeSpecificGateActivities(threadPoolInstance._cpuUtilization = cpuUtilizationReader.CurrentUtilization);
						if (!booleanConfig && threadPoolInstance._pendingBlockingAdjustment == PendingBlockingAdjustment.None && threadPoolInstance._separated.numRequestedWorkers > 0 && SufficientDelaySinceLastDequeue(threadPoolInstance))
						{
							bool flag3 = false;
							threadAdjustmentLock.Acquire();
							try
							{
								ThreadCounts threadCounts = threadPoolInstance._separated.counts;
								while (threadCounts.NumProcessingWork < threadPoolInstance._maxThreads && threadCounts.NumProcessingWork >= threadCounts.NumThreadsGoal)
								{
									if (booleanConfig2)
									{
										Debugger.Break();
									}
									ThreadCounts newCounts = threadCounts;
									short newThreadCount = (newCounts.NumThreadsGoal = (short)(threadCounts.NumProcessingWork + 1));
									ThreadCounts threadCounts2 = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, threadCounts);
									if (threadCounts2 == threadCounts)
									{
										HillClimbing.ThreadPoolHillClimber.ForceChange(newThreadCount, HillClimbing.StateOrTransition.Starvation);
										flag3 = true;
										break;
									}
									threadCounts = threadCounts2;
								}
							}
							finally
							{
								threadAdjustmentLock.Release();
							}
							if (flag3)
							{
								WorkerThread.MaybeAddWorkingWorker(threadPoolInstance);
							}
						}
						if (!flag2 && threadPoolInstance._separated.numRequestedWorkers <= 0 && threadPoolInstance._pendingBlockingAdjustment == PendingBlockingAdjustment.None && Interlocked.Decrement(ref threadPoolInstance._separated.gateThreadRunningState) <= GetRunningStateForNumRuns(0))
						{
							break;
						}
					}
				}
			}

			public static void Wake(PortableThreadPool threadPoolInstance)
			{
				DelayEvent.Set();
				EnsureRunning(threadPoolInstance);
			}

			private static bool SufficientDelaySinceLastDequeue(PortableThreadPool threadPoolInstance)
			{
				uint num = (uint)(Environment.TickCount - threadPoolInstance._separated.lastDequeueTime);
				uint num2 = ((threadPoolInstance._cpuUtilization >= 80) ? ((uint)(threadPoolInstance._separated.counts.NumThreadsGoal * 1000)) : 500u);
				return num > num2;
			}

			internal static void EnsureRunning(PortableThreadPool threadPoolInstance)
			{
				if (threadPoolInstance._separated.gateThreadRunningState != GetRunningStateForNumRuns(2))
				{
					EnsureRunningSlow(threadPoolInstance);
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal static void EnsureRunningSlow(PortableThreadPool threadPoolInstance)
			{
				int num = Interlocked.Exchange(ref threadPoolInstance._separated.gateThreadRunningState, GetRunningStateForNumRuns(2));
				if (num == GetRunningStateForNumRuns(0))
				{
					RunGateThreadEvent.Set();
				}
				else if ((num & 4) == 0)
				{
					CreateGateThread(threadPoolInstance);
				}
			}

			private static int GetRunningStateForNumRuns(int numRuns)
			{
				return 4 | numRuns;
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private static void CreateGateThread(PortableThreadPool threadPoolInstance)
			{
				bool flag = false;
				try
				{
					Thread thread = new Thread(GateThreadStart, 262144)
					{
						IsThreadPoolThread = true,
						IsBackground = true,
						Name = ".NET ThreadPool Gate"
					};
					thread.UnsafeStart();
					flag = true;
				}
				finally
				{
					if (!flag)
					{
						Interlocked.Exchange(ref threadPoolInstance._separated.gateThreadRunningState, 0);
					}
				}
			}
		}

		private sealed class HillClimbing
		{
			public enum StateOrTransition
			{
				Warmup,
				Initializing,
				RandomMove,
				ClimbingMove,
				ChangePoint,
				Stabilizing,
				Starvation,
				ThreadTimedOut,
				CooperativeBlocking
			}

			private struct LogEntry
			{
				public int tickCount;

				public StateOrTransition stateOrTransition;

				public int newControlSetting;

				public int lastHistoryCount;

				public float lastHistoryMean;
			}

			private struct Complex
			{
				public double Imaginary { get; }

				public double Real { get; }

				public Complex(double real, double imaginary)
				{
					Real = real;
					Imaginary = imaginary;
				}

				public static Complex operator *(double scalar, Complex complex)
				{
					return new Complex(scalar * complex.Real, scalar * complex.Imaginary);
				}

				public static Complex operator /(Complex complex, double scalar)
				{
					return new Complex(complex.Real / scalar, complex.Imaginary / scalar);
				}

				public static Complex operator -(Complex lhs, Complex rhs)
				{
					return new Complex(lhs.Real - rhs.Real, lhs.Imaginary - rhs.Imaginary);
				}

				public static Complex operator /(Complex lhs, Complex rhs)
				{
					double num = rhs.Real * rhs.Real + rhs.Imaginary * rhs.Imaginary;
					return new Complex((lhs.Real * rhs.Real + lhs.Imaginary * rhs.Imaginary) / num, ((0.0 - lhs.Real) * rhs.Imaginary + lhs.Imaginary * rhs.Real) / num);
				}

				public double Abs()
				{
					return Math.Sqrt(Real * Real + Imaginary * Imaginary);
				}
			}

			public static readonly bool IsDisabled = AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.HillClimbing.Disable", defaultValue: false);

			public static readonly HillClimbing ThreadPoolHillClimber = new HillClimbing();

			private readonly int _wavePeriod;

			private readonly int _samplesToMeasure;

			private readonly double _targetThroughputRatio;

			private readonly double _targetSignalToNoiseRatio;

			private readonly double _maxChangePerSecond;

			private readonly double _maxChangePerSample;

			private readonly int _maxThreadWaveMagnitude;

			private readonly int _sampleIntervalMsLow;

			private readonly double _threadMagnitudeMultiplier;

			private readonly int _sampleIntervalMsHigh;

			private readonly double _throughputErrorSmoothingFactor;

			private readonly double _gainExponent;

			private readonly double _maxSampleError;

			private double _currentControlSetting;

			private long _totalSamples;

			private int _lastThreadCount;

			private double _averageThroughputNoise;

			private double _secondsElapsedSinceLastChange;

			private double _completionsSinceLastChange;

			private int _accumulatedCompletionCount;

			private double _accumulatedSampleDurationSeconds;

			private readonly double[] _samples;

			private readonly double[] _threadCounts;

			private int _currentSampleMs;

			private readonly Random _randomIntervalGenerator = new Random();

			private readonly LogEntry[] _log = new LogEntry[200];

			private int _logStart;

			private int _logSize;

			public HillClimbing()
			{
				_wavePeriod = AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.WavePeriod", 4, allowNegative: false);
				_maxThreadWaveMagnitude = AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.MaxWaveMagnitude", 20, allowNegative: false);
				_threadMagnitudeMultiplier = (double)AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.WaveMagnitudeMultiplier", 100, allowNegative: false) / 100.0;
				_samplesToMeasure = _wavePeriod * AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.WaveHistorySize", 8, allowNegative: false);
				_targetThroughputRatio = (double)AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.Bias", 15, allowNegative: false) / 100.0;
				_targetSignalToNoiseRatio = (double)AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.TargetSignalToNoiseRatio", 300, allowNegative: false) / 100.0;
				_maxChangePerSecond = AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.MaxChangePerSecond", 4, allowNegative: false);
				_maxChangePerSample = AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.MaxChangePerSample", 20, allowNegative: false);
				int int32Config = AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.SampleIntervalLow", 10, allowNegative: false);
				int int32Config2 = AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.SampleIntervalHigh", 200, allowNegative: false);
				if (int32Config <= int32Config2)
				{
					_sampleIntervalMsLow = int32Config;
					_sampleIntervalMsHigh = int32Config2;
				}
				else
				{
					_sampleIntervalMsLow = 10;
					_sampleIntervalMsHigh = 200;
				}
				_throughputErrorSmoothingFactor = (double)AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.ErrorSmoothingFactor", 1, allowNegative: false) / 100.0;
				_gainExponent = (double)AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.GainExponent", 200, allowNegative: false) / 100.0;
				_maxSampleError = (double)AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.HillClimbing.MaxSampleErrorPercent", 15, allowNegative: false) / 100.0;
				_samples = new double[_samplesToMeasure];
				_threadCounts = new double[_samplesToMeasure];
				_currentSampleMs = _randomIntervalGenerator.Next(_sampleIntervalMsLow, _sampleIntervalMsHigh + 1);
			}

			public (int newThreadCount, int newSampleMs) Update(int currentThreadCount, double sampleDurationSeconds, int numCompletions)
			{
				if (currentThreadCount != _lastThreadCount)
				{
					ForceChange(currentThreadCount, StateOrTransition.Initializing);
				}
				_secondsElapsedSinceLastChange += sampleDurationSeconds;
				_completionsSinceLastChange += numCompletions;
				sampleDurationSeconds += _accumulatedSampleDurationSeconds;
				numCompletions += _accumulatedCompletionCount;
				if (_totalSamples > 0 && ((double)currentThreadCount - 1.0) / (double)numCompletions >= _maxSampleError)
				{
					_accumulatedSampleDurationSeconds = sampleDurationSeconds;
					_accumulatedCompletionCount = numCompletions;
					return (currentThreadCount, 10);
				}
				_accumulatedSampleDurationSeconds = 0.0;
				_accumulatedCompletionCount = 0;
				double num = (double)numCompletions / sampleDurationSeconds;
				if (NativeRuntimeEventSource.Log.IsEnabled())
				{
					NativeRuntimeEventSource.Log.ThreadPoolWorkerThreadAdjustmentSample(num, 0);
				}
				int num2 = (int)(_totalSamples % _samplesToMeasure);
				_samples[num2] = num;
				_threadCounts[num2] = currentThreadCount;
				_totalSamples++;
				Complex complex = default(Complex);
				Complex complex2 = default(Complex);
				double num3 = 0.0;
				Complex complex3 = default(Complex);
				double num4 = 0.0;
				StateOrTransition state = StateOrTransition.Warmup;
				int num5 = (int)Math.Min(_totalSamples - 1, _samplesToMeasure) / _wavePeriod * _wavePeriod;
				if (num5 > _wavePeriod)
				{
					double num6 = 0.0;
					double num7 = 0.0;
					for (int i = 0; i < num5; i++)
					{
						num6 += _samples[(_totalSamples - num5 + i) % _samplesToMeasure];
						num7 += _threadCounts[(_totalSamples - num5 + i) % _samplesToMeasure];
					}
					double num8 = num6 / (double)num5;
					double num9 = num7 / (double)num5;
					if (num8 > 0.0 && num9 > 0.0)
					{
						double period = (double)num5 / ((double)num5 / (double)_wavePeriod + 1.0);
						double num10 = (double)num5 / ((double)num5 / (double)_wavePeriod - 1.0);
						complex2 = GetWaveComponent(_samples, num5, _wavePeriod) / num8;
						num3 = (GetWaveComponent(_samples, num5, period) / num8).Abs();
						if (num10 <= (double)num5)
						{
							num3 = Math.Max(num3, (GetWaveComponent(_samples, num5, num10) / num8).Abs());
						}
						complex = GetWaveComponent(_threadCounts, num5, _wavePeriod) / num9;
						if (_averageThroughputNoise == 0.0)
						{
							_averageThroughputNoise = num3;
						}
						else
						{
							_averageThroughputNoise = _throughputErrorSmoothingFactor * num3 + (1.0 - _throughputErrorSmoothingFactor) * _averageThroughputNoise;
						}
						if (complex.Abs() > 0.0)
						{
							complex3 = (complex2 - _targetThroughputRatio * complex) / complex;
							state = StateOrTransition.ClimbingMove;
						}
						else
						{
							complex3 = new Complex(0.0, 0.0);
							state = StateOrTransition.Stabilizing;
						}
						double num11 = Math.Max(_averageThroughputNoise, num3);
						num4 = ((!(num11 > 0.0)) ? 1.0 : (complex.Abs() / num11 / _targetSignalToNoiseRatio));
					}
				}
				double num12 = Math.Min(1.0, Math.Max(-1.0, complex3.Real));
				num12 *= Math.Min(1.0, Math.Max(0.0, num4));
				double num13 = _maxChangePerSecond * sampleDurationSeconds;
				num12 = Math.Pow(Math.Abs(num12), _gainExponent) * (double)((num12 >= 0.0) ? 1 : (-1)) * num13;
				num12 = Math.Min(num12, _maxChangePerSample);
				PortableThreadPool threadPoolInstance = ThreadPoolInstance;
				if (num12 > 0.0 && threadPoolInstance._cpuUtilization > 95)
				{
					num12 = 0.0;
				}
				_currentControlSetting += num12;
				int val = (int)(0.5 + _currentControlSetting * _averageThroughputNoise * _targetSignalToNoiseRatio * _threadMagnitudeMultiplier * 2.0);
				val = Math.Min(val, _maxThreadWaveMagnitude);
				val = Math.Max(val, 1);
				int maxThreads = threadPoolInstance._maxThreads;
				int minThreadsGoal = threadPoolInstance.MinThreadsGoal;
				_currentControlSetting = Math.Min(maxThreads - val, _currentControlSetting);
				_currentControlSetting = Math.Max(minThreadsGoal, _currentControlSetting);
				int val2 = (int)(_currentControlSetting + (double)(val * (_totalSamples / (_wavePeriod / 2) % 2)));
				val2 = Math.Min(maxThreads, val2);
				val2 = Math.Max(minThreadsGoal, val2);
				if (NativeRuntimeEventSource.Log.IsEnabled())
				{
					NativeRuntimeEventSource.Log.ThreadPoolWorkerThreadAdjustmentStats(sampleDurationSeconds, num, complex.Real, complex2.Real, num3, _averageThroughputNoise, complex3.Real, num4, _currentControlSetting, (ushort)val, 0);
				}
				if (val2 != currentThreadCount)
				{
					ChangeThreadCount(val2, state);
					_secondsElapsedSinceLastChange = 0.0;
					_completionsSinceLastChange = 0.0;
				}
				int item = ((!(complex3.Real < 0.0) || val2 != minThreadsGoal) ? _currentSampleMs : ((int)(0.5 + (double)_currentSampleMs * (10.0 * Math.Min(0.0 - complex3.Real, 1.0)))));
				return (val2, item);
			}

			private void ChangeThreadCount(int newThreadCount, StateOrTransition state)
			{
				_lastThreadCount = newThreadCount;
				if (state != StateOrTransition.CooperativeBlocking)
				{
					_currentSampleMs = _randomIntervalGenerator.Next(_sampleIntervalMsLow, _sampleIntervalMsHigh + 1);
				}
				double throughput = ((_secondsElapsedSinceLastChange > 0.0) ? (_completionsSinceLastChange / _secondsElapsedSinceLastChange) : 0.0);
				LogTransition(newThreadCount, throughput, state);
			}

			private void LogTransition(int newThreadCount, double throughput, StateOrTransition stateOrTransition)
			{
				int num = (_logStart + _logSize) % 200;
				if (_logSize == 200)
				{
					_logStart = (_logStart + 1) % 200;
					_logSize--;
				}
				ref LogEntry reference = ref _log[num];
				reference.tickCount = Environment.TickCount;
				reference.stateOrTransition = stateOrTransition;
				reference.newControlSetting = newThreadCount;
				reference.lastHistoryCount = (int)(Math.Min(_totalSamples, _samplesToMeasure) / _wavePeriod) * _wavePeriod;
				reference.lastHistoryMean = (float)throughput;
				_logSize++;
				if (NativeRuntimeEventSource.Log.IsEnabled())
				{
					NativeRuntimeEventSource.Log.ThreadPoolWorkerThreadAdjustmentAdjustment(throughput, (uint)newThreadCount, (NativeRuntimeEventSource.ThreadAdjustmentReasonMap)stateOrTransition, 0);
				}
			}

			public void ForceChange(int newThreadCount, StateOrTransition state)
			{
				if (_lastThreadCount != newThreadCount)
				{
					_currentControlSetting += newThreadCount - _lastThreadCount;
					ChangeThreadCount(newThreadCount, state);
				}
			}

			private Complex GetWaveComponent(double[] samples, int numSamples, double period)
			{
				double num = Math.PI * 2.0 / period;
				double num2 = Math.Cos(num);
				double num3 = 2.0 * num2;
				double num4 = 0.0;
				double num5 = 0.0;
				double num6 = 0.0;
				for (int i = 0; i < numSamples; i++)
				{
					num4 = num3 * num5 - num6 + samples[(_totalSamples - numSamples + i) % _samplesToMeasure];
					num6 = num5;
					num5 = num4;
				}
				return new Complex(num5 - num6 * num2, num6 * Math.Sin(num)) / numSamples;
			}
		}

		private struct ThreadCounts
		{
			private ulong _data;

			public short NumProcessingWork
			{
				get
				{
					return GetInt16Value(0);
				}
				set
				{
					SetInt16Value(Math.Max((short)0, value), 0);
				}
			}

			public short NumExistingThreads
			{
				get
				{
					return GetInt16Value(16);
				}
				set
				{
					SetInt16Value(Math.Max((short)0, value), 16);
				}
			}

			public short NumThreadsGoal
			{
				get
				{
					return GetInt16Value(32);
				}
				set
				{
					SetInt16Value(Math.Max((short)1, value), 32);
				}
			}

			private ThreadCounts(ulong data)
			{
				_data = data;
			}

			private short GetInt16Value(byte shift)
			{
				return (short)(_data >> (int)shift);
			}

			private void SetInt16Value(short value, byte shift)
			{
				_data = (_data & (ulong)(~(65535L << (int)shift))) | ((ulong)(ushort)value << (int)shift);
			}

			public ThreadCounts InterlockedSetNumThreadsGoal(short value)
			{
				ThreadCounts threadCounts = this;
				ThreadCounts threadCounts2;
				while (true)
				{
					threadCounts2 = threadCounts;
					threadCounts2.NumThreadsGoal = value;
					ThreadCounts threadCounts3 = InterlockedCompareExchange(threadCounts2, threadCounts);
					if (threadCounts3 == threadCounts)
					{
						break;
					}
					threadCounts = threadCounts3;
				}
				return threadCounts2;
			}

			public ThreadCounts VolatileRead()
			{
				return new ThreadCounts(Volatile.Read(ref _data));
			}

			public ThreadCounts InterlockedCompareExchange(ThreadCounts newCounts, ThreadCounts oldCounts)
			{
				return new ThreadCounts(Interlocked.CompareExchange(ref _data, newCounts._data, oldCounts._data));
			}

			public static bool operator ==(ThreadCounts lhs, ThreadCounts rhs)
			{
				return lhs._data == rhs._data;
			}

			public override bool Equals([NotNullWhen(true)] object obj)
			{
				if (obj is ThreadCounts threadCounts)
				{
					return _data == threadCounts._data;
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (int)_data + (int)(_data >> 32);
			}
		}

		private sealed class WaitThreadNode
		{
			public WaitThread Thread { get; }

			public WaitThreadNode Next { get; set; }

			public WaitThreadNode(WaitThread thread)
			{
				Thread = thread;
			}
		}

		internal sealed class WaitThread
		{
			private readonly RegisteredWaitHandle[] _registeredWaits = new RegisteredWaitHandle[63];

			private readonly SafeWaitHandle[] _waitHandles = new SafeWaitHandle[64];

			private int _numUserWaits;

			private readonly RegisteredWaitHandle[] _pendingRemoves = new RegisteredWaitHandle[63];

			private int _numPendingRemoves;

			private readonly AutoResetEvent _changeHandlesEvent = new AutoResetEvent(initialState: false);

			internal bool AnyUserWaits => _numUserWaits != 0;

			public WaitThread()
			{
				_waitHandles[0] = _changeHandlesEvent.SafeWaitHandle;
				Thread thread = new Thread(WaitThreadStart, 262144)
				{
					IsThreadPoolThread = true,
					IsBackground = true,
					Name = ".NET ThreadPool Wait"
				};
				thread.UnsafeStart();
			}

			private void WaitThreadStart()
			{
				while (true)
				{
					int num = ProcessRemovals();
					int tickCount = Environment.TickCount;
					int num2 = -1;
					if (num == 0)
					{
						num2 = 20000;
					}
					else
					{
						for (int i = 0; i < num; i++)
						{
							RegisteredWaitHandle registeredWaitHandle = _registeredWaits[i];
							if (!registeredWaitHandle.IsInfiniteTimeout)
							{
								int num3 = Math.Max(0, registeredWaitHandle.TimeoutTimeMs - tickCount);
								num2 = ((num2 != -1) ? Math.Min(num3, num2) : num3);
								if (num2 == 0)
								{
									break;
								}
							}
						}
					}
					int num4 = WaitHandle.WaitAny(new ReadOnlySpan<SafeWaitHandle>(_waitHandles, 0, num + 1), num2);
					if (num4 >= 128 && num4 < 129 + num)
					{
						num4 += -128;
					}
					switch (num4)
					{
					case 0:
						break;
					default:
					{
						RegisteredWaitHandle registeredHandle = _registeredWaits[num4 - 1];
						QueueWaitCompletion(registeredHandle, timedOut: false);
						break;
					}
					case 258:
					{
						if (num == 0 && ThreadPoolInstance.TryRemoveWaitThread(this))
						{
							return;
						}
						tickCount = Environment.TickCount;
						for (int j = 0; j < num; j++)
						{
							RegisteredWaitHandle registeredWaitHandle2 = _registeredWaits[j];
							if (!registeredWaitHandle2.IsInfiniteTimeout && tickCount - registeredWaitHandle2.TimeoutTimeMs >= 0)
							{
								QueueWaitCompletion(registeredWaitHandle2, timedOut: true);
							}
						}
						break;
					}
					}
				}
			}

			private int ProcessRemovals()
			{
				PortableThreadPool threadPoolInstance = ThreadPoolInstance;
				threadPoolInstance._waitThreadLock.Acquire();
				try
				{
					if (_numPendingRemoves == 0 || _numUserWaits == 0)
					{
						return _numUserWaits;
					}
					int numUserWaits = _numUserWaits;
					int numPendingRemoves = _numPendingRemoves;
					for (int i = 0; i < _numPendingRemoves; i++)
					{
						RegisteredWaitHandle registeredWaitHandle = _pendingRemoves[i];
						int numUserWaits2 = _numUserWaits;
						int j;
						for (j = 0; j < numUserWaits2 && registeredWaitHandle != _registeredWaits[j]; j++)
						{
						}
						registeredWaitHandle.OnRemoveWait();
						if (j + 1 < numUserWaits2)
						{
							int num = j;
							int num2 = numUserWaits2;
							Array.Copy(_registeredWaits, num + 1, _registeredWaits, num, num2 - (num + 1));
							_registeredWaits[num2 - 1] = null;
							num++;
							num2++;
							Array.Copy(_waitHandles, num + 1, _waitHandles, num, num2 - (num + 1));
							_waitHandles[num2 - 1] = null;
						}
						else
						{
							_registeredWaits[j] = null;
							_waitHandles[j + 1] = null;
						}
						_numUserWaits = numUserWaits2 - 1;
						_pendingRemoves[i] = null;
						registeredWaitHandle.Handle.DangerousRelease();
					}
					_numPendingRemoves = 0;
					return _numUserWaits;
				}
				finally
				{
					threadPoolInstance._waitThreadLock.Release();
				}
			}

			private void QueueWaitCompletion(RegisteredWaitHandle registeredHandle, bool timedOut)
			{
				registeredHandle.RequestCallback();
				if (registeredHandle.Repeating)
				{
					registeredHandle.RestartTimeout();
				}
				else
				{
					UnregisterWait(registeredHandle, blocking: false);
				}
				ThreadPool.UnsafeQueueWaitCompletion(new CompleteWaitThreadPoolWorkItem(registeredHandle, timedOut));
			}

			public bool RegisterWaitHandle(RegisteredWaitHandle handle)
			{
				if (_numUserWaits == 63)
				{
					return false;
				}
				bool success = false;
				handle.Handle.DangerousAddRef(ref success);
				_registeredWaits[_numUserWaits] = handle;
				_waitHandles[_numUserWaits + 1] = handle.Handle;
				_numUserWaits++;
				handle.WaitThread = this;
				_changeHandlesEvent.Set();
				return true;
			}

			public void UnregisterWait(RegisteredWaitHandle handle)
			{
				UnregisterWait(handle, blocking: true);
			}

			private void UnregisterWait(RegisteredWaitHandle handle, bool blocking)
			{
				bool flag = false;
				PortableThreadPool threadPoolInstance = ThreadPoolInstance;
				threadPoolInstance._waitThreadLock.Acquire();
				try
				{
					if (Array.IndexOf(_registeredWaits, handle) != -1)
					{
						if (Array.IndexOf(_pendingRemoves, handle) == -1)
						{
							_pendingRemoves[_numPendingRemoves++] = handle;
							_changeHandlesEvent.Set();
						}
						flag = true;
					}
				}
				finally
				{
					threadPoolInstance._waitThreadLock.Release();
				}
				if (blocking)
				{
					if (handle.IsBlocking)
					{
						handle.WaitForCallbacks();
					}
					else if (flag)
					{
						handle.WaitForRemoval();
					}
				}
			}
		}

		private static class WorkerThread
		{
			private static readonly LowLevelLifoSemaphore s_semaphore = new LowLevelLifoSemaphore(0, 32767, AppContextConfigHelper.GetInt32Config("System.Threading.ThreadPool.UnfairSemaphoreSpinLimit", 70, allowNegative: false), delegate
			{
				if (NativeRuntimeEventSource.Log.IsEnabled())
				{
					NativeRuntimeEventSource.Log.ThreadPoolWorkerThreadWait((uint)ThreadPoolInstance._separated.counts.VolatileRead().NumExistingThreads, 0u, 0);
				}
			});

			private static readonly ThreadStart s_workerThreadStart = WorkerThreadStart;

			private static void WorkerThreadStart()
			{
				Thread.CurrentThread.SetThreadPoolWorkerThreadName();
				PortableThreadPool threadPoolInstance = ThreadPoolInstance;
				if (NativeRuntimeEventSource.Log.IsEnabled())
				{
					NativeRuntimeEventSource.Log.ThreadPoolWorkerThreadStart((uint)threadPoolInstance._separated.counts.VolatileRead().NumExistingThreads, 0u, 0);
				}
				LowLevelLock threadAdjustmentLock = threadPoolInstance._threadAdjustmentLock;
				LowLevelLifoSemaphore lowLevelLifoSemaphore = s_semaphore;
				while (true)
				{
					bool spinWait = true;
					while (lowLevelLifoSemaphore.Wait(20000, spinWait))
					{
						bool flag = false;
						while (TakeActiveRequest(threadPoolInstance))
						{
							threadPoolInstance._separated.lastDequeueTime = Environment.TickCount;
							if (!ThreadPoolWorkQueue.Dispatch())
							{
								flag = true;
								break;
							}
							if (threadPoolInstance._separated.numRequestedWorkers <= 0)
							{
								break;
							}
							Thread.UninterruptibleSleep0();
							if (!Environment.IsSingleProcessor)
							{
								Thread.SpinWait(1);
							}
						}
						spinWait = !flag;
						if (!flag)
						{
							RemoveWorkingWorker(threadPoolInstance);
						}
					}
					threadAdjustmentLock.Acquire();
					try
					{
						ThreadCounts threadCounts = threadPoolInstance._separated.counts;
						while (threadCounts.NumExistingThreads > threadCounts.NumProcessingWork)
						{
							ThreadCounts newCounts = threadCounts;
							short num = --newCounts.NumExistingThreads;
							short newThreadCount = (newCounts.NumThreadsGoal = Math.Max(threadPoolInstance.MinThreadsGoal, Math.Min(num, threadCounts.NumThreadsGoal)));
							ThreadCounts threadCounts2 = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, threadCounts);
							if (threadCounts2 == threadCounts)
							{
								HillClimbing.ThreadPoolHillClimber.ForceChange(newThreadCount, HillClimbing.StateOrTransition.ThreadTimedOut);
								if (NativeRuntimeEventSource.Log.IsEnabled())
								{
									NativeRuntimeEventSource.Log.ThreadPoolWorkerThreadStop((uint)num, 0u, 0);
								}
								return;
							}
							threadCounts = threadCounts2;
						}
					}
					finally
					{
						threadAdjustmentLock.Release();
					}
				}
			}

			private static void RemoveWorkingWorker(PortableThreadPool threadPoolInstance)
			{
				ThreadCounts threadCounts = threadPoolInstance._separated.counts;
				while (true)
				{
					ThreadCounts newCounts = threadCounts;
					newCounts.NumProcessingWork--;
					ThreadCounts threadCounts2 = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, threadCounts);
					if (threadCounts2 == threadCounts)
					{
						break;
					}
					threadCounts = threadCounts2;
				}
				if (threadPoolInstance._separated.numRequestedWorkers > 0)
				{
					MaybeAddWorkingWorker(threadPoolInstance);
				}
			}

			internal static void MaybeAddWorkingWorker(PortableThreadPool threadPoolInstance)
			{
				ThreadCounts threadCounts = threadPoolInstance._separated.counts;
				short numProcessingWork;
				short num;
				short numExistingThreads;
				short num2;
				while (true)
				{
					numProcessingWork = threadCounts.NumProcessingWork;
					if (numProcessingWork >= threadCounts.NumThreadsGoal)
					{
						return;
					}
					num = (short)(numProcessingWork + 1);
					numExistingThreads = threadCounts.NumExistingThreads;
					num2 = Math.Max(numExistingThreads, num);
					ThreadCounts newCounts = threadCounts;
					newCounts.NumProcessingWork = num;
					newCounts.NumExistingThreads = num2;
					ThreadCounts threadCounts2 = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, threadCounts);
					if (threadCounts2 == threadCounts)
					{
						break;
					}
					threadCounts = threadCounts2;
				}
				int num3 = num2 - numExistingThreads;
				int num4 = num - numProcessingWork;
				if (num4 > 0)
				{
					s_semaphore.Release(num4);
				}
				while (num3 > 0)
				{
					if (TryCreateWorkerThread())
					{
						num3--;
						continue;
					}
					threadCounts = threadPoolInstance._separated.counts;
					while (true)
					{
						ThreadCounts newCounts2 = threadCounts;
						newCounts2.NumProcessingWork -= (short)num3;
						newCounts2.NumExistingThreads -= (short)num3;
						ThreadCounts threadCounts3 = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts2, threadCounts);
						if (!(threadCounts3 == threadCounts))
						{
							threadCounts = threadCounts3;
							continue;
						}
						break;
					}
					break;
				}
			}

			internal static bool ShouldStopProcessingWorkNow(PortableThreadPool threadPoolInstance)
			{
				ThreadCounts threadCounts = threadPoolInstance._separated.counts;
				while (true)
				{
					if (threadCounts.NumProcessingWork <= threadCounts.NumThreadsGoal)
					{
						return false;
					}
					ThreadCounts newCounts = threadCounts;
					newCounts.NumProcessingWork--;
					ThreadCounts threadCounts2 = threadPoolInstance._separated.counts.InterlockedCompareExchange(newCounts, threadCounts);
					if (threadCounts2 == threadCounts)
					{
						break;
					}
					threadCounts = threadCounts2;
				}
				return true;
			}

			private static bool TakeActiveRequest(PortableThreadPool threadPoolInstance)
			{
				int num = threadPoolInstance._separated.numRequestedWorkers;
				while (num > 0)
				{
					int num2 = Interlocked.CompareExchange(ref threadPoolInstance._separated.numRequestedWorkers, num - 1, num);
					if (num2 == num)
					{
						return true;
					}
					num = num2;
				}
				return false;
			}

			private static bool TryCreateWorkerThread()
			{
				try
				{
					Thread thread = new Thread(s_workerThreadStart);
					thread.IsThreadPoolThread = true;
					thread.IsBackground = true;
					thread.UnsafeStart();
				}
				catch (ThreadStartException)
				{
					return false;
				}
				catch (OutOfMemoryException)
				{
					return false;
				}
				return true;
			}
		}

		private struct CountsOfThreadsProcessingUserCallbacks
		{
			private uint _data;

			public short Current => GetInt16Value(0);

			public short HighWatermark => GetInt16Value(16);

			private CountsOfThreadsProcessingUserCallbacks(uint data)
			{
				_data = data;
			}

			private short GetInt16Value(byte shift)
			{
				return (short)(_data >> (int)shift);
			}

			private void SetInt16Value(short value, byte shift)
			{
				_data = (_data & (uint)(~(65535 << (int)shift))) | (uint)((ushort)value << (int)shift);
			}

			public void IncrementCurrent()
			{
				if (Current < HighWatermark)
				{
					_data++;
				}
				else
				{
					_data += 65537u;
				}
			}

			public void DecrementCurrent()
			{
				_data--;
			}

			public void ResetHighWatermark()
			{
				SetInt16Value(Current, 16);
			}

			public CountsOfThreadsProcessingUserCallbacks InterlockedCompareExchange(CountsOfThreadsProcessingUserCallbacks newCounts, CountsOfThreadsProcessingUserCallbacks oldCounts)
			{
				return new CountsOfThreadsProcessingUserCallbacks(Interlocked.CompareExchange(ref _data, newCounts._data, oldCounts._data));
			}

			public static bool operator ==(CountsOfThreadsProcessingUserCallbacks lhs, CountsOfThreadsProcessingUserCallbacks rhs)
			{
				return lhs._data == rhs._data;
			}

			public override bool Equals([NotNullWhen(true)] object obj)
			{
				if (obj is CountsOfThreadsProcessingUserCallbacks countsOfThreadsProcessingUserCallbacks)
				{
					return _data == countsOfThreadsProcessingUserCallbacks._data;
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (int)_data;
			}
		}

		private struct CpuUtilizationReader
		{
			public long _idleTime;

			public long _kernelTime;

			public long _userTime;

			public int CurrentUtilization
			{
				get
				{
					if (!Interop.Kernel32.GetSystemTimes(out var idle, out var kernel, out var user))
					{
						return 0;
					}
					long num = user - _userTime + (kernel - _kernelTime);
					long num2 = num - (idle - _idleTime);
					_kernelTime = kernel;
					_userTime = user;
					_idleTime = idle;
					if (num > 0 && num2 > 0)
					{
						long val = num2 * 100 / num;
						val = Math.Min(val, 100L);
						return (int)val;
					}
					return 0;
				}
			}
		}

		private static readonly short ForcedMinWorkerThreads = AppContextConfigHelper.GetInt16Config("System.Threading.ThreadPool.MinThreads", 0, allowNegative: false);

		private static readonly short ForcedMaxWorkerThreads = AppContextConfigHelper.GetInt16Config("System.Threading.ThreadPool.MaxThreads", 0, allowNegative: false);

		[ThreadStatic]
		private static object t_completionCountObject;

		public static readonly PortableThreadPool ThreadPoolInstance = new PortableThreadPool();

		private int _cpuUtilization;

		private short _minThreads;

		private short _maxThreads;

		private long _currentSampleStartTime;

		private readonly ThreadInt64PersistentCounter _completionCounter = new ThreadInt64PersistentCounter();

		private int _threadAdjustmentIntervalMs;

		private short _numBlockedThreads;

		private short _numThreadsAddedDueToBlocking;

		private PendingBlockingAdjustment _pendingBlockingAdjustment;

		private long _memoryUsageBytes;

		private long _memoryLimitBytes;

		private readonly LowLevelLock _threadAdjustmentLock = new LowLevelLock();

		private CacheLineSeparated _separated;

		private WaitThreadNode _waitThreadsHead;

		private readonly LowLevelLock _waitThreadLock = new LowLevelLock();

		private CountsOfThreadsProcessingUserCallbacks _countsOfThreadsProcessingUserCallbacks;

		public int ThreadCount => _separated.counts.VolatileRead().NumExistingThreads;

		public long CompletedWorkItemCount => _completionCounter.Count;

		public short MinThreadsGoal => Math.Min(_separated.counts.NumThreadsGoal, TargetThreadsGoalForBlockingAdjustment);

		private short TargetThreadsGoalForBlockingAdjustment
		{
			get
			{
				if (_numBlockedThreads > 0)
				{
					return (short)Math.Min((ushort)(_minThreads + _numBlockedThreads), (ushort)_maxThreads);
				}
				return _minThreads;
			}
		}

		private PortableThreadPool()
		{
			_minThreads = ((ForcedMinWorkerThreads > 0) ? ForcedMinWorkerThreads : ((short)Environment.ProcessorCount));
			if (_minThreads > short.MaxValue)
			{
				_minThreads = short.MaxValue;
			}
			_maxThreads = (short)((ForcedMaxWorkerThreads > 0) ? ForcedMaxWorkerThreads : 1023);
			if (_maxThreads > short.MaxValue)
			{
				_maxThreads = short.MaxValue;
			}
			else if (_maxThreads < _minThreads)
			{
				_maxThreads = _minThreads;
			}
			_separated.counts.NumThreadsGoal = _minThreads;
		}

		public bool SetMinThreads(int workerThreads, int ioCompletionThreads)
		{
			if (workerThreads < 0 || ioCompletionThreads < 0)
			{
				return false;
			}
			bool flag = false;
			bool flag2 = false;
			_threadAdjustmentLock.Acquire();
			try
			{
				if (workerThreads > _maxThreads || !ThreadPool.CanSetMinIOCompletionThreads(ioCompletionThreads))
				{
					return false;
				}
				ThreadPool.SetMinIOCompletionThreads(ioCompletionThreads);
				if (ForcedMinWorkerThreads != 0)
				{
					return true;
				}
				short num = (_minThreads = (short)Math.Max(1, Math.Min(workerThreads, 32767)));
				if (_numBlockedThreads > 0)
				{
					if (_pendingBlockingAdjustment != PendingBlockingAdjustment.Immediately)
					{
						_pendingBlockingAdjustment = PendingBlockingAdjustment.Immediately;
						flag2 = true;
					}
				}
				else if (_separated.counts.NumThreadsGoal < num)
				{
					_separated.counts.InterlockedSetNumThreadsGoal(num);
					if (_separated.numRequestedWorkers > 0)
					{
						flag = true;
					}
				}
			}
			finally
			{
				_threadAdjustmentLock.Release();
			}
			if (flag)
			{
				WorkerThread.MaybeAddWorkingWorker(this);
			}
			else if (flag2)
			{
				GateThread.Wake(this);
			}
			return true;
		}

		public int GetMinThreads()
		{
			return Volatile.Read(ref _minThreads);
		}

		public bool SetMaxThreads(int workerThreads, int ioCompletionThreads)
		{
			if (workerThreads <= 0 || ioCompletionThreads <= 0)
			{
				return false;
			}
			_threadAdjustmentLock.Acquire();
			try
			{
				if (workerThreads < _minThreads || !ThreadPool.CanSetMaxIOCompletionThreads(ioCompletionThreads))
				{
					return false;
				}
				ThreadPool.SetMaxIOCompletionThreads(ioCompletionThreads);
				if (ForcedMaxWorkerThreads != 0)
				{
					return true;
				}
				short num = (_maxThreads = (short)Math.Min(workerThreads, 32767));
				if (_separated.counts.NumThreadsGoal > num)
				{
					_separated.counts.InterlockedSetNumThreadsGoal(num);
				}
				return true;
			}
			finally
			{
				_threadAdjustmentLock.Release();
			}
		}

		public int GetMaxThreads()
		{
			return Volatile.Read(ref _maxThreads);
		}

		public int GetAvailableThreads()
		{
			ThreadCounts threadCounts = _separated.counts.VolatileRead();
			int num = _maxThreads - threadCounts.NumProcessingWork;
			if (num < 0)
			{
				return 0;
			}
			return num;
		}

		public object GetOrCreateThreadLocalCompletionCountObject()
		{
			return t_completionCountObject ?? CreateThreadLocalCompletionCountObject();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private object CreateThreadLocalCompletionCountObject()
		{
			return t_completionCountObject = _completionCounter.CreateThreadLocalCountObject();
		}

		private void NotifyWorkItemProgress(object threadLocalCompletionCountObject, int currentTimeMs)
		{
			ThreadInt64PersistentCounter.Increment(threadLocalCompletionCountObject);
			_separated.lastDequeueTime = currentTimeMs;
			if (ShouldAdjustMaxWorkersActive(currentTimeMs))
			{
				AdjustMaxWorkersActive();
			}
		}

		internal void NotifyWorkItemProgress()
		{
			NotifyWorkItemProgress(GetOrCreateThreadLocalCompletionCountObject(), Environment.TickCount);
		}

		internal bool NotifyWorkItemComplete(object threadLocalCompletionCountObject, int currentTimeMs)
		{
			NotifyWorkItemProgress(threadLocalCompletionCountObject, currentTimeMs);
			return !WorkerThread.ShouldStopProcessingWorkNow(this);
		}

		private void AdjustMaxWorkersActive()
		{
			LowLevelLock threadAdjustmentLock = _threadAdjustmentLock;
			if (!threadAdjustmentLock.TryAcquire())
			{
				return;
			}
			bool flag = false;
			try
			{
				ThreadCounts counts = _separated.counts;
				if (counts.NumProcessingWork > counts.NumThreadsGoal || _pendingBlockingAdjustment != 0)
				{
					return;
				}
				long currentSampleStartTime = _currentSampleStartTime;
				long timestamp = Stopwatch.GetTimestamp();
				long frequency = Stopwatch.Frequency;
				double num = (double)(timestamp - currentSampleStartTime) / (double)frequency;
				if (num * 1000.0 >= (double)(_threadAdjustmentIntervalMs / 2))
				{
					int tickCount = Environment.TickCount;
					int num2 = (int)_completionCounter.Count;
					int numCompletions = num2 - _separated.priorCompletionCount;
					short numThreadsGoal = counts.NumThreadsGoal;
					int num3;
					(num3, _threadAdjustmentIntervalMs) = HillClimbing.ThreadPoolHillClimber.Update(numThreadsGoal, num, numCompletions);
					if (numThreadsGoal != (short)num3)
					{
						_separated.counts.InterlockedSetNumThreadsGoal((short)num3);
						if (num3 > numThreadsGoal)
						{
							flag = true;
						}
					}
					_separated.priorCompletionCount = num2;
					_separated.nextCompletedWorkRequestsTime = tickCount + _threadAdjustmentIntervalMs;
					Volatile.Write(ref _separated.priorCompletedWorkRequestsTime, tickCount);
					_currentSampleStartTime = timestamp;
				}
			}
			finally
			{
				threadAdjustmentLock.Release();
			}
			if (flag)
			{
				WorkerThread.MaybeAddWorkingWorker(this);
			}
		}

		private bool ShouldAdjustMaxWorkersActive(int currentTimeMs)
		{
			if (HillClimbing.IsDisabled)
			{
				return false;
			}
			int num = Volatile.Read(ref _separated.priorCompletedWorkRequestsTime);
			uint num2 = (uint)(_separated.nextCompletedWorkRequestsTime - num);
			uint num3 = (uint)(currentTimeMs - num);
			if (num3 < num2)
			{
				return false;
			}
			ThreadCounts counts = _separated.counts;
			if (counts.NumProcessingWork > counts.NumThreadsGoal)
			{
				return false;
			}
			return _pendingBlockingAdjustment == PendingBlockingAdjustment.None;
		}

		internal void RequestWorker()
		{
			Interlocked.Increment(ref _separated.numRequestedWorkers);
			WorkerThread.MaybeAddWorkingWorker(this);
			GateThread.EnsureRunning(this);
		}

		private bool OnGen2GCCallback()
		{
			GCMemoryInfo gCMemoryInfo = GC.GetGCMemoryInfo();
			_memoryLimitBytes = gCMemoryInfo.HighMemoryLoadThresholdBytes;
			_memoryUsageBytes = Math.Min(gCMemoryInfo.MemoryLoadBytes, gCMemoryInfo.HighMemoryLoadThresholdBytes);
			return true;
		}

		public bool NotifyThreadBlocked()
		{
			if (!BlockingConfig.IsCooperativeBlockingEnabled || !Thread.CurrentThread.IsThreadPoolThread)
			{
				return false;
			}
			bool flag = false;
			_threadAdjustmentLock.Acquire();
			try
			{
				_numBlockedThreads++;
				if (_pendingBlockingAdjustment != PendingBlockingAdjustment.WithDelayIfNecessary && _separated.counts.NumThreadsGoal < TargetThreadsGoalForBlockingAdjustment)
				{
					if (_pendingBlockingAdjustment == PendingBlockingAdjustment.None)
					{
						flag = true;
					}
					_pendingBlockingAdjustment = PendingBlockingAdjustment.WithDelayIfNecessary;
				}
			}
			finally
			{
				_threadAdjustmentLock.Release();
			}
			if (flag)
			{
				GateThread.Wake(this);
			}
			return true;
		}

		public void NotifyThreadUnblocked()
		{
			bool flag = false;
			_threadAdjustmentLock.Acquire();
			try
			{
				_numBlockedThreads--;
				if (_pendingBlockingAdjustment != PendingBlockingAdjustment.Immediately && _numThreadsAddedDueToBlocking > 0 && _separated.counts.NumThreadsGoal > TargetThreadsGoalForBlockingAdjustment)
				{
					flag = true;
					_pendingBlockingAdjustment = PendingBlockingAdjustment.Immediately;
				}
			}
			finally
			{
				_threadAdjustmentLock.Release();
			}
			if (flag)
			{
				GateThread.Wake(this);
			}
		}

		private uint PerformBlockingAdjustment(bool previousDelayElapsed)
		{
			_threadAdjustmentLock.Acquire();
			uint result;
			bool addWorker;
			try
			{
				result = PerformBlockingAdjustment(previousDelayElapsed, out addWorker);
			}
			finally
			{
				_threadAdjustmentLock.Release();
			}
			if (addWorker)
			{
				WorkerThread.MaybeAddWorkingWorker(this);
			}
			return result;
		}

		private uint PerformBlockingAdjustment(bool previousDelayElapsed, out bool addWorker)
		{
			_pendingBlockingAdjustment = PendingBlockingAdjustment.None;
			addWorker = false;
			short targetThreadsGoalForBlockingAdjustment = TargetThreadsGoalForBlockingAdjustment;
			ThreadCounts counts = _separated.counts;
			short num = counts.NumThreadsGoal;
			if (num == targetThreadsGoalForBlockingAdjustment)
			{
				return 0u;
			}
			if (num > targetThreadsGoalForBlockingAdjustment)
			{
				if (_numThreadsAddedDueToBlocking <= 0)
				{
					return 0u;
				}
				short num2 = Math.Min((short)(num - targetThreadsGoalForBlockingAdjustment), _numThreadsAddedDueToBlocking);
				_numThreadsAddedDueToBlocking -= num2;
				num -= num2;
				_separated.counts.InterlockedSetNumThreadsGoal(num);
				HillClimbing.ThreadPoolHillClimber.ForceChange(num, HillClimbing.StateOrTransition.CooperativeBlocking);
				return 0u;
			}
			short num3 = (short)Math.Min((ushort)(_minThreads + BlockingConfig.ThreadsToAddWithoutDelay), (ushort)_maxThreads);
			short val = Math.Max(num3, Math.Min(counts.NumExistingThreads, _maxThreads));
			short num4 = Math.Min(targetThreadsGoalForBlockingAdjustment, val);
			short num5;
			if (num < num4)
			{
				num5 = num4;
			}
			else
			{
				if (!previousDelayElapsed)
				{
					goto IL_019f;
				}
				num5 = (short)(num + 1);
			}
			if (num5 > counts.NumExistingThreads)
			{
				long memoryLimitBytes = _memoryLimitBytes;
				if (memoryLimitBytes > 0)
				{
					long num6 = _memoryUsageBytes + (long)counts.NumExistingThreads * 65536L;
					long num7 = memoryLimitBytes * 8 / 10;
					if (num6 >= num7)
					{
						return 0u;
					}
					long val2 = counts.NumExistingThreads + (num7 - num6) / 65536;
					num5 = (short)Math.Min(num5, val2);
					if (num5 <= num)
					{
						return 0u;
					}
				}
			}
			_numThreadsAddedDueToBlocking += (short)(num5 - num);
			counts = _separated.counts.InterlockedSetNumThreadsGoal(num5);
			HillClimbing.ThreadPoolHillClimber.ForceChange(num5, HillClimbing.StateOrTransition.CooperativeBlocking);
			if (counts.NumProcessingWork >= num && _separated.numRequestedWorkers > 0)
			{
				addWorker = true;
			}
			num = num5;
			if (num >= targetThreadsGoalForBlockingAdjustment)
			{
				return 0u;
			}
			goto IL_019f;
			IL_019f:
			_pendingBlockingAdjustment = PendingBlockingAdjustment.WithDelayIfNecessary;
			int num8 = 1 + (num - num3) / BlockingConfig.ThreadsPerDelayStep;
			return Math.Min((uint)num8 * BlockingConfig.DelayStepMs, BlockingConfig.MaxDelayMs);
		}

		internal static void EnsureGateThreadRunning()
		{
			GateThread.EnsureRunning(ThreadPoolInstance);
		}

		internal void RegisterWaitHandle(RegisteredWaitHandle handle)
		{
			if (NativeRuntimeEventSource.Log.IsEnabled())
			{
				NativeRuntimeEventSource.Log.ThreadPoolIOEnqueue(handle);
			}
			_waitThreadLock.Acquire();
			try
			{
				WaitThreadNode waitThreadNode = _waitThreadsHead;
				if (waitThreadNode == null)
				{
					waitThreadNode = (_waitThreadsHead = new WaitThreadNode(new WaitThread()));
				}
				WaitThreadNode waitThreadNode2;
				do
				{
					if (waitThreadNode.Thread.RegisterWaitHandle(handle))
					{
						return;
					}
					waitThreadNode2 = waitThreadNode;
					waitThreadNode = waitThreadNode.Next;
				}
				while (waitThreadNode != null);
				waitThreadNode2.Next = new WaitThreadNode(new WaitThread());
				waitThreadNode2.Next.Thread.RegisterWaitHandle(handle);
			}
			finally
			{
				_waitThreadLock.Release();
			}
		}

		internal static void CompleteWait(RegisteredWaitHandle handle, bool timedOut)
		{
			if (NativeRuntimeEventSource.Log.IsEnabled())
			{
				NativeRuntimeEventSource.Log.ThreadPoolIODequeue(handle);
			}
			handle.PerformCallback(timedOut);
		}

		private bool TryRemoveWaitThread(WaitThread thread)
		{
			_waitThreadLock.Acquire();
			try
			{
				if (thread.AnyUserWaits)
				{
					return false;
				}
				RemoveWaitThread(thread);
			}
			finally
			{
				_waitThreadLock.Release();
			}
			return true;
		}

		private void RemoveWaitThread(WaitThread thread)
		{
			WaitThreadNode waitThreadNode = _waitThreadsHead;
			if (waitThreadNode.Thread == thread)
			{
				_waitThreadsHead = waitThreadNode.Next;
				return;
			}
			WaitThreadNode waitThreadNode2;
			do
			{
				waitThreadNode2 = waitThreadNode;
				waitThreadNode = waitThreadNode.Next;
			}
			while (waitThreadNode != null && waitThreadNode.Thread != thread);
			if (waitThreadNode != null)
			{
				waitThreadNode2.Next = waitThreadNode.Next;
			}
		}

		public void ReportThreadStatus(bool isProcessingUserCallback)
		{
			CountsOfThreadsProcessingUserCallbacks countsOfThreadsProcessingUserCallbacks = _countsOfThreadsProcessingUserCallbacks;
			while (true)
			{
				CountsOfThreadsProcessingUserCallbacks newCounts = countsOfThreadsProcessingUserCallbacks;
				if (isProcessingUserCallback)
				{
					newCounts.IncrementCurrent();
				}
				else
				{
					newCounts.DecrementCurrent();
				}
				CountsOfThreadsProcessingUserCallbacks countsOfThreadsProcessingUserCallbacks2 = _countsOfThreadsProcessingUserCallbacks.InterlockedCompareExchange(newCounts, countsOfThreadsProcessingUserCallbacks);
				if (!(countsOfThreadsProcessingUserCallbacks2 == countsOfThreadsProcessingUserCallbacks))
				{
					countsOfThreadsProcessingUserCallbacks = countsOfThreadsProcessingUserCallbacks2;
					continue;
				}
				break;
			}
		}

		private short GetAndResetHighWatermarkCountOfThreadsProcessingUserCallbacks()
		{
			CountsOfThreadsProcessingUserCallbacks countsOfThreadsProcessingUserCallbacks = _countsOfThreadsProcessingUserCallbacks;
			CountsOfThreadsProcessingUserCallbacks countsOfThreadsProcessingUserCallbacks2;
			while (true)
			{
				CountsOfThreadsProcessingUserCallbacks newCounts = countsOfThreadsProcessingUserCallbacks;
				newCounts.ResetHighWatermark();
				countsOfThreadsProcessingUserCallbacks2 = _countsOfThreadsProcessingUserCallbacks.InterlockedCompareExchange(newCounts, countsOfThreadsProcessingUserCallbacks);
				if (countsOfThreadsProcessingUserCallbacks2 == countsOfThreadsProcessingUserCallbacks || countsOfThreadsProcessingUserCallbacks2.HighWatermark == countsOfThreadsProcessingUserCallbacks2.Current)
				{
					break;
				}
				countsOfThreadsProcessingUserCallbacks = countsOfThreadsProcessingUserCallbacks2;
			}
			return countsOfThreadsProcessingUserCallbacks2.HighWatermark;
		}
	}
	internal sealed class LowLevelLifoSemaphore : IDisposable
	{
		private struct Counts
		{
			private ulong _data;

			public uint SignalCount
			{
				get
				{
					return GetUInt32Value(0);
				}
				set
				{
					SetUInt32Value(value, 0);
				}
			}

			public ushort WaiterCount => GetUInt16Value(32);

			public byte SpinnerCount => GetByteValue(48);

			public byte CountOfWaitersSignaledToWake => GetByteValue(56);

			private Counts(ulong data)
			{
				_data = data;
			}

			private uint GetUInt32Value(byte shift)
			{
				return (uint)(_data >> (int)shift);
			}

			private void SetUInt32Value(uint value, byte shift)
			{
				_data = (_data & ~(4294967295uL << (int)shift)) | ((ulong)value << (int)shift);
			}

			private ushort GetUInt16Value(byte shift)
			{
				return (ushort)(_data >> (int)shift);
			}

			private byte GetByteValue(byte shift)
			{
				return (byte)(_data >> (int)shift);
			}

			public void AddSignalCount(uint value)
			{
				_data += value;
			}

			public void DecrementSignalCount()
			{
				_data--;
			}

			public void IncrementWaiterCount()
			{
				_data += 4294967296uL;
			}

			public void DecrementWaiterCount()
			{
				_data -= 4294967296uL;
			}

			public void InterlockedDecrementWaiterCount()
			{
				Counts counts = new Counts(Interlocked.Add(ref _data, 18446744069414584320uL));
			}

			public void IncrementSpinnerCount()
			{
				_data += 281474976710656uL;
			}

			public void DecrementSpinnerCount()
			{
				_data -= 281474976710656uL;
			}

			public void AddUpToMaxCountOfWaitersSignaledToWake(uint value)
			{
				uint num = (uint)(255 - CountOfWaitersSignaledToWake);
				if (value > num)
				{
					value = num;
				}
				_data += (ulong)value << 56;
			}

			public void DecrementCountOfWaitersSignaledToWake()
			{
				_data -= 72057594037927936uL;
			}

			public Counts InterlockedCompareExchange(Counts newCounts, Counts oldCounts)
			{
				return new Counts(Interlocked.CompareExchange(ref _data, newCounts._data, oldCounts._data));
			}

			public static bool operator ==(Counts lhs, Counts rhs)
			{
				return lhs._data == rhs._data;
			}

			public override bool Equals([NotNullWhen(true)] object obj)
			{
				if (obj is Counts counts)
				{
					return _data == counts._data;
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (int)_data + (int)(_data >> 32);
			}
		}

		private struct CacheLineSeparatedCounts
		{
			private readonly PaddingFor32 _pad1;

			public Counts _counts;

			private readonly PaddingFor32 _pad2;
		}

		private CacheLineSeparatedCounts _separated;

		private readonly int _maximumSignalCount;

		private readonly int _spinCount;

		private readonly Action _onWait;

		private IntPtr _completionPort;

		public LowLevelLifoSemaphore(int initialSignalCount, int maximumSignalCount, int spinCount, Action onWait)
		{
			_separated = default(CacheLineSeparatedCounts);
			_separated._counts.SignalCount = (uint)initialSignalCount;
			_maximumSignalCount = maximumSignalCount;
			_spinCount = spinCount;
			_onWait = onWait;
			Create(maximumSignalCount);
		}

		public bool Wait(int timeoutMs, bool spinWait)
		{
			int num = (spinWait ? _spinCount : 0);
			Counts counts = _separated._counts;
			Counts newCounts;
			while (true)
			{
				newCounts = counts;
				if (counts.SignalCount != 0)
				{
					newCounts.DecrementSignalCount();
				}
				else if (timeoutMs != 0)
				{
					if (num > 0 && newCounts.SpinnerCount < byte.MaxValue)
					{
						newCounts.IncrementSpinnerCount();
					}
					else
					{
						newCounts.IncrementWaiterCount();
					}
				}
				Counts counts2 = _separated._counts.InterlockedCompareExchange(newCounts, counts);
				if (counts2 == counts)
				{
					break;
				}
				counts = counts2;
			}
			if (counts.SignalCount != 0)
			{
				return true;
			}
			if (newCounts.WaiterCount != counts.WaiterCount)
			{
				return WaitForSignal(timeoutMs);
			}
			if (timeoutMs == 0)
			{
				return false;
			}
			int processorCount = Environment.ProcessorCount;
			int num2 = ((processorCount <= 1) ? 10 : 0);
			while (num2 < num)
			{
				LowLevelSpinWaiter.Wait(num2, 10, processorCount);
				num2++;
				counts = _separated._counts;
				while (counts.SignalCount != 0)
				{
					Counts newCounts2 = counts;
					newCounts2.DecrementSignalCount();
					newCounts2.DecrementSpinnerCount();
					Counts counts3 = _separated._counts.InterlockedCompareExchange(newCounts2, counts);
					if (counts3 == counts)
					{
						return true;
					}
					counts = counts3;
				}
			}
			counts = _separated._counts;
			while (true)
			{
				Counts newCounts3 = counts;
				newCounts3.DecrementSpinnerCount();
				if (counts.SignalCount != 0)
				{
					newCounts3.DecrementSignalCount();
				}
				else
				{
					newCounts3.IncrementWaiterCount();
				}
				Counts counts4 = _separated._counts.InterlockedCompareExchange(newCounts3, counts);
				if (counts4 == counts)
				{
					break;
				}
				counts = counts4;
			}
			if (counts.SignalCount == 0)
			{
				return WaitForSignal(timeoutMs);
			}
			return true;
		}

		public void Release(int releaseCount)
		{
			Counts counts = _separated._counts;
			int num;
			while (true)
			{
				Counts newCounts = counts;
				newCounts.AddSignalCount((uint)releaseCount);
				num = (int)(Math.Min(newCounts.SignalCount, (uint)(counts.WaiterCount + counts.SpinnerCount)) - counts.SpinnerCount - counts.CountOfWaitersSignaledToWake);
				if (num > 0)
				{
					if (num > releaseCount)
					{
						num = releaseCount;
					}
					newCounts.AddUpToMaxCountOfWaitersSignaledToWake((uint)num);
				}
				Counts counts2 = _separated._counts.InterlockedCompareExchange(newCounts, counts);
				if (counts2 == counts)
				{
					break;
				}
				counts = counts2;
			}
			if (num > 0)
			{
				ReleaseCore(num);
			}
		}

		private bool WaitForSignal(int timeoutMs)
		{
			_onWait();
			Counts counts;
			do
			{
				if (!WaitCore(timeoutMs))
				{
					_separated._counts.InterlockedDecrementWaiterCount();
					return false;
				}
				counts = _separated._counts;
				while (true)
				{
					Counts newCounts = counts;
					if (counts.SignalCount != 0)
					{
						newCounts.DecrementSignalCount();
						newCounts.DecrementWaiterCount();
					}
					if (counts.CountOfWaitersSignaledToWake != 0)
					{
						newCounts.DecrementCountOfWaitersSignaledToWake();
					}
					Counts counts2 = _separated._counts.InterlockedCompareExchange(newCounts, counts);
					if (counts2 == counts)
					{
						break;
					}
					counts = counts2;
				}
			}
			while (counts.SignalCount == 0);
			return true;
		}

		private void Create(int maximumSignalCount)
		{
			_completionPort = Interop.Kernel32.CreateIoCompletionPort(new IntPtr(-1), IntPtr.Zero, UIntPtr.Zero, maximumSignalCount);
			if (_completionPort == IntPtr.Zero)
			{
				int lastPInvokeError = Marshal.GetLastPInvokeError();
				OutOfMemoryException ex = new OutOfMemoryException();
				ex.HResult = lastPInvokeError;
				throw ex;
			}
		}

		~LowLevelLifoSemaphore()
		{
			if (_completionPort != IntPtr.Zero)
			{
				Dispose();
			}
		}

		public bool WaitCore(int timeoutMs)
		{
			int lpNumberOfBytes;
			UIntPtr CompletionKey;
			IntPtr lpOverlapped;
			return Interop.Kernel32.GetQueuedCompletionStatus(_completionPort, out lpNumberOfBytes, out CompletionKey, out lpOverlapped, timeoutMs);
		}

		public void ReleaseCore(int count)
		{
			for (int i = 0; i < count; i++)
			{
				if (!Interop.Kernel32.PostQueuedCompletionStatus(_completionPort, 1, UIntPtr.Zero, IntPtr.Zero))
				{
					int lastPInvokeError = Marshal.GetLastPInvokeError();
					OutOfMemoryException ex = new OutOfMemoryException();
					ex.HResult = lastPInvokeError;
					throw ex;
				}
			}
		}

		public void Dispose()
		{
			Interop.Kernel32.CloseHandle(_completionPort);
			_completionPort = IntPtr.Zero;
			GC.SuppressFinalize(this);
		}
	}
}
namespace System.Threading.Tasks
{
	internal enum AsyncCausalityStatus
	{
		Started,
		Completed,
		Canceled,
		Error
	}
	internal enum CausalityRelation
	{
		AssignDelegate,
		Join,
		Choice,
		Cancel,
		Error
	}
	internal enum CausalitySynchronousWork
	{
		CompletionNotification,
		ProgressNotification,
		Execution
	}
	[DebuggerDisplay("Concurrent={ConcurrentTaskCountForDebugger}, Exclusive={ExclusiveTaskCountForDebugger}, Mode={ModeForDebugger}")]
	[DebuggerTypeProxy(typeof(DebugView))]
	public class ConcurrentExclusiveSchedulerPair
	{
		private sealed class CompletionState : Task
		{
			internal bool m_completionRequested;

			internal bool m_completionQueued;

			internal List<Exception> m_exceptions;
		}

		private sealed class SchedulerWorkItem : IThreadPoolWorkItem
		{
			private readonly ConcurrentExclusiveSchedulerPair _pair;

			internal SchedulerWorkItem(ConcurrentExclusiveSchedulerPair pair)
			{
				_pair = pair;
			}

			void IThreadPoolWorkItem.Execute()
			{
				if (_pair.m_processingCount == -1)
				{
					_pair.ProcessExclusiveTasks();
				}
				else
				{
					_pair.ProcessConcurrentTasks();
				}
			}
		}

		[DebuggerDisplay("Count={CountForDebugger}, MaxConcurrencyLevel={m_maxConcurrencyLevel}, Id={Id}")]
		[DebuggerTypeProxy(typeof(DebugView))]
		private sealed class ConcurrentExclusiveTaskScheduler : TaskScheduler
		{
			private sealed class DebugView
			{
				private readonly ConcurrentExclusiveTaskScheduler m_taskScheduler;

				public int MaximumConcurrencyLevel => m_taskScheduler.m_maxConcurrencyLevel;

				public IEnumerable<Task> ScheduledTasks => m_taskScheduler.m_tasks;

				public ConcurrentExclusiveSchedulerPair SchedulerPair => m_taskScheduler.m_pair;

				public DebugView(ConcurrentExclusiveTaskScheduler scheduler)
				{
					m_taskScheduler = scheduler;
				}
			}

			private readonly ConcurrentExclusiveSchedulerPair m_pair;

			private readonly int m_maxConcurrencyLevel;

			private readonly ProcessingMode m_processingMode;

			internal readonly IProducerConsumerQueue<Task> m_tasks;

			public override int MaximumConcurrencyLevel => m_maxConcurrencyLevel;

			private int CountForDebugger => m_tasks.Count;

			internal ConcurrentExclusiveTaskScheduler(ConcurrentExclusiveSchedulerPair pair, int maxConcurrencyLevel, ProcessingMode processingMode)
			{
				m_pair = pair;
				m_maxConcurrencyLevel = maxConcurrencyLevel;
				m_processingMode = processingMode;
				IProducerConsumerQueue<Task> tasks;
				if (processingMode != ProcessingMode.ProcessingExclusiveTask)
				{
					IProducerConsumerQueue<Task> producerConsumerQueue = new MultiProducerMultiConsumerQueue<Task>();
					tasks = producerConsumerQueue;
				}
				else
				{
					IProducerConsumerQueue<Task> producerConsumerQueue = new SingleProducerSingleConsumerQueue<Task>();
					tasks = producerConsumerQueue;
				}
				m_tasks = tasks;
			}

			protected internal override void QueueTask(Task task)
			{
				lock (m_pair.ValueLock)
				{
					if (m_pair.CompletionRequested)
					{
						throw new InvalidOperationException(GetType().ToString());
					}
					m_tasks.Enqueue(task);
					m_pair.ProcessAsyncIfNecessary();
				}
			}

			internal void ExecuteTask(Task task)
			{
				TryExecuteTask(task);
			}

			protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
			{
				if (!taskWasPreviouslyQueued && m_pair.CompletionRequested)
				{
					return false;
				}
				bool flag = m_pair.m_underlyingTaskScheduler == TaskScheduler.Default;
				if (flag && taskWasPreviouslyQueued && !Thread.CurrentThread.IsThreadPoolThread)
				{
					return false;
				}
				if (m_pair.m_threadProcessingMode.Value == m_processingMode)
				{
					if (!flag || taskWasPreviouslyQueued)
					{
						return TryExecuteTaskInlineOnTargetScheduler(task);
					}
					return TryExecuteTask(task);
				}
				return false;
			}

			private bool TryExecuteTaskInlineOnTargetScheduler(Task task)
			{
				Task<bool> task2 = new Task<bool>(delegate(object s)
				{
					TupleSlim<ConcurrentExclusiveTaskScheduler, Task> tupleSlim = (TupleSlim<ConcurrentExclusiveTaskScheduler, Task>)s;
					return tupleSlim.Item1.TryExecuteTask(tupleSlim.Item2);
				}, new TupleSlim<ConcurrentExclusiveTaskScheduler, Task>(this, task));
				try
				{
					task2.RunSynchronously(m_pair.m_underlyingTaskScheduler);
					return task2.Result;
				}
				catch
				{
					_ = task2.Exception;
					throw;
				}
				finally
				{
					task2.Dispose();
				}
			}

			protected override IEnumerable<Task> GetScheduledTasks()
			{
				return m_tasks;
			}
		}

		private sealed class DebugView
		{
			private readonly ConcurrentExclusiveSchedulerPair m_pair;

			public ProcessingMode Mode => m_pair.ModeForDebugger;

			public IEnumerable<Task> ScheduledExclusive => m_pair.m_exclusiveTaskScheduler.m_tasks;

			public IEnumerable<Task> ScheduledConcurrent => m_pair.m_concurrentTaskScheduler.m_tasks;

			public int CurrentlyExecutingTaskCount
			{
				get
				{
					if (m_pair.m_processingCount != -1)
					{
						return m_pair.m_processingCount;
					}
					return 1;
				}
			}

			public TaskScheduler TargetScheduler => m_pair.m_underlyingTaskScheduler;

			public DebugView(ConcurrentExclusiveSchedulerPair pair)
			{
				m_pair = pair;
			}
		}

		[Flags]
		private enum ProcessingMode : byte
		{
			NotCurrentlyProcessing = 0,
			ProcessingExclusiveTask = 1,
			ProcessingConcurrentTasks = 2,
			Completing = 4,
			Completed = 8
		}

		private readonly ThreadLocal<ProcessingMode> m_threadProcessingMode = new ThreadLocal<ProcessingMode>();

		private readonly ConcurrentExclusiveTaskScheduler m_concurrentTaskScheduler;

		private readonly ConcurrentExclusiveTaskScheduler m_exclusiveTaskScheduler;

		private readonly TaskScheduler m_underlyingTaskScheduler;

		private readonly int m_maxConcurrencyLevel;

		private readonly int m_maxItemsPerTask;

		private int m_processingCount;

		private CompletionState m_completionState;

		private SchedulerWorkItem m_threadPoolWorkItem;

		private static int DefaultMaxConcurrencyLevel => Environment.ProcessorCount;

		private object ValueLock => m_threadProcessingMode;

		public Task Completion => EnsureCompletionStateInitialized();

		private bool CompletionRequested
		{
			get
			{
				if (m_completionState != null)
				{
					return Volatile.Read(ref m_completionState.m_completionRequested);
				}
				return false;
			}
		}

		private bool ReadyToComplete
		{
			get
			{
				if (!CompletionRequested || m_processingCount != 0)
				{
					return false;
				}
				CompletionState completionState = EnsureCompletionStateInitialized();
				if (completionState.m_exceptions == null || completionState.m_exceptions.Count <= 0)
				{
					if (m_concurrentTaskScheduler.m_tasks.IsEmpty)
					{
						return m_exclusiveTaskScheduler.m_tasks.IsEmpty;
					}
					return false;
				}
				return true;
			}
		}

		public TaskScheduler ConcurrentScheduler => m_concurrentTaskScheduler;

		public TaskScheduler ExclusiveScheduler => m_exclusiveTaskScheduler;

		private int ConcurrentTaskCountForDebugger => m_concurrentTaskScheduler.m_tasks.Count;

		private int ExclusiveTaskCountForDebugger => m_exclusiveTaskScheduler.m_tasks.Count;

		private ProcessingMode ModeForDebugger
		{
			get
			{
				if (m_completionState != null && m_completionState.IsCompleted)
				{
					return ProcessingMode.Completed;
				}
				ProcessingMode processingMode = ProcessingMode.NotCurrentlyProcessing;
				if (m_processingCount == -1)
				{
					processingMode |= ProcessingMode.ProcessingExclusiveTask;
				}
				if (m_processingCount >= 1)
				{
					processingMode |= ProcessingMode.ProcessingConcurrentTasks;
				}
				if (CompletionRequested)
				{
					processingMode |= ProcessingMode.Completing;
				}
				return processingMode;
			}
		}

		public ConcurrentExclusiveSchedulerPair()
			: this(TaskScheduler.Default, DefaultMaxConcurrencyLevel, -1)
		{
		}

		public ConcurrentExclusiveSchedulerPair(TaskScheduler taskScheduler)
			: this(taskScheduler, DefaultMaxConcurrencyLevel, -1)
		{
		}

		public ConcurrentExclusiveSchedulerPair(TaskScheduler taskScheduler, int maxConcurrencyLevel)
			: this(taskScheduler, maxConcurrencyLevel, -1)
		{
		}

		public ConcurrentExclusiveSchedulerPair(TaskScheduler taskScheduler, int maxConcurrencyLevel, int maxItemsPerTask)
		{
			if (taskScheduler == null)
			{
				throw new ArgumentNullException("taskScheduler");
			}
			if (maxConcurrencyLevel == 0 || maxConcurrencyLevel < -1)
			{
				throw new ArgumentOutOfRangeException("maxConcurrencyLevel");
			}
			if (maxItemsPerTask == 0 || maxItemsPerTask < -1)
			{
				throw new ArgumentOutOfRangeException("maxItemsPerTask");
			}
			m_underlyingTaskScheduler = taskScheduler;
			m_maxConcurrencyLevel = maxConcurrencyLevel;
			m_maxItemsPerTask = maxItemsPerTask;
			int maximumConcurrencyLevel = taskScheduler.MaximumConcurrencyLevel;
			if (maximumConcurrencyLevel > 0 && maximumConcurrencyLevel < m_maxConcurrencyLevel)
			{
				m_maxConcurrencyLevel = maximumConcurrencyLevel;
			}
			if (m_maxConcurrencyLevel == -1)
			{
				m_maxConcurrencyLevel = int.MaxValue;
			}
			if (m_maxItemsPerTask == -1)
			{
				m_maxItemsPerTask = int.MaxValue;
			}
			m_exclusiveTaskScheduler = new ConcurrentExclusiveTaskScheduler(this, 1, ProcessingMode.ProcessingExclusiveTask);
			m_concurrentTaskScheduler = new ConcurrentExclusiveTaskScheduler(this, m_maxConcurrencyLevel, ProcessingMode.ProcessingConcurrentTasks);
		}

		public void Complete()
		{
			lock (ValueLock)
			{
				if (!CompletionRequested)
				{
					RequestCompletion();
					CleanupStateIfCompletingAndQuiesced();
				}
			}
		}

		private CompletionState EnsureCompletionStateInitialized()
		{
			return Volatile.Read(ref m_completionState) ?? InitializeCompletionState();
			CompletionState InitializeCompletionState()
			{
				Interlocked.CompareExchange(ref m_completionState, new CompletionState(), null);
				return m_completionState;
			}
		}

		private void RequestCompletion()
		{
			EnsureCompletionStateInitialized().m_completionRequested = true;
		}

		private void CleanupStateIfCompletingAndQuiesced()
		{
			if (ReadyToComplete)
			{
				CompleteTaskAsync();
			}
		}

		private void CompleteTaskAsync()
		{
			CompletionState completionState = EnsureCompletionStateInitialized();
			if (!completionState.m_completionQueued)
			{
				completionState.m_completionQueued = true;
				ThreadPool.QueueUserWorkItem(delegate(object state)
				{
					ConcurrentExclusiveSchedulerPair concurrentExclusiveSchedulerPair = (ConcurrentExclusiveSchedulerPair)state;
					List<Exception> exceptions = concurrentExclusiveSchedulerPair.m_completionState.m_exceptions;
					bool flag = ((exceptions != null && exceptions.Count > 0) ? concurrentExclusiveSchedulerPair.m_completionState.TrySetException(exceptions) : concurrentExclusiveSchedulerPair.m_completionState.TrySetResult());
					concurrentExclusiveSchedulerPair.m_threadProcessingMode.Dispose();
				}, this);
			}
		}

		private void FaultWithTask(Task faultedTask)
		{
			AggregateException exception = faultedTask.Exception;
			CompletionState completionState = EnsureCompletionStateInitialized();
			CompletionState completionState2 = completionState;
			if (completionState2.m_exceptions == null)
			{
				completionState2.m_exceptions = new List<Exception>(exception.InnerExceptionCount);
			}
			completionState.m_exceptions.AddRange(exception.InternalInnerExceptions);
			RequestCompletion();
		}

		private void ProcessAsyncIfNecessary(bool fairly = false)
		{
			if (m_processingCount < 0)
			{
				return;
			}
			bool flag = !m_exclusiveTaskScheduler.m_tasks.IsEmpty;
			Task task = null;
			if (m_processingCount == 0 && flag)
			{
				m_processingCount = -1;
				if (!TryQueueThreadPoolWorkItem(fairly))
				{
					try
					{
						task = new Task(delegate(object thisPair)
						{
							((ConcurrentExclusiveSchedulerPair)thisPair).ProcessExclusiveTasks();
						}, this, default(CancellationToken), GetCreationOptionsForTask(fairly));
						task.Start(m_underlyingTaskScheduler);
					}
					catch (Exception exception)
					{
						m_processingCount = 0;
						FaultWithTask(task ?? Task.FromException(exception));
					}
				}
			}
			else
			{
				int count = m_concurrentTaskScheduler.m_tasks.Count;
				if (count > 0 && !flag && m_processingCount < m_maxConcurrencyLevel)
				{
					for (int i = 0; i < count; i++)
					{
						if (m_processingCount >= m_maxConcurrencyLevel)
						{
							break;
						}
						m_processingCount++;
						if (TryQueueThreadPoolWorkItem(fairly))
						{
							continue;
						}
						try
						{
							task = new Task(delegate(object thisPair)
							{
								((ConcurrentExclusiveSchedulerPair)thisPair).ProcessConcurrentTasks();
							}, this, default(CancellationToken), GetCreationOptionsForTask(fairly));
							task.Start(m_underlyingTaskScheduler);
						}
						catch (Exception exception2)
						{
							m_processingCount--;
							FaultWithTask(task ?? Task.FromException(exception2));
						}
					}
				}
			}
			CleanupStateIfCompletingAndQuiesced();
		}

		private bool TryQueueThreadPoolWorkItem(bool fairly)
		{
			if (TaskScheduler.Default == m_underlyingTaskScheduler)
			{
				IThreadPoolWorkItem callBack = m_threadPoolWorkItem ?? (m_threadPoolWorkItem = new SchedulerWorkItem(this));
				ThreadPool.UnsafeQueueUserWorkItemInternal(callBack, !fairly);
				return true;
			}
			return false;
		}

		private void ProcessExclusiveTasks()
		{
			try
			{
				m_threadProcessingMode.Value = ProcessingMode.ProcessingExclusiveTask;
				for (int i = 0; i < m_maxItemsPerTask; i++)
				{
					if (!m_exclusiveTaskScheduler.m_tasks.TryDequeue(out var result))
					{
						break;
					}
					if (!result.IsFaulted)
					{
						m_exclusiveTaskScheduler.ExecuteTask(result);
					}
				}
			}
			finally
			{
				m_threadProcessingMode.Value = ProcessingMode.NotCurrentlyProcessing;
				lock (ValueLock)
				{
					m_processingCount = 0;
					ProcessAsyncIfNecessary(fairly: true);
				}
			}
		}

		private void ProcessConcurrentTasks()
		{
			try
			{
				m_threadProcessingMode.Value = ProcessingMode.ProcessingConcurrentTasks;
				for (int i = 0; i < m_maxItemsPerTask; i++)
				{
					if (!m_concurrentTaskScheduler.m_tasks.TryDequeue(out var result))
					{
						break;
					}
					if (!result.IsFaulted)
					{
						m_concurrentTaskScheduler.ExecuteTask(result);
					}
					if (!m_exclusiveTaskScheduler.m_tasks.IsEmpty)
					{
						break;
					}
				}
			}
			finally
			{
				m_threadProcessingMode.Value = ProcessingMode.NotCurrentlyProcessing;
				lock (ValueLock)
				{
					if (m_processingCount > 0)
					{
						m_processingCount--;
					}
					ProcessAsyncIfNecessary(fairly: true);
				}
			}
		}

		internal static TaskCreationOptions GetCreationOptionsForTask(bool isReplacementReplica = false)
		{
			TaskCreationOptions taskCreationOptions = TaskCreationOptions.DenyChildAttach;
			if (isReplacementReplica)
			{
				taskCreationOptions |= TaskCreationOptions.PreferFairness;
			}
			return taskCreationOptions;
		}
	}
	[DebuggerTypeProxy(typeof(SystemThreadingTasks_FutureDebugView<>))]
	[DebuggerDisplay("Id = {Id}, Status = {Status}, Method = {DebuggerDisplayMethodDescription}, Result = {DebuggerDisplayResultDescription}")]
	public class Task<TResult> : Task
	{
		internal static class TaskWhenAnyCast
		{
			internal static readonly Func<Task<Task>, Task<TResult>> Value = (Task<Task> completed) => (Task<TResult>)completed.Result;
		}

		internal static readonly Task<TResult> s_defaultResultTask = TaskCache.CreateCacheableTask(default(TResult));

		private static TaskFactory<TResult> s_Factory;

		internal TResult m_result;

		private string DebuggerDisplayResultDescription
		{
			get
			{
				if (!base.IsCompletedSuccessfully)
				{
					return SR.TaskT_DebuggerNoResult;
				}
				TResult result = m_result;
				return result?.ToString() ?? "";
			}
		}

		private string DebuggerDisplayMethodDescription => m_action?.Method.ToString() ?? "{null}";

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public TResult Result
		{
			get
			{
				if (!base.IsWaitNotificationEnabledOrNotRanToCompletion)
				{
					return m_result;
				}
				return GetResultCore(waitCompletionNotification: true);
			}
		}

		internal TResult ResultOnSuccess => m_result;

		public new static TaskFactory<TResult> Factory => Volatile.Read(ref s_Factory) ?? Interlocked.CompareExchange(ref s_Factory, new TaskFactory<TResult>(), null) ?? s_Factory;

		internal Task()
		{
		}

		internal Task(object state, TaskCreationOptions options)
			: base(state, options, promiseStyle: true)
		{
		}

		internal Task(TResult result)
			: base(canceled: false, TaskCreationOptions.None, default(CancellationToken))
		{
			m_result = result;
		}

		internal Task(bool canceled, TResult result, TaskCreationOptions creationOptions, CancellationToken ct)
			: base(canceled, creationOptions, ct)
		{
			if (!canceled)
			{
				m_result = result;
			}
		}

		public Task(Func<TResult> function)
			: this(function, (Task)null, default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, (TaskScheduler)null)
		{
		}

		public Task(Func<TResult> function, CancellationToken cancellationToken)
			: this(function, (Task)null, cancellationToken, TaskCreationOptions.None, InternalTaskOptions.None, (TaskScheduler)null)
		{
		}

		public Task(Func<TResult> function, TaskCreationOptions creationOptions)
			: this(function, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, InternalTaskOptions.None, (TaskScheduler)null)
		{
		}

		public Task(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
			: this(function, Task.InternalCurrentIfAttached(creationOptions), cancellationToken, creationOptions, InternalTaskOptions.None, (TaskScheduler)null)
		{
		}

		public Task(Func<object?, TResult> function, object? state)
			: this((Delegate)function, state, (Task)null, default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, (TaskScheduler)null)
		{
		}

		public Task(Func<object?, TResult> function, object? state, CancellationToken cancellationToken)
			: this((Delegate)function, state, (Task)null, cancellationToken, TaskCreationOptions.None, InternalTaskOptions.None, (TaskScheduler)null)
		{
		}

		public Task(Func<object?, TResult> function, object? state, TaskCreationOptions creationOptions)
			: this((Delegate)function, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, InternalTaskOptions.None, (TaskScheduler)null)
		{
		}

		public Task(Func<object?, TResult> function, object? state, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
			: this((Delegate)function, state, Task.InternalCurrentIfAttached(creationOptions), cancellationToken, creationOptions, InternalTaskOptions.None, (TaskScheduler)null)
		{
		}

		internal Task(Func<TResult> valueSelector, Task parent, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
			: base(valueSelector, null, parent, cancellationToken, creationOptions, internalOptions, scheduler)
		{
		}

		internal Task(Delegate valueSelector, object state, Task parent, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
			: base(valueSelector, state, parent, cancellationToken, creationOptions, internalOptions, scheduler)
		{
		}

		internal static Task<TResult> StartNew(Task parent, Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
		{
			if (function == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.function);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task<TResult> task = new Task<TResult>(function, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler);
			task.ScheduleAndStart(needsProtection: false);
			return task;
		}

		internal static Task<TResult> StartNew(Task parent, Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
		{
			if (function == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.function);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task<TResult> task = new Task<TResult>(function, state, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler);
			task.ScheduleAndStart(needsProtection: false);
			return task;
		}

		internal bool TrySetResult(TResult result)
		{
			bool result2 = false;
			if (AtomicStateUpdate(67108864, 90177536))
			{
				m_result = result;
				Interlocked.Exchange(ref m_stateFlags, m_stateFlags | 0x1000000);
				ContingentProperties contingentProperties = m_contingentProperties;
				if (contingentProperties != null)
				{
					NotifyParentIfPotentiallyAttachedTask();
					contingentProperties.SetCompleted();
				}
				FinishContinuations();
				result2 = true;
			}
			return result2;
		}

		internal void DangerousSetResult(TResult result)
		{
			if (m_contingentProperties?.m_parent != null)
			{
				bool flag = TrySetResult(result);
				return;
			}
			m_result = result;
			m_stateFlags |= 16777216;
		}

		internal TResult GetResultCore(bool waitCompletionNotification)
		{
			if (!base.IsCompleted)
			{
				InternalWait(-1, default(CancellationToken));
			}
			if (waitCompletionNotification)
			{
				NotifyDebuggerOfWaitCompletionIfNecessary();
			}
			if (!base.IsCompletedSuccessfully)
			{
				ThrowIfExceptional(includeTaskCanceledExceptions: true);
			}
			return m_result;
		}

		internal override void InnerInvoke()
		{
			if (m_action is Func<TResult> func)
			{
				m_result = func();
			}
			else if (m_action is Func<object, TResult> func2)
			{
				m_result = func2(m_stateObject);
			}
		}

		public new TaskAwaiter<TResult> GetAwaiter()
		{
			return new TaskAwaiter<TResult>(this);
		}

		public new ConfiguredTaskAwaitable<TResult> ConfigureAwait(bool continueOnCapturedContext)
		{
			return new ConfiguredTaskAwaitable<TResult>(this, continueOnCapturedContext);
		}

		public new Task<TResult> WaitAsync(CancellationToken cancellationToken)
		{
			return WaitAsync(uint.MaxValue, cancellationToken);
		}

		public new Task<TResult> WaitAsync(TimeSpan timeout)
		{
			return WaitAsync(Task.ValidateTimeout(timeout, ExceptionArgument.timeout), default(CancellationToken));
		}

		public new Task<TResult> WaitAsync(TimeSpan timeout, CancellationToken cancellationToken)
		{
			return WaitAsync(Task.ValidateTimeout(timeout, ExceptionArgument.timeout), cancellationToken);
		}

		private Task<TResult> WaitAsync(uint millisecondsTimeout, CancellationToken cancellationToken)
		{
			if (base.IsCompleted || (!cancellationToken.CanBeCanceled && millisecondsTimeout == uint.MaxValue))
			{
				return this;
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<TResult>(cancellationToken);
			}
			if (millisecondsTimeout == 0)
			{
				return Task.FromException<TResult>(new TimeoutException());
			}
			return new CancellationPromise<TResult>(this, millisecondsTimeout, cancellationToken);
		}

		public Task ContinueWith(Action<Task<TResult>> continuationAction)
		{
			return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task<TResult>> continuationAction, CancellationToken cancellationToken)
		{
			return ContinueWith(continuationAction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task<TResult>> continuationAction, TaskScheduler scheduler)
		{
			return ContinueWith(continuationAction, scheduler, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task<TResult>> continuationAction, TaskContinuationOptions continuationOptions)
		{
			return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), continuationOptions);
		}

		public Task ContinueWith(Action<Task<TResult>> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			return ContinueWith(continuationAction, scheduler, cancellationToken, continuationOptions);
		}

		internal Task ContinueWith(Action<Task<TResult>> continuationAction, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
		{
			if (continuationAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationAction);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task.CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var internalOptions);
			Task task = new ContinuationTaskFromResultTask<TResult>(this, continuationAction, null, creationOptions, internalOptions);
			ContinueWithCore(task, scheduler, cancellationToken, continuationOptions);
			return task;
		}

		public Task ContinueWith(Action<Task<TResult>, object?> continuationAction, object? state)
		{
			return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task<TResult>, object?> continuationAction, object? state, CancellationToken cancellationToken)
		{
			return ContinueWith(continuationAction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task<TResult>, object?> continuationAction, object? state, TaskScheduler scheduler)
		{
			return ContinueWith(continuationAction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task<TResult>, object?> continuationAction, object? state, TaskContinuationOptions continuationOptions)
		{
			return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions);
		}

		public Task ContinueWith(Action<Task<TResult>, object?> continuationAction, object? state, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			return ContinueWith(continuationAction, state, scheduler, cancellationToken, continuationOptions);
		}

		internal Task ContinueWith(Action<Task<TResult>, object> continuationAction, object state, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
		{
			if (continuationAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationAction);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task.CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var internalOptions);
			Task task = new ContinuationTaskFromResultTask<TResult>(this, continuationAction, state, creationOptions, internalOptions);
			ContinueWithCore(task, scheduler, cancellationToken, continuationOptions);
			return task;
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction)
		{
			return ContinueWith(continuationFunction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, CancellationToken cancellationToken)
		{
			return ContinueWith(continuationFunction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, TaskScheduler scheduler)
		{
			return ContinueWith(continuationFunction, scheduler, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			return ContinueWith(continuationFunction, TaskScheduler.Current, default(CancellationToken), continuationOptions);
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			return ContinueWith(continuationFunction, scheduler, cancellationToken, continuationOptions);
		}

		internal Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, TNewResult> continuationFunction, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task.CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var internalOptions);
			Task<TNewResult> task = new ContinuationResultTaskFromResultTask<TResult, TNewResult>(this, continuationFunction, null, creationOptions, internalOptions);
			ContinueWithCore(task, scheduler, cancellationToken, continuationOptions);
			return task;
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object?, TNewResult> continuationFunction, object? state)
		{
			return ContinueWith(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object?, TNewResult> continuationFunction, object? state, CancellationToken cancellationToken)
		{
			return ContinueWith(continuationFunction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object?, TNewResult> continuationFunction, object? state, TaskScheduler scheduler)
		{
			return ContinueWith(continuationFunction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object?, TNewResult> continuationFunction, object? state, TaskContinuationOptions continuationOptions)
		{
			return ContinueWith(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions);
		}

		public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object?, TNewResult> continuationFunction, object? state, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			return ContinueWith(continuationFunction, state, scheduler, cancellationToken, continuationOptions);
		}

		internal Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object, TNewResult> continuationFunction, object state, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task.CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var internalOptions);
			Task<TNewResult> task = new ContinuationResultTaskFromResultTask<TResult, TNewResult>(this, continuationFunction, state, creationOptions, internalOptions);
			ContinueWithCore(task, scheduler, cancellationToken, continuationOptions);
			return task;
		}
	}
	internal sealed class SystemThreadingTasks_FutureDebugView<TResult>
	{
		private readonly Task<TResult> m_task;

		public TResult Result
		{
			get
			{
				if (m_task.Status != TaskStatus.RanToCompletion)
				{
					return default(TResult);
				}
				return m_task.Result;
			}
		}

		public object AsyncState => m_task.AsyncState;

		public TaskCreationOptions CreationOptions => m_task.CreationOptions;

		public Exception Exception => m_task.Exception;

		public int Id => m_task.Id;

		public bool CancellationPending
		{
			get
			{
				if (m_task.Status == TaskStatus.WaitingToRun)
				{
					return m_task.CancellationToken.IsCancellationRequested;
				}
				return false;
			}
		}

		public TaskStatus Status => m_task.Status;

		public SystemThreadingTasks_FutureDebugView(Task<TResult> task)
		{
			m_task = task;
		}
	}
	public class TaskFactory<TResult>
	{
		private sealed class FromAsyncTrimPromise<TInstance> : Task<TResult> where TInstance : class
		{
			internal static readonly AsyncCallback s_completeFromAsyncResult = CompleteFromAsyncResult;

			private TInstance m_thisRef;

			private Func<TInstance, IAsyncResult, TResult> m_endMethod;

			internal FromAsyncTrimPromise(TInstance thisRef, Func<TInstance, IAsyncResult, TResult> endMethod)
			{
				m_thisRef = thisRef;
				m_endMethod = endMethod;
			}

			internal static void CompleteFromAsyncResult(IAsyncResult asyncResult)
			{
				if (asyncResult == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.asyncResult);
				}
				FromAsyncTrimPromise<TInstance> fromAsyncTrimPromise = asyncResult.AsyncState as FromAsyncTrimPromise<TInstance>;
				if (fromAsyncTrimPromise == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.InvalidOperation_WrongAsyncResultOrEndCalledMultiple, ExceptionArgument.asyncResult);
				}
				TInstance thisRef = fromAsyncTrimPromise.m_thisRef;
				Func<TInstance, IAsyncResult, TResult> endMethod = fromAsyncTrimPromise.m_endMethod;
				fromAsyncTrimPromise.m_thisRef = null;
				fromAsyncTrimPromise.m_endMethod = null;
				if (endMethod == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.InvalidOperation_WrongAsyncResultOrEndCalledMultiple, ExceptionArgument.asyncResult);
				}
				if (!asyncResult.CompletedSynchronously)
				{
					fromAsyncTrimPromise.Complete(thisRef, endMethod, asyncResult, requiresSynchronization: true);
				}
			}

			internal void Complete(TInstance thisRef, Func<TInstance, IAsyncResult, TResult> endMethod, IAsyncResult asyncResult, bool requiresSynchronization)
			{
				try
				{
					TResult result = endMethod(thisRef, asyncResult);
					bool flag;
					if (requiresSynchronization)
					{
						flag = TrySetResult(result);
						return;
					}
					DangerousSetResult(result);
					flag = true;
				}
				catch (OperationCanceledException ex)
				{
					bool flag = TrySetCanceled(ex.CancellationToken, ex);
				}
				catch (Exception exceptionObject)
				{
					bool flag = TrySetException(exceptionObject);
				}
			}
		}

		private readonly CancellationToken m_defaultCancellationToken;

		private readonly TaskScheduler m_defaultScheduler;

		private readonly TaskCreationOptions m_defaultCreationOptions;

		private readonly TaskContinuationOptions m_defaultContinuationOptions;

		private TaskScheduler DefaultScheduler => m_defaultScheduler ?? TaskScheduler.Current;

		public CancellationToken CancellationToken => m_defaultCancellationToken;

		public TaskScheduler? Scheduler => m_defaultScheduler;

		public TaskCreationOptions CreationOptions => m_defaultCreationOptions;

		public TaskContinuationOptions ContinuationOptions => m_defaultContinuationOptions;

		private TaskScheduler GetDefaultScheduler(Task currTask)
		{
			if (m_defaultScheduler != null)
			{
				return m_defaultScheduler;
			}
			if (currTask != null && (currTask.CreationOptions & TaskCreationOptions.HideScheduler) == 0)
			{
				return currTask.ExecutingTaskScheduler;
			}
			return TaskScheduler.Default;
		}

		public TaskFactory()
		{
		}

		public TaskFactory(CancellationToken cancellationToken)
		{
			m_defaultCancellationToken = cancellationToken;
		}

		public TaskFactory(TaskScheduler? scheduler)
		{
			m_defaultScheduler = scheduler;
		}

		public TaskFactory(TaskCreationOptions creationOptions, TaskContinuationOptions continuationOptions)
		{
			TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
			TaskFactory.CheckCreationOptions(creationOptions);
			m_defaultCreationOptions = creationOptions;
			m_defaultContinuationOptions = continuationOptions;
		}

		public TaskFactory(CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskContinuationOptions continuationOptions, TaskScheduler? scheduler)
			: this(creationOptions, continuationOptions)
		{
			m_defaultCancellationToken = cancellationToken;
			m_defaultScheduler = scheduler;
		}

		public Task<TResult> StartNew(Func<TResult> function)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, m_defaultCancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew(Func<TResult> function, CancellationToken cancellationToken)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, cancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew(Func<TResult> function, TaskCreationOptions creationOptions)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, m_defaultCancellationToken, creationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return Task<TResult>.StartNew(Task.InternalCurrentIfAttached(creationOptions), function, cancellationToken, creationOptions, InternalTaskOptions.None, scheduler);
		}

		public Task<TResult> StartNew(Func<object?, TResult> function, object? state)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, state, m_defaultCancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew(Func<object?, TResult> function, object? state, CancellationToken cancellationToken)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, state, cancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew(Func<object?, TResult> function, object? state, TaskCreationOptions creationOptions)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, state, m_defaultCancellationToken, creationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew(Func<object?, TResult> function, object? state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return Task<TResult>.StartNew(Task.InternalCurrentIfAttached(creationOptions), function, state, cancellationToken, creationOptions, InternalTaskOptions.None, scheduler);
		}

		private static void FromAsyncCoreLogic(IAsyncResult iar, Func<IAsyncResult, TResult> endFunction, Action<IAsyncResult> endAction, Task<TResult> promise, bool requiresSynchronization)
		{
			Exception ex = null;
			OperationCanceledException ex2 = null;
			TResult result = default(TResult);
			try
			{
				if (endFunction != null)
				{
					result = endFunction(iar);
				}
				else
				{
					endAction(iar);
				}
			}
			catch (OperationCanceledException ex3)
			{
				ex2 = ex3;
			}
			catch (Exception ex4)
			{
				ex = ex4;
			}
			finally
			{
				if (ex2 != null)
				{
					promise.TrySetCanceled(ex2.CancellationToken, ex2);
				}
				else if (ex != null)
				{
					promise.TrySetException(ex);
				}
				else
				{
					if (TplEventSource.Log.IsEnabled())
					{
						TplEventSource.Log.TraceOperationEnd(promise.Id, AsyncCausalityStatus.Completed);
					}
					if (Task.s_asyncDebuggingEnabled)
					{
						Task.RemoveFromActiveTasks(promise);
					}
					if (requiresSynchronization)
					{
						promise.TrySetResult(result);
					}
					else
					{
						promise.DangerousSetResult(result);
					}
				}
			}
		}

		public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)
		{
			return FromAsyncImpl(asyncResult, endMethod, null, m_defaultCreationOptions, DefaultScheduler);
		}

		public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions)
		{
			return FromAsyncImpl(asyncResult, endMethod, null, creationOptions, DefaultScheduler);
		}

		public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return FromAsyncImpl(asyncResult, endMethod, null, creationOptions, scheduler);
		}

		internal static Task<TResult> FromAsyncImpl(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endFunction, Action<IAsyncResult> endAction, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			if (asyncResult == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.asyncResult);
			}
			if (endFunction == null && endAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.endMethod);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			TaskFactory.CheckFromAsyncOptions(creationOptions, hasBeginMethod: false);
			Task<TResult> promise = new Task<TResult>((object)null, creationOptions);
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(promise.Id, "TaskFactory.FromAsync", 0L);
			}
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(promise);
			}
			Task t = new Task((Action<object>)delegate
			{
				FromAsyncCoreLogic(asyncResult, endFunction, endAction, promise, requiresSynchronization: true);
			}, null, null, default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, null);
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(t.Id, "TaskFactory.FromAsync Callback", 0L);
			}
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(t);
			}
			if (asyncResult.IsCompleted)
			{
				try
				{
					t.InternalRunSynchronously(scheduler, waitForCompletion: false);
				}
				catch (Exception exceptionObject)
				{
					promise.TrySetException(exceptionObject);
				}
			}
			else
			{
				ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, delegate
				{
					try
					{
						t.InternalRunSynchronously(scheduler, waitForCompletion: false);
					}
					catch (Exception exceptionObject2)
					{
						promise.TrySetException(exceptionObject2);
					}
				}, null, -1, executeOnlyOnce: true);
			}
			return promise;
		}

		public Task<TResult> FromAsync(Func<AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, object? state)
		{
			return FromAsyncImpl(beginMethod, endMethod, null, state, m_defaultCreationOptions);
		}

		public Task<TResult> FromAsync(Func<AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, object? state, TaskCreationOptions creationOptions)
		{
			return FromAsyncImpl(beginMethod, endMethod, null, state, creationOptions);
		}

		internal static Task<TResult> FromAsyncImpl(Func<AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endFunction, Action<IAsyncResult> endAction, object state, TaskCreationOptions creationOptions)
		{
			if (beginMethod == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.beginMethod);
			}
			if (endFunction == null && endAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.endMethod);
			}
			TaskFactory.CheckFromAsyncOptions(creationOptions, hasBeginMethod: true);
			Task<TResult> promise = new Task<TResult>(state, creationOptions);
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(promise.Id, "TaskFactory.FromAsync: " + beginMethod.Method.Name, 0L);
			}
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(promise);
			}
			try
			{
				IAsyncResult asyncResult = beginMethod(delegate(IAsyncResult iar)
				{
					if (!iar.CompletedSynchronously)
					{
						FromAsyncCoreLogic(iar, endFunction, endAction, promise, requiresSynchronization: true);
					}
				}, state);
				if (asyncResult.CompletedSynchronously)
				{
					FromAsyncCoreLogic(asyncResult, endFunction, endAction, promise, requiresSynchronization: false);
				}
			}
			catch
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(promise.Id, AsyncCausalityStatus.Error);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.RemoveFromActiveTasks(promise);
				}
				promise.TrySetResult();
				throw;
			}
			return promise;
		}

		public Task<TResult> FromAsync<TArg1>(Func<TArg1, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object? state)
		{
			return FromAsyncImpl(beginMethod, endMethod, null, arg1, state, m_defaultCreationOptions);
		}

		public Task<TResult> FromAsync<TArg1>(Func<TArg1, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object? state, TaskCreationOptions creationOptions)
		{
			return FromAsyncImpl(beginMethod, endMethod, null, arg1, state, creationOptions);
		}

		internal static Task<TResult> FromAsyncImpl<TArg1>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endFunction, Action<IAsyncResult> endAction, TArg1 arg1, object state, TaskCreationOptions creationOptions)
		{
			if (beginMethod == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.beginMethod);
			}
			if (endFunction == null && endAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.endFunction);
			}
			TaskFactory.CheckFromAsyncOptions(creationOptions, hasBeginMethod: true);
			Task<TResult> promise = new Task<TResult>(state, creationOptions);
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(promise.Id, "TaskFactory.FromAsync: " + beginMethod.Method.Name, 0L);
			}
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(promise);
			}
			try
			{
				IAsyncResult asyncResult = beginMethod(arg1, delegate(IAsyncResult iar)
				{
					if (!iar.CompletedSynchronously)
					{
						FromAsyncCoreLogic(iar, endFunction, endAction, promise, requiresSynchronization: true);
					}
				}, state);
				if (asyncResult.CompletedSynchronously)
				{
					FromAsyncCoreLogic(asyncResult, endFunction, endAction, promise, requiresSynchronization: false);
				}
			}
			catch
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(promise.Id, AsyncCausalityStatus.Error);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.RemoveFromActiveTasks(promise);
				}
				promise.TrySetResult();
				throw;
			}
			return promise;
		}

		public Task<TResult> FromAsync<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, object? state)
		{
			return FromAsyncImpl(beginMethod, endMethod, null, arg1, arg2, state, m_defaultCreationOptions);
		}

		public Task<TResult> FromAsync<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, object? state, TaskCreationOptions creationOptions)
		{
			return FromAsyncImpl(beginMethod, endMethod, null, arg1, arg2, state, creationOptions);
		}

		internal static Task<TResult> FromAsyncImpl<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endFunction, Action<IAsyncResult> endAction, TArg1 arg1, TArg2 arg2, object state, TaskCreationOptions creationOptions)
		{
			if (beginMethod == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.beginMethod);
			}
			if (endFunction == null && endAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.endMethod);
			}
			TaskFactory.CheckFromAsyncOptions(creationOptions, hasBeginMethod: true);
			Task<TResult> promise = new Task<TResult>(state, creationOptions);
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(promise.Id, "TaskFactory.FromAsync: " + beginMethod.Method.Name, 0L);
			}
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(promise);
			}
			try
			{
				IAsyncResult asyncResult = beginMethod(arg1, arg2, delegate(IAsyncResult iar)
				{
					if (!iar.CompletedSynchronously)
					{
						FromAsyncCoreLogic(iar, endFunction, endAction, promise, requiresSynchronization: true);
					}
				}, state);
				if (asyncResult.CompletedSynchronously)
				{
					FromAsyncCoreLogic(asyncResult, endFunction, endAction, promise, requiresSynchronization: false);
				}
			}
			catch
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(promise.Id, AsyncCausalityStatus.Error);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.RemoveFromActiveTasks(promise);
				}
				promise.TrySetResult();
				throw;
			}
			return promise;
		}

		public Task<TResult> FromAsync<TArg1, TArg2, TArg3>(Func<TArg1, TArg2, TArg3, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object? state)
		{
			return FromAsyncImpl(beginMethod, endMethod, null, arg1, arg2, arg3, state, m_defaultCreationOptions);
		}

		public Task<TResult> FromAsync<TArg1, TArg2, TArg3>(Func<TArg1, TArg2, TArg3, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object? state, TaskCreationOptions creationOptions)
		{
			return FromAsyncImpl(beginMethod, endMethod, null, arg1, arg2, arg3, state, creationOptions);
		}

		internal static Task<TResult> FromAsyncImpl<TArg1, TArg2, TArg3>(Func<TArg1, TArg2, TArg3, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endFunction, Action<IAsyncResult> endAction, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state, TaskCreationOptions creationOptions)
		{
			if (beginMethod == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.beginMethod);
			}
			if (endFunction == null && endAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.endMethod);
			}
			TaskFactory.CheckFromAsyncOptions(creationOptions, hasBeginMethod: true);
			Task<TResult> promise = new Task<TResult>(state, creationOptions);
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(promise.Id, "TaskFactory.FromAsync: " + beginMethod.Method.Name, 0L);
			}
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(promise);
			}
			try
			{
				IAsyncResult asyncResult = beginMethod(arg1, arg2, arg3, delegate(IAsyncResult iar)
				{
					if (!iar.CompletedSynchronously)
					{
						FromAsyncCoreLogic(iar, endFunction, endAction, promise, requiresSynchronization: true);
					}
				}, state);
				if (asyncResult.CompletedSynchronously)
				{
					FromAsyncCoreLogic(asyncResult, endFunction, endAction, promise, requiresSynchronization: false);
				}
			}
			catch
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(promise.Id, AsyncCausalityStatus.Error);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.RemoveFromActiveTasks(promise);
				}
				promise.TrySetResult();
				throw;
			}
			return promise;
		}

		internal static Task<TResult> FromAsyncTrim<TInstance, TArgs>(TInstance thisRef, TArgs args, Func<TInstance, TArgs, AsyncCallback, object, IAsyncResult> beginMethod, Func<TInstance, IAsyncResult, TResult> endMethod) where TInstance : class
		{
			FromAsyncTrimPromise<TInstance> fromAsyncTrimPromise = new FromAsyncTrimPromise<TInstance>(thisRef, endMethod);
			IAsyncResult asyncResult = beginMethod(thisRef, args, FromAsyncTrimPromise<TInstance>.s_completeFromAsyncResult, fromAsyncTrimPromise);
			if (asyncResult.CompletedSynchronously)
			{
				fromAsyncTrimPromise.Complete(thisRef, endMethod, asyncResult, requiresSynchronization: false);
			}
			return fromAsyncTrimPromise;
		}

		private static Task<TResult> CreateCanceledTask(TaskContinuationOptions continuationOptions, CancellationToken ct)
		{
			Task.CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var _);
			return new Task<TResult>(canceled: true, default(TResult), creationOptions, ct);
		}

		public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
		}

		public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, CancellationToken cancellationToken)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
		}

		internal static Task<TResult> ContinueWhenAllImpl<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, Action<Task<TAntecedentResult>[]> continuationAction, TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler)
		{
			TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task<TAntecedentResult>[] tasksCopy = TaskFactory.CheckMultiContinuationTasksAndCopy(tasks);
			if (cancellationToken.IsCancellationRequested && (continuationOptions & TaskContinuationOptions.LazyCancellation) == 0)
			{
				return CreateCanceledTask(continuationOptions, cancellationToken);
			}
			Task<Task<TAntecedentResult>[]> task = TaskFactory.CommonCWAllLogic(tasksCopy);
			if (continuationFunction != null)
			{
				return task.ContinueWith(GenericDelegateCache<TAntecedentResult, TResult>.CWAllFuncDelegate, continuationFunction, scheduler, cancellationToken, continuationOptions);
			}
			return task.ContinueWith(GenericDelegateCache<TAntecedentResult, TResult>.CWAllActionDelegate, continuationAction, scheduler, cancellationToken, continuationOptions);
		}

		internal static Task<TResult> ContinueWhenAllImpl(Task[] tasks, Func<Task[], TResult> continuationFunction, Action<Task[]> continuationAction, TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler)
		{
			TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task[] tasksCopy = TaskFactory.CheckMultiContinuationTasksAndCopy(tasks);
			if (cancellationToken.IsCancellationRequested && (continuationOptions & TaskContinuationOptions.LazyCancellation) == 0)
			{
				return CreateCanceledTask(continuationOptions, cancellationToken);
			}
			Task<Task[]> task = TaskFactory.CommonCWAllLogic(tasksCopy);
			if (continuationFunction != null)
			{
				return task.ContinueWith(delegate(Task<Task[]> completedTasks, object state)
				{
					completedTasks.NotifyDebuggerOfWaitCompletionIfNecessary();
					return ((Func<Task[], TResult>)state)(completedTasks.Result);
				}, continuationFunction, scheduler, cancellationToken, continuationOptions);
			}
			return task.ContinueWith(delegate(Task<Task[]> completedTasks, object state)
			{
				completedTasks.NotifyDebuggerOfWaitCompletionIfNecessary();
				((Action<Task[]>)state)(completedTasks.Result);
				return default(TResult);
			}, continuationAction, scheduler, cancellationToken, continuationOptions);
		}

		public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
		}

		public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			return ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
		}

		internal static Task<TResult> ContinueWhenAnyImpl(Task[] tasks, Func<Task, TResult> continuationFunction, Action<Task> continuationAction, TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler)
		{
			TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			if (tasks.Length == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_EmptyTaskList, ExceptionArgument.tasks);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task<Task> task = TaskFactory.CommonCWAnyLogic(tasks);
			if (cancellationToken.IsCancellationRequested && (continuationOptions & TaskContinuationOptions.LazyCancellation) == 0)
			{
				return CreateCanceledTask(continuationOptions, cancellationToken);
			}
			if (continuationFunction != null)
			{
				return task.ContinueWith((Task<Task> completedTask, object state) => ((Func<Task, TResult>)state)(completedTask.Result), continuationFunction, scheduler, cancellationToken, continuationOptions);
			}
			return task.ContinueWith(delegate(Task<Task> completedTask, object state)
			{
				((Action<Task>)state)(completedTask.Result);
				return default(TResult);
			}, continuationAction, scheduler, cancellationToken, continuationOptions);
		}

		internal static Task<TResult> ContinueWhenAnyImpl<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, Action<Task<TAntecedentResult>> continuationAction, TaskContinuationOptions continuationOptions, CancellationToken cancellationToken, TaskScheduler scheduler)
		{
			TaskFactory.CheckMultiTaskContinuationOptions(continuationOptions);
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			if (tasks.Length == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_EmptyTaskList, ExceptionArgument.tasks);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task<Task> task = TaskFactory.CommonCWAnyLogic(tasks);
			if (cancellationToken.IsCancellationRequested && (continuationOptions & TaskContinuationOptions.LazyCancellation) == 0)
			{
				return CreateCanceledTask(continuationOptions, cancellationToken);
			}
			if (continuationFunction != null)
			{
				return task.ContinueWith(GenericDelegateCache<TAntecedentResult, TResult>.CWAnyFuncDelegate, continuationFunction, scheduler, cancellationToken, continuationOptions);
			}
			return task.ContinueWith(GenericDelegateCache<TAntecedentResult, TResult>.CWAnyActionDelegate, continuationAction, scheduler, cancellationToken, continuationOptions);
		}
	}
	internal static class GenericDelegateCache<TAntecedentResult, TResult>
	{
		internal static Func<Task<Task>, object, TResult> CWAnyFuncDelegate = delegate(Task<Task> wrappedWinner, object state)
		{
			Func<Task<TAntecedentResult>, TResult> func2 = (Func<Task<TAntecedentResult>, TResult>)state;
			Task<TAntecedentResult> arg = (Task<TAntecedentResult>)wrappedWinner.Result;
			return func2(arg);
		};

		internal static Func<Task<Task>, object, TResult> CWAnyActionDelegate = delegate(Task<Task> wrappedWinner, object state)
		{
			Action<Task<TAntecedentResult>> action2 = (Action<Task<TAntecedentResult>>)state;
			Task<TAntecedentResult> obj = (Task<TAntecedentResult>)wrappedWinner.Result;
			action2(obj);
			return default(TResult);
		};

		internal static Func<Task<Task<TAntecedentResult>[]>, object, TResult> CWAllFuncDelegate = delegate(Task<Task<TAntecedentResult>[]> wrappedAntecedents, object state)
		{
			wrappedAntecedents.NotifyDebuggerOfWaitCompletionIfNecessary();
			Func<Task<TAntecedentResult>[], TResult> func = (Func<Task<TAntecedentResult>[], TResult>)state;
			return func(wrappedAntecedents.Result);
		};

		internal static Func<Task<Task<TAntecedentResult>[]>, object, TResult> CWAllActionDelegate = delegate(Task<Task<TAntecedentResult>[]> wrappedAntecedents, object state)
		{
			wrappedAntecedents.NotifyDebuggerOfWaitCompletionIfNecessary();
			Action<Task<TAntecedentResult>[]> action = (Action<Task<TAntecedentResult>[]>)state;
			action(wrappedAntecedents.Result);
			return default(TResult);
		};
	}
	internal interface IProducerConsumerQueue<T> : IEnumerable<T>, System.Collections.IEnumerable
	{
		bool IsEmpty { get; }

		int Count { get; }

		void Enqueue(T item);

		bool TryDequeue([MaybeNullWhen(false)] out T result);
	}
	[DebuggerDisplay("Count = {Count}")]
	internal sealed class MultiProducerMultiConsumerQueue<T> : ConcurrentQueue<T>, IProducerConsumerQueue<T>, IEnumerable<T>, System.Collections.IEnumerable
	{
		bool IProducerConsumerQueue<T>.IsEmpty => base.IsEmpty;

		int IProducerConsumerQueue<T>.Count => base.Count;

		void IProducerConsumerQueue<T>.Enqueue(T item)
		{
			Enqueue(item);
		}

		bool IProducerConsumerQueue<T>.TryDequeue([MaybeNullWhen(false)] out T result)
		{
			return TryDequeue(out result);
		}
	}
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(SingleProducerSingleConsumerQueue<>.SingleProducerSingleConsumerQueue_DebugView))]
	internal sealed class SingleProducerSingleConsumerQueue<T> : IProducerConsumerQueue<T>, IEnumerable<T>, System.Collections.IEnumerable
	{
		[StructLayout(LayoutKind.Sequential)]
		private sealed class Segment
		{
			internal Segment m_next;

			internal readonly T[] m_array;

			internal SegmentState m_state;

			internal Segment(int size)
			{
				m_array = new T[size];
			}
		}

		private struct SegmentState
		{
			internal PaddingFor32 m_pad0;

			internal volatile int m_first;

			internal int m_lastCopy;

			internal PaddingFor32 m_pad1;

			internal int m_firstCopy;

			internal volatile int m_last;

			internal PaddingFor32 m_pad2;
		}

		private sealed class SingleProducerSingleConsumerQueue_DebugView
		{
			private readonly SingleProducerSingleConsumerQueue<T> m_queue;

			public SingleProducerSingleConsumerQueue_DebugView(SingleProducerSingleConsumerQueue<T> queue)
			{
				m_queue = queue;
			}
		}

		private volatile Segment m_head;

		private volatile Segment m_tail;

		public bool IsEmpty
		{
			get
			{
				Segment head = m_head;
				if (head.m_state.m_first != head.m_state.m_lastCopy)
				{
					return false;
				}
				if (head.m_state.m_first != head.m_state.m_last)
				{
					return false;
				}
				return head.m_next == null;
			}
		}

		public int Count
		{
			get
			{
				int num = 0;
				for (Segment segment = m_head; segment != null; segment = segment.m_next)
				{
					int num2 = segment.m_array.Length;
					int first;
					int last;
					do
					{
						first = segment.m_state.m_first;
						last = segment.m_state.m_last;
					}
					while (first != segment.m_state.m_first);
					num += (last - first) & (num2 - 1);
				}
				return num;
			}
		}

		internal SingleProducerSingleConsumerQueue()
		{
			m_head = (m_tail = new Segment(32));
		}

		public void Enqueue(T item)
		{
			Segment segment = m_tail;
			T[] array = segment.m_array;
			int last = segment.m_state.m_last;
			int num = (last + 1) & (array.Length - 1);
			if (num != segment.m_state.m_firstCopy)
			{
				array[last] = item;
				segment.m_state.m_last = num;
			}
			else
			{
				EnqueueSlow(item, ref segment);
			}
		}

		private void EnqueueSlow(T item, ref Segment segment)
		{
			if (segment.m_state.m_firstCopy != segment.m_state.m_first)
			{
				segment.m_state.m_firstCopy = segment.m_state.m_first;
				Enqueue(item);
				return;
			}
			int num = m_tail.m_array.Length << 1;
			if (num > 16777216)
			{
				num = 16777216;
			}
			Segment segment2 = new Segment(num);
			segment2.m_array[0] = item;
			segment2.m_state.m_last = 1;
			segment2.m_state.m_lastCopy = 1;
			Volatile.Write(ref m_tail.m_next, segment2);
			m_tail = segment2;
		}

		public bool TryDequeue([MaybeNullWhen(false)] out T result)
		{
			Segment segment = m_head;
			T[] array = segment.m_array;
			int first = segment.m_state.m_first;
			if (first != segment.m_state.m_lastCopy)
			{
				result = array[first];
				array[first] = default(T);
				segment.m_state.m_first = (first + 1) & (array.Length - 1);
				return true;
			}
			return TryDequeueSlow(ref segment, ref array, out result);
		}

		private bool TryDequeueSlow(ref Segment segment, ref T[] array, [MaybeNullWhen(false)] out T result)
		{
			if (segment.m_state.m_last != segment.m_state.m_lastCopy)
			{
				segment.m_state.m_lastCopy = segment.m_state.m_last;
				return TryDequeue(out result);
			}
			if (segment.m_next != null && segment.m_state.m_first == segment.m_state.m_last)
			{
				segment = segment.m_next;
				array = segment.m_array;
				m_head = segment;
			}
			int first = segment.m_state.m_first;
			if (first == segment.m_state.m_last)
			{
				result = default(T);
				return false;
			}
			result = array[first];
			array[first] = default(T);
			segment.m_state.m_first = (first + 1) & (segment.m_array.Length - 1);
			segment.m_state.m_lastCopy = segment.m_state.m_last;
			return true;
		}

		public IEnumerator<T> GetEnumerator()
		{
			for (Segment segment = m_head; segment != null; segment = segment.m_next)
			{
				for (int pt = segment.m_state.m_first; pt != segment.m_state.m_last; pt = (pt + 1) & (segment.m_array.Length - 1))
				{
					yield return segment.m_array[pt];
				}
			}
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public enum TaskStatus
	{
		Created,
		WaitingForActivation,
		WaitingToRun,
		Running,
		WaitingForChildrenToComplete,
		RanToCompletion,
		Canceled,
		Faulted
	}
	[DebuggerTypeProxy(typeof(SystemThreadingTasks_TaskDebugView))]
	[DebuggerDisplay("Id = {Id}, Status = {Status}, Method = {DebuggerDisplayMethodDescription}")]
	public class Task : IAsyncResult, IDisposable
	{
		[Flags]
		internal enum TaskStateFlags
		{
			Started = 0x10000,
			DelegateInvoked = 0x20000,
			Disposed = 0x40000,
			ExceptionObservedByParent = 0x80000,
			CancellationAcknowledged = 0x100000,
			Faulted = 0x200000,
			Canceled = 0x400000,
			WaitingOnChildren = 0x800000,
			RanToCompletion = 0x1000000,
			WaitingForActivation = 0x2000000,
			CompletionReserved = 0x4000000,
			WaitCompletionNotification = 0x10000000,
			ExecutionContextIsNull = 0x20000000,
			TaskScheduledWasFired = 0x40000000,
			CompletedMask = 0x1600000,
			OptionsMask = 0xFFFF
		}

		internal sealed class ContingentProperties
		{
			internal ExecutionContext m_capturedContext;

			internal volatile ManualResetEventSlim m_completionEvent;

			internal volatile TaskExceptionHolder m_exceptionsHolder;

			internal CancellationToken m_cancellationToken;

			internal StrongBox<CancellationTokenRegistration> m_cancellationRegistration;

			internal volatile int m_internalCancellationRequested;

			internal volatile int m_completionCountdown = 1;

			internal volatile List<Task> m_exceptionalChildren;

			internal Task m_parent;

			internal void SetCompleted()
			{
				m_completionEvent?.Set();
			}

			internal void UnregisterCancellationCallback()
			{
				if (m_cancellationRegistration != null)
				{
					try
					{
						m_cancellationRegistration.Value.Dispose();
					}
					catch (ObjectDisposedException)
					{
					}
					m_cancellationRegistration = null;
				}
			}
		}

		private protected sealed class CancellationPromise<TResult> : Task<TResult>, ITaskCompletionAction
		{
			private readonly Task _task;

			private readonly CancellationTokenRegistration _registration;

			private readonly TimerQueueTimer _timer;

			bool ITaskCompletionAction.InvokeMayRunArbitraryCode => true;

			internal CancellationPromise(Task source, uint millisecondsDelay, CancellationToken token)
			{
				_task = source;
				source.AddCompletionAction(this);
				if (millisecondsDelay != uint.MaxValue)
				{
					_timer = new TimerQueueTimer(delegate(object state)
					{
						CancellationPromise<TResult> cancellationPromise2 = (CancellationPromise<TResult>)state;
						if (cancellationPromise2.TrySetException(new TimeoutException()))
						{
							cancellationPromise2.Cleanup();
						}
					}, this, millisecondsDelay, uint.MaxValue, flowExecutionContext: false);
				}
				_registration = token.UnsafeRegister(delegate(object state, CancellationToken cancellationToken)
				{
					CancellationPromise<TResult> cancellationPromise = (CancellationPromise<TResult>)state;
					if (cancellationPromise.TrySetCanceled(cancellationToken))
					{
						cancellationPromise.Cleanup();
					}
				}, this);
				if (base.IsCompleted)
				{
					Cleanup();
				}
			}

			void ITaskCompletionAction.Invoke(Task completingTask)
			{
				if (completingTask.Status switch
				{
					TaskStatus.Canceled => TrySetCanceled(completingTask.CancellationToken, completingTask.GetCancellationExceptionDispatchInfo()), 
					TaskStatus.Faulted => TrySetException(completingTask.GetExceptionDispatchInfos()), 
					_ => (completingTask is Task<TResult> task) ? TrySetResult(task.Result) : TrySetResult(), 
				})
				{
					Cleanup();
				}
			}

			private void Cleanup()
			{
				_registration.Dispose();
				_timer?.Close();
				_task.RemoveContinuation(this);
			}
		}

		private sealed class SetOnInvokeMres : ManualResetEventSlim, ITaskCompletionAction
		{
			public bool InvokeMayRunArbitraryCode => false;

			internal SetOnInvokeMres()
				: base(initialState: false, 0)
			{
			}

			public void Invoke(Task completingTask)
			{
				Set();
			}
		}

		private sealed class SetOnCountdownMres : ManualResetEventSlim, ITaskCompletionAction
		{
			private int _count;

			public bool InvokeMayRunArbitraryCode => false;

			internal SetOnCountdownMres(int count)
			{
				_count = count;
			}

			public void Invoke(Task completingTask)
			{
				if (Interlocked.Decrement(ref _count) == 0)
				{
					Set();
				}
			}
		}

		private class DelayPromise : Task
		{
			private static readonly TimerCallback s_timerCallback = TimerCallback;

			private readonly TimerQueueTimer _timer;

			internal DelayPromise(uint millisecondsDelay)
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationBegin(base.Id, "Task.Delay", 0L);
				}
				if (s_asyncDebuggingEnabled)
				{
					AddToActiveTasks(this);
				}
				if (millisecondsDelay != uint.MaxValue)
				{
					_timer = new TimerQueueTimer(s_timerCallback, this, millisecondsDelay, uint.MaxValue, flowExecutionContext: false);
					if (base.IsCompleted)
					{
						_timer.Close();
					}
				}
			}

			private static void TimerCallback(object state)
			{
				((DelayPromise)state).CompleteTimedOut();
			}

			private void CompleteTimedOut()
			{
				if (TrySetResult())
				{
					Cleanup();
					if (s_asyncDebuggingEnabled)
					{
						RemoveFromActiveTasks(this);
					}
					if (TplEventSource.Log.IsEnabled())
					{
						TplEventSource.Log.TraceOperationEnd(base.Id, AsyncCausalityStatus.Completed);
					}
				}
			}

			protected virtual void Cleanup()
			{
				_timer?.Close();
			}
		}

		private sealed class DelayPromiseWithCancellation : DelayPromise
		{
			private readonly CancellationTokenRegistration _registration;

			internal DelayPromiseWithCancellation(uint millisecondsDelay, CancellationToken token)
				: base(millisecondsDelay)
			{
				_registration = token.UnsafeRegister(delegate(object state, CancellationToken cancellationToken)
				{
					DelayPromiseWithCancellation delayPromiseWithCancellation = (DelayPromiseWithCancellation)state;
					if (delayPromiseWithCancellation.TrySetCanceled(cancellationToken))
					{
						delayPromiseWithCancellation.Cleanup();
					}
				}, this);
				if (base.IsCompleted)
				{
					_registration.Dispose();
				}
			}

			protected override void Cleanup()
			{
				_registration.Dispose();
				base.Cleanup();
			}
		}

		private sealed class WhenAllPromise : Task, ITaskCompletionAction
		{
			private readonly Task[] m_tasks;

			private int m_count;

			public bool InvokeMayRunArbitraryCode => true;

			private protected override bool ShouldNotifyDebuggerOfWaitCompletion
			{
				get
				{
					if (base.ShouldNotifyDebuggerOfWaitCompletion)
					{
						return AnyTaskRequiresNotifyDebuggerOfWaitCompletion(m_tasks);
					}
					return false;
				}
			}

			internal WhenAllPromise(Task[] tasks)
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationBegin(base.Id, "Task.WhenAll", 0L);
				}
				if (s_asyncDebuggingEnabled)
				{
					AddToActiveTasks(this);
				}
				m_tasks = tasks;
				m_count = tasks.Length;
				foreach (Task task in tasks)
				{
					if (task.IsCompleted)
					{
						Invoke(task);
					}
					else
					{
						task.AddCompletionAction(this);
					}
				}
			}

			public void Invoke(Task completedTask)
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationRelation(base.Id, CausalityRelation.Join);
				}
				if (Interlocked.Decrement(ref m_count) != 0)
				{
					return;
				}
				List<ExceptionDispatchInfo> list = null;
				Task task = null;
				for (int i = 0; i < m_tasks.Length; i++)
				{
					Task task2 = m_tasks[i];
					if (task2.IsFaulted)
					{
						if (list == null)
						{
							list = new List<ExceptionDispatchInfo>();
						}
						list.AddRange(task2.GetExceptionDispatchInfos());
					}
					else if (task2.IsCanceled && task == null)
					{
						task = task2;
					}
					if (task2.IsWaitNotificationEnabled)
					{
						SetNotificationForWaitCompletion(enabled: true);
					}
					else
					{
						m_tasks[i] = null;
					}
				}
				if (list != null)
				{
					TrySetException(list);
					return;
				}
				if (task != null)
				{
					TrySetCanceled(task.CancellationToken, task.GetCancellationExceptionDispatchInfo());
					return;
				}
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(base.Id, AsyncCausalityStatus.Completed);
				}
				if (s_asyncDebuggingEnabled)
				{
					RemoveFromActiveTasks(this);
				}
				TrySetResult();
			}
		}

		private sealed class WhenAllPromise<T> : Task<T[]>, ITaskCompletionAction
		{
			private readonly Task<T>[] m_tasks;

			private int m_count;

			public bool InvokeMayRunArbitraryCode => true;

			private protected override bool ShouldNotifyDebuggerOfWaitCompletion
			{
				get
				{
					if (base.ShouldNotifyDebuggerOfWaitCompletion)
					{
						Task[] tasks = m_tasks;
						return AnyTaskRequiresNotifyDebuggerOfWaitCompletion(tasks);
					}
					return false;
				}
			}

			internal WhenAllPromise(Task<T>[] tasks)
			{
				m_tasks = tasks;
				m_count = tasks.Length;
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationBegin(base.Id, "Task.WhenAll", 0L);
				}
				if (s_asyncDebuggingEnabled)
				{
					AddToActiveTasks(this);
				}
				foreach (Task<T> task in tasks)
				{
					if (task.IsCompleted)
					{
						Invoke(task);
					}
					else
					{
						task.AddCompletionAction(this);
					}
				}
			}

			public void Invoke(Task ignored)
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationRelation(base.Id, CausalityRelation.Join);
				}
				if (Interlocked.Decrement(ref m_count) != 0)
				{
					return;
				}
				T[] array = new T[m_tasks.Length];
				List<ExceptionDispatchInfo> list = null;
				Task task = null;
				for (int i = 0; i < m_tasks.Length; i++)
				{
					Task<T> task2 = m_tasks[i];
					if (task2.IsFaulted)
					{
						if (list == null)
						{
							list = new List<ExceptionDispatchInfo>();
						}
						list.AddRange(task2.GetExceptionDispatchInfos());
					}
					else if (task2.IsCanceled)
					{
						if (task == null)
						{
							task = task2;
						}
					}
					else
					{
						array[i] = task2.GetResultCore(waitCompletionNotification: false);
					}
					if (task2.IsWaitNotificationEnabled)
					{
						SetNotificationForWaitCompletion(enabled: true);
					}
					else
					{
						m_tasks[i] = null;
					}
				}
				if (list != null)
				{
					TrySetException(list);
					return;
				}
				if (task != null)
				{
					TrySetCanceled(task.CancellationToken, task.GetCancellationExceptionDispatchInfo());
					return;
				}
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(base.Id, AsyncCausalityStatus.Completed);
				}
				if (s_asyncDebuggingEnabled)
				{
					RemoveFromActiveTasks(this);
				}
				TrySetResult(array);
			}
		}

		private sealed class TwoTaskWhenAnyPromise<TTask> : Task<TTask>, ITaskCompletionAction where TTask : Task
		{
			private TTask _task1;

			private TTask _task2;

			public bool InvokeMayRunArbitraryCode => true;

			public TwoTaskWhenAnyPromise(TTask task1, TTask task2)
			{
				_task1 = task1;
				_task2 = task2;
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationBegin(base.Id, "Task.WhenAny", 0L);
				}
				if (s_asyncDebuggingEnabled)
				{
					AddToActiveTasks(this);
				}
				task1.AddCompletionAction(this);
				task2.AddCompletionAction(this);
				if (task1.IsCompleted)
				{
					task2.RemoveContinuation(this);
				}
			}

			public void Invoke(Task completingTask)
			{
				Task task;
				if ((task = Interlocked.Exchange(ref _task1, null)) != null)
				{
					Task task2 = _task2;
					_task2 = null;
					if (TplEventSource.Log.IsEnabled())
					{
						TplEventSource.Log.TraceOperationRelation(base.Id, CausalityRelation.Choice);
						TplEventSource.Log.TraceOperationEnd(base.Id, AsyncCausalityStatus.Completed);
					}
					if (s_asyncDebuggingEnabled)
					{
						RemoveFromActiveTasks(this);
					}
					if (!task.IsCompleted)
					{
						task.RemoveContinuation(this);
					}
					else
					{
						task2.RemoveContinuation(this);
					}
					bool flag = TrySetResult((TTask)completingTask);
				}
			}
		}

		[ThreadStatic]
		internal static Task t_currentTask;

		internal static int s_taskIdCounter;

		private int m_taskId;

		internal Delegate m_action;

		internal object m_stateObject;

		internal TaskScheduler m_taskScheduler;

		internal volatile int m_stateFlags;

		private volatile object m_continuationObject;

		private static readonly object s_taskCompletionSentinel = new object();

		internal static bool s_asyncDebuggingEnabled;

		private static Dictionary<int, Task> s_currentActiveTasks;

		internal ContingentProperties m_contingentProperties;

		internal static readonly Task<VoidTaskResult> s_cachedCompleted = new Task<VoidTaskResult>(canceled: false, default(VoidTaskResult), (TaskCreationOptions)16384, default(CancellationToken));

		private static readonly ContextCallback s_ecCallback = delegate(object obj)
		{
			Unsafe.As<Task>(obj).InnerInvoke();
		};

		private Task? ParentForDebugger => m_contingentProperties?.m_parent;

		private int StateFlagsForDebugger => m_stateFlags;

		private TaskStateFlags StateFlags => (TaskStateFlags)(m_stateFlags & -65536);

		private string DebuggerDisplayMethodDescription => m_action?.Method.ToString() ?? "{null}";

		internal TaskCreationOptions Options => OptionsMethod(m_stateFlags);

		internal bool IsWaitNotificationEnabledOrNotRanToCompletion
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (m_stateFlags & 0x11000000) != 16777216;
			}
		}

		private protected virtual bool ShouldNotifyDebuggerOfWaitCompletion => IsWaitNotificationEnabled;

		internal bool IsWaitNotificationEnabled => (m_stateFlags & 0x10000000) != 0;

		public int Id
		{
			get
			{
				if (Volatile.Read(ref m_taskId) == 0)
				{
					int value = NewId();
					Interlocked.CompareExchange(ref m_taskId, value, 0);
				}
				return m_taskId;
			}
		}

		public static int? CurrentId => InternalCurrent?.Id;

		internal static Task? InternalCurrent => t_currentTask;

		public AggregateException? Exception
		{
			get
			{
				AggregateException result = null;
				if (IsFaulted)
				{
					result = GetExceptions(includeTaskCanceledExceptions: false);
				}
				return result;
			}
		}

		public TaskStatus Status
		{
			get
			{
				int stateFlags = m_stateFlags;
				if (((uint)stateFlags & 0x200000u) != 0)
				{
					return TaskStatus.Faulted;
				}
				if (((uint)stateFlags & 0x400000u) != 0)
				{
					return TaskStatus.Canceled;
				}
				if (((uint)stateFlags & 0x1000000u) != 0)
				{
					return TaskStatus.RanToCompletion;
				}
				if (((uint)stateFlags & 0x800000u) != 0)
				{
					return TaskStatus.WaitingForChildrenToComplete;
				}
				if (((uint)stateFlags & 0x20000u) != 0)
				{
					return TaskStatus.Running;
				}
				if (((uint)stateFlags & 0x10000u) != 0)
				{
					return TaskStatus.WaitingToRun;
				}
				if (((uint)stateFlags & 0x2000000u) != 0)
				{
					return TaskStatus.WaitingForActivation;
				}
				return TaskStatus.Created;
			}
		}

		public bool IsCanceled => (m_stateFlags & 0x600000) == 4194304;

		internal bool IsCancellationRequested
		{
			get
			{
				ContingentProperties contingentProperties = Volatile.Read(ref m_contingentProperties);
				if (contingentProperties != null)
				{
					if (contingentProperties.m_internalCancellationRequested != 1)
					{
						return contingentProperties.m_cancellationToken.IsCancellationRequested;
					}
					return true;
				}
				return false;
			}
		}

		internal CancellationToken CancellationToken => Volatile.Read(ref m_contingentProperties)?.m_cancellationToken ?? default(CancellationToken);

		internal bool IsCancellationAcknowledged => (m_stateFlags & 0x100000) != 0;

		public bool IsCompleted
		{
			get
			{
				int stateFlags = m_stateFlags;
				return IsCompletedMethod(stateFlags);
			}
		}

		public bool IsCompletedSuccessfully => (m_stateFlags & 0x1600000) == 16777216;

		public TaskCreationOptions CreationOptions => Options & (TaskCreationOptions)(-65281);

		WaitHandle IAsyncResult.AsyncWaitHandle
		{
			get
			{
				if (((uint)m_stateFlags & 0x40000u) != 0)
				{
					ThrowHelper.ThrowObjectDisposedException(ExceptionResource.Task_ThrowIfDisposed);
				}
				return CompletedEvent.WaitHandle;
			}
		}

		public object? AsyncState => m_stateObject;

		bool IAsyncResult.CompletedSynchronously => false;

		internal TaskScheduler? ExecutingTaskScheduler => m_taskScheduler;

		public static TaskFactory Factory { get; } = new TaskFactory();


		public static Task CompletedTask => s_cachedCompleted;

		internal ManualResetEventSlim CompletedEvent
		{
			get
			{
				ContingentProperties contingentProperties = EnsureContingentPropertiesInitialized();
				if (contingentProperties.m_completionEvent == null)
				{
					bool isCompleted = IsCompleted;
					ManualResetEventSlim manualResetEventSlim = new ManualResetEventSlim(isCompleted);
					if (Interlocked.CompareExchange(ref contingentProperties.m_completionEvent, manualResetEventSlim, null) != null)
					{
						manualResetEventSlim.Dispose();
					}
					else if (!isCompleted && IsCompleted)
					{
						manualResetEventSlim.Set();
					}
				}
				return contingentProperties.m_completionEvent;
			}
		}

		internal bool ExceptionRecorded
		{
			get
			{
				ContingentProperties contingentProperties = Volatile.Read(ref m_contingentProperties);
				if (contingentProperties != null && contingentProperties.m_exceptionsHolder != null)
				{
					return contingentProperties.m_exceptionsHolder.ContainsFaultList;
				}
				return false;
			}
		}

		public bool IsFaulted => (m_stateFlags & 0x200000) != 0;

		internal ExecutionContext? CapturedContext
		{
			get
			{
				if ((m_stateFlags & 0x20000000) == 536870912)
				{
					return null;
				}
				return m_contingentProperties?.m_capturedContext ?? ExecutionContext.Default;
			}
			set
			{
				if (value == null)
				{
					m_stateFlags |= 536870912;
				}
				else if (value != ExecutionContext.Default)
				{
					EnsureContingentPropertiesInitializedUnsafe().m_capturedContext = value;
				}
			}
		}

		internal bool IsExceptionObservedByParent => (m_stateFlags & 0x80000) != 0;

		internal bool IsDelegateInvoked => (m_stateFlags & 0x20000) != 0;

		internal static bool AddToActiveTasks(Task task)
		{
			Dictionary<int, Task> dictionary = Volatile.Read(ref s_currentActiveTasks) ?? Interlocked.CompareExchange(ref s_currentActiveTasks, new Dictionary<int, Task>(), null) ?? s_currentActiveTasks;
			int id = task.Id;
			lock (dictionary)
			{
				dictionary[id] = task;
			}
			return true;
		}

		internal static void RemoveFromActiveTasks(Task task)
		{
			Dictionary<int, Task> dictionary = s_currentActiveTasks;
			if (dictionary == null)
			{
				return;
			}
			int id = task.Id;
			lock (dictionary)
			{
				dictionary.Remove(id);
			}
		}

		internal Task(bool canceled, TaskCreationOptions creationOptions, CancellationToken ct)
		{
			if (canceled)
			{
				m_stateFlags = (int)((TaskCreationOptions)5242880 | creationOptions);
				m_contingentProperties = new ContingentProperties
				{
					m_cancellationToken = ct,
					m_internalCancellationRequested = 1
				};
			}
			else
			{
				m_stateFlags = (int)((TaskCreationOptions)16777216 | creationOptions);
			}
		}

		internal Task()
		{
			m_stateFlags = 33555456;
		}

		internal Task(object state, TaskCreationOptions creationOptions, bool promiseStyle)
		{
			if (((uint)creationOptions & 0xFFFFFFBBu) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions);
			}
			if ((creationOptions & TaskCreationOptions.AttachedToParent) != 0)
			{
				Task internalCurrent = InternalCurrent;
				if (internalCurrent != null)
				{
					EnsureContingentPropertiesInitializedUnsafe().m_parent = internalCurrent;
				}
			}
			TaskConstructorCore(null, state, default(CancellationToken), creationOptions, InternalTaskOptions.PromiseTask, null);
		}

		public Task(Action action)
			: this(action, null, null, default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, null)
		{
		}

		public Task(Action action, CancellationToken cancellationToken)
			: this(action, null, null, cancellationToken, TaskCreationOptions.None, InternalTaskOptions.None, null)
		{
		}

		public Task(Action action, TaskCreationOptions creationOptions)
			: this(action, null, InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, InternalTaskOptions.None, null)
		{
		}

		public Task(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
			: this(action, null, InternalCurrentIfAttached(creationOptions), cancellationToken, creationOptions, InternalTaskOptions.None, null)
		{
		}

		public Task(Action<object?> action, object? state)
			: this(action, state, null, default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.None, null)
		{
		}

		public Task(Action<object?> action, object? state, CancellationToken cancellationToken)
			: this(action, state, null, cancellationToken, TaskCreationOptions.None, InternalTaskOptions.None, null)
		{
		}

		public Task(Action<object?> action, object? state, TaskCreationOptions creationOptions)
			: this(action, state, InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, InternalTaskOptions.None, null)
		{
		}

		public Task(Action<object?> action, object? state, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
			: this(action, state, InternalCurrentIfAttached(creationOptions), cancellationToken, creationOptions, InternalTaskOptions.None, null)
		{
		}

		internal Task(Delegate action, object state, Task parent, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
		{
			if ((object)action == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action);
			}
			if (parent != null && (creationOptions & TaskCreationOptions.AttachedToParent) != 0)
			{
				EnsureContingentPropertiesInitializedUnsafe().m_parent = parent;
			}
			TaskConstructorCore(action, state, cancellationToken, creationOptions, internalOptions, scheduler);
			CapturedContext = ExecutionContext.Capture();
		}

		internal void TaskConstructorCore(Delegate action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
		{
			m_action = action;
			m_stateObject = state;
			m_taskScheduler = scheduler;
			if (((uint)creationOptions & 0xFFFFFFA0u) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions);
			}
			int num = (int)creationOptions | (int)internalOptions;
			m_stateFlags = (((object)m_action == null || (internalOptions & InternalTaskOptions.ContinuationTask) != 0) ? (num | 0x2000000) : num);
			ContingentProperties contingentProperties = m_contingentProperties;
			if (contingentProperties != null)
			{
				Task parent = contingentProperties.m_parent;
				if (parent != null && (creationOptions & TaskCreationOptions.AttachedToParent) != 0 && (parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0)
				{
					parent.AddNewChild();
				}
			}
			if (cancellationToken.CanBeCanceled)
			{
				AssignCancellationToken(cancellationToken, null, null);
			}
		}

		private void AssignCancellationToken(CancellationToken cancellationToken, Task antecedent, TaskContinuation continuation)
		{
			ContingentProperties contingentProperties = EnsureContingentPropertiesInitializedUnsafe();
			contingentProperties.m_cancellationToken = cancellationToken;
			try
			{
				if ((Options & (TaskCreationOptions)13312) != 0)
				{
					return;
				}
				if (cancellationToken.IsCancellationRequested)
				{
					InternalCancel();
					return;
				}
				CancellationTokenRegistration value = ((antecedent != null) ? cancellationToken.UnsafeRegister(delegate(object t)
				{
					TupleSlim<Task, Task, TaskContinuation> tupleSlim = (TupleSlim<Task, Task, TaskContinuation>)t;
					Task item = tupleSlim.Item1;
					Task item2 = tupleSlim.Item2;
					item2.RemoveContinuation(tupleSlim.Item3);
					item.InternalCancel();
				}, new TupleSlim<Task, Task, TaskContinuation>(this, antecedent, continuation)) : cancellationToken.UnsafeRegister(delegate(object t)
				{
					((Task)t).InternalCancel();
				}, this));
				contingentProperties.m_cancellationRegistration = new StrongBox<CancellationTokenRegistration>(value);
			}
			catch
			{
				Task task = m_contingentProperties?.m_parent;
				if (task != null && (Options & TaskCreationOptions.AttachedToParent) != 0 && (task.Options & TaskCreationOptions.DenyChildAttach) == 0)
				{
					task.DisregardChild();
				}
				throw;
			}
		}

		internal static TaskCreationOptions OptionsMethod(int flags)
		{
			return (TaskCreationOptions)(flags & 0xFFFF);
		}

		internal bool AtomicStateUpdate(int newBits, int illegalBits)
		{
			int stateFlags = m_stateFlags;
			if ((stateFlags & illegalBits) == 0)
			{
				if (Interlocked.CompareExchange(ref m_stateFlags, stateFlags | newBits, stateFlags) != stateFlags)
				{
					return AtomicStateUpdateSlow(newBits, illegalBits);
				}
				return true;
			}
			return false;
		}

		private bool AtomicStateUpdateSlow(int newBits, int illegalBits)
		{
			int num = m_stateFlags;
			while (true)
			{
				if ((num & illegalBits) != 0)
				{
					return false;
				}
				int num2 = Interlocked.CompareExchange(ref m_stateFlags, num | newBits, num);
				if (num2 == num)
				{
					break;
				}
				num = num2;
			}
			return true;
		}

		internal bool AtomicStateUpdate(int newBits, int illegalBits, ref int oldFlags)
		{
			int num = (oldFlags = m_stateFlags);
			while (true)
			{
				if ((num & illegalBits) != 0)
				{
					return false;
				}
				oldFlags = Interlocked.CompareExchange(ref m_stateFlags, num | newBits, num);
				if (oldFlags == num)
				{
					break;
				}
				num = oldFlags;
			}
			return true;
		}

		internal void SetNotificationForWaitCompletion(bool enabled)
		{
			if (enabled)
			{
				bool flag = AtomicStateUpdate(268435456, 90177536);
			}
			else
			{
				Interlocked.And(ref m_stateFlags, -268435457);
			}
		}

		internal bool NotifyDebuggerOfWaitCompletionIfNecessary()
		{
			if (IsWaitNotificationEnabled && ShouldNotifyDebuggerOfWaitCompletion)
			{
				NotifyDebuggerOfWaitCompletion();
				return true;
			}
			return false;
		}

		internal static bool AnyTaskRequiresNotifyDebuggerOfWaitCompletion(Task[] tasks)
		{
			foreach (Task task in tasks)
			{
				if (task != null && task.IsWaitNotificationEnabled && task.ShouldNotifyDebuggerOfWaitCompletion)
				{
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void NotifyDebuggerOfWaitCompletion()
		{
			SetNotificationForWaitCompletion(enabled: false);
		}

		internal bool MarkStarted()
		{
			return AtomicStateUpdate(65536, 4259840);
		}

		internal void FireTaskScheduledIfNeeded(TaskScheduler ts)
		{
			if ((m_stateFlags & 0x40000000) == 0)
			{
				m_stateFlags |= 1073741824;
				if (TplEventSource.Log.IsEnabled())
				{
					Task internalCurrent = InternalCurrent;
					Task task = m_contingentProperties?.m_parent;
					TplEventSource.Log.TaskScheduled(ts.Id, internalCurrent?.Id ?? 0, Id, task?.Id ?? 0, (int)Options);
				}
			}
		}

		internal void AddNewChild()
		{
			ContingentProperties contingentProperties = EnsureContingentPropertiesInitialized();
			if (contingentProperties.m_completionCountdown == 1)
			{
				contingentProperties.m_completionCountdown++;
			}
			else
			{
				Interlocked.Increment(ref contingentProperties.m_completionCountdown);
			}
		}

		internal void DisregardChild()
		{
			ContingentProperties contingentProperties = EnsureContingentPropertiesInitialized();
			Interlocked.Decrement(ref contingentProperties.m_completionCountdown);
		}

		public void Start()
		{
			Start(TaskScheduler.Current);
		}

		public void Start(TaskScheduler scheduler)
		{
			int stateFlags = m_stateFlags;
			if (IsCompletedMethod(stateFlags))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_Start_TaskCompleted);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			TaskCreationOptions taskCreationOptions = OptionsMethod(stateFlags);
			if ((taskCreationOptions & (TaskCreationOptions)1024) != 0)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_Start_Promise);
			}
			if ((taskCreationOptions & (TaskCreationOptions)512) != 0)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_Start_ContinuationTask);
			}
			if (Interlocked.CompareExchange(ref m_taskScheduler, scheduler, null) != null)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_Start_AlreadyStarted);
			}
			ScheduleAndStart(needsProtection: true);
		}

		public void RunSynchronously()
		{
			InternalRunSynchronously(TaskScheduler.Current, waitForCompletion: true);
		}

		public void RunSynchronously(TaskScheduler scheduler)
		{
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			InternalRunSynchronously(scheduler, waitForCompletion: true);
		}

		internal void InternalRunSynchronously(TaskScheduler scheduler, bool waitForCompletion)
		{
			int stateFlags = m_stateFlags;
			TaskCreationOptions taskCreationOptions = OptionsMethod(stateFlags);
			if ((taskCreationOptions & (TaskCreationOptions)512) != 0)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_RunSynchronously_Continuation);
			}
			if ((taskCreationOptions & (TaskCreationOptions)1024) != 0)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_RunSynchronously_Promise);
			}
			if (IsCompletedMethod(stateFlags))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_RunSynchronously_TaskCompleted);
			}
			if (Interlocked.CompareExchange(ref m_taskScheduler, scheduler, null) != null)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_RunSynchronously_AlreadyStarted);
			}
			if (MarkStarted())
			{
				bool flag = false;
				try
				{
					if (!scheduler.TryRunInline(this, taskWasPreviouslyQueued: false))
					{
						scheduler.InternalQueueTask(this);
						flag = true;
					}
					if (waitForCompletion && !IsCompleted)
					{
						SpinThenBlockingWait(-1, default(CancellationToken));
					}
					return;
				}
				catch (Exception innerException)
				{
					if (!flag)
					{
						TaskSchedulerException ex = new TaskSchedulerException(innerException);
						AddException(ex);
						Finish(userDelegateExecute: false);
						m_contingentProperties.m_exceptionsHolder.MarkAsHandled(calledFromFinalizer: false);
						throw ex;
					}
					throw;
				}
			}
			ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_RunSynchronously_TaskCompleted);
		}

		internal static Task InternalStartNew(Task creatingTask, Delegate action, object state, CancellationToken cancellationToken, TaskScheduler scheduler, TaskCreationOptions options, InternalTaskOptions internalOptions)
		{
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			Task task = new Task(action, state, creatingTask, cancellationToken, options, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler);
			task.ScheduleAndStart(needsProtection: false);
			return task;
		}

		internal static int NewId()
		{
			int num;
			do
			{
				num = Interlocked.Increment(ref s_taskIdCounter);
			}
			while (num == 0);
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.NewID(num);
			}
			return num;
		}

		internal static Task InternalCurrentIfAttached(TaskCreationOptions creationOptions)
		{
			if ((creationOptions & TaskCreationOptions.AttachedToParent) == 0)
			{
				return null;
			}
			return InternalCurrent;
		}

		internal ContingentProperties EnsureContingentPropertiesInitialized()
		{
			return Volatile.Read(ref m_contingentProperties) ?? InitializeContingentProperties();
			ContingentProperties InitializeContingentProperties()
			{
				Interlocked.CompareExchange(ref m_contingentProperties, new ContingentProperties(), null);
				return m_contingentProperties;
			}
		}

		internal ContingentProperties EnsureContingentPropertiesInitializedUnsafe()
		{
			return m_contingentProperties ?? (m_contingentProperties = new ContingentProperties());
		}

		private static bool IsCompletedMethod(int flags)
		{
			return (flags & 0x1600000) != 0;
		}

		internal void SpinUntilCompleted()
		{
			SpinWait spinWait = default(SpinWait);
			while (!IsCompleted)
			{
				spinWait.SpinOnce();
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				if ((Options & (TaskCreationOptions)16384) != 0)
				{
					return;
				}
				if (!IsCompleted)
				{
					ThrowHelper.ThrowInvalidOperationException(ExceptionResource.Task_Dispose_NotCompleted);
				}
				ContingentProperties contingentProperties = Volatile.Read(ref m_contingentProperties);
				if (contingentProperties != null)
				{
					ManualResetEventSlim completionEvent = contingentProperties.m_completionEvent;
					if (completionEvent != null)
					{
						contingentProperties.m_completionEvent = null;
						if (!completionEvent.IsSet)
						{
							completionEvent.Set();
						}
						completionEvent.Dispose();
					}
				}
			}
			m_stateFlags |= 262144;
		}

		internal void ScheduleAndStart(bool needsProtection)
		{
			if (needsProtection)
			{
				if (!MarkStarted())
				{
					return;
				}
			}
			else
			{
				m_stateFlags |= 65536;
			}
			if (s_asyncDebuggingEnabled)
			{
				AddToActiveTasks(this);
			}
			if (TplEventSource.Log.IsEnabled() && (Options & (TaskCreationOptions)512) == 0)
			{
				TplEventSource.Log.TraceOperationBegin(Id, "Task: " + m_action.Method.Name, 0L);
			}
			try
			{
				m_taskScheduler.InternalQueueTask(this);
			}
			catch (Exception innerException)
			{
				TaskSchedulerException ex = new TaskSchedulerException(innerException);
				AddException(ex);
				Finish(userDelegateExecute: false);
				if ((Options & (TaskCreationOptions)512) == 0)
				{
					m_contingentProperties.m_exceptionsHolder.MarkAsHandled(calledFromFinalizer: false);
				}
				throw ex;
			}
		}

		internal void AddException(object exceptionObject)
		{
			AddException(exceptionObject, representsCancellation: false);
		}

		internal void AddException(object exceptionObject, bool representsCancellation)
		{
			ContingentProperties contingentProperties = EnsureContingentPropertiesInitialized();
			if (contingentProperties.m_exceptionsHolder == null)
			{
				TaskExceptionHolder taskExceptionHolder = new TaskExceptionHolder(this);
				if (Interlocked.CompareExchange(ref contingentProperties.m_exceptionsHolder, taskExceptionHolder, null) != null)
				{
					taskExceptionHolder.MarkAsHandled(calledFromFinalizer: false);
				}
			}
			lock (contingentProperties)
			{
				contingentProperties.m_exceptionsHolder.Add(exceptionObject, representsCancellation);
			}
		}

		private AggregateException GetExceptions(bool includeTaskCanceledExceptions)
		{
			Exception ex = null;
			if (includeTaskCanceledExceptions && IsCanceled)
			{
				ex = new TaskCanceledException(this);
				ex.SetCurrentStackTrace();
			}
			if (ExceptionRecorded)
			{
				return m_contingentProperties.m_exceptionsHolder.CreateExceptionObject(calledFromFinalizer: false, ex);
			}
			if (ex != null)
			{
				return new AggregateException(ex);
			}
			return null;
		}

		internal List<ExceptionDispatchInfo> GetExceptionDispatchInfos()
		{
			return m_contingentProperties.m_exceptionsHolder.GetExceptionDispatchInfos();
		}

		internal ExceptionDispatchInfo GetCancellationExceptionDispatchInfo()
		{
			ContingentProperties contingentProperties = Volatile.Read(ref m_contingentProperties);
			if (contingentProperties == null)
			{
				return null;
			}
			return contingentProperties.m_exceptionsHolder?.GetCancellationExceptionDispatchInfo();
		}

		internal void MarkExceptionsAsHandled()
		{
			ContingentProperties contingentProperties = Volatile.Read(ref m_contingentProperties);
			if (contingentProperties != null)
			{
				contingentProperties.m_exceptionsHolder?.MarkAsHandled(calledFromFinalizer: false);
			}
		}

		internal void ThrowIfExceptional(bool includeTaskCanceledExceptions)
		{
			Exception exceptions = GetExceptions(includeTaskCanceledExceptions);
			if (exceptions != null)
			{
				UpdateExceptionObservedStatus();
				throw exceptions;
			}
		}

		internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext)
		{
			ExceptionDispatchInfo state2 = ExceptionDispatchInfo.Capture(exception);
			if (targetContext != null)
			{
				try
				{
					targetContext.Post(delegate(object state)
					{
						((ExceptionDispatchInfo)state).Throw();
					}, state2);
					return;
				}
				catch (Exception ex)
				{
					state2 = ExceptionDispatchInfo.Capture(new AggregateException(exception, ex));
				}
			}
			ThreadPool.QueueUserWorkItem(delegate(object state)
			{
				((ExceptionDispatchInfo)state).Throw();
			}, state2);
		}

		internal void UpdateExceptionObservedStatus()
		{
			Task task = m_contingentProperties?.m_parent;
			if (task != null && (Options & TaskCreationOptions.AttachedToParent) != 0 && (task.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0 && InternalCurrent == task)
			{
				m_stateFlags |= 524288;
			}
		}

		internal void Finish(bool userDelegateExecute)
		{
			if (m_contingentProperties == null)
			{
				FinishStageTwo();
			}
			else
			{
				FinishSlow(userDelegateExecute);
			}
		}

		private void FinishSlow(bool userDelegateExecute)
		{
			if (!userDelegateExecute)
			{
				FinishStageTwo();
				return;
			}
			ContingentProperties contingentProperties = m_contingentProperties;
			if (contingentProperties.m_completionCountdown == 1 || Interlocked.Decrement(ref contingentProperties.m_completionCountdown) == 0)
			{
				FinishStageTwo();
			}
			else
			{
				AtomicStateUpdate(8388608, 23068672);
			}
			List<Task> exceptionalChildren = contingentProperties.m_exceptionalChildren;
			if (exceptionalChildren == null)
			{
				return;
			}
			lock (exceptionalChildren)
			{
				exceptionalChildren.RemoveAll((Task t) => t.IsExceptionObservedByParent);
			}
		}

		private void FinishStageTwo()
		{
			ContingentProperties contingentProperties = Volatile.Read(ref m_contingentProperties);
			if (contingentProperties != null)
			{
				AddExceptionsFromChildren(contingentProperties);
			}
			int num;
			if (ExceptionRecorded)
			{
				num = 2097152;
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(Id, AsyncCausalityStatus.Error);
				}
				if (s_asyncDebuggingEnabled)
				{
					RemoveFromActiveTasks(this);
				}
			}
			else if (IsCancellationRequested && IsCancellationAcknowledged)
			{
				num = 4194304;
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(Id, AsyncCausalityStatus.Canceled);
				}
				if (s_asyncDebuggingEnabled)
				{
					RemoveFromActiveTasks(this);
				}
			}
			else
			{
				num = 16777216;
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(Id, AsyncCausalityStatus.Completed);
				}
				if (s_asyncDebuggingEnabled)
				{
					RemoveFromActiveTasks(this);
				}
			}
			Interlocked.Exchange(ref m_stateFlags, m_stateFlags | num);
			contingentProperties = Volatile.Read(ref m_contingentProperties);
			if (contingentProperties != null)
			{
				contingentProperties.SetCompleted();
				contingentProperties.UnregisterCancellationCallback();
			}
			FinishStageThree();
		}

		internal void FinishStageThree()
		{
			m_action = null;
			ContingentProperties contingentProperties = m_contingentProperties;
			if (contingentProperties != null)
			{
				contingentProperties.m_capturedContext = null;
				NotifyParentIfPotentiallyAttachedTask();
			}
			FinishContinuations();
		}

		internal void NotifyParentIfPotentiallyAttachedTask()
		{
			Task task = m_contingentProperties?.m_parent;
			if (task != null && (task.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0 && ((uint)m_stateFlags & 0xFFFFu & 4u) != 0)
			{
				task.ProcessChildCompletion(this);
			}
		}

		internal void ProcessChildCompletion(Task childTask)
		{
			ContingentProperties contingentProperties = Volatile.Read(ref m_contingentProperties);
			if (childTask.IsFaulted && !childTask.IsExceptionObservedByParent)
			{
				if (contingentProperties.m_exceptionalChildren == null)
				{
					Interlocked.CompareExchange(ref contingentProperties.m_exceptionalChildren, new List<Task>(), null);
				}
				List<Task> exceptionalChildren = contingentProperties.m_exceptionalChildren;
				if (exceptionalChildren != null)
				{
					lock (exceptionalChildren)
					{
						exceptionalChildren.Add(childTask);
					}
				}
			}
			if (Interlocked.Decrement(ref contingentProperties.m_completionCountdown) == 0)
			{
				FinishStageTwo();
			}
		}

		internal void AddExceptionsFromChildren(ContingentProperties props)
		{
			List<Task> exceptionalChildren = props.m_exceptionalChildren;
			if (exceptionalChildren == null)
			{
				return;
			}
			lock (exceptionalChildren)
			{
				foreach (Task item in exceptionalChildren)
				{
					if (item.IsFaulted && !item.IsExceptionObservedByParent)
					{
						TaskExceptionHolder exceptionsHolder = Volatile.Read(ref item.m_contingentProperties).m_exceptionsHolder;
						AddException(exceptionsHolder.CreateExceptionObject(calledFromFinalizer: false, null));
					}
				}
			}
			props.m_exceptionalChildren = null;
		}

		internal bool ExecuteEntry()
		{
			int oldFlags = 0;
			if (!AtomicStateUpdate(131072, 23199744, ref oldFlags) && (oldFlags & 0x400000) == 0)
			{
				return false;
			}
			if (!IsCancellationRequested & !IsCanceled)
			{
				ExecuteWithThreadLocal(ref t_currentTask);
			}
			else
			{
				ExecuteEntryCancellationRequestedOrCanceled();
			}
			return true;
		}

		internal virtual void ExecuteFromThreadPool(Thread threadPoolThread)
		{
			ExecuteEntryUnsafe(threadPoolThread);
		}

		internal void ExecuteEntryUnsafe(Thread threadPoolThread)
		{
			m_stateFlags |= 131072;
			if (!IsCancellationRequested & !IsCanceled)
			{
				ExecuteWithThreadLocal(ref t_currentTask, threadPoolThread);
			}
			else
			{
				ExecuteEntryCancellationRequestedOrCanceled();
			}
		}

		internal void ExecuteEntryCancellationRequestedOrCanceled()
		{
			if (!IsCanceled)
			{
				int num = Interlocked.Exchange(ref m_stateFlags, m_stateFlags | 0x400000);
				if ((num & 0x400000) == 0)
				{
					CancellationCleanupLogic();
				}
			}
		}

		private void ExecuteWithThreadLocal(ref Task currentTaskSlot, Thread threadPoolThread = null)
		{
			Task task = currentTaskSlot;
			TplEventSource log = TplEventSource.Log;
			Guid oldActivityThatWillContinue = default(Guid);
			bool flag = log.IsEnabled();
			if (flag)
			{
				if (log.TasksSetActivityIds)
				{
					EventSource.SetCurrentThreadActivityId(TplEventSource.CreateGuidForTaskID(Id), out oldActivityThatWillContinue);
				}
				if (task != null)
				{
					log.TaskStarted(task.m_taskScheduler.Id, task.Id, Id);
				}
				else
				{
					log.TaskStarted(TaskScheduler.Current.Id, 0, Id);
				}
				log.TraceSynchronousWorkBegin(Id, CausalitySynchronousWork.Execution);
			}
			try
			{
				currentTaskSlot = this;
				try
				{
					ExecutionContext capturedContext = CapturedContext;
					if (capturedContext == null)
					{
						InnerInvoke();
					}
					else if (threadPoolThread == null)
					{
						ExecutionContext.RunInternal(capturedContext, s_ecCallback, this);
					}
					else
					{
						ExecutionContext.RunFromThreadPoolDispatchLoop(threadPoolThread, capturedContext, s_ecCallback, this);
					}
				}
				catch (Exception unhandledException)
				{
					HandleException(unhandledException);
				}
				if (flag)
				{
					log.TraceSynchronousWorkEnd(CausalitySynchronousWork.Execution);
				}
				Finish(userDelegateExecute: true);
			}
			finally
			{
				currentTaskSlot = task;
				if (flag)
				{
					if (task != null)
					{
						log.TaskCompleted(task.m_taskScheduler.Id, task.Id, Id, IsFaulted);
					}
					else
					{
						log.TaskCompleted(TaskScheduler.Current.Id, 0, Id, IsFaulted);
					}
					if (log.TasksSetActivityIds)
					{
						EventSource.SetCurrentThreadActivityId(oldActivityThatWillContinue);
					}
				}
			}
		}

		internal virtual void InnerInvoke()
		{
			if (m_action is Action action)
			{
				action();
			}
			else if (m_action is Action<object> action2)
			{
				action2(m_stateObject);
			}
		}

		private void HandleException(Exception unhandledException)
		{
			if (unhandledException is OperationCanceledException ex && IsCancellationRequested && m_contingentProperties.m_cancellationToken == ex.CancellationToken)
			{
				SetCancellationAcknowledged();
				AddException(ex, representsCancellation: true);
			}
			else
			{
				AddException(unhandledException);
			}
		}

		public TaskAwaiter GetAwaiter()
		{
			return new TaskAwaiter(this);
		}

		public ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext)
		{
			return new ConfiguredTaskAwaitable(this, continueOnCapturedContext);
		}

		internal void SetContinuationForAwait(Action continuationAction, bool continueOnCapturedContext, bool flowExecutionContext)
		{
			TaskContinuation taskContinuation = null;
			if (continueOnCapturedContext)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && current.GetType() != typeof(SynchronizationContext))
				{
					taskContinuation = new SynchronizationContextAwaitTaskContinuation(current, continuationAction, flowExecutionContext);
				}
				else
				{
					TaskScheduler internalCurrent = TaskScheduler.InternalCurrent;
					if (internalCurrent != null && internalCurrent != TaskScheduler.Default)
					{
						taskContinuation = new TaskSchedulerAwaitTaskContinuation(internalCurrent, continuationAction, flowExecutionContext);
					}
				}
			}
			if (taskContinuation == null && flowExecutionContext)
			{
				taskContinuation = new AwaitTaskContinuation(continuationAction, flowExecutionContext: true);
			}
			if (taskContinuation != null)
			{
				if (!AddTaskContinuation(taskContinuation, addBeforeOthers: false))
				{
					taskContinuation.Run(this, canInlineContinuationTask: false);
				}
			}
			else if (!AddTaskContinuation(continuationAction, addBeforeOthers: false))
			{
				AwaitTaskContinuation.UnsafeScheduleAction(continuationAction, this);
			}
		}

		internal void UnsafeSetContinuationForAwait(IAsyncStateMachineBox stateMachineBox, bool continueOnCapturedContext)
		{
			if (continueOnCapturedContext)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && current.GetType() != typeof(SynchronizationContext))
				{
					SynchronizationContextAwaitTaskContinuation synchronizationContextAwaitTaskContinuation = new SynchronizationContextAwaitTaskContinuation(current, stateMachineBox.MoveNextAction, flowExecutionContext: false);
					if (!AddTaskContinuation(synchronizationContextAwaitTaskContinuation, addBeforeOthers: false))
					{
						synchronizationContextAwaitTaskContinuation.Run(this, canInlineContinuationTask: false);
					}
					return;
				}
				TaskScheduler internalCurrent = TaskScheduler.InternalCurrent;
				if (internalCurrent != null && internalCurrent != TaskScheduler.Default)
				{
					TaskSchedulerAwaitTaskContinuation taskSchedulerAwaitTaskContinuation = new TaskSchedulerAwaitTaskContinuation(internalCurrent, stateMachineBox.MoveNextAction, flowExecutionContext: false);
					if (!AddTaskContinuation(taskSchedulerAwaitTaskContinuation, addBeforeOthers: false))
					{
						taskSchedulerAwaitTaskContinuation.Run(this, canInlineContinuationTask: false);
					}
					return;
				}
			}
			if (!AddTaskContinuation(stateMachineBox, addBeforeOthers: false))
			{
				ThreadPool.UnsafeQueueUserWorkItemInternal(stateMachineBox, preferLocal: true);
			}
		}

		public static YieldAwaitable Yield()
		{
			return default(YieldAwaitable);
		}

		public void Wait()
		{
			Wait(-1, default(CancellationToken));
		}

		public bool Wait(TimeSpan timeout)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.timeout);
			}
			return Wait((int)num, default(CancellationToken));
		}

		public void Wait(CancellationToken cancellationToken)
		{
			Wait(-1, cancellationToken);
		}

		public bool Wait(int millisecondsTimeout)
		{
			return Wait(millisecondsTimeout, default(CancellationToken));
		}

		public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
		{
			if (millisecondsTimeout < -1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.millisecondsTimeout);
			}
			if (!IsWaitNotificationEnabledOrNotRanToCompletion)
			{
				return true;
			}
			if (!InternalWait(millisecondsTimeout, cancellationToken))
			{
				return false;
			}
			if (IsWaitNotificationEnabledOrNotRanToCompletion)
			{
				NotifyDebuggerOfWaitCompletionIfNecessary();
				if (IsCanceled)
				{
					cancellationToken.ThrowIfCancellationRequested();
				}
				ThrowIfExceptional(includeTaskCanceledExceptions: true);
			}
			return true;
		}

		public Task WaitAsync(CancellationToken cancellationToken)
		{
			return WaitAsync(uint.MaxValue, cancellationToken);
		}

		public Task WaitAsync(TimeSpan timeout)
		{
			return WaitAsync(ValidateTimeout(timeout, ExceptionArgument.timeout), default(CancellationToken));
		}

		public Task WaitAsync(TimeSpan timeout, CancellationToken cancellationToken)
		{
			return WaitAsync(ValidateTimeout(timeout, ExceptionArgument.timeout), cancellationToken);
		}

		private Task WaitAsync(uint millisecondsTimeout, CancellationToken cancellationToken)
		{
			if (IsCompleted || (!cancellationToken.CanBeCanceled && millisecondsTimeout == uint.MaxValue))
			{
				return this;
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return FromCanceled(cancellationToken);
			}
			if (millisecondsTimeout == 0)
			{
				return FromException(new TimeoutException());
			}
			return new CancellationPromise<VoidTaskResult>(this, millisecondsTimeout, cancellationToken);
		}

		private bool WrappedTryRunInline()
		{
			if (m_taskScheduler == null)
			{
				return false;
			}
			try
			{
				return m_taskScheduler.TryRunInline(this, taskWasPreviouslyQueued: true);
			}
			catch (Exception innerException)
			{
				throw new TaskSchedulerException(innerException);
			}
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		internal bool InternalWait(int millisecondsTimeout, CancellationToken cancellationToken)
		{
			return InternalWaitCore(millisecondsTimeout, cancellationToken);
		}

		private bool InternalWaitCore(int millisecondsTimeout, CancellationToken cancellationToken)
		{
			if (IsCompleted)
			{
				return true;
			}
			TplEventSource log = TplEventSource.Log;
			bool flag = log.IsEnabled();
			if (flag)
			{
				Task internalCurrent = InternalCurrent;
				log.TaskWaitBegin(internalCurrent?.m_taskScheduler.Id ?? TaskScheduler.Default.Id, internalCurrent?.Id ?? 0, Id, TplEventSource.TaskWaitBehavior.Synchronous, 0);
			}
			Debugger.NotifyOfCrossThreadDependency();
			bool result = (millisecondsTimeout == -1 && !cancellationToken.CanBeCanceled && WrappedTryRunInline() && IsCompleted) || SpinThenBlockingWait(millisecondsTimeout, cancellationToken);
			if (flag)
			{
				Task internalCurrent2 = InternalCurrent;
				if (internalCurrent2 != null)
				{
					log.TaskWaitEnd(internalCurrent2.m_taskScheduler.Id, internalCurrent2.Id, Id);
				}
				else
				{
					log.TaskWaitEnd(TaskScheduler.Default.Id, 0, Id);
				}
				log.TaskWaitContinuationComplete(Id);
			}
			return result;
		}

		private bool SpinThenBlockingWait(int millisecondsTimeout, CancellationToken cancellationToken)
		{
			bool flag = millisecondsTimeout == -1;
			uint num = ((!flag) ? ((uint)Environment.TickCount) : 0u);
			bool flag2 = SpinWait(millisecondsTimeout);
			if (!flag2)
			{
				SetOnInvokeMres setOnInvokeMres = new SetOnInvokeMres();
				try
				{
					AddCompletionAction(setOnInvokeMres, addBeforeOthers: true);
					if (flag)
					{
						bool flag3 = ThreadPool.NotifyThreadBlocked();
						try
						{
							flag2 = setOnInvokeMres.Wait(-1, cancellationToken);
						}
						finally
						{
							if (flag3)
							{
								ThreadPool.NotifyThreadUnblocked();
							}
						}
					}
					else
					{
						uint num2 = (uint)Environment.TickCount - num;
						if (num2 < millisecondsTimeout)
						{
							bool flag4 = ThreadPool.NotifyThreadBlocked();
							try
							{
								flag2 = setOnInvokeMres.Wait((int)(millisecondsTimeout - num2), cancellationToken);
							}
							finally
							{
								if (flag4)
								{
									ThreadPool.NotifyThreadUnblocked();
								}
							}
						}
					}
				}
				finally
				{
					if (!IsCompleted)
					{
						RemoveContinuation(setOnInvokeMres);
					}
				}
			}
			return flag2;
		}

		private bool SpinWait(int millisecondsTimeout)
		{
			if (IsCompleted)
			{
				return true;
			}
			if (millisecondsTimeout == 0)
			{
				return false;
			}
			int spinCountforSpinBeforeWait = System.Threading.SpinWait.SpinCountforSpinBeforeWait;
			SpinWait spinWait = default(SpinWait);
			while (spinWait.Count < spinCountforSpinBeforeWait)
			{
				spinWait.SpinOnce(-1);
				if (IsCompleted)
				{
					return true;
				}
			}
			return false;
		}

		internal void InternalCancel()
		{
			TaskSchedulerException ex = null;
			bool flag = false;
			if (((uint)m_stateFlags & 0x10000u) != 0)
			{
				TaskScheduler taskScheduler = m_taskScheduler;
				try
				{
					flag = taskScheduler?.TryDequeue(this) ?? false;
				}
				catch (Exception innerException)
				{
					ex = new TaskSchedulerException(innerException);
				}
			}
			RecordInternalCancellationRequest();
			bool flag2 = false;
			if (flag)
			{
				flag2 = AtomicStateUpdate(4194304, 4325376);
			}
			else if ((m_stateFlags & 0x10000) == 0)
			{
				flag2 = AtomicStateUpdate(4194304, 23265280);
			}
			if (flag2)
			{
				CancellationCleanupLogic();
			}
			if (ex != null)
			{
				throw ex;
			}
		}

		internal void InternalCancelContinueWithInitialState()
		{
			m_stateFlags |= 4194304;
			CancellationCleanupLogic();
		}

		internal void RecordInternalCancellationRequest()
		{
			EnsureContingentPropertiesInitialized().m_internalCancellationRequested = 1;
		}

		internal void RecordInternalCancellationRequest(CancellationToken tokenToRecord, object cancellationException)
		{
			RecordInternalCancellationRequest();
			if (tokenToRecord != default(CancellationToken))
			{
				m_contingentProperties.m_cancellationToken = tokenToRecord;
			}
			if (cancellationException != null)
			{
				AddException(cancellationException, representsCancellation: true);
			}
		}

		internal void CancellationCleanupLogic()
		{
			Interlocked.Exchange(ref m_stateFlags, m_stateFlags | 0x400000);
			ContingentProperties contingentProperties = Volatile.Read(ref m_contingentProperties);
			if (contingentProperties != null)
			{
				contingentProperties.SetCompleted();
				contingentProperties.UnregisterCancellationCallback();
			}
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationEnd(Id, AsyncCausalityStatus.Canceled);
			}
			if (s_asyncDebuggingEnabled)
			{
				RemoveFromActiveTasks(this);
			}
			FinishStageThree();
		}

		private void SetCancellationAcknowledged()
		{
			m_stateFlags |= 1048576;
		}

		internal bool TrySetResult()
		{
			if (AtomicStateUpdate(83886080, 90177536))
			{
				ContingentProperties contingentProperties = m_contingentProperties;
				if (contingentProperties != null)
				{
					NotifyParentIfPotentiallyAttachedTask();
					contingentProperties.SetCompleted();
				}
				FinishContinuations();
				return true;
			}
			return false;
		}

		internal bool TrySetException(object exceptionObject)
		{
			bool result = false;
			EnsureContingentPropertiesInitialized();
			if (AtomicStateUpdate(67108864, 90177536))
			{
				AddException(exceptionObject);
				Finish(userDelegateExecute: false);
				result = true;
			}
			return result;
		}

		internal bool TrySetCanceled(CancellationToken tokenToRecord)
		{
			return TrySetCanceled(tokenToRecord, null);
		}

		internal bool TrySetCanceled(CancellationToken tokenToRecord, object cancellationException)
		{
			bool result = false;
			if (AtomicStateUpdate(67108864, 90177536))
			{
				RecordInternalCancellationRequest(tokenToRecord, cancellationException);
				CancellationCleanupLogic();
				result = true;
			}
			return result;
		}

		internal void FinishContinuations()
		{
			object obj = Interlocked.Exchange(ref m_continuationObject, s_taskCompletionSentinel);
			if (obj != null)
			{
				RunContinuations(obj);
			}
		}

		private void RunContinuations(object continuationObject)
		{
			TplEventSource log = TplEventSource.Log;
			bool flag = log.IsEnabled();
			if (flag)
			{
				log.TraceSynchronousWorkBegin(Id, CausalitySynchronousWork.CompletionNotification);
			}
			bool flag2 = (m_stateFlags & 0x40) == 0 && RuntimeHelpers.TryEnsureSufficientExecutionStack();
			if (!(continuationObject is IAsyncStateMachineBox box))
			{
				if (!(continuationObject is Action action))
				{
					if (!(continuationObject is TaskContinuation taskContinuation))
					{
						if (continuationObject is ITaskCompletionAction completionAction)
						{
							RunOrQueueCompletionAction(completionAction, flag2);
							LogFinishCompletionNotification();
							return;
						}
						List<object> list = (List<object>)continuationObject;
						lock (list)
						{
						}
						int count = list.Count;
						if (flag2)
						{
							bool flag3 = false;
							for (int i = 0; i < count; i++)
							{
								object obj = list[i];
								if (obj == null)
								{
									continue;
								}
								if (obj is ContinueWithTaskContinuation continueWithTaskContinuation)
								{
									if ((continueWithTaskContinuation.m_options & TaskContinuationOptions.ExecuteSynchronously) == 0)
									{
										list[i] = null;
										if (flag)
										{
											log.RunningContinuationList(Id, i, continueWithTaskContinuation);
										}
										continueWithTaskContinuation.Run(this, canInlineContinuationTask: false);
									}
								}
								else
								{
									if (obj is ITaskCompletionAction)
									{
										continue;
									}
									if (flag3)
									{
										list[i] = null;
										if (flag)
										{
											log.RunningContinuationList(Id, i, obj);
										}
										if (!(obj is IAsyncStateMachineBox box2))
										{
											if (obj is Action action2)
											{
												AwaitTaskContinuation.RunOrScheduleAction(action2, allowInlining: false);
											}
											else
											{
												((TaskContinuation)obj).Run(this, canInlineContinuationTask: false);
											}
										}
										else
										{
											AwaitTaskContinuation.RunOrScheduleAction(box2, allowInlining: false);
										}
									}
									flag3 = true;
								}
							}
						}
						for (int j = 0; j < count; j++)
						{
							object obj2 = list[j];
							if (obj2 == null)
							{
								continue;
							}
							list[j] = null;
							if (flag)
							{
								log.RunningContinuationList(Id, j, obj2);
							}
							if (!(obj2 is IAsyncStateMachineBox box3))
							{
								if (!(obj2 is Action action3))
								{
									if (obj2 is TaskContinuation taskContinuation2)
									{
										taskContinuation2.Run(this, flag2);
									}
									else
									{
										RunOrQueueCompletionAction((ITaskCompletionAction)obj2, flag2);
									}
								}
								else
								{
									AwaitTaskContinuation.RunOrScheduleAction(action3, flag2);
								}
							}
							else
							{
								AwaitTaskContinuation.RunOrScheduleAction(box3, flag2);
							}
						}
						LogFinishCompletionNotification();
					}
					else
					{
						taskContinuation.Run(this, flag2);
						LogFinishCompletionNotification();
					}
				}
				else
				{
					AwaitTaskContinuation.RunOrScheduleAction(action, flag2);
					LogFinishCompletionNotification();
				}
			}
			else
			{
				AwaitTaskContinuation.RunOrScheduleAction(box, flag2);
				LogFinishCompletionNotification();
			}
		}

		private void RunOrQueueCompletionAction(ITaskCompletionAction completionAction, bool allowInlining)
		{
			if (allowInlining || !completionAction.InvokeMayRunArbitraryCode)
			{
				completionAction.Invoke(this);
			}
			else
			{
				ThreadPool.UnsafeQueueUserWorkItemInternal(new CompletionActionInvoker(completionAction, this), preferLocal: true);
			}
		}

		private static void LogFinishCompletionNotification()
		{
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceSynchronousWorkEnd(CausalitySynchronousWork.CompletionNotification);
			}
		}

		public Task ContinueWith(Action<Task> continuationAction)
		{
			return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task> continuationAction, CancellationToken cancellationToken)
		{
			return ContinueWith(continuationAction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task> continuationAction, TaskScheduler scheduler)
		{
			return ContinueWith(continuationAction, scheduler, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task> continuationAction, TaskContinuationOptions continuationOptions)
		{
			return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), continuationOptions);
		}

		public Task ContinueWith(Action<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			return ContinueWith(continuationAction, scheduler, cancellationToken, continuationOptions);
		}

		private Task ContinueWith(Action<Task> continuationAction, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
		{
			if (continuationAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationAction);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var internalOptions);
			Task task = new ContinuationTaskFromTask(this, continuationAction, null, creationOptions, internalOptions);
			ContinueWithCore(task, scheduler, cancellationToken, continuationOptions);
			return task;
		}

		public Task ContinueWith(Action<Task, object?> continuationAction, object? state)
		{
			return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task, object?> continuationAction, object? state, CancellationToken cancellationToken)
		{
			return ContinueWith(continuationAction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task, object?> continuationAction, object? state, TaskScheduler scheduler)
		{
			return ContinueWith(continuationAction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task ContinueWith(Action<Task, object?> continuationAction, object? state, TaskContinuationOptions continuationOptions)
		{
			return ContinueWith(continuationAction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions);
		}

		public Task ContinueWith(Action<Task, object?> continuationAction, object? state, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			return ContinueWith(continuationAction, state, scheduler, cancellationToken, continuationOptions);
		}

		private Task ContinueWith(Action<Task, object> continuationAction, object state, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
		{
			if (continuationAction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationAction);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var internalOptions);
			Task task = new ContinuationTaskFromTask(this, continuationAction, state, creationOptions, internalOptions);
			ContinueWithCore(task, scheduler, cancellationToken, continuationOptions);
			return task;
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction)
		{
			return ContinueWith(continuationFunction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
		{
			return ContinueWith(continuationFunction, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, TaskScheduler scheduler)
		{
			return ContinueWith(continuationFunction, scheduler, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			return ContinueWith(continuationFunction, TaskScheduler.Current, default(CancellationToken), continuationOptions);
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			return ContinueWith(continuationFunction, scheduler, cancellationToken, continuationOptions);
		}

		private Task<TResult> ContinueWith<TResult>(Func<Task, TResult> continuationFunction, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var internalOptions);
			Task<TResult> task = new ContinuationResultTaskFromTask<TResult>(this, continuationFunction, null, creationOptions, internalOptions);
			ContinueWithCore(task, scheduler, cancellationToken, continuationOptions);
			return task;
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, object?, TResult> continuationFunction, object? state)
		{
			return ContinueWith(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, object?, TResult> continuationFunction, object? state, CancellationToken cancellationToken)
		{
			return ContinueWith(continuationFunction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, object?, TResult> continuationFunction, object? state, TaskScheduler scheduler)
		{
			return ContinueWith(continuationFunction, state, scheduler, default(CancellationToken), TaskContinuationOptions.None);
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, object?, TResult> continuationFunction, object? state, TaskContinuationOptions continuationOptions)
		{
			return ContinueWith(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), continuationOptions);
		}

		public Task<TResult> ContinueWith<TResult>(Func<Task, object?, TResult> continuationFunction, object? state, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			return ContinueWith(continuationFunction, state, scheduler, cancellationToken, continuationOptions);
		}

		private Task<TResult> ContinueWith<TResult>(Func<Task, object, TResult> continuationFunction, object state, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.continuationFunction);
			}
			if (scheduler == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.scheduler);
			}
			CreationOptionsFromContinuationOptions(continuationOptions, out var creationOptions, out var internalOptions);
			Task<TResult> task = new ContinuationResultTaskFromTask<TResult>(this, continuationFunction, state, creationOptions, internalOptions);
			ContinueWithCore(task, scheduler, cancellationToken, continuationOptions);
			return task;
		}

		internal static void CreationOptionsFromContinuationOptions(TaskContinuationOptions continuationOptions, out TaskCreationOptions creationOptions, out InternalTaskOptions internalOptions)
		{
			if ((continuationOptions & (TaskContinuationOptions.LongRunning | TaskContinuationOptions.ExecuteSynchronously)) == (TaskContinuationOptions.LongRunning | TaskContinuationOptions.ExecuteSynchronously))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.continuationOptions, ExceptionResource.Task_ContinueWith_ESandLR);
			}
			if (((uint)continuationOptions & 0xFFF0FF80u) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.continuationOptions);
			}
			if ((continuationOptions & (TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.NotOnRanToCompletion)) == (TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.NotOnRanToCompletion))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.continuationOptions, ExceptionResource.Task_ContinueWith_NotOnAnything);
			}
			creationOptions = (TaskCreationOptions)(continuationOptions & (TaskContinuationOptions.PreferFairness | TaskContinuationOptions.LongRunning | TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.DenyChildAttach | TaskContinuationOptions.HideScheduler | TaskContinuationOptions.RunContinuationsAsynchronously));
			internalOptions = (((continuationOptions & TaskContinuationOptions.LazyCancellation) != 0) ? (InternalTaskOptions.ContinuationTask | InternalTaskOptions.LazyCancellation) : InternalTaskOptions.ContinuationTask);
		}

		internal void ContinueWithCore(Task continuationTask, TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions options)
		{
			TaskContinuation taskContinuation = new ContinueWithTaskContinuation(continuationTask, options, scheduler);
			if (cancellationToken.CanBeCanceled)
			{
				if (IsCompleted || cancellationToken.IsCancellationRequested)
				{
					continuationTask.AssignCancellationToken(cancellationToken, null, null);
				}
				else
				{
					continuationTask.AssignCancellationToken(cancellationToken, this, taskContinuation);
				}
			}
			if (continuationTask.IsCompleted)
			{
				return;
			}
			if ((Options & (TaskCreationOptions)1024) != 0 && !(this is ITaskCompletionAction))
			{
				TplEventSource log = TplEventSource.Log;
				if (log.IsEnabled())
				{
					log.AwaitTaskContinuationScheduled(TaskScheduler.Current.Id, CurrentId.GetValueOrDefault(), continuationTask.Id);
				}
			}
			if (!AddTaskContinuation(taskContinuation, addBeforeOthers: false))
			{
				taskContinuation.Run(this, canInlineContinuationTask: true);
			}
		}

		internal void AddCompletionAction(ITaskCompletionAction action, bool addBeforeOthers = false)
		{
			if (!AddTaskContinuation(action, addBeforeOthers))
			{
				action.Invoke(this);
			}
		}

		private bool AddTaskContinuationComplex(object tc, bool addBeforeOthers)
		{
			object continuationObject = m_continuationObject;
			if (continuationObject != s_taskCompletionSentinel && !(continuationObject is List<object>))
			{
				Interlocked.CompareExchange(ref m_continuationObject, new List<object> { continuationObject }, continuationObject);
			}
			if (m_continuationObject is List<object> list)
			{
				lock (list)
				{
					if (m_continuationObject != s_taskCompletionSentinel)
					{
						if (list.Count == list.Capacity)
						{
							list.RemoveAll((object l) => l == null);
						}
						if (addBeforeOthers)
						{
							list.Insert(0, tc);
						}
						else
						{
							list.Add(tc);
						}
						return true;
					}
				}
			}
			return false;
		}

		private bool AddTaskContinuation(object tc, bool addBeforeOthers)
		{
			if (IsCompleted)
			{
				return false;
			}
			if (m_continuationObject != null || Interlocked.CompareExchange(ref m_continuationObject, tc, null) != null)
			{
				return AddTaskContinuationComplex(tc, addBeforeOthers);
			}
			return true;
		}

		internal void RemoveContinuation(object continuationObject)
		{
			object continuationObject2 = m_continuationObject;
			if (continuationObject2 == s_taskCompletionSentinel)
			{
				return;
			}
			List<object> list = continuationObject2 as List<object>;
			if (list == null)
			{
				if (Interlocked.CompareExchange(ref m_continuationObject, new List<object>(), continuationObject) == continuationObject)
				{
					return;
				}
				list = m_continuationObject as List<object>;
			}
			if (list == null)
			{
				return;
			}
			lock (list)
			{
				if (m_continuationObject != s_taskCompletionSentinel)
				{
					int num = list.IndexOf(continuationObject);
					if (num != -1)
					{
						list[num] = null;
					}
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		[UnsupportedOSPlatform("browser")]
		public static void WaitAll(params Task[] tasks)
		{
			WaitAllCore(tasks, -1, default(CancellationToken));
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		[UnsupportedOSPlatform("browser")]
		public static bool WaitAll(Task[] tasks, TimeSpan timeout)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.timeout);
			}
			return WaitAllCore(tasks, (int)num, default(CancellationToken));
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		[UnsupportedOSPlatform("browser")]
		public static bool WaitAll(Task[] tasks, int millisecondsTimeout)
		{
			return WaitAllCore(tasks, millisecondsTimeout, default(CancellationToken));
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		[UnsupportedOSPlatform("browser")]
		public static void WaitAll(Task[] tasks, CancellationToken cancellationToken)
		{
			WaitAllCore(tasks, -1, cancellationToken);
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		[UnsupportedOSPlatform("browser")]
		public static bool WaitAll(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
		{
			return WaitAllCore(tasks, millisecondsTimeout, cancellationToken);
		}

		[UnsupportedOSPlatform("browser")]
		private static bool WaitAllCore(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
		{
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			if (millisecondsTimeout < -1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.millisecondsTimeout);
			}
			cancellationToken.ThrowIfCancellationRequested();
			List<Exception> exceptions = null;
			List<Task> list = null;
			List<Task> list2 = null;
			bool flag = false;
			bool flag2 = false;
			bool flag3 = true;
			for (int num = tasks.Length - 1; num >= 0; num--)
			{
				Task task = tasks[num];
				if (task == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_WaitMulti_NullTask, ExceptionArgument.tasks);
				}
				bool flag4 = task.IsCompleted;
				if (!flag4)
				{
					if (millisecondsTimeout != -1 || cancellationToken.CanBeCanceled)
					{
						AddToList(task, ref list, tasks.Length);
					}
					else
					{
						flag4 = task.WrappedTryRunInline() && task.IsCompleted;
						if (!flag4)
						{
							AddToList(task, ref list, tasks.Length);
						}
					}
				}
				if (flag4)
				{
					if (task.IsFaulted)
					{
						flag = true;
					}
					else if (task.IsCanceled)
					{
						flag2 = true;
					}
					if (task.IsWaitNotificationEnabled)
					{
						AddToList(task, ref list2, 1);
					}
				}
			}
			if (list != null)
			{
				flag3 = WaitAllBlockingCore(list, millisecondsTimeout, cancellationToken);
				if (flag3)
				{
					foreach (Task item in list)
					{
						if (item.IsFaulted)
						{
							flag = true;
						}
						else if (item.IsCanceled)
						{
							flag2 = true;
						}
						if (item.IsWaitNotificationEnabled)
						{
							AddToList(item, ref list2, 1);
						}
					}
				}
				GC.KeepAlive(tasks);
			}
			if (flag3 && list2 != null)
			{
				foreach (Task item2 in list2)
				{
					if (item2.NotifyDebuggerOfWaitCompletionIfNecessary())
					{
						break;
					}
				}
			}
			if (flag3 && (flag || flag2))
			{
				if (!flag)
				{
					cancellationToken.ThrowIfCancellationRequested();
				}
				foreach (Task t in tasks)
				{
					AddExceptionsForCompletedTask(ref exceptions, t);
				}
				ThrowHelper.ThrowAggregateException(exceptions);
			}
			return flag3;
		}

		private static void AddToList<T>(T item, ref List<T> list, int initSize)
		{
			if (list == null)
			{
				list = new List<T>(initSize);
			}
			list.Add(item);
		}

		[UnsupportedOSPlatform("browser")]
		private static bool WaitAllBlockingCore(List<Task> tasks, int millisecondsTimeout, CancellationToken cancellationToken)
		{
			bool flag = false;
			SetOnCountdownMres setOnCountdownMres = new SetOnCountdownMres(tasks.Count);
			try
			{
				foreach (Task task in tasks)
				{
					task.AddCompletionAction(setOnCountdownMres, addBeforeOthers: true);
				}
				flag = setOnCountdownMres.Wait(millisecondsTimeout, cancellationToken);
			}
			finally
			{
				if (!flag)
				{
					foreach (Task task2 in tasks)
					{
						if (!task2.IsCompleted)
						{
							task2.RemoveContinuation(setOnCountdownMres);
						}
					}
				}
			}
			return flag;
		}

		internal static void AddExceptionsForCompletedTask(ref List<Exception> exceptions, Task t)
		{
			AggregateException exceptions2 = t.GetExceptions(includeTaskCanceledExceptions: true);
			if (exceptions2 != null)
			{
				t.UpdateExceptionObservedStatus();
				if (exceptions == null)
				{
					exceptions = new List<Exception>(exceptions2.InnerExceptionCount);
				}
				exceptions.AddRange(exceptions2.InternalInnerExceptions);
			}
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		public static int WaitAny(params Task[] tasks)
		{
			return WaitAnyCore(tasks, -1, default(CancellationToken));
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		public static int WaitAny(Task[] tasks, TimeSpan timeout)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > int.MaxValue)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.timeout);
			}
			return WaitAnyCore(tasks, (int)num, default(CancellationToken));
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		public static int WaitAny(Task[] tasks, CancellationToken cancellationToken)
		{
			return WaitAnyCore(tasks, -1, cancellationToken);
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		public static int WaitAny(Task[] tasks, int millisecondsTimeout)
		{
			return WaitAnyCore(tasks, millisecondsTimeout, default(CancellationToken));
		}

		[MethodImpl(MethodImplOptions.NoOptimization)]
		public static int WaitAny(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
		{
			return WaitAnyCore(tasks, millisecondsTimeout, cancellationToken);
		}

		private static int WaitAnyCore(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
		{
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			if (millisecondsTimeout < -1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.millisecondsTimeout);
			}
			cancellationToken.ThrowIfCancellationRequested();
			int num = -1;
			for (int i = 0; i < tasks.Length; i++)
			{
				Task task = tasks[i];
				if (task == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_WaitMulti_NullTask, ExceptionArgument.tasks);
				}
				if (num == -1 && task.IsCompleted)
				{
					num = i;
				}
			}
			if (num == -1 && tasks.Length != 0)
			{
				Task<Task> task2 = TaskFactory.CommonCWAnyLogic(tasks, isSyncBlocking: true);
				if (task2.Wait(millisecondsTimeout, cancellationToken))
				{
					num = Array.IndexOf(tasks, task2.Result);
				}
				else
				{
					TaskFactory.CommonCWAnyLogicCleanup(task2);
				}
			}
			GC.KeepAlive(tasks);
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Task<TResult> FromResult<TResult>(TResult result)
		{
			if (result == null)
			{
				return Task<TResult>.s_defaultResultTask;
			}
			if (typeof(TResult).IsValueType)
			{
				if (typeof(TResult) == typeof(bool))
				{
					Task<bool> value = (((bool)(object)result) ? TaskCache.s_trueTask : TaskCache.s_falseTask);
					return Unsafe.As<Task<TResult>>(value);
				}
				if (typeof(TResult) == typeof(int))
				{
					int num = (int)(object)result;
					if ((uint)(num - -1) < 10u)
					{
						Task<int> value2 = TaskCache.s_int32Tasks[num - -1];
						return Unsafe.As<Task<TResult>>(value2);
					}
				}
				else if ((typeof(TResult) == typeof(uint) && (uint)(object)result == 0) || (typeof(TResult) == typeof(byte) && (byte)(object)result == 0) || (typeof(TResult) == typeof(sbyte) && (sbyte)(object)result == 0) || (typeof(TResult) == typeof(char) && (char)(object)result == '\0') || (typeof(TResult) == typeof(long) && (long)(object)result == 0L) || (typeof(TResult) == typeof(ulong) && (ulong)(object)result == 0L) || (typeof(TResult) == typeof(short) && (short)(object)result == 0) || (typeof(TResult) == typeof(ushort) && (ushort)(object)result == 0) || (typeof(TResult) == typeof(IntPtr) && (IntPtr)0 == (IntPtr)(object)result) || (typeof(TResult) == typeof(UIntPtr) && (UIntPtr)0u == (UIntPtr)(object)result))
				{
					return Task<TResult>.s_defaultResultTask;
				}
			}
			return new Task<TResult>(result);
		}

		public static Task FromException(Exception exception)
		{
			if (exception == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exception);
			}
			Task task = new Task();
			bool flag = task.TrySetException(exception);
			return task;
		}

		public static Task<TResult> FromException<TResult>(Exception exception)
		{
			if (exception == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exception);
			}
			Task<TResult> task = new Task<TResult>();
			bool flag = task.TrySetException(exception);
			return task;
		}

		public static Task FromCanceled(CancellationToken cancellationToken)
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.cancellationToken);
			}
			return new Task(canceled: true, TaskCreationOptions.None, cancellationToken);
		}

		public static Task<TResult> FromCanceled<TResult>(CancellationToken cancellationToken)
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.cancellationToken);
			}
			return new Task<TResult>(canceled: true, default(TResult), TaskCreationOptions.None, cancellationToken);
		}

		internal static Task FromCanceled(OperationCanceledException exception)
		{
			Task task = new Task();
			bool flag = task.TrySetCanceled(exception.CancellationToken, exception);
			return task;
		}

		internal static Task<TResult> FromCanceled<TResult>(OperationCanceledException exception)
		{
			Task<TResult> task = new Task<TResult>();
			bool flag = task.TrySetCanceled(exception.CancellationToken, exception);
			return task;
		}

		public static Task Run(Action action)
		{
			return InternalStartNew(null, action, null, default(CancellationToken), TaskScheduler.Default, TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None);
		}

		public static Task Run(Action action, CancellationToken cancellationToken)
		{
			return InternalStartNew(null, action, null, cancellationToken, TaskScheduler.Default, TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None);
		}

		public static Task<TResult> Run<TResult>(Func<TResult> function)
		{
			return Task<TResult>.StartNew(null, function, default(CancellationToken), TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None, TaskScheduler.Default);
		}

		public static Task<TResult> Run<TResult>(Func<TResult> function, CancellationToken cancellationToken)
		{
			return Task<TResult>.StartNew(null, function, cancellationToken, TaskCreationOptions.DenyChildAttach, InternalTaskOptions.None, TaskScheduler.Default);
		}

		public static Task Run(Func<Task?> function)
		{
			return Run(function, default(CancellationToken));
		}

		public static Task Run(Func<Task?> function, CancellationToken cancellationToken)
		{
			if (function == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.function);
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return FromCanceled(cancellationToken);
			}
			Task<Task> outerTask = Task<Task>.Factory.StartNew(function, cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			return new UnwrapPromise<VoidTaskResult>(outerTask, lookForOce: true);
		}

		public static Task<TResult> Run<TResult>(Func<Task<TResult>?> function)
		{
			return Run(function, default(CancellationToken));
		}

		public static Task<TResult> Run<TResult>(Func<Task<TResult>?> function, CancellationToken cancellationToken)
		{
			if (function == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.function);
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return FromCanceled<TResult>(cancellationToken);
			}
			Task<Task<TResult>> outerTask = Task<Task<TResult>>.Factory.StartNew(function, cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			return new UnwrapPromise<TResult>(outerTask, lookForOce: true);
		}

		public static Task Delay(TimeSpan delay)
		{
			return Delay(delay, default(CancellationToken));
		}

		public static Task Delay(TimeSpan delay, CancellationToken cancellationToken)
		{
			return Delay(ValidateTimeout(delay, ExceptionArgument.delay), cancellationToken);
		}

		public static Task Delay(int millisecondsDelay)
		{
			return Delay(millisecondsDelay, default(CancellationToken));
		}

		public static Task Delay(int millisecondsDelay, CancellationToken cancellationToken)
		{
			if (millisecondsDelay < -1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.millisecondsDelay, ExceptionResource.Task_Delay_InvalidMillisecondsDelay);
			}
			return Delay((uint)millisecondsDelay, cancellationToken);
		}

		private static Task Delay(uint millisecondsDelay, CancellationToken cancellationToken)
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				if (millisecondsDelay != 0)
				{
					if (!cancellationToken.CanBeCanceled)
					{
						return new DelayPromise(millisecondsDelay);
					}
					return new DelayPromiseWithCancellation(millisecondsDelay, cancellationToken);
				}
				return CompletedTask;
			}
			return FromCanceled(cancellationToken);
		}

		internal static uint ValidateTimeout(TimeSpan timeout, ExceptionArgument argument)
		{
			long num = (long)timeout.TotalMilliseconds;
			if (num < -1 || num > 4294967294u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(argument, ExceptionResource.Task_InvalidTimerTimeSpan);
			}
			return (uint)num;
		}

		public static Task WhenAll(IEnumerable<Task> tasks)
		{
			if (tasks is ICollection<Task> collection)
			{
				if (tasks is Task[] tasks2)
				{
					return WhenAll(tasks2);
				}
				int num = 0;
				Task[] array = new Task[collection.Count];
				foreach (Task task in tasks)
				{
					if (task == null)
					{
						ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
					}
					array[num++] = task;
				}
				return InternalWhenAll(array);
			}
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			List<Task> list = new List<Task>();
			foreach (Task task2 in tasks)
			{
				if (task2 == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
				}
				list.Add(task2);
			}
			return InternalWhenAll(list.ToArray());
		}

		public static Task WhenAll(params Task[] tasks)
		{
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			int num = tasks.Length;
			if (num == 0)
			{
				return InternalWhenAll(tasks);
			}
			Task[] array = new Task[num];
			for (int i = 0; i < num; i++)
			{
				Task task = tasks[i];
				if (task == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
				}
				array[i] = task;
			}
			return InternalWhenAll(array);
		}

		private static Task InternalWhenAll(Task[] tasks)
		{
			if (tasks.Length != 0)
			{
				return new WhenAllPromise(tasks);
			}
			return CompletedTask;
		}

		public static Task<TResult[]> WhenAll<TResult>(IEnumerable<Task<TResult>> tasks)
		{
			if (tasks is Task<TResult>[] tasks2)
			{
				return WhenAll(tasks2);
			}
			if (tasks is ICollection<Task<TResult>> collection)
			{
				int num = 0;
				Task<TResult>[] array = new Task<TResult>[collection.Count];
				foreach (Task<TResult> task in tasks)
				{
					if (task == null)
					{
						ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
					}
					array[num++] = task;
				}
				return InternalWhenAll(array);
			}
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			List<Task<TResult>> list = new List<Task<TResult>>();
			foreach (Task<TResult> task2 in tasks)
			{
				if (task2 == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
				}
				list.Add(task2);
			}
			return InternalWhenAll(list.ToArray());
		}

		public static Task<TResult[]> WhenAll<TResult>(params Task<TResult>[] tasks)
		{
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			int num = tasks.Length;
			if (num == 0)
			{
				return InternalWhenAll(tasks);
			}
			Task<TResult>[] array = new Task<TResult>[num];
			for (int i = 0; i < num; i++)
			{
				Task<TResult> task = tasks[i];
				if (task == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
				}
				array[i] = task;
			}
			return InternalWhenAll(array);
		}

		private static Task<TResult[]> InternalWhenAll<TResult>(Task<TResult>[] tasks)
		{
			if (tasks.Length != 0)
			{
				return new WhenAllPromise<TResult>(tasks);
			}
			return new Task<TResult[]>(canceled: false, Array.Empty<TResult>(), TaskCreationOptions.None, default(CancellationToken));
		}

		public static Task<Task> WhenAny(params Task[] tasks)
		{
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			if (tasks.Length == 2)
			{
				return WhenAny(tasks[0], tasks[1]);
			}
			if (tasks.Length == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_EmptyTaskList, ExceptionArgument.tasks);
			}
			int num = tasks.Length;
			Task[] array = new Task[num];
			for (int i = 0; i < num; i++)
			{
				Task task = tasks[i];
				if (task == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
				}
				array[i] = task;
			}
			return TaskFactory.CommonCWAnyLogic(array);
		}

		public static Task<Task> WhenAny(Task task1, Task task2)
		{
			if (task1 != null && task2 != null)
			{
				if (!task1.IsCompleted)
				{
					if (!task2.IsCompleted)
					{
						return new TwoTaskWhenAnyPromise<Task>(task1, task2);
					}
					return FromResult(task2);
				}
				return FromResult(task1);
			}
			throw new ArgumentNullException((task1 == null) ? "task1" : "task2");
		}

		public static Task<Task> WhenAny(IEnumerable<Task> tasks)
		{
			if (tasks is ICollection<Task> collection)
			{
				if (tasks is Task[] tasks2)
				{
					return WhenAny(tasks2);
				}
				int count = collection.Count;
				if (count <= 0)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_EmptyTaskList, ExceptionArgument.tasks);
				}
				int num = 0;
				Task[] array = new Task[count];
				foreach (Task task in tasks)
				{
					if (task == null)
					{
						ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
					}
					array[num++] = task;
				}
				return TaskFactory.CommonCWAnyLogic(array);
			}
			if (tasks == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks);
			}
			List<Task> list = new List<Task>();
			foreach (Task task2 in tasks)
			{
				if (task2 == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_NullTask, ExceptionArgument.tasks);
				}
				list.Add(task2);
			}
			if (list.Count == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Task_MultiTaskContinuation_EmptyTaskList, ExceptionArgument.tasks);
			}
			return TaskFactory.CommonCWAnyLogic(list);
		}

		public static Task<Task<TResult>> WhenAny<TResult>(params Task<TResult>[] tasks)
		{
			if (tasks != null && tasks.Length == 2)
			{
				return WhenAny(tasks[0], tasks[1]);
			}
			Task<Task> task = WhenAny((Task[])tasks);
			return task.ContinueWith(Task<TResult>.TaskWhenAnyCast.Value, default(CancellationToken), TaskContinuationOptions.DenyChildAttach | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
		}

		public static Task<Task<TResult>> WhenAny<TResult>(Task<TResult> task1, Task<TResult> task2)
		{
			if (task1 != null && task2 != null)
			{
				if (!task1.IsCompleted)
				{
					if (!task2.IsCompleted)
					{
						return new TwoTaskWhenAnyPromise<Task<TResult>>(task1, task2);
					}
					return FromResult(task2);
				}
				return FromResult(task1);
			}
			throw new ArgumentNullException((task1 == null) ? "task1" : "task2");
		}

		public static Task<Task<TResult>> WhenAny<TResult>(IEnumerable<Task<TResult>> tasks)
		{
			Task<Task> task = WhenAny((IEnumerable<Task>)tasks);
			return task.ContinueWith(Task<TResult>.TaskWhenAnyCast.Value, default(CancellationToken), TaskContinuationOptions.DenyChildAttach | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
		}

		internal static Task<TResult> CreateUnwrapPromise<TResult>(Task outerTask, bool lookForOce)
		{
			return new UnwrapPromise<TResult>(outerTask, lookForOce);
		}

		internal virtual Delegate[] GetDelegateContinuationsForDebugger()
		{
			if (m_continuationObject != this)
			{
				return GetDelegatesFromContinuationObject(m_continuationObject);
			}
			return null;
		}

		private static Delegate[] GetDelegatesFromContinuationObject(object continuationObject)
		{
			if (continuationObject != null)
			{
				if (continuationObject is Action action)
				{
					return new Delegate[1] { AsyncMethodBuilderCore.TryGetStateMachineForDebugger(action) };
				}
				if (continuationObject is TaskContinuation taskContinuation)
				{
					return taskContinuation.GetDelegateContinuationsForDebugger();
				}
				if (continuationObject is Task task)
				{
					Delegate[] delegateContinuationsForDebugger = task.GetDelegateContinuationsForDebugger();
					if (delegateContinuationsForDebugger != null)
					{
						return delegateContinuationsForDebugger;
					}
				}
				if (continuationObject is ITaskCompletionAction taskCompletionAction)
				{
					return new Delegate[1]
					{
						new Action<Task>(taskCompletionAction.Invoke)
					};
				}
				if (continuationObject is List<object> list)
				{
					List<Delegate> list2 = new List<Delegate>();
					foreach (object item in list)
					{
						Delegate[] delegatesFromContinuationObject = GetDelegatesFromContinuationObject(item);
						if (delegatesFromContinuationObject == null)
						{
							continue;
						}
						Delegate[] array = delegatesFromContinuationObject;
						foreach (Delegate @delegate in array)
						{
							if ((object)@delegate != null)
							{
								list2.Add(@delegate);
							}
						}
					}
					return list2.ToArray();
				}
			}
			return null;
		}

		private static Task GetActiveTaskFromId(int taskId)
		{
			Task value = null;
			s_currentActiveTasks?.TryGetValue(taskId, out value);
			return value;
		}
	}
	internal sealed class CompletionActionInvoker : IThreadPoolWorkItem
	{
		private readonly ITaskCompletionAction m_action;

		private readonly Task m_completingTask;

		internal CompletionActionInvoker(ITaskCompletionAction action, Task completingTask)
		{
			m_action = action;
			m_completingTask = completingTask;
		}

		void IThreadPoolWorkItem.Execute()
		{
			m_action.Invoke(m_completingTask);
		}
	}
	internal sealed class SystemThreadingTasks_TaskDebugView
	{
		private readonly Task m_task;

		public object AsyncState => m_task.AsyncState;

		public TaskCreationOptions CreationOptions => m_task.CreationOptions;

		public Exception Exception => m_task.Exception;

		public int Id => m_task.Id;

		public bool CancellationPending
		{
			get
			{
				if (m_task.Status == TaskStatus.WaitingToRun)
				{
					return m_task.CancellationToken.IsCancellationRequested;
				}
				return false;
			}
		}

		public TaskStatus Status => m_task.Status;

		public SystemThreadingTasks_TaskDebugView(Task task)
		{
			m_task = task;
		}
	}
	[Flags]
	public enum TaskCreationOptions
	{
		None = 0,
		PreferFairness = 1,
		LongRunning = 2,
		AttachedToParent = 4,
		DenyChildAttach = 8,
		HideScheduler = 0x10,
		RunContinuationsAsynchronously = 0x40
	}
	[Flags]
	internal enum InternalTaskOptions
	{
		None = 0,
		InternalOptionsMask = 0xFF00,
		ContinuationTask = 0x200,
		PromiseTask = 0x400,
		LazyCancellation = 0x1000,
		QueuedByRuntime = 0x2000,
		DoNotDispose = 0x4000
	}
	[Flags]
	public enum TaskContinuationOptions
	{
		None = 0,
		PreferFairness = 1,
		LongRunning = 2,
		AttachedToParent = 4,
		DenyChildAttach = 8,
		HideScheduler = 0x10,
		LazyCancellation = 0x20,
		RunContinuationsAsynchronously = 0x40,
		NotOnRanToCompletion = 0x10000,
		NotOnFaulted = 0x20000,
		NotOnCanceled = 0x40000,
		OnlyOnRanToCompletion = 0x60000,
		OnlyOnFaulted = 0x50000,
		OnlyOnCanceled = 0x30000,
		ExecuteSynchronously = 0x80000
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct VoidTaskResult
	{
	}
	internal interface ITaskCompletionAction
	{
		bool InvokeMayRunArbitraryCode { get; }

		void Invoke(Task completingTask);
	}
	internal sealed class UnwrapPromise<TResult> : Task<TResult>, ITaskCompletionAction
	{
		private byte _state;

		private readonly bool _lookForOce;

		public bool InvokeMayRunArbitraryCode => true;

		public UnwrapPromise(Task outerTask, bool lookForOce)
			: base((object)null, outerTask.CreationOptions & TaskCreationOptions.AttachedToParent)
		{
			_lookForOce = lookForOce;
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(base.Id, "Task.Unwrap", 0L);
			}
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(this);
			}
			if (outerTask.IsCompleted)
			{
				ProcessCompletedOuterTask(outerTask);
			}
			else
			{
				outerTask.AddCompletionAction(this);
			}
		}

		public void Invoke(Task completingTask)
		{
			if (RuntimeHelpers.TryEnsureSufficientExecutionStack())
			{
				InvokeCore(completingTask);
			}
			else
			{
				InvokeCoreAsync(completingTask);
			}
		}

		private void InvokeCore(Task completingTask)
		{
			switch (_state)
			{
			case 0:
				ProcessCompletedOuterTask(completingTask);
				break;
			case 1:
			{
				bool flag = TrySetFromTask(completingTask, lookForOce: false);
				_state = 2;
				break;
			}
			}
		}

		private void InvokeCoreAsync(Task completingTask)
		{
			ThreadPool.UnsafeQueueUserWorkItem(delegate(object state)
			{
				TupleSlim<UnwrapPromise<TResult>, Task> tupleSlim = (TupleSlim<UnwrapPromise<TResult>, Task>)state;
				tupleSlim.Item1.InvokeCore(tupleSlim.Item2);
			}, new TupleSlim<UnwrapPromise<TResult>, Task>(this, completingTask));
		}

		private void ProcessCompletedOuterTask(Task task)
		{
			_state = 1;
			switch (task.Status)
			{
			case TaskStatus.Canceled:
			case TaskStatus.Faulted:
			{
				bool flag = TrySetFromTask(task, _lookForOce);
				break;
			}
			case TaskStatus.RanToCompletion:
				ProcessInnerTask((task is Task<Task<TResult>> task2) ? task2.Result : ((Task<Task>)task).Result);
				break;
			}
		}

		private bool TrySetFromTask(Task task, bool lookForOce)
		{
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationRelation(base.Id, CausalityRelation.Join);
			}
			bool result = false;
			switch (task.Status)
			{
			case TaskStatus.Canceled:
				result = TrySetCanceled(task.CancellationToken, task.GetCancellationExceptionDispatchInfo());
				break;
			case TaskStatus.Faulted:
			{
				List<ExceptionDispatchInfo> exceptionDispatchInfos = task.GetExceptionDispatchInfos();
				ExceptionDispatchInfo exceptionDispatchInfo;
				result = ((!lookForOce || exceptionDispatchInfos.Count <= 0 || (exceptionDispatchInfo = exceptionDispatchInfos[0]) == null || !(exceptionDispatchInfo.SourceException is OperationCanceledException ex)) ? TrySetException(exceptionDispatchInfos) : TrySetCanceled(ex.CancellationToken, exceptionDispatchInfo));
				break;
			}
			case TaskStatus.RanToCompletion:
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationEnd(base.Id, AsyncCausalityStatus.Completed);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.RemoveFromActiveTasks(this);
				}
				result = TrySetResult((task is Task<TResult> task2) ? task2.Result : default(TResult));
				break;
			}
			return result;
		}

		private void ProcessInnerTask(Task task)
		{
			if (task == null)
			{
				TrySetCanceled(default(CancellationToken));
				_state = 2;
			}
			else if (task.IsCompleted)
			{
				TrySetFromTask(task, lookForOce: false);
				_state = 2;
			}
			else
			{
				task.AddCompletionAction(this);
			}
		}
	}
	public static class TaskAsyncEnumerableExtensions
	{
		public static ConfiguredAsyncDisposable ConfigureAwait(this IAsyncDisposable source, bool continueOnCapturedContext)
		{
			return new ConfiguredAsyncDisposable(source, continueOnCapturedContext);
		}

		public static ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait<T>(this IAsyncEnumerable<T> source, bool continueOnCapturedContext)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(source, continueOnCapturedContext, default(CancellationToken));
		}

		public static ConfiguredCancelableAsyncEnumerable<T> WithCancellation<T>(this IAsyncEnumerable<T> source, CancellationToken cancellationToken)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(source, continueOnCapturedContext: true, cancellationToken);
		}
	}
	internal static class TaskCache
	{
		internal static readonly Task<bool> s_trueTask = CreateCacheableTask(result: true);

		internal static readonly Task<bool> s_falseTask = CreateCacheableTask(result: false);

		internal static readonly Task<int>[] s_int32Tasks = CreateInt32Tasks();

		internal static Task<TResult> CreateCacheableTask<TResult>(TResult result)
		{
			return new Task<TResult>(canceled: false, result, (TaskCreationOptions)16384, default(CancellationToken));
		}

		private static Task<int>[] CreateInt32Tasks()
		{
			Task<int>[] array = new Task<int>[10];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = CreateCacheableTask(i + -1);
			}
			return array;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class TaskCanceledException : OperationCanceledException
	{
		[NonSerialized]
		private readonly Task _canceledTask;

		public Task? Task => _canceledTask;

		public TaskCanceledException()
			: base(SR.TaskCanceledException_ctor_DefaultMessage)
		{
		}

		public TaskCanceledException(string? message)
			: base(message)
		{
		}

		public TaskCanceledException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		public TaskCanceledException(string? message, Exception? innerException, CancellationToken token)
			: base(message, innerException, token)
		{
		}

		public TaskCanceledException(Task? task)
			: base(SR.TaskCanceledException_ctor_DefaultMessage, task?.CancellationToken ?? CancellationToken.None)
		{
			_canceledTask = task;
		}

		protected TaskCanceledException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public class TaskCompletionSource
	{
		private readonly Task _task;

		public Task Task => _task;

		public TaskCompletionSource()
		{
			_task = new Task();
		}

		public TaskCompletionSource(TaskCreationOptions creationOptions)
			: this(null, creationOptions)
		{
		}

		public TaskCompletionSource(object? state)
			: this(state, TaskCreationOptions.None)
		{
		}

		public TaskCompletionSource(object? state, TaskCreationOptions creationOptions)
		{
			_task = new Task(state, creationOptions, promiseStyle: true);
		}

		public void SetException(Exception exception)
		{
			if (!TrySetException(exception))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public void SetException(IEnumerable<Exception> exceptions)
		{
			if (!TrySetException(exceptions))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public bool TrySetException(Exception exception)
		{
			if (exception == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exception);
			}
			bool flag = _task.TrySetException(exception);
			if (!flag && !_task.IsCompleted)
			{
				_task.SpinUntilCompleted();
			}
			return flag;
		}

		public bool TrySetException(IEnumerable<Exception> exceptions)
		{
			if (exceptions == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exceptions);
			}
			List<Exception> list = new List<Exception>();
			foreach (Exception exception in exceptions)
			{
				if (exception == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.TaskCompletionSourceT_TrySetException_NullException, ExceptionArgument.exceptions);
				}
				list.Add(exception);
			}
			if (list.Count == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.TaskCompletionSourceT_TrySetException_NoExceptions, ExceptionArgument.exceptions);
			}
			bool flag = _task.TrySetException(list);
			if (!flag && !_task.IsCompleted)
			{
				_task.SpinUntilCompleted();
			}
			return flag;
		}

		public void SetResult()
		{
			if (!TrySetResult())
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public bool TrySetResult()
		{
			bool flag = _task.TrySetResult();
			if (!flag)
			{
				_task.SpinUntilCompleted();
			}
			return flag;
		}

		public void SetCanceled()
		{
			SetCanceled(default(CancellationToken));
		}

		public void SetCanceled(CancellationToken cancellationToken)
		{
			if (!TrySetCanceled(cancellationToken))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public bool TrySetCanceled()
		{
			return TrySetCanceled(default(CancellationToken));
		}

		public bool TrySetCanceled(CancellationToken cancellationToken)
		{
			bool flag = _task.TrySetCanceled(cancellationToken);
			if (!flag && !_task.IsCompleted)
			{
				_task.SpinUntilCompleted();
			}
			return flag;
		}
	}
	public class TaskCompletionSource<TResult>
	{
		private readonly Task<TResult> _task;

		public Task<TResult> Task => _task;

		public TaskCompletionSource()
		{
			_task = new Task<TResult>();
		}

		public TaskCompletionSource(TaskCreationOptions creationOptions)
			: this((object?)null, creationOptions)
		{
		}

		public TaskCompletionSource(object? state)
			: this(state, TaskCreationOptions.None)
		{
		}

		public TaskCompletionSource(object? state, TaskCreationOptions creationOptions)
		{
			_task = new Task<TResult>(state, creationOptions);
		}

		public void SetException(Exception exception)
		{
			if (!TrySetException(exception))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public void SetException(IEnumerable<Exception> exceptions)
		{
			if (!TrySetException(exceptions))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public bool TrySetException(Exception exception)
		{
			if (exception == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exception);
			}
			bool flag = _task.TrySetException(exception);
			if (!flag && !_task.IsCompleted)
			{
				_task.SpinUntilCompleted();
			}
			return flag;
		}

		public bool TrySetException(IEnumerable<Exception> exceptions)
		{
			if (exceptions == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exceptions);
			}
			List<Exception> list = new List<Exception>();
			foreach (Exception exception in exceptions)
			{
				if (exception == null)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.TaskCompletionSourceT_TrySetException_NullException, ExceptionArgument.exceptions);
				}
				list.Add(exception);
			}
			if (list.Count == 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.TaskCompletionSourceT_TrySetException_NoExceptions, ExceptionArgument.exceptions);
			}
			bool flag = _task.TrySetException(list);
			if (!flag && !_task.IsCompleted)
			{
				_task.SpinUntilCompleted();
			}
			return flag;
		}

		public void SetResult(TResult result)
		{
			if (!TrySetResult(result))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public bool TrySetResult(TResult result)
		{
			bool flag = _task.TrySetResult(result);
			if (!flag)
			{
				_task.SpinUntilCompleted();
			}
			return flag;
		}

		public void SetCanceled()
		{
			SetCanceled(default(CancellationToken));
		}

		public void SetCanceled(CancellationToken cancellationToken)
		{
			if (!TrySetCanceled(cancellationToken))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public bool TrySetCanceled()
		{
			return TrySetCanceled(default(CancellationToken));
		}

		public bool TrySetCanceled(CancellationToken cancellationToken)
		{
			bool flag = _task.TrySetCanceled(cancellationToken);
			if (!flag && !_task.IsCompleted)
			{
				_task.SpinUntilCompleted();
			}
			return flag;
		}
	}
	internal sealed class ContinuationTaskFromTask : Task
	{
		private Task m_antecedent;

		public ContinuationTaskFromTask(Task antecedent, Delegate action, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions)
			: base(action, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, null)
		{
			m_antecedent = antecedent;
		}

		internal override void InnerInvoke()
		{
			Task antecedent = m_antecedent;
			m_antecedent = null;
			antecedent.NotifyDebuggerOfWaitCompletionIfNecessary();
			if (m_action is Action<Task> action)
			{
				action(antecedent);
			}
			else if (m_action is Action<Task, object> action2)
			{
				action2(antecedent, m_stateObject);
			}
		}
	}
	internal sealed class ContinuationResultTaskFromTask<TResult> : Task<TResult>
	{
		private Task m_antecedent;

		public ContinuationResultTaskFromTask(Task antecedent, Delegate function, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions)
			: base(function, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, (TaskScheduler)null)
		{
			m_antecedent = antecedent;
		}

		internal override void InnerInvoke()
		{
			Task antecedent = m_antecedent;
			m_antecedent = null;
			antecedent.NotifyDebuggerOfWaitCompletionIfNecessary();
			if (m_action is Func<Task, TResult> func)
			{
				m_result = func(antecedent);
			}
			else if (m_action is Func<Task, object, TResult> func2)
			{
				m_result = func2(antecedent, m_stateObject);
			}
		}
	}
	internal sealed class ContinuationTaskFromResultTask<TAntecedentResult> : Task
	{
		private Task<TAntecedentResult> m_antecedent;

		public ContinuationTaskFromResultTask(Task<TAntecedentResult> antecedent, Delegate action, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions)
			: base(action, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, null)
		{
			m_antecedent = antecedent;
		}

		internal override void InnerInvoke()
		{
			Task<TAntecedentResult> antecedent = m_antecedent;
			m_antecedent = null;
			antecedent.NotifyDebuggerOfWaitCompletionIfNecessary();
			if (m_action is Action<Task<TAntecedentResult>> action)
			{
				action(antecedent);
			}
			else if (m_action is Action<Task<TAntecedentResult>, object> action2)
			{
				action2(antecedent, m_stateObject);
			}
		}
	}
	internal sealed class ContinuationResultTaskFromResultTask<TAntecedentResult, TResult> : Task<TResult>
	{
		private Task<TAntecedentResult> m_antecedent;

		public ContinuationResultTaskFromResultTask(Task<TAntecedentResult> antecedent, Delegate function, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions)
			: base(function, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, (TaskScheduler)null)
		{
			m_antecedent = antecedent;
		}

		internal override void InnerInvoke()
		{
			Task<TAntecedentResult> antecedent = m_antecedent;
			m_antecedent = null;
			antecedent.NotifyDebuggerOfWaitCompletionIfNecessary();
			if (m_action is Func<Task<TAntecedentResult>, TResult> func)
			{
				m_result = func(antecedent);
			}
			else if (m_action is Func<Task<TAntecedentResult>, object, TResult> func2)
			{
				m_result = func2(antecedent, m_stateObject);
			}
		}
	}
	internal abstract class TaskContinuation
	{
		internal abstract void Run(Task completedTask, bool canInlineContinuationTask);

		protected static void InlineIfPossibleOrElseQueue(Task task, bool needsProtection)
		{
			if (needsProtection)
			{
				if (!task.MarkStarted())
				{
					return;
				}
			}
			else
			{
				task.m_stateFlags |= 65536;
			}
			try
			{
				if (!task.m_taskScheduler.TryRunInline(task, taskWasPreviouslyQueued: false))
				{
					task.m_taskScheduler.InternalQueueTask(task);
				}
			}
			catch (Exception innerException)
			{
				TaskSchedulerException exceptionObject = new TaskSchedulerException(innerException);
				task.AddException(exceptionObject);
				task.Finish(userDelegateExecute: false);
			}
		}

		internal abstract Delegate[] GetDelegateContinuationsForDebugger();
	}
	internal sealed class ContinueWithTaskContinuation : TaskContinuation
	{
		internal Task m_task;

		internal readonly TaskContinuationOptions m_options;

		private readonly TaskScheduler m_taskScheduler;

		internal ContinueWithTaskContinuation(Task task, TaskContinuationOptions options, TaskScheduler scheduler)
		{
			m_task = task;
			m_options = options;
			m_taskScheduler = scheduler;
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(m_task.Id, "Task.ContinueWith: " + task.m_action.Method.Name, 0L);
			}
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(m_task);
			}
		}

		internal override void Run(Task completedTask, bool canInlineContinuationTask)
		{
			Task task = m_task;
			m_task = null;
			TaskContinuationOptions options = m_options;
			if (completedTask.IsCompletedSuccessfully ? ((options & TaskContinuationOptions.NotOnRanToCompletion) == 0) : (completedTask.IsCanceled ? ((options & TaskContinuationOptions.NotOnCanceled) == 0) : ((options & TaskContinuationOptions.NotOnFaulted) == 0)))
			{
				if (TplEventSource.Log.IsEnabled() && !task.IsCanceled)
				{
					TplEventSource.Log.TraceOperationRelation(task.Id, CausalityRelation.AssignDelegate);
				}
				task.m_taskScheduler = m_taskScheduler;
				if (!canInlineContinuationTask || (options & TaskContinuationOptions.ExecuteSynchronously) == 0)
				{
					try
					{
						task.ScheduleAndStart(needsProtection: true);
						return;
					}
					catch (TaskSchedulerException)
					{
						return;
					}
				}
				TaskContinuation.InlineIfPossibleOrElseQueue(task, needsProtection: true);
			}
			else
			{
				Task.ContingentProperties contingentProperties = task.m_contingentProperties;
				if (contingentProperties == null || contingentProperties.m_cancellationToken == default(CancellationToken))
				{
					task.InternalCancelContinueWithInitialState();
				}
				else
				{
					task.InternalCancel();
				}
			}
		}

		internal override Delegate[] GetDelegateContinuationsForDebugger()
		{
			if (m_task != null)
			{
				if ((object)m_task.m_action != null)
				{
					return new Delegate[1] { m_task.m_action };
				}
				return m_task.GetDelegateContinuationsForDebugger();
			}
			return null;
		}
	}
	internal sealed class SynchronizationContextAwaitTaskContinuation : AwaitTaskContinuation
	{
		private static readonly SendOrPostCallback s_postCallback = delegate(object state)
		{
			((Action)state)();
		};

		private static ContextCallback s_postActionCallback;

		private readonly SynchronizationContext m_syncContext;

		internal SynchronizationContextAwaitTaskContinuation(SynchronizationContext context, Action action, bool flowExecutionContext)
			: base(action, flowExecutionContext)
		{
			m_syncContext = context;
		}

		internal sealed override void Run(Task task, bool canInlineContinuationTask)
		{
			if (canInlineContinuationTask && m_syncContext == SynchronizationContext.Current)
			{
				RunCallback(AwaitTaskContinuation.GetInvokeActionCallback(), m_action, ref Task.t_currentTask);
				return;
			}
			TplEventSource log = TplEventSource.Log;
			if (log.IsEnabled())
			{
				m_continuationId = Task.NewId();
				log.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, m_continuationId);
			}
			RunCallback(GetPostActionCallback(), this, ref Task.t_currentTask);
		}

		private static void PostAction(object state)
		{
			SynchronizationContextAwaitTaskContinuation synchronizationContextAwaitTaskContinuation = (SynchronizationContextAwaitTaskContinuation)state;
			TplEventSource log = TplEventSource.Log;
			if (log.IsEnabled() && log.TasksSetActivityIds && synchronizationContextAwaitTaskContinuation.m_continuationId != 0)
			{
				synchronizationContextAwaitTaskContinuation.m_syncContext.Post(s_postCallback, GetActionLogDelegate(synchronizationContextAwaitTaskContinuation.m_continuationId, synchronizationContextAwaitTaskContinuation.m_action));
			}
			else
			{
				synchronizationContextAwaitTaskContinuation.m_syncContext.Post(s_postCallback, synchronizationContextAwaitTaskContinuation.m_action);
			}
		}

		private static Action GetActionLogDelegate(int continuationId, Action action)
		{
			return delegate
			{
				Guid activityId = TplEventSource.CreateGuidForTaskID(continuationId);
				EventSource.SetCurrentThreadActivityId(activityId, out var oldActivityThatWillContinue);
				try
				{
					action();
				}
				finally
				{
					EventSource.SetCurrentThreadActivityId(oldActivityThatWillContinue);
				}
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ContextCallback GetPostActionCallback()
		{
			return PostAction;
		}
	}
	internal sealed class TaskSchedulerAwaitTaskContinuation : AwaitTaskContinuation
	{
		private readonly TaskScheduler m_scheduler;

		internal TaskSchedulerAwaitTaskContinuation(TaskScheduler scheduler, Action action, bool flowExecutionContext)
			: base(action, flowExecutionContext)
		{
			m_scheduler = scheduler;
		}

		internal sealed override void Run(Task ignored, bool canInlineContinuationTask)
		{
			if (m_scheduler == TaskScheduler.Default)
			{
				base.Run(ignored, canInlineContinuationTask);
				return;
			}
			bool flag = canInlineContinuationTask && (TaskScheduler.InternalCurrent == m_scheduler || Thread.CurrentThread.IsThreadPoolThread);
			Task task = CreateTask(delegate(object state)
			{
				try
				{
					((Action)state)();
				}
				catch (Exception exception)
				{
					Task.ThrowAsync(exception, null);
				}
			}, m_action, m_scheduler);
			if (flag)
			{
				TaskContinuation.InlineIfPossibleOrElseQueue(task, needsProtection: false);
				return;
			}
			try
			{
				task.ScheduleAndStart(needsProtection: false);
			}
			catch (TaskSchedulerException)
			{
			}
		}
	}
	internal class AwaitTaskContinuation : TaskContinuation, IThreadPoolWorkItem
	{
		private readonly ExecutionContext m_capturedContext;

		protected readonly Action m_action;

		protected int m_continuationId;

		private static readonly ContextCallback s_invokeContextCallback = delegate(object state)
		{
			((Action)state)();
		};

		private static readonly Action<Action> s_invokeAction = delegate(Action action)
		{
			action();
		};

		internal static bool IsValidLocationForInlining
		{
			get
			{
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && current.GetType() != typeof(SynchronizationContext))
				{
					return false;
				}
				TaskScheduler internalCurrent = TaskScheduler.InternalCurrent;
				if (internalCurrent != null)
				{
					return internalCurrent == TaskScheduler.Default;
				}
				return true;
			}
		}

		internal AwaitTaskContinuation(Action action, bool flowExecutionContext)
		{
			m_action = action;
			if (flowExecutionContext)
			{
				m_capturedContext = ExecutionContext.Capture();
			}
		}

		protected Task CreateTask(Action<object> action, object state, TaskScheduler scheduler)
		{
			return new Task(action, state, null, default(CancellationToken), TaskCreationOptions.None, InternalTaskOptions.QueuedByRuntime, scheduler)
			{
				CapturedContext = m_capturedContext
			};
		}

		internal override void Run(Task task, bool canInlineContinuationTask)
		{
			if (canInlineContinuationTask && IsValidLocationForInlining)
			{
				RunCallback(GetInvokeActionCallback(), m_action, ref Task.t_currentTask);
				return;
			}
			TplEventSource log = TplEventSource.Log;
			if (log.IsEnabled())
			{
				m_continuationId = Task.NewId();
				log.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, m_continuationId);
			}
			ThreadPool.UnsafeQueueUserWorkItemInternal(this, preferLocal: true);
		}

		void IThreadPoolWorkItem.Execute()
		{
			TplEventSource log = TplEventSource.Log;
			ExecutionContext capturedContext = m_capturedContext;
			if (!log.IsEnabled() && capturedContext == null)
			{
				m_action();
				return;
			}
			Guid oldActivityThatWillContinue = default(Guid);
			if (log.IsEnabled() && log.TasksSetActivityIds && m_continuationId != 0)
			{
				Guid activityId = TplEventSource.CreateGuidForTaskID(m_continuationId);
				EventSource.SetCurrentThreadActivityId(activityId, out oldActivityThatWillContinue);
			}
			try
			{
				if (capturedContext == null || capturedContext.IsDefault)
				{
					m_action();
				}
				else
				{
					ExecutionContext.RunForThreadPoolUnsafe(capturedContext, s_invokeAction, in m_action);
				}
			}
			finally
			{
				if (log.IsEnabled() && log.TasksSetActivityIds && m_continuationId != 0)
				{
					EventSource.SetCurrentThreadActivityId(oldActivityThatWillContinue);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected static ContextCallback GetInvokeActionCallback()
		{
			return s_invokeContextCallback;
		}

		protected void RunCallback(ContextCallback callback, object state, ref Task currentTask)
		{
			Task task = currentTask;
			try
			{
				if (task != null)
				{
					currentTask = null;
				}
				ExecutionContext capturedContext = m_capturedContext;
				if (capturedContext == null)
				{
					callback(state);
				}
				else
				{
					ExecutionContext.RunInternal(capturedContext, callback, state);
				}
			}
			catch (Exception exception)
			{
				Task.ThrowAsync(exception, null);
			}
			finally
			{
				if (task != null)
				{
					currentTask = task;
				}
			}
		}

		internal static void RunOrScheduleAction(Action action, bool allowInlining)
		{
			Task t_currentTask = Task.t_currentTask;
			if (!allowInlining || !IsValidLocationForInlining)
			{
				UnsafeScheduleAction(action, t_currentTask);
				return;
			}
			try
			{
				if (t_currentTask != null)
				{
					Task.t_currentTask = null;
				}
				action();
			}
			catch (Exception exception)
			{
				Task.ThrowAsync(exception, null);
			}
			finally
			{
				if (t_currentTask != null)
				{
					Task.t_currentTask = t_currentTask;
				}
			}
		}

		internal static void RunOrScheduleAction(IAsyncStateMachineBox box, bool allowInlining)
		{
			Task t_currentTask = Task.t_currentTask;
			if (!allowInlining || !IsValidLocationForInlining)
			{
				if (TplEventSource.Log.IsEnabled())
				{
					UnsafeScheduleAction(box.MoveNextAction, t_currentTask);
				}
				else
				{
					ThreadPool.UnsafeQueueUserWorkItemInternal(box, preferLocal: true);
				}
				return;
			}
			try
			{
				if (t_currentTask != null)
				{
					Task.t_currentTask = null;
				}
				box.MoveNext();
			}
			catch (Exception exception)
			{
				Task.ThrowAsync(exception, null);
			}
			finally
			{
				if (t_currentTask != null)
				{
					Task.t_currentTask = t_currentTask;
				}
			}
		}

		internal static void UnsafeScheduleAction(Action action, Task task)
		{
			AwaitTaskContinuation awaitTaskContinuation = new AwaitTaskContinuation(action, flowExecutionContext: false);
			TplEventSource log = TplEventSource.Log;
			if (log.IsEnabled() && task != null)
			{
				awaitTaskContinuation.m_continuationId = Task.NewId();
				log.AwaitTaskContinuationScheduled((task.ExecutingTaskScheduler ?? TaskScheduler.Default).Id, task.Id, awaitTaskContinuation.m_continuationId);
			}
			ThreadPool.UnsafeQueueUserWorkItemInternal(awaitTaskContinuation, preferLocal: true);
		}

		internal override Delegate[] GetDelegateContinuationsForDebugger()
		{
			return new Delegate[1] { AsyncMethodBuilderCore.TryGetStateMachineForDebugger(m_action) };
		}
	}
	internal sealed class TaskExceptionHolder
	{
		private readonly Task m_task;

		private volatile List<ExceptionDispatchInfo> m_faultExceptions;

		private ExceptionDispatchInfo m_cancellationException;

		private volatile bool m_isHandled;

		internal bool ContainsFaultList => m_faultExceptions != null;

		internal TaskExceptionHolder(Task task)
		{
			m_task = task;
		}

		~TaskExceptionHolder()
		{
			if (m_faultExceptions != null && !m_isHandled)
			{
				AggregateException exception = new AggregateException(SR.TaskExceptionHolder_UnhandledException, m_faultExceptions);
				UnobservedTaskExceptionEventArgs ueea = new UnobservedTaskExceptionEventArgs(exception);
				TaskScheduler.PublishUnobservedTaskException(m_task, ueea);
			}
		}

		internal void Add(object exceptionObject, bool representsCancellation)
		{
			if (representsCancellation)
			{
				SetCancellationException(exceptionObject);
			}
			else
			{
				AddFaultException(exceptionObject);
			}
		}

		private void SetCancellationException(object exceptionObject)
		{
			if (exceptionObject is OperationCanceledException source)
			{
				m_cancellationException = ExceptionDispatchInfo.Capture(source);
			}
			else
			{
				ExceptionDispatchInfo cancellationException = exceptionObject as ExceptionDispatchInfo;
				m_cancellationException = cancellationException;
			}
			MarkAsHandled(calledFromFinalizer: false);
		}

		private void AddFaultException(object exceptionObject)
		{
			List<ExceptionDispatchInfo> list = m_faultExceptions;
			if (list == null)
			{
				list = (m_faultExceptions = new List<ExceptionDispatchInfo>(1));
			}
			if (exceptionObject is Exception source)
			{
				list.Add(ExceptionDispatchInfo.Capture(source));
			}
			else if (exceptionObject is ExceptionDispatchInfo item)
			{
				list.Add(item);
			}
			else if (exceptionObject is IEnumerable<Exception> enumerable)
			{
				foreach (Exception item2 in enumerable)
				{
					list.Add(ExceptionDispatchInfo.Capture(item2));
				}
			}
			else
			{
				if (!(exceptionObject is IEnumerable<ExceptionDispatchInfo> collection))
				{
					throw new ArgumentException(SR.TaskExceptionHolder_UnknownExceptionType, "exceptionObject");
				}
				list.AddRange(collection);
			}
			if (list.Count > 0)
			{
				MarkAsUnhandled();
			}
		}

		private void MarkAsUnhandled()
		{
			if (m_isHandled)
			{
				GC.ReRegisterForFinalize(this);
				m_isHandled = false;
			}
		}

		internal void MarkAsHandled(bool calledFromFinalizer)
		{
			if (!m_isHandled)
			{
				if (!calledFromFinalizer)
				{
					GC.SuppressFinalize(this);
				}
				m_isHandled = true;
			}
		}

		internal AggregateException CreateExceptionObject(bool calledFromFinalizer, Exception includeThisException)
		{
			List<ExceptionDispatchInfo> faultExceptions = m_faultExceptions;
			MarkAsHandled(calledFromFinalizer);
			if (includeThisException == null)
			{
				return new AggregateException(faultExceptions);
			}
			Exception[] array = new Exception[faultExceptions.Count + 1];
			for (int i = 0; i < array.Length - 1; i++)
			{
				array[i] = faultExceptions[i].SourceException;
			}
			array[^1] = includeThisException;
			return new AggregateException(array);
		}

		internal List<ExceptionDispatchInfo> GetExceptionDispatchInfos()
		{
			List<ExceptionDispatchInfo> faultExceptions = m_faultExceptions;
			MarkAsHandled(calledFromFinalizer: false);
			return faultExceptions;
		}

		internal ExceptionDispatchInfo GetCancellationExceptionDispatchInfo()
		{
			return m_cancellationException;
		}
	}
	public static class TaskExtensions
	{
		public static Task Unwrap(this Task<Task> task)
		{
			if (task == null)
			{
				throw new ArgumentNullException("task");
			}
			object task2;
			if (task.IsCompletedSuccessfully)
			{
				task2 = task.Result;
				if (task2 == null)
				{
					return Task.FromCanceled(new CancellationToken(canceled: true));
				}
			}
			else
			{
				task2 = Task.CreateUnwrapPromise<VoidTaskResult>(task, lookForOce: false);
			}
			return (Task)task2;
		}

		public static Task<TResult> Unwrap<TResult>(this Task<Task<TResult>> task)
		{
			if (task == null)
			{
				throw new ArgumentNullException("task");
			}
			Task<TResult> task2;
			if (task.IsCompletedSuccessfully)
			{
				task2 = task.Result;
				if (task2 == null)
				{
					return Task.FromCanceled<TResult>(new CancellationToken(canceled: true));
				}
			}
			else
			{
				task2 = Task.CreateUnwrapPromise<TResult>(task, lookForOce: false);
			}
			return task2;
		}
	}
	public class TaskFactory
	{
		private sealed class CompleteOnCountdownPromise : Task<Task[]>, ITaskCompletionAction
		{
			private readonly Task[] _tasks;

			private int _count;

			public bool InvokeMayRunArbitraryCode => true;

			private protected override bool ShouldNotifyDebuggerOfWaitCompletion
			{
				get
				{
					if (base.ShouldNotifyDebuggerOfWaitCompletion)
					{
						return Task.AnyTaskRequiresNotifyDebuggerOfWaitCompletion(_tasks);
					}
					return false;
				}
			}

			internal CompleteOnCountdownPromise(Task[] tasksCopy)
			{
				_tasks = tasksCopy;
				_count = tasksCopy.Length;
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationBegin(base.Id, "TaskFactory.ContinueWhenAll", 0L);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.AddToActiveTasks(this);
				}
			}

			public void Invoke(Task completingTask)
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationRelation(base.Id, CausalityRelation.Join);
				}
				if (completingTask.IsWaitNotificationEnabled)
				{
					SetNotificationForWaitCompletion(enabled: true);
				}
				if (Interlocked.Decrement(ref _count) == 0)
				{
					if (TplEventSource.Log.IsEnabled())
					{
						TplEventSource.Log.TraceOperationEnd(base.Id, AsyncCausalityStatus.Completed);
					}
					if (Task.s_asyncDebuggingEnabled)
					{
						Task.RemoveFromActiveTasks(this);
					}
					TrySetResult(_tasks);
				}
			}
		}

		private sealed class CompleteOnCountdownPromise<T> : Task<Task<T>[]>, ITaskCompletionAction
		{
			private readonly Task<T>[] _tasks;

			private int _count;

			public bool InvokeMayRunArbitraryCode => true;

			private protected override bool ShouldNotifyDebuggerOfWaitCompletion
			{
				get
				{
					if (base.ShouldNotifyDebuggerOfWaitCompletion)
					{
						Task[] tasks = _tasks;
						return Task.AnyTaskRequiresNotifyDebuggerOfWaitCompletion(tasks);
					}
					return false;
				}
			}

			internal CompleteOnCountdownPromise(Task<T>[] tasksCopy)
			{
				_tasks = tasksCopy;
				_count = tasksCopy.Length;
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationBegin(base.Id, "TaskFactory.ContinueWhenAll<>", 0L);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.AddToActiveTasks(this);
				}
			}

			public void Invoke(Task completingTask)
			{
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationRelation(base.Id, CausalityRelation.Join);
				}
				if (completingTask.IsWaitNotificationEnabled)
				{
					SetNotificationForWaitCompletion(enabled: true);
				}
				if (Interlocked.Decrement(ref _count) == 0)
				{
					if (TplEventSource.Log.IsEnabled())
					{
						TplEventSource.Log.TraceOperationEnd(base.Id, AsyncCausalityStatus.Completed);
					}
					if (Task.s_asyncDebuggingEnabled)
					{
						Task.RemoveFromActiveTasks(this);
					}
					TrySetResult(_tasks);
				}
			}
		}

		internal sealed class CompleteOnInvokePromise : Task<Task>, ITaskCompletionAction
		{
			private IList<Task> _tasks;

			private int _stateFlags;

			public bool InvokeMayRunArbitraryCode => (_stateFlags & 2) == 0;

			public CompleteOnInvokePromise(IList<Task> tasks, bool isSyncBlocking)
			{
				_tasks = tasks;
				if (isSyncBlocking)
				{
					_stateFlags = 2;
				}
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationBegin(base.Id, "TaskFactory.ContinueWhenAny", 0L);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.AddToActiveTasks(this);
				}
			}

			public void Invoke(Task completingTask)
			{
				int stateFlags = _stateFlags;
				int num = stateFlags & 2;
				if (((uint)stateFlags & (true ? 1u : 0u)) != 0 || Interlocked.Exchange(ref _stateFlags, num | 1) != num)
				{
					return;
				}
				if (TplEventSource.Log.IsEnabled())
				{
					TplEventSource.Log.TraceOperationRelation(base.Id, CausalityRelation.Choice);
					TplEventSource.Log.TraceOperationEnd(base.Id, AsyncCausalityStatus.Completed);
				}
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.RemoveFromActiveTasks(this);
				}
				bool flag = TrySetResult(completingTask);
				IList<Task> tasks = _tasks;
				int count = tasks.Count;
				for (int i = 0; i < count; i++)
				{
					Task task = tasks[i];
					if (task != null && !task.IsCompleted)
					{
						task.RemoveContinuation(this);
					}
				}
				_tasks = null;
			}
		}

		private readonly CancellationToken m_defaultCancellationToken;

		private readonly TaskScheduler m_defaultScheduler;

		private readonly TaskCreationOptions m_defaultCreationOptions;

		private readonly TaskContinuationOptions m_defaultContinuationOptions;

		private TaskScheduler DefaultScheduler => m_defaultScheduler ?? TaskScheduler.Current;

		public CancellationToken CancellationToken => m_defaultCancellationToken;

		public TaskScheduler? Scheduler => m_defaultScheduler;

		public TaskCreationOptions CreationOptions => m_defaultCreationOptions;

		public TaskContinuationOptions ContinuationOptions => m_defaultContinuationOptions;

		private TaskScheduler GetDefaultScheduler(Task currTask)
		{
			TaskScheduler? taskScheduler = m_defaultScheduler;
			if (taskScheduler == null)
			{
				if (currTask == null || (currTask.CreationOptions & TaskCreationOptions.HideScheduler) != 0)
				{
					return TaskScheduler.Default;
				}
				taskScheduler = currTask.ExecutingTaskScheduler;
			}
			return taskScheduler;
		}

		public TaskFactory()
		{
		}

		public TaskFactory(CancellationToken cancellationToken)
		{
			m_defaultCancellationToken = cancellationToken;
		}

		public TaskFactory(TaskScheduler? scheduler)
		{
			m_defaultScheduler = scheduler;
		}

		public TaskFactory(TaskCreationOptions creationOptions, TaskContinuationOptions continuationOptions)
		{
			CheckMultiTaskContinuationOptions(continuationOptions);
			CheckCreationOptions(creationOptions);
			m_defaultCreationOptions = creationOptions;
			m_defaultContinuationOptions = continuationOptions;
		}

		public TaskFactory(CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskContinuationOptions continuationOptions, TaskScheduler? scheduler)
			: this(creationOptions, continuationOptions)
		{
			m_defaultCancellationToken = cancellationToken;
			m_defaultScheduler = scheduler;
		}

		internal static void CheckCreationOptions(TaskCreationOptions creationOptions)
		{
			if (((uint)creationOptions & 0xFFFFFFA0u) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions);
			}
		}

		public Task StartNew(Action action)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task.InternalStartNew(internalCurrent, action, null, m_defaultCancellationToken, GetDefaultScheduler(internalCurrent), m_defaultCreationOptions, InternalTaskOptions.None);
		}

		public Task StartNew(Action action, CancellationToken cancellationToken)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task.InternalStartNew(internalCurrent, action, null, cancellationToken, GetDefaultScheduler(internalCurrent), m_defaultCreationOptions, InternalTaskOptions.None);
		}

		public Task StartNew(Action action, TaskCreationOptions creationOptions)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task.InternalStartNew(internalCurrent, action, null, m_defaultCancellationToken, GetDefaultScheduler(internalCurrent), creationOptions, InternalTaskOptions.None);
		}

		public Task StartNew(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return Task.InternalStartNew(Task.InternalCurrentIfAttached(creationOptions), action, null, cancellationToken, scheduler, creationOptions, InternalTaskOptions.None);
		}

		public Task StartNew(Action<object?> action, object? state)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task.InternalStartNew(internalCurrent, action, state, m_defaultCancellationToken, GetDefaultScheduler(internalCurrent), m_defaultCreationOptions, InternalTaskOptions.None);
		}

		public Task StartNew(Action<object?> action, object? state, CancellationToken cancellationToken)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task.InternalStartNew(internalCurrent, action, state, cancellationToken, GetDefaultScheduler(internalCurrent), m_defaultCreationOptions, InternalTaskOptions.None);
		}

		public Task StartNew(Action<object?> action, object? state, TaskCreationOptions creationOptions)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task.InternalStartNew(internalCurrent, action, state, m_defaultCancellationToken, GetDefaultScheduler(internalCurrent), creationOptions, InternalTaskOptions.None);
		}

		public Task StartNew(Action<object?> action, object? state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return Task.InternalStartNew(Task.InternalCurrentIfAttached(creationOptions), action, state, cancellationToken, scheduler, creationOptions, InternalTaskOptions.None);
		}

		public Task<TResult> StartNew<TResult>(Func<TResult> function)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, m_defaultCancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew<TResult>(Func<TResult> function, CancellationToken cancellationToken)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, cancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew<TResult>(Func<TResult> function, TaskCreationOptions creationOptions)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, m_defaultCancellationToken, creationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew<TResult>(Func<TResult> function, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return Task<TResult>.StartNew(Task.InternalCurrentIfAttached(creationOptions), function, cancellationToken, creationOptions, InternalTaskOptions.None, scheduler);
		}

		public Task<TResult> StartNew<TResult>(Func<object?, TResult> function, object? state)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, state, m_defaultCancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew<TResult>(Func<object?, TResult> function, object? state, CancellationToken cancellationToken)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, state, cancellationToken, m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew<TResult>(Func<object?, TResult> function, object? state, TaskCreationOptions creationOptions)
		{
			Task internalCurrent = Task.InternalCurrent;
			return Task<TResult>.StartNew(internalCurrent, function, state, m_defaultCancellationToken, creationOptions, InternalTaskOptions.None, GetDefaultScheduler(internalCurrent));
		}

		public Task<TResult> StartNew<TResult>(Func<object?, TResult> function, object? state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return Task<TResult>.StartNew(Task.InternalCurrentIfAttached(creationOptions), function, state, cancellationToken, creationOptions, InternalTaskOptions.None, scheduler);
		}

		public Task FromAsync(IAsyncResult asyncResult, Action<IAsyncResult> endMethod)
		{
			return FromAsync(asyncResult, endMethod, m_defaultCreationOptions, DefaultScheduler);
		}

		public Task FromAsync(IAsyncResult asyncResult, Action<IAsyncResult> endMethod, TaskCreationOptions creationOptions)
		{
			return FromAsync(asyncResult, endMethod, creationOptions, DefaultScheduler);
		}

		public Task FromAsync(IAsyncResult asyncResult, Action<IAsyncResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return TaskFactory<VoidTaskResult>.FromAsyncImpl(asyncResult, null, endMethod, creationOptions, scheduler);
		}

		public Task FromAsync(Func<AsyncCallback, object?, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, object? state)
		{
			return FromAsync(beginMethod, endMethod, state, m_defaultCreationOptions);
		}

		public Task FromAsync(Func<AsyncCallback, object?, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, object? state, TaskCreationOptions creationOptions)
		{
			return TaskFactory<VoidTaskResult>.FromAsyncImpl(beginMethod, null, endMethod, state, creationOptions);
		}

		public Task FromAsync<TArg1>(Func<TArg1, AsyncCallback, object?, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, object? state)
		{
			return FromAsync(beginMethod, endMethod, arg1, state, m_defaultCreationOptions);
		}

		public Task FromAsync<TArg1>(Func<TArg1, AsyncCallback, object?, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, object? state, TaskCreationOptions creationOptions)
		{
			return TaskFactory<VoidTaskResult>.FromAsyncImpl(beginMethod, null, endMethod, arg1, state, creationOptions);
		}

		public Task FromAsync<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object?, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, object? state)
		{
			return FromAsync(beginMethod, endMethod, arg1, arg2, state, m_defaultCreationOptions);
		}

		public Task FromAsync<TArg1, TArg2>(Func<TArg1, TArg2, AsyncCallback, object?, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, object? state, TaskCreationOptions creationOptions)
		{
			return TaskFactory<VoidTaskResult>.FromAsyncImpl(beginMethod, null, endMethod, arg1, arg2, state, creationOptions);
		}

		public Task FromAsync<TArg1, TArg2, TArg3>(Func<TArg1, TArg2, TArg3, AsyncCallback, object?, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object? state)
		{
			return FromAsync(beginMethod, endMethod, arg1, arg2, arg3, state, m_defaultCreationOptions);
		}

		public Task FromAsync<TArg1, TArg2, TArg3>(Func<TArg1, TArg2, TArg3, AsyncCallback, object?, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object? state, TaskCreationOptions creationOptions)
		{
			return TaskFactory<VoidTaskResult>.FromAsyncImpl(beginMethod, null, endMethod, arg1, arg2, arg3, state, creationOptions);
		}

		public Task<TResult> FromAsync<TResult>(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)
		{
			return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, m_defaultCreationOptions, DefaultScheduler);
		}

		public Task<TResult> FromAsync<TResult>(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions)
		{
			return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, creationOptions, DefaultScheduler);
		}

		public Task<TResult> FromAsync<TResult>(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod, TaskCreationOptions creationOptions, TaskScheduler scheduler)
		{
			return TaskFactory<TResult>.FromAsyncImpl(asyncResult, endMethod, null, creationOptions, scheduler);
		}

		public Task<TResult> FromAsync<TResult>(Func<AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, object? state)
		{
			return TaskFactory<TResult>.FromAsyncImpl(beginMethod, endMethod, null, state, m_defaultCreationOptions);
		}

		public Task<TResult> FromAsync<TResult>(Func<AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, object? state, TaskCreationOptions creationOptions)
		{
			return TaskFactory<TResult>.FromAsyncImpl(beginMethod, endMethod, null, state, creationOptions);
		}

		public Task<TResult> FromAsync<TArg1, TResult>(Func<TArg1, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object? state)
		{
			return TaskFactory<TResult>.FromAsyncImpl(beginMethod, endMethod, null, arg1, state, m_defaultCreationOptions);
		}

		public Task<TResult> FromAsync<TArg1, TResult>(Func<TArg1, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, object? state, TaskCreationOptions creationOptions)
		{
			return TaskFactory<TResult>.FromAsyncImpl(beginMethod, endMethod, null, arg1, state, creationOptions);
		}

		public Task<TResult> FromAsync<TArg1, TArg2, TResult>(Func<TArg1, TArg2, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, object? state)
		{
			return TaskFactory<TResult>.FromAsyncImpl(beginMethod, endMethod, null, arg1, arg2, state, m_defaultCreationOptions);
		}

		public Task<TResult> FromAsync<TArg1, TArg2, TResult>(Func<TArg1, TArg2, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, object? state, TaskCreationOptions creationOptions)
		{
			return TaskFactory<TResult>.FromAsyncImpl(beginMethod, endMethod, null, arg1, arg2, state, creationOptions);
		}

		public Task<TResult> FromAsync<TArg1, TArg2, TArg3, TResult>(Func<TArg1, TArg2, TArg3, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object? state)
		{
			return TaskFactory<TResult>.FromAsyncImpl(beginMethod, endMethod, null, arg1, arg2, arg3, state, m_defaultCreationOptions);
		}

		public Task<TResult> FromAsync<TArg1, TArg2, TArg3, TResult>(Func<TArg1, TArg2, TArg3, AsyncCallback, object?, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object? state, TaskCreationOptions creationOptions)
		{
			return TaskFactory<TResult>.FromAsyncImpl(beginMethod, endMethod, null, arg1, arg2, arg3, state, creationOptions);
		}

		internal static void CheckFromAsyncOptions(TaskCreationOptions creationOptions, bool hasBeginMethod)
		{
			if (hasBeginMethod)
			{
				if ((creationOptions & TaskCreationOptions.LongRunning) != 0)
				{
					throw new ArgumentOutOfRangeException("creationOptions", SR.Task_FromAsync_LongRunning);
				}
				if ((creationOptions & TaskCreationOptions.PreferFairness) != 0)
				{
					throw new ArgumentOutOfRangeException("creationOptions", SR.Task_FromAsync_PreferFairness);
				}
			}
			if (((uint)creationOptions & 0xFFFFFFE0u) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.creationOptions);
			}
		}

		internal static Task<Task[]> CommonCWAllLogic(Task[] tasksCopy)
		{
			CompleteOnCountdownPromise completeOnCountdownPromise = new CompleteOnCountdownPromise(tasksCopy);
			for (int i = 0; i < tasksCopy.Length; i++)
			{
				if (tasksCopy[i].IsCompleted)
				{
					completeOnCountdownPromise.Invoke(tasksCopy[i]);
				}
				else
				{
					tasksCopy[i].AddCompletionAction(completeOnCountdownPromise);
				}
			}
			return completeOnCountdownPromise;
		}

		internal static Task<Task<T>[]> CommonCWAllLogic<T>(Task<T>[] tasksCopy)
		{
			CompleteOnCountdownPromise<T> completeOnCountdownPromise = new CompleteOnCountdownPromise<T>(tasksCopy);
			for (int i = 0; i < tasksCopy.Length; i++)
			{
				if (tasksCopy[i].IsCompleted)
				{
					completeOnCountdownPromise.Invoke(tasksCopy[i]);
				}
				else
				{
					tasksCopy[i].AddCompletionAction(completeOnCountdownPromise);
				}
			}
			return completeOnCountdownPromise;
		}

		public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, CancellationToken cancellationToken)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, TaskContinuationOptions continuationOptions)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAll(Task[] tasks, Action<Task[]> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler);
		}

		public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction, CancellationToken cancellationToken)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction, TaskContinuationOptions continuationOptions)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>[]> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAllImpl(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler);
		}

		public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TResult>(Task[] tasks, Func<Task[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
		}

		public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, CancellationToken cancellationToken)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>[], TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAllImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
		}

		internal static Task<Task> CommonCWAnyLogic(IList<Task> tasks, bool isSyncBlocking = false)
		{
			CompleteOnInvokePromise completeOnInvokePromise = new CompleteOnInvokePromise(tasks, isSyncBlocking);
			bool flag = false;
			int count = tasks.Count;
			for (int i = 0; i < count; i++)
			{
				Task task = tasks[i];
				if (task == null)
				{
					throw new ArgumentException(SR.Task_MultiTaskContinuation_NullTask, "tasks");
				}
				if (flag)
				{
					continue;
				}
				if (completeOnInvokePromise.IsCompleted)
				{
					flag = true;
					continue;
				}
				if (task.IsCompleted)
				{
					completeOnInvokePromise.Invoke(task);
					flag = true;
					continue;
				}
				task.AddCompletionAction(completeOnInvokePromise, isSyncBlocking);
				if (completeOnInvokePromise.IsCompleted)
				{
					task.RemoveContinuation(completeOnInvokePromise);
				}
			}
			return completeOnInvokePromise;
		}

		internal static void CommonCWAnyLogicCleanup(Task<Task> continuation)
		{
			((CompleteOnInvokePromise)continuation).Invoke(null);
		}

		public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, CancellationToken cancellationToken)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, TaskContinuationOptions continuationOptions)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAny(Task[] tasks, Action<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler);
		}

		public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TResult>(Task[] tasks, Func<Task, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
		}

		public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task<TResult> ContinueWhenAny<TAntecedentResult, TResult>(Task<TAntecedentResult>[] tasks, Func<Task<TAntecedentResult>, TResult> continuationFunction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationFunction == null)
			{
				throw new ArgumentNullException("continuationFunction");
			}
			return TaskFactory<TResult>.ContinueWhenAnyImpl(tasks, continuationFunction, null, continuationOptions, cancellationToken, scheduler);
		}

		public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, m_defaultContinuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction, CancellationToken cancellationToken)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, m_defaultContinuationOptions, cancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction, TaskContinuationOptions continuationOptions)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, continuationOptions, m_defaultCancellationToken, DefaultScheduler);
		}

		public Task ContinueWhenAny<TAntecedentResult>(Task<TAntecedentResult>[] tasks, Action<Task<TAntecedentResult>> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
		{
			if (continuationAction == null)
			{
				throw new ArgumentNullException("continuationAction");
			}
			return TaskFactory<VoidTaskResult>.ContinueWhenAnyImpl(tasks, null, continuationAction, continuationOptions, cancellationToken, scheduler);
		}

		internal static Task[] CheckMultiContinuationTasksAndCopy(Task[] tasks)
		{
			if (tasks == null)
			{
				throw new ArgumentNullException("tasks");
			}
			if (tasks.Length == 0)
			{
				throw new ArgumentException(SR.Task_MultiTaskContinuation_EmptyTaskList, "tasks");
			}
			Task[] array = new Task[tasks.Length];
			for (int i = 0; i < tasks.Length; i++)
			{
				array[i] = tasks[i];
				if (array[i] == null)
				{
					throw new ArgumentException(SR.Task_MultiTaskContinuation_NullTask, "tasks");
				}
			}
			return array;
		}

		internal static Task<TResult>[] CheckMultiContinuationTasksAndCopy<TResult>(Task<TResult>[] tasks)
		{
			if (tasks == null)
			{
				throw new ArgumentNullException("tasks");
			}
			if (tasks.Length == 0)
			{
				throw new ArgumentException(SR.Task_MultiTaskContinuation_EmptyTaskList, "tasks");
			}
			Task<TResult>[] array = new Task<TResult>[tasks.Length];
			for (int i = 0; i < tasks.Length; i++)
			{
				array[i] = tasks[i];
				if (array[i] == null)
				{
					throw new ArgumentException(SR.Task_MultiTaskContinuation_NullTask, "tasks");
				}
			}
			return array;
		}

		internal static void CheckMultiTaskContinuationOptions(TaskContinuationOptions continuationOptions)
		{
			if ((continuationOptions & (TaskContinuationOptions.LongRunning | TaskContinuationOptions.ExecuteSynchronously)) == (TaskContinuationOptions.LongRunning | TaskContinuationOptions.ExecuteSynchronously))
			{
				throw new ArgumentOutOfRangeException("continuationOptions", SR.Task_ContinueWith_ESandLR);
			}
			if (((uint)continuationOptions & 0xFFF0FFC0u) != 0)
			{
				throw new ArgumentOutOfRangeException("continuationOptions");
			}
			if ((continuationOptions & (TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.NotOnRanToCompletion)) != 0)
			{
				throw new ArgumentOutOfRangeException("continuationOptions", SR.Task_MultiTaskContinuation_FireOptions);
			}
		}
	}
	[DebuggerDisplay("Id={Id}")]
	[DebuggerTypeProxy(typeof(SystemThreadingTasks_TaskSchedulerDebugView))]
	public abstract class TaskScheduler
	{
		internal sealed class SystemThreadingTasks_TaskSchedulerDebugView
		{
			private readonly TaskScheduler m_taskScheduler;

			public int Id => m_taskScheduler.Id;

			public IEnumerable<Task> ScheduledTasks => m_taskScheduler.GetScheduledTasks();

			public SystemThreadingTasks_TaskSchedulerDebugView(TaskScheduler scheduler)
			{
				m_taskScheduler = scheduler;
			}
		}

		internal readonly struct TaskSchedulerAwaiter : ICriticalNotifyCompletion, INotifyCompletion
		{
			private readonly TaskScheduler _scheduler;

			public bool IsCompleted => false;

			public TaskSchedulerAwaiter(TaskScheduler scheduler)
			{
				_scheduler = scheduler;
			}

			public void GetResult()
			{
			}

			public void OnCompleted(Action continuation)
			{
				Task.Factory.StartNew(continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, _scheduler);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				if (_scheduler == Default)
				{
					ThreadPool.UnsafeQueueUserWorkItem(delegate(Action s)
					{
						s();
					}, continuation, preferLocal: true);
				}
				else
				{
					OnCompleted(continuation);
				}
			}
		}

		private static ConditionalWeakTable<TaskScheduler, object> s_activeTaskSchedulers;

		private static readonly TaskScheduler s_defaultTaskScheduler = new ThreadPoolTaskScheduler();

		internal static int s_taskSchedulerIdCounter;

		private volatile int m_taskSchedulerId;

		public virtual int MaximumConcurrencyLevel => int.MaxValue;

		public static TaskScheduler Default => s_defaultTaskScheduler;

		public static TaskScheduler Current => InternalCurrent ?? Default;

		internal static TaskScheduler? InternalCurrent
		{
			get
			{
				Task internalCurrent = Task.InternalCurrent;
				if (internalCurrent == null || (internalCurrent.CreationOptions & TaskCreationOptions.HideScheduler) != 0)
				{
					return null;
				}
				return internalCurrent.ExecutingTaskScheduler;
			}
		}

		public int Id
		{
			get
			{
				if (m_taskSchedulerId == 0)
				{
					int num;
					do
					{
						num = Interlocked.Increment(ref s_taskSchedulerIdCounter);
					}
					while (num == 0);
					Interlocked.CompareExchange(ref m_taskSchedulerId, num, 0);
				}
				return m_taskSchedulerId;
			}
		}

		public static event EventHandler<UnobservedTaskExceptionEventArgs>? UnobservedTaskException;

		protected internal abstract void QueueTask(Task task);

		protected abstract bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued);

		protected abstract IEnumerable<Task>? GetScheduledTasks();

		internal bool TryRunInline(Task task, bool taskWasPreviouslyQueued)
		{
			TaskScheduler executingTaskScheduler = task.ExecutingTaskScheduler;
			if (executingTaskScheduler != this && executingTaskScheduler != null)
			{
				return executingTaskScheduler.TryRunInline(task, taskWasPreviouslyQueued);
			}
			if (executingTaskScheduler == null || (object)task.m_action == null || task.IsDelegateInvoked || task.IsCanceled || !RuntimeHelpers.TryEnsureSufficientExecutionStack())
			{
				return false;
			}
			if (TplEventSource.Log.IsEnabled())
			{
				task.FireTaskScheduledIfNeeded(this);
			}
			bool flag = TryExecuteTaskInline(task, taskWasPreviouslyQueued);
			if (flag && !task.IsDelegateInvoked && !task.IsCanceled)
			{
				throw new InvalidOperationException(SR.TaskScheduler_InconsistentStateAfterTryExecuteTaskInline);
			}
			return flag;
		}

		protected internal virtual bool TryDequeue(Task task)
		{
			return false;
		}

		internal virtual void NotifyWorkItemProgress()
		{
		}

		internal void InternalQueueTask(Task task)
		{
			if (TplEventSource.Log.IsEnabled())
			{
				task.FireTaskScheduledIfNeeded(this);
			}
			QueueTask(task);
		}

		protected TaskScheduler()
		{
			if (Debugger.IsAttached)
			{
				AddToActiveTaskSchedulers();
			}
		}

		private void AddToActiveTaskSchedulers()
		{
			ConditionalWeakTable<TaskScheduler, object> conditionalWeakTable = s_activeTaskSchedulers;
			if (conditionalWeakTable == null)
			{
				Interlocked.CompareExchange(ref s_activeTaskSchedulers, new ConditionalWeakTable<TaskScheduler, object>(), null);
				conditionalWeakTable = s_activeTaskSchedulers;
			}
			conditionalWeakTable.Add(this, null);
		}

		public static TaskScheduler FromCurrentSynchronizationContext()
		{
			return new SynchronizationContextTaskScheduler();
		}

		protected bool TryExecuteTask(Task task)
		{
			if (task.ExecutingTaskScheduler != this)
			{
				throw new InvalidOperationException(SR.TaskScheduler_ExecuteTask_WrongTaskScheduler);
			}
			return task.ExecuteEntry();
		}

		internal static void PublishUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs ueea)
		{
			TaskScheduler.UnobservedTaskException?.Invoke(sender, ueea);
		}

		internal Task[] GetScheduledTasksForDebugger()
		{
			IEnumerable<Task> scheduledTasks = GetScheduledTasks();
			if (scheduledTasks == null)
			{
				return null;
			}
			Task[] array = scheduledTasks as Task[];
			if (array == null)
			{
				array = new List<Task>(scheduledTasks).ToArray();
			}
			Task[] array2 = array;
			foreach (Task task in array2)
			{
				_ = task.Id;
			}
			return array;
		}

		internal static TaskScheduler[] GetTaskSchedulersForDebugger()
		{
			if (s_activeTaskSchedulers == null)
			{
				return new TaskScheduler[1] { s_defaultTaskScheduler };
			}
			List<TaskScheduler> list = new List<TaskScheduler>();
			foreach (KeyValuePair<TaskScheduler, object> item in (IEnumerable<KeyValuePair<TaskScheduler, object>>)s_activeTaskSchedulers)
			{
				list.Add(item.Key);
			}
			if (!list.Contains(s_defaultTaskScheduler))
			{
				list.Add(s_defaultTaskScheduler);
			}
			TaskScheduler[] array = list.ToArray();
			TaskScheduler[] array2 = array;
			foreach (TaskScheduler taskScheduler in array2)
			{
				_ = taskScheduler.Id;
			}
			return array;
		}

		internal TaskSchedulerAwaiter GetAwaiter()
		{
			return new TaskSchedulerAwaiter(this);
		}
	}
	internal sealed class SynchronizationContextTaskScheduler : TaskScheduler
	{
		private readonly SynchronizationContext m_synchronizationContext;

		private static readonly SendOrPostCallback s_postCallback = delegate(object s)
		{
			((Task)s).ExecuteEntry();
		};

		public override int MaximumConcurrencyLevel => 1;

		internal SynchronizationContextTaskScheduler()
		{
			m_synchronizationContext = SynchronizationContext.Current ?? throw new InvalidOperationException(SR.TaskScheduler_FromCurrentSynchronizationContext_NoCurrent);
		}

		protected internal override void QueueTask(Task task)
		{
			m_synchronizationContext.Post(s_postCallback, task);
		}

		protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
		{
			if (SynchronizationContext.Current == m_synchronizationContext)
			{
				return TryExecuteTask(task);
			}
			return false;
		}

		protected override IEnumerable<Task> GetScheduledTasks()
		{
			return null;
		}
	}
	public class UnobservedTaskExceptionEventArgs : EventArgs
	{
		private readonly AggregateException m_exception;

		internal bool m_observed;

		public bool Observed => m_observed;

		public AggregateException Exception => m_exception;

		public UnobservedTaskExceptionEventArgs(AggregateException exception)
		{
			m_exception = exception;
		}

		public void SetObserved()
		{
			m_observed = true;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class TaskSchedulerException : Exception
	{
		public TaskSchedulerException()
			: base(SR.TaskSchedulerException_ctor_DefaultMessage)
		{
		}

		public TaskSchedulerException(string? message)
			: base(message)
		{
		}

		public TaskSchedulerException(Exception? innerException)
			: base(SR.TaskSchedulerException_ctor_DefaultMessage, innerException)
		{
		}

		public TaskSchedulerException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		protected TaskSchedulerException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal sealed class ThreadPoolTaskScheduler : TaskScheduler
	{
		private static readonly ParameterizedThreadStart s_longRunningThreadWork = delegate(object s)
		{
			((Task)s).ExecuteEntryUnsafe(null);
		};

		internal ThreadPoolTaskScheduler()
		{
			_ = base.Id;
		}

		protected internal override void QueueTask(Task task)
		{
			TaskCreationOptions options = task.Options;
			_ = Thread.IsThreadStartSupported;
			if ((options & TaskCreationOptions.LongRunning) != 0)
			{
				Thread thread = new Thread(s_longRunningThreadWork);
				thread.IsBackground = true;
				thread.Name = ".NET Long Running Task";
				thread.UnsafeStart(task);
			}
			else
			{
				ThreadPool.UnsafeQueueUserWorkItemInternal(task, (options & TaskCreationOptions.PreferFairness) == 0);
			}
		}

		protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
		{
			if (taskWasPreviouslyQueued && !ThreadPool.TryPopCustomWorkItem(task))
			{
				return false;
			}
			try
			{
				task.ExecuteEntryUnsafe(null);
			}
			finally
			{
				if (taskWasPreviouslyQueued)
				{
					NotifyWorkItemProgress();
				}
			}
			return true;
		}

		protected internal override bool TryDequeue(Task task)
		{
			return ThreadPool.TryPopCustomWorkItem(task);
		}

		protected override IEnumerable<Task> GetScheduledTasks()
		{
			return FilterTasksFromWorkItems(ThreadPool.GetQueuedWorkItems());
		}

		private static IEnumerable<Task> FilterTasksFromWorkItems(IEnumerable<object> tpwItems)
		{
			foreach (object tpwItem in tpwItems)
			{
				if (tpwItem is Task task)
				{
					yield return task;
				}
			}
		}

		internal override void NotifyWorkItemProgress()
		{
			ThreadPool.NotifyWorkItemProgress();
		}
	}
	[EventSource(Name = "System.Threading.Tasks.TplEventSource", Guid = "2e5dba47-a3d2-4d16-8ee0-6671ffdcd7b5", LocalizationResources = "System.Private.CoreLib.Strings")]
	internal sealed class TplEventSource : EventSource
	{
		public enum TaskWaitBehavior
		{
			Synchronous = 1,
			Asynchronous
		}

		public static class Tasks
		{
			public const EventTask Loop = (EventTask)1;

			public const EventTask Invoke = (EventTask)2;

			public const EventTask TaskExecute = (EventTask)3;

			public const EventTask TaskWait = (EventTask)4;

			public const EventTask ForkJoin = (EventTask)5;

			public const EventTask TaskScheduled = (EventTask)6;

			public const EventTask AwaitTaskContinuationScheduled = (EventTask)7;

			public const EventTask TraceOperation = (EventTask)8;

			public const EventTask TraceSynchronousWork = (EventTask)9;
		}

		public static class Keywords
		{
			public const EventKeywords TaskTransfer = (EventKeywords)1L;

			public const EventKeywords Tasks = (EventKeywords)2L;

			public const EventKeywords Parallel = (EventKeywords)4L;

			public const EventKeywords AsyncCausalityOperation = (EventKeywords)8L;

			public const EventKeywords AsyncCausalityRelation = (EventKeywords)16L;

			public const EventKeywords AsyncCausalitySynchronousWork = (EventKeywords)32L;

			public const EventKeywords TaskStops = (EventKeywords)64L;

			public const EventKeywords TasksFlowActivityIds = (EventKeywords)128L;

			public const EventKeywords AsyncMethod = (EventKeywords)256L;

			public const EventKeywords TasksSetActivityIds = (EventKeywords)65536L;

			public const EventKeywords Debug = (EventKeywords)131072L;

			public const EventKeywords DebugActivityId = (EventKeywords)262144L;
		}

		private const string EventSourceSuppressMessage = "Parameters to this method are primitive and are trimmer safe";

		internal bool TasksSetActivityIds;

		internal bool Debug;

		private bool DebugActivityId;

		private const int DefaultAppDomainID = 1;

		public static readonly TplEventSource Log = new TplEventSource();

		private const int TASKSCHEDULED_ID = 7;

		private const int TASKSTARTED_ID = 8;

		private const int TASKCOMPLETED_ID = 9;

		private const int TASKWAITBEGIN_ID = 10;

		private const int TASKWAITEND_ID = 11;

		private const int AWAITTASKCONTINUATIONSCHEDULED_ID = 12;

		private const int TASKWAITCONTINUATIONCOMPLETE_ID = 13;

		private const int TASKWAITCONTINUATIONSTARTED_ID = 19;

		private const int TRACEOPERATIONSTART_ID = 14;

		private const int TRACEOPERATIONSTOP_ID = 15;

		private const int TRACEOPERATIONRELATION_ID = 16;

		private const int TRACESYNCHRONOUSWORKSTART_ID = 17;

		private const int TRACESYNCHRONOUSWORKSTOP_ID = 18;

		private protected override ReadOnlySpan<byte> ProviderMetadata => new byte[40]
		{
			40, 0, 83, 121, 115, 116, 101, 109, 46, 84,
			104, 114, 101, 97, 100, 105, 110, 103, 46, 84,
			97, 115, 107, 115, 46, 84, 112, 108, 69, 118,
			101, 110, 116, 83, 111, 117, 114, 99, 101, 0
		};

		protected override void OnEventCommand(EventCommandEventArgs command)
		{
			if (IsEnabled(EventLevel.Informational, (EventKeywords)128L))
			{
				ActivityTracker.Instance.Enable();
			}
			else
			{
				TasksSetActivityIds = IsEnabled(EventLevel.Informational, (EventKeywords)65536L);
			}
			Debug = IsEnabled(EventLevel.Informational, (EventKeywords)131072L);
			DebugActivityId = IsEnabled(EventLevel.Informational, (EventKeywords)262144L);
		}

		private TplEventSource(int _)
		{
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(7, Task = (EventTask)6, Version = 1, Opcode = EventOpcode.Send, Level = EventLevel.Informational, Keywords = (EventKeywords)3L)]
		public unsafe void TaskScheduled(int OriginatingTaskSchedulerID, int OriginatingTaskID, int TaskID, int CreatingTaskID, int TaskCreationOptions, int appDomain = 1)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)3L))
			{
				EventData* ptr = stackalloc EventData[6];
				ptr->Size = 4;
				ptr->DataPointer = (IntPtr)(&OriginatingTaskSchedulerID);
				ptr->Reserved = 0;
				ptr[1].Size = 4;
				ptr[1].DataPointer = (IntPtr)(&OriginatingTaskID);
				ptr[1].Reserved = 0;
				ptr[2].Size = 4;
				ptr[2].DataPointer = (IntPtr)(&TaskID);
				ptr[2].Reserved = 0;
				ptr[3].Size = 4;
				ptr[3].DataPointer = (IntPtr)(&CreatingTaskID);
				ptr[3].Reserved = 0;
				ptr[4].Size = 4;
				ptr[4].DataPointer = (IntPtr)(&TaskCreationOptions);
				ptr[4].Reserved = 0;
				ptr[5].Size = 4;
				ptr[5].DataPointer = (IntPtr)(&appDomain);
				ptr[5].Reserved = 0;
				if (TasksSetActivityIds)
				{
					Guid guid = CreateGuidForTaskID(TaskID);
					WriteEventWithRelatedActivityIdCore(7, &guid, 6, ptr);
				}
				else
				{
					WriteEventCore(7, 6, ptr);
				}
			}
		}

		[Event(8, Level = EventLevel.Informational, Keywords = (EventKeywords)2L)]
		public void TaskStarted(int OriginatingTaskSchedulerID, int OriginatingTaskID, int TaskID)
		{
			if (IsEnabled(EventLevel.Informational, (EventKeywords)2L))
			{
				WriteEvent(8, OriginatingTaskSchedulerID, OriginatingTaskID, TaskID);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(9, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)64L)]
		public unsafe void TaskCompleted(int OriginatingTaskSchedulerID, int OriginatingTaskID, int TaskID, bool IsExceptional)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)2L))
			{
				EventData* ptr = stackalloc EventData[4];
				int num = (IsExceptional ? 1 : 0);
				ptr->Size = 4;
				ptr->DataPointer = (IntPtr)(&OriginatingTaskSchedulerID);
				ptr->Reserved = 0;
				ptr[1].Size = 4;
				ptr[1].DataPointer = (IntPtr)(&OriginatingTaskID);
				ptr[1].Reserved = 0;
				ptr[2].Size = 4;
				ptr[2].DataPointer = (IntPtr)(&TaskID);
				ptr[2].Reserved = 0;
				ptr[3].Size = 4;
				ptr[3].DataPointer = (IntPtr)(&num);
				ptr[3].Reserved = 0;
				WriteEventCore(9, 4, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(10, Version = 3, Task = (EventTask)4, Opcode = EventOpcode.Send, Level = EventLevel.Informational, Keywords = (EventKeywords)3L)]
		public unsafe void TaskWaitBegin(int OriginatingTaskSchedulerID, int OriginatingTaskID, int TaskID, TaskWaitBehavior Behavior, int ContinueWithTaskID)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)3L))
			{
				EventData* ptr = stackalloc EventData[5];
				ptr->Size = 4;
				ptr->DataPointer = (IntPtr)(&OriginatingTaskSchedulerID);
				ptr->Reserved = 0;
				ptr[1].Size = 4;
				ptr[1].DataPointer = (IntPtr)(&OriginatingTaskID);
				ptr[1].Reserved = 0;
				ptr[2].Size = 4;
				ptr[2].DataPointer = (IntPtr)(&TaskID);
				ptr[2].Reserved = 0;
				ptr[3].Size = 4;
				ptr[3].DataPointer = (IntPtr)(&Behavior);
				ptr[3].Reserved = 0;
				ptr[4].Size = 4;
				ptr[4].DataPointer = (IntPtr)(&ContinueWithTaskID);
				ptr[4].Reserved = 0;
				if (TasksSetActivityIds)
				{
					Guid guid = CreateGuidForTaskID(TaskID);
					WriteEventWithRelatedActivityIdCore(10, &guid, 5, ptr);
				}
				else
				{
					WriteEventCore(10, 5, ptr);
				}
			}
		}

		[Event(11, Level = EventLevel.Verbose, Keywords = (EventKeywords)2L)]
		public void TaskWaitEnd(int OriginatingTaskSchedulerID, int OriginatingTaskID, int TaskID)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Verbose, (EventKeywords)2L))
			{
				WriteEvent(11, OriginatingTaskSchedulerID, OriginatingTaskID, TaskID);
			}
		}

		[Event(13, Level = EventLevel.Verbose, Keywords = (EventKeywords)64L)]
		public void TaskWaitContinuationComplete(int TaskID)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Verbose, (EventKeywords)64L))
			{
				WriteEvent(13, TaskID);
			}
		}

		[Event(19, Level = EventLevel.Verbose, Keywords = (EventKeywords)2L)]
		public void TaskWaitContinuationStarted(int TaskID)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Verbose, (EventKeywords)2L))
			{
				WriteEvent(19, TaskID);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(12, Task = (EventTask)7, Opcode = EventOpcode.Send, Level = EventLevel.Informational, Keywords = (EventKeywords)3L)]
		public unsafe void AwaitTaskContinuationScheduled(int OriginatingTaskSchedulerID, int OriginatingTaskID, int ContinueWithTaskId)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)3L))
			{
				EventData* ptr = stackalloc EventData[3];
				ptr->Size = 4;
				ptr->DataPointer = (IntPtr)(&OriginatingTaskSchedulerID);
				ptr->Reserved = 0;
				ptr[1].Size = 4;
				ptr[1].DataPointer = (IntPtr)(&OriginatingTaskID);
				ptr[1].Reserved = 0;
				ptr[2].Size = 4;
				ptr[2].DataPointer = (IntPtr)(&ContinueWithTaskId);
				ptr[2].Reserved = 0;
				if (TasksSetActivityIds)
				{
					Guid guid = CreateGuidForTaskID(ContinueWithTaskId);
					WriteEventWithRelatedActivityIdCore(12, &guid, 3, ptr);
				}
				else
				{
					WriteEventCore(12, 3, ptr);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(14, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		public unsafe void TraceOperationBegin(int TaskID, string OperationName, long RelatedContext)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)8L))
			{
				fixed (char* ptr2 = OperationName)
				{
					EventData* ptr = stackalloc EventData[3];
					ptr->Size = 4;
					ptr->DataPointer = (IntPtr)(&TaskID);
					ptr->Reserved = 0;
					ptr[1].Size = (OperationName.Length + 1) * 2;
					ptr[1].DataPointer = (IntPtr)ptr2;
					ptr[1].Reserved = 0;
					ptr[2].Size = 8;
					ptr[2].DataPointer = (IntPtr)(&RelatedContext);
					ptr[2].Reserved = 0;
					WriteEventCore(14, 3, ptr);
				}
			}
		}

		[Event(16, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)16L)]
		public void TraceOperationRelation(int TaskID, CausalityRelation Relation)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)16L))
			{
				WriteEvent(16, TaskID, (int)Relation);
			}
		}

		[Event(15, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		public void TraceOperationEnd(int TaskID, AsyncCausalityStatus Status)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)8L))
			{
				WriteEvent(15, TaskID, (int)Status);
			}
		}

		[Event(17, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)32L)]
		public void TraceSynchronousWorkBegin(int TaskID, CausalitySynchronousWork Work)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)32L))
			{
				WriteEvent(17, TaskID, (int)Work);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[Event(18, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)32L)]
		public unsafe void TraceSynchronousWorkEnd(CausalitySynchronousWork Work)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Informational, (EventKeywords)32L))
			{
				EventData* ptr = stackalloc EventData[1];
				ptr->Size = 4;
				ptr->DataPointer = (IntPtr)(&Work);
				ptr->Reserved = 0;
				WriteEventCore(18, 1, ptr);
			}
		}

		[NonEvent]
		public unsafe void RunningContinuation(int TaskID, object Object)
		{
			RunningContinuation(TaskID, (long)(nuint)(*(nint*)Unsafe.AsPointer(ref Object)));
		}

		[Event(20, Keywords = (EventKeywords)131072L)]
		private void RunningContinuation(int TaskID, long Object)
		{
			if (Debug)
			{
				WriteEvent(20, TaskID, Object);
			}
		}

		[NonEvent]
		public unsafe void RunningContinuationList(int TaskID, int Index, object Object)
		{
			RunningContinuationList(TaskID, Index, (long)(nuint)(*(nint*)Unsafe.AsPointer(ref Object)));
		}

		[Event(21, Keywords = (EventKeywords)131072L)]
		public void RunningContinuationList(int TaskID, int Index, long Object)
		{
			if (Debug)
			{
				WriteEvent(21, TaskID, Index, Object);
			}
		}

		[Event(23, Keywords = (EventKeywords)131072L)]
		public void DebugFacilityMessage(string Facility, string Message)
		{
			WriteEvent(23, Facility, Message);
		}

		[Event(24, Keywords = (EventKeywords)131072L)]
		public void DebugFacilityMessage1(string Facility, string Message, string Value1)
		{
			WriteEvent(24, Facility, Message, Value1);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Guid parameter is safe with WriteEvent")]
		[Event(25, Keywords = (EventKeywords)262144L)]
		public void SetActivityId(Guid NewId)
		{
			if (DebugActivityId)
			{
				WriteEvent(25, NewId);
			}
		}

		[Event(26, Keywords = (EventKeywords)131072L)]
		public void NewID(int TaskID)
		{
			if (Debug)
			{
				WriteEvent(26, TaskID);
			}
		}

		[NonEvent]
		public void IncompleteAsyncMethod(IAsyncStateMachineBox stateMachineBox)
		{
			if (IsEnabled() && IsEnabled(EventLevel.Warning, (EventKeywords)256L))
			{
				IAsyncStateMachine stateMachineObject = stateMachineBox.GetStateMachineObject();
				if (stateMachineObject != null)
				{
					string asyncStateMachineDescription = AsyncMethodBuilderCore.GetAsyncStateMachineDescription(stateMachineObject);
					IncompleteAsyncMethod(asyncStateMachineDescription);
				}
			}
		}

		[Event(27, Level = EventLevel.Warning, Keywords = (EventKeywords)256L)]
		private void IncompleteAsyncMethod(string stateMachineDescription)
		{
			WriteEvent(27, stateMachineDescription);
		}

		internal static Guid CreateGuidForTaskID(int taskID)
		{
			int processId = Environment.ProcessId;
			return new Guid(taskID, 1, 0, (byte)processId, (byte)(processId >> 8), (byte)(processId >> 16), (byte)(processId >> 24), byte.MaxValue, 220, 215, 181);
		}

		private TplEventSource()
			: base(new Guid(777894471u, 41938, 19734, 142, 224, 102, 113, byte.MaxValue, 220, 215, 181), "System.Threading.Tasks.TplEventSource")
		{
		}
	}
	[StructLayout(LayoutKind.Auto)]
	[AsyncMethodBuilder(typeof(AsyncValueTaskMethodBuilder))]
	public readonly struct ValueTask : IEquatable<ValueTask>
	{
		private sealed class ValueTaskSourceAsTask : Task
		{
			private static readonly Action<object> s_completionAction = delegate(object state)
			{
				if (state is ValueTaskSourceAsTask valueTaskSourceAsTask)
				{
					IValueTaskSource source = valueTaskSourceAsTask._source;
					if (source != null)
					{
						valueTaskSourceAsTask._source = null;
						ValueTaskSourceStatus status = source.GetStatus(valueTaskSourceAsTask._token);
						try
						{
							source.GetResult(valueTaskSourceAsTask._token);
							valueTaskSourceAsTask.TrySetResult();
							return;
						}
						catch (Exception ex)
						{
							if (status == ValueTaskSourceStatus.Canceled)
							{
								if (ex is OperationCanceledException ex2)
								{
									valueTaskSourceAsTask.TrySetCanceled(ex2.CancellationToken, ex2);
								}
								else
								{
									valueTaskSourceAsTask.TrySetCanceled(new CancellationToken(canceled: true));
								}
							}
							else
							{
								valueTaskSourceAsTask.TrySetException(ex);
							}
							return;
						}
					}
				}
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.state);
			};

			private IValueTaskSource _source;

			private readonly short _token;

			internal ValueTaskSourceAsTask(IValueTaskSource source, short token)
			{
				_token = token;
				_source = source;
				source.OnCompleted(s_completionAction, this, token, ValueTaskSourceOnCompletedFlags.None);
			}
		}

		private static volatile Task s_canceledTask;

		internal readonly object _obj;

		internal readonly short _token;

		internal readonly bool _continueOnCapturedContext;

		public static ValueTask CompletedTask => default(ValueTask);

		public bool IsCompleted
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return true;
				}
				if (obj is Task task)
				{
					return task.IsCompleted;
				}
				return Unsafe.As<IValueTaskSource>(obj).GetStatus(_token) != ValueTaskSourceStatus.Pending;
			}
		}

		public bool IsCompletedSuccessfully
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return true;
				}
				if (obj is Task task)
				{
					return task.IsCompletedSuccessfully;
				}
				return Unsafe.As<IValueTaskSource>(obj).GetStatus(_token) == ValueTaskSourceStatus.Succeeded;
			}
		}

		public bool IsFaulted
		{
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return false;
				}
				if (obj is Task task)
				{
					return task.IsFaulted;
				}
				return Unsafe.As<IValueTaskSource>(obj).GetStatus(_token) == ValueTaskSourceStatus.Faulted;
			}
		}

		public bool IsCanceled
		{
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return false;
				}
				if (obj is Task task)
				{
					return task.IsCanceled;
				}
				return Unsafe.As<IValueTaskSource>(obj).GetStatus(_token) == ValueTaskSourceStatus.Canceled;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ValueTask(Task task)
		{
			if (task == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.task);
			}
			_obj = task;
			_continueOnCapturedContext = true;
			_token = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ValueTask(IValueTaskSource source, short token)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			_obj = source;
			_token = token;
			_continueOnCapturedContext = true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ValueTask(object obj, short token, bool continueOnCapturedContext)
		{
			_obj = obj;
			_token = token;
			_continueOnCapturedContext = continueOnCapturedContext;
		}

		public static ValueTask<TResult> FromResult<TResult>(TResult result)
		{
			return new ValueTask<TResult>(result);
		}

		public static ValueTask FromCanceled(CancellationToken cancellationToken)
		{
			return new ValueTask(Task.FromCanceled(cancellationToken));
		}

		public static ValueTask<TResult> FromCanceled<TResult>(CancellationToken cancellationToken)
		{
			return new ValueTask<TResult>(Task.FromCanceled<TResult>(cancellationToken));
		}

		public static ValueTask FromException(Exception exception)
		{
			return new ValueTask(Task.FromException(exception));
		}

		public static ValueTask<TResult> FromException<TResult>(Exception exception)
		{
			return new ValueTask<TResult>(Task.FromException<TResult>(exception));
		}

		public override int GetHashCode()
		{
			return _obj?.GetHashCode() ?? 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is ValueTask)
			{
				return Equals((ValueTask)obj);
			}
			return false;
		}

		public bool Equals(ValueTask other)
		{
			if (_obj == other._obj)
			{
				return _token == other._token;
			}
			return false;
		}

		public static bool operator ==(ValueTask left, ValueTask right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(ValueTask left, ValueTask right)
		{
			return !left.Equals(right);
		}

		public Task AsTask()
		{
			object obj = _obj;
			object obj2;
			if (obj != null)
			{
				obj2 = obj as Task;
				if (obj2 == null)
				{
					return GetTaskForValueTaskSource(Unsafe.As<IValueTaskSource>(obj));
				}
			}
			else
			{
				obj2 = Task.CompletedTask;
			}
			return (Task)obj2;
		}

		public ValueTask Preserve()
		{
			if (_obj != null)
			{
				return new ValueTask(AsTask());
			}
			return this;
		}

		private Task GetTaskForValueTaskSource(IValueTaskSource t)
		{
			ValueTaskSourceStatus status = t.GetStatus(_token);
			if (status != 0)
			{
				try
				{
					t.GetResult(_token);
					return Task.CompletedTask;
				}
				catch (Exception ex)
				{
					if (status == ValueTaskSourceStatus.Canceled)
					{
						if (ex is OperationCanceledException ex2)
						{
							Task task = new Task();
							task.TrySetCanceled(ex2.CancellationToken, ex2);
							return task;
						}
						return s_canceledTask ?? (s_canceledTask = Task.FromCanceled(new CancellationToken(canceled: true)));
					}
					return Task.FromException(ex);
				}
			}
			return new ValueTaskSourceAsTask(t, _token);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ThrowIfCompletedUnsuccessfully()
		{
			object obj = _obj;
			if (obj != null)
			{
				if (obj is Task task)
				{
					TaskAwaiter.ValidateEnd(task);
				}
				else
				{
					Unsafe.As<IValueTaskSource>(obj).GetResult(_token);
				}
			}
		}

		public ValueTaskAwaiter GetAwaiter()
		{
			return new ValueTaskAwaiter(in this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ConfiguredValueTaskAwaitable ConfigureAwait(bool continueOnCapturedContext)
		{
			ValueTask value = new ValueTask(_obj, _token, continueOnCapturedContext);
			return new ConfiguredValueTaskAwaitable(in value);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	[AsyncMethodBuilder(typeof(AsyncValueTaskMethodBuilder<>))]
	public readonly struct ValueTask<TResult> : IEquatable<ValueTask<TResult>>
	{
		private sealed class ValueTaskSourceAsTask : Task<TResult>
		{
			private static readonly Action<object> s_completionAction = delegate(object state)
			{
				if (state is ValueTaskSourceAsTask valueTaskSourceAsTask)
				{
					IValueTaskSource<TResult> source = valueTaskSourceAsTask._source;
					if (source != null)
					{
						valueTaskSourceAsTask._source = null;
						ValueTaskSourceStatus status = source.GetStatus(valueTaskSourceAsTask._token);
						try
						{
							valueTaskSourceAsTask.TrySetResult(source.GetResult(valueTaskSourceAsTask._token));
							return;
						}
						catch (Exception ex)
						{
							if (status == ValueTaskSourceStatus.Canceled)
							{
								if (ex is OperationCanceledException ex2)
								{
									valueTaskSourceAsTask.TrySetCanceled(ex2.CancellationToken, ex2);
								}
								else
								{
									valueTaskSourceAsTask.TrySetCanceled(new CancellationToken(canceled: true));
								}
							}
							else
							{
								valueTaskSourceAsTask.TrySetException(ex);
							}
							return;
						}
					}
				}
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.state);
			};

			private IValueTaskSource<TResult> _source;

			private readonly short _token;

			public ValueTaskSourceAsTask(IValueTaskSource<TResult> source, short token)
			{
				_source = source;
				_token = token;
				source.OnCompleted(s_completionAction, this, token, ValueTaskSourceOnCompletedFlags.None);
			}
		}

		private static volatile Task<TResult> s_canceledTask;

		internal readonly object _obj;

		internal readonly TResult _result;

		internal readonly short _token;

		internal readonly bool _continueOnCapturedContext;

		public bool IsCompleted
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return true;
				}
				if (obj is Task<TResult> task)
				{
					return task.IsCompleted;
				}
				return Unsafe.As<IValueTaskSource<TResult>>(obj).GetStatus(_token) != ValueTaskSourceStatus.Pending;
			}
		}

		public bool IsCompletedSuccessfully
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return true;
				}
				if (obj is Task<TResult> task)
				{
					return task.IsCompletedSuccessfully;
				}
				return Unsafe.As<IValueTaskSource<TResult>>(obj).GetStatus(_token) == ValueTaskSourceStatus.Succeeded;
			}
		}

		public bool IsFaulted
		{
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return false;
				}
				if (obj is Task<TResult> task)
				{
					return task.IsFaulted;
				}
				return Unsafe.As<IValueTaskSource<TResult>>(obj).GetStatus(_token) == ValueTaskSourceStatus.Faulted;
			}
		}

		public bool IsCanceled
		{
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return false;
				}
				if (obj is Task<TResult> task)
				{
					return task.IsCanceled;
				}
				return Unsafe.As<IValueTaskSource<TResult>>(obj).GetStatus(_token) == ValueTaskSourceStatus.Canceled;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public TResult Result
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				object obj = _obj;
				if (obj == null)
				{
					return _result;
				}
				if (obj is Task<TResult> task)
				{
					TaskAwaiter.ValidateEnd(task);
					return task.ResultOnSuccess;
				}
				return Unsafe.As<IValueTaskSource<TResult>>(obj).GetResult(_token);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ValueTask(TResult result)
		{
			_result = result;
			_obj = null;
			_continueOnCapturedContext = true;
			_token = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ValueTask(Task<TResult> task)
		{
			if (task == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.task);
			}
			_obj = task;
			_result = default(TResult);
			_continueOnCapturedContext = true;
			_token = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ValueTask(IValueTaskSource<TResult> source, short token)
		{
			if (source == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
			}
			_obj = source;
			_token = token;
			_result = default(TResult);
			_continueOnCapturedContext = true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ValueTask(object obj, TResult result, short token, bool continueOnCapturedContext)
		{
			_obj = obj;
			_result = result;
			_token = token;
			_continueOnCapturedContext = continueOnCapturedContext;
		}

		public override int GetHashCode()
		{
			if (_obj == null)
			{
				if (_result == null)
				{
					return 0;
				}
				return _result.GetHashCode();
			}
			return _obj.GetHashCode();
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is ValueTask<TResult>)
			{
				return Equals((ValueTask<TResult>)obj);
			}
			return false;
		}

		public bool Equals(ValueTask<TResult> other)
		{
			if (_obj == null && other._obj == null)
			{
				return EqualityComparer<TResult>.Default.Equals(_result, other._result);
			}
			if (_obj == other._obj)
			{
				return _token == other._token;
			}
			return false;
		}

		public static bool operator ==(ValueTask<TResult> left, ValueTask<TResult> right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(ValueTask<TResult> left, ValueTask<TResult> right)
		{
			return !left.Equals(right);
		}

		public Task<TResult> AsTask()
		{
			object obj = _obj;
			if (obj == null)
			{
				return Task.FromResult(_result);
			}
			if (obj is Task<TResult> result)
			{
				return result;
			}
			return GetTaskForValueTaskSource(Unsafe.As<IValueTaskSource<TResult>>(obj));
		}

		public ValueTask<TResult> Preserve()
		{
			if (_obj != null)
			{
				return new ValueTask<TResult>(AsTask());
			}
			return this;
		}

		private Task<TResult> GetTaskForValueTaskSource(IValueTaskSource<TResult> t)
		{
			ValueTaskSourceStatus status = t.GetStatus(_token);
			if (status != 0)
			{
				try
				{
					return Task.FromResult(t.GetResult(_token));
				}
				catch (Exception ex)
				{
					if (status == ValueTaskSourceStatus.Canceled)
					{
						if (ex is OperationCanceledException ex2)
						{
							Task<TResult> task = new Task<TResult>();
							task.TrySetCanceled(ex2.CancellationToken, ex2);
							return task;
						}
						return s_canceledTask ?? (s_canceledTask = Task.FromCanceled<TResult>(new CancellationToken(canceled: true)));
					}
					return Task.FromException<TResult>(ex);
				}
			}
			return new ValueTaskSourceAsTask(t, _token);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ValueTaskAwaiter<TResult> GetAwaiter()
		{
			return new ValueTaskAwaiter<TResult>(in this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ConfiguredValueTaskAwaitable<TResult> ConfigureAwait(bool continueOnCapturedContext)
		{
			ValueTask<TResult> value = new ValueTask<TResult>(_obj, _result, _token, continueOnCapturedContext);
			return new ConfiguredValueTaskAwaitable<TResult>(in value);
		}

		public override string? ToString()
		{
			if (IsCompletedSuccessfully)
			{
				Debugger.NotifyOfCrossThreadDependency();
				TResult result = Result;
				if (result != null)
				{
					return result.ToString();
				}
			}
			return string.Empty;
		}
	}
	internal static class TaskToApm
	{
		internal sealed class TaskAsyncResult : IAsyncResult
		{
			internal readonly Task _task;

			private readonly AsyncCallback _callback;

			public object AsyncState { get; }

			public bool CompletedSynchronously { get; }

			public bool IsCompleted => _task.IsCompleted;

			public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

			internal TaskAsyncResult(Task task, object state, AsyncCallback callback)
			{
				_task = task;
				AsyncState = state;
				if (task.IsCompleted)
				{
					CompletedSynchronously = true;
					callback?.Invoke(this);
				}
				else if (callback != null)
				{
					_callback = callback;
					_task.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter().OnCompleted(InvokeCallback);
				}
			}

			private void InvokeCallback()
			{
				_callback(this);
			}
		}

		public static IAsyncResult Begin(Task task, AsyncCallback callback, object state)
		{
			return new TaskAsyncResult(task, state, callback);
		}

		public static void End(IAsyncResult asyncResult)
		{
			Task task = GetTask(asyncResult);
			if (task != null)
			{
				task.GetAwaiter().GetResult();
			}
			else
			{
				ThrowArgumentException(asyncResult);
			}
		}

		public static TResult End<TResult>(IAsyncResult asyncResult)
		{
			if (GetTask(asyncResult) is Task<TResult> task)
			{
				return task.GetAwaiter().GetResult();
			}
			ThrowArgumentException(asyncResult);
			return default(TResult);
		}

		public static Task GetTask(IAsyncResult asyncResult)
		{
			return (asyncResult as TaskAsyncResult)?._task;
		}

		[DoesNotReturn]
		private static void ThrowArgumentException(IAsyncResult asyncResult)
		{
			throw (asyncResult == null) ? new ArgumentNullException("asyncResult") : new ArgumentException(null, "asyncResult");
		}
	}
}
namespace System.Threading.Tasks.Sources
{
	[Flags]
	public enum ValueTaskSourceOnCompletedFlags
	{
		None = 0,
		UseSchedulingContext = 1,
		FlowExecutionContext = 2
	}
	public enum ValueTaskSourceStatus
	{
		Pending,
		Succeeded,
		Faulted,
		Canceled
	}
	public interface IValueTaskSource
	{
		ValueTaskSourceStatus GetStatus(short token);

		void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags);

		void GetResult(short token);
	}
	public interface IValueTaskSource<out TResult>
	{
		ValueTaskSourceStatus GetStatus(short token);

		void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags);

		TResult GetResult(short token);
	}
	[StructLayout(LayoutKind.Auto)]
	public struct ManualResetValueTaskSourceCore<TResult>
	{
		private Action<object> _continuation;

		private object _continuationState;

		private ExecutionContext _executionContext;

		private object _capturedContext;

		private bool _completed;

		private TResult _result;

		private ExceptionDispatchInfo _error;

		private short _version;

		public bool RunContinuationsAsynchronously { get; set; }

		public short Version => _version;

		public void Reset()
		{
			_version++;
			_completed = false;
			_result = default(TResult);
			_error = null;
			_executionContext = null;
			_capturedContext = null;
			_continuation = null;
			_continuationState = null;
		}

		public void SetResult(TResult result)
		{
			_result = result;
			SignalCompletion();
		}

		public void SetException(Exception error)
		{
			_error = ExceptionDispatchInfo.Capture(error);
			SignalCompletion();
		}

		public ValueTaskSourceStatus GetStatus(short token)
		{
			ValidateToken(token);
			if (_continuation != null && _completed)
			{
				if (_error != null)
				{
					if (!(_error.SourceException is OperationCanceledException))
					{
						return ValueTaskSourceStatus.Faulted;
					}
					return ValueTaskSourceStatus.Canceled;
				}
				return ValueTaskSourceStatus.Succeeded;
			}
			return ValueTaskSourceStatus.Pending;
		}

		[StackTraceHidden]
		public TResult GetResult(short token)
		{
			if (token != _version || !_completed || _error != null)
			{
				ThrowForFailedGetResult(token);
			}
			return _result;
		}

		[StackTraceHidden]
		private void ThrowForFailedGetResult(short token)
		{
			if (token != _version || !_completed)
			{
				ThrowHelper.ThrowInvalidOperationException();
			}
			_error?.Throw();
		}

		public void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags)
		{
			if (continuation == null)
			{
				throw new ArgumentNullException("continuation");
			}
			ValidateToken(token);
			if ((flags & ValueTaskSourceOnCompletedFlags.FlowExecutionContext) != 0)
			{
				_executionContext = ExecutionContext.Capture();
			}
			if ((flags & ValueTaskSourceOnCompletedFlags.UseSchedulingContext) != 0)
			{
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && current.GetType() != typeof(SynchronizationContext))
				{
					_capturedContext = current;
				}
				else
				{
					TaskScheduler current2 = TaskScheduler.Current;
					if (current2 != TaskScheduler.Default)
					{
						_capturedContext = current2;
					}
				}
			}
			object obj = _continuation;
			if (obj == null)
			{
				_continuationState = state;
				obj = Interlocked.CompareExchange(ref _continuation, continuation, null);
			}
			if (obj == null)
			{
				return;
			}
			if (obj != ManualResetValueTaskSourceCoreShared.s_sentinel)
			{
				ThrowHelper.ThrowInvalidOperationException();
			}
			object capturedContext = _capturedContext;
			if (capturedContext != null)
			{
				if (!(capturedContext is SynchronizationContext synchronizationContext))
				{
					if (capturedContext is TaskScheduler scheduler)
					{
						Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler);
					}
				}
				else
				{
					synchronizationContext.Post(delegate(object s)
					{
						TupleSlim<Action<object>, object> tupleSlim = (TupleSlim<Action<object>, object>)s;
						tupleSlim.Item1(tupleSlim.Item2);
					}, new TupleSlim<Action<object>, object>(continuation, state));
				}
			}
			else if (_executionContext != null)
			{
				ThreadPool.QueueUserWorkItem<object>(continuation, state, preferLocal: true);
			}
			else
			{
				ThreadPool.UnsafeQueueUserWorkItem<object>(continuation, state, preferLocal: true);
			}
		}

		private void ValidateToken(short token)
		{
			if (token != _version)
			{
				ThrowHelper.ThrowInvalidOperationException();
			}
		}

		private void SignalCompletion()
		{
			if (_completed)
			{
				ThrowHelper.ThrowInvalidOperationException();
			}
			_completed = true;
			if (_continuation == null && Interlocked.CompareExchange(ref _continuation, ManualResetValueTaskSourceCoreShared.s_sentinel, null) == null)
			{
				return;
			}
			if (_executionContext == null)
			{
				if (_capturedContext == null)
				{
					if (RunContinuationsAsynchronously)
					{
						ThreadPool.UnsafeQueueUserWorkItem(_continuation, _continuationState, preferLocal: true);
					}
					else
					{
						_continuation(_continuationState);
					}
				}
				else
				{
					InvokeSchedulerContinuation();
				}
			}
			else
			{
				InvokeContinuationWithContext();
			}
		}

		private void InvokeContinuationWithContext()
		{
			ExecutionContext executionContext = ExecutionContext.CaptureForRestore();
			ExecutionContext.Restore(_executionContext);
			if (_capturedContext == null)
			{
				if (RunContinuationsAsynchronously)
				{
					try
					{
						ThreadPool.QueueUserWorkItem(_continuation, _continuationState, preferLocal: true);
						return;
					}
					finally
					{
						ExecutionContext.RestoreInternal(executionContext);
					}
				}
				ExceptionDispatchInfo exceptionDispatchInfo = null;
				SynchronizationContext current = SynchronizationContext.Current;
				try
				{
					_continuation(_continuationState);
				}
				catch (Exception source)
				{
					exceptionDispatchInfo = ExceptionDispatchInfo.Capture(source);
				}
				finally
				{
					SynchronizationContext.SetSynchronizationContext(current);
					ExecutionContext.RestoreInternal(executionContext);
				}
				exceptionDispatchInfo?.Throw();
				return;
			}
			try
			{
				InvokeSchedulerContinuation();
			}
			finally
			{
				ExecutionContext.RestoreInternal(executionContext);
			}
		}

		private void InvokeSchedulerContinuation()
		{
			object capturedContext = _capturedContext;
			if (!(capturedContext is SynchronizationContext synchronizationContext))
			{
				if (capturedContext is TaskScheduler scheduler)
				{
					Task.Factory.StartNew(_continuation, _continuationState, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler);
				}
			}
			else
			{
				synchronizationContext.Post(delegate(object s)
				{
					TupleSlim<Action<object>, object> tupleSlim = (TupleSlim<Action<object>, object>)s;
					tupleSlim.Item1(tupleSlim.Item2);
				}, new TupleSlim<Action<object>, object>(_continuation, _continuationState));
			}
		}
	}
	internal static class ManualResetValueTaskSourceCoreShared
	{
		internal static readonly Action<object> s_sentinel = CompletionSentinel;

		private static void CompletionSentinel(object _)
		{
			ThrowHelper.ThrowInvalidOperationException();
		}
	}
}
namespace System.Text
{
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class StringBuilder : ISerializable
	{
		public struct ChunkEnumerator
		{
			private sealed class ManyChunkInfo
			{
				private readonly StringBuilder[] _chunks;

				private int _chunkPos;

				public bool MoveNext(ref StringBuilder current)
				{
					int num = ++_chunkPos;
					if (_chunks.Length <= num)
					{
						return false;
					}
					current = _chunks[num];
					return true;
				}

				public ManyChunkInfo(StringBuilder stringBuilder, int chunkCount)
				{
					_chunks = new StringBuilder[chunkCount];
					while (0 <= --chunkCount)
					{
						_chunks[chunkCount] = stringBuilder;
						stringBuilder = stringBuilder.m_ChunkPrevious;
					}
					_chunkPos = -1;
				}
			}

			private readonly StringBuilder _firstChunk;

			private StringBuilder _currentChunk;

			private readonly ManyChunkInfo _manyChunks;

			public ReadOnlyMemory<char> Current
			{
				get
				{
					if (_currentChunk == null)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return new ReadOnlyMemory<char>(_currentChunk.m_ChunkChars, 0, _currentChunk.m_ChunkLength);
				}
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			public ChunkEnumerator GetEnumerator()
			{
				return this;
			}

			public bool MoveNext()
			{
				if (_currentChunk == _firstChunk)
				{
					return false;
				}
				if (_manyChunks != null)
				{
					return _manyChunks.MoveNext(ref _currentChunk);
				}
				StringBuilder stringBuilder = _firstChunk;
				while (stringBuilder.m_ChunkPrevious != _currentChunk)
				{
					stringBuilder = stringBuilder.m_ChunkPrevious;
				}
				_currentChunk = stringBuilder;
				return true;
			}

			internal ChunkEnumerator(StringBuilder stringBuilder)
			{
				_firstChunk = stringBuilder;
				_currentChunk = null;
				_manyChunks = null;
				int num = ChunkCount(stringBuilder);
				if (8 < num)
				{
					_manyChunks = new ManyChunkInfo(stringBuilder, num);
				}
			}

			private static int ChunkCount(StringBuilder stringBuilder)
			{
				int num = 0;
				while (stringBuilder != null)
				{
					num++;
					stringBuilder = stringBuilder.m_ChunkPrevious;
				}
				return num;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[InterpolatedStringHandler]
		public struct AppendInterpolatedStringHandler
		{
			internal readonly StringBuilder _stringBuilder;

			private readonly IFormatProvider _provider;

			private readonly bool _hasCustomFormatter;

			public AppendInterpolatedStringHandler(int literalLength, int formattedCount, StringBuilder stringBuilder)
			{
				_stringBuilder = stringBuilder;
				_provider = null;
				_hasCustomFormatter = false;
			}

			public AppendInterpolatedStringHandler(int literalLength, int formattedCount, StringBuilder stringBuilder, IFormatProvider? provider)
			{
				_stringBuilder = stringBuilder;
				_provider = provider;
				_hasCustomFormatter = provider != null && DefaultInterpolatedStringHandler.HasCustomFormatter(provider);
			}

			public void AppendLiteral(string value)
			{
				_stringBuilder.Append(value);
			}

			public void AppendFormatted<T>(T value)
			{
				if (_hasCustomFormatter)
				{
					AppendCustomFormatter(value, null);
				}
				else if (value is IFormattable)
				{
					if (value is ISpanFormattable)
					{
						Span<char> remainingCurrentChunk = _stringBuilder.RemainingCurrentChunk;
						if (((ISpanFormattable)(object)value).TryFormat(remainingCurrentChunk, out var charsWritten, default(ReadOnlySpan<char>), _provider))
						{
							if ((uint)charsWritten > (uint)remainingCurrentChunk.Length)
							{
								FormatError();
							}
							_stringBuilder.m_ChunkLength += charsWritten;
						}
						else
						{
							AppendFormattedWithTempSpace(value, 0, null);
						}
					}
					else
					{
						_stringBuilder.Append(((IFormattable)(object)value).ToString(null, _provider));
					}
				}
				else if (value != null)
				{
					_stringBuilder.Append(value.ToString());
				}
			}

			public void AppendFormatted<T>(T value, string? format)
			{
				if (_hasCustomFormatter)
				{
					AppendCustomFormatter(value, format);
				}
				else if (value is IFormattable)
				{
					if (value is ISpanFormattable)
					{
						Span<char> remainingCurrentChunk = _stringBuilder.RemainingCurrentChunk;
						if (((ISpanFormattable)(object)value).TryFormat(remainingCurrentChunk, out var charsWritten, format, _provider))
						{
							if ((uint)charsWritten > (uint)remainingCurrentChunk.Length)
							{
								FormatError();
							}
							_stringBuilder.m_ChunkLength += charsWritten;
						}
						else
						{
							AppendFormattedWithTempSpace(value, 0, format);
						}
					}
					else
					{
						_stringBuilder.Append(((IFormattable)(object)value).ToString(format, _provider));
					}
				}
				else if (value != null)
				{
					_stringBuilder.Append(value.ToString());
				}
			}

			public void AppendFormatted<T>(T value, int alignment)
			{
				AppendFormatted(value, alignment, null);
			}

			public void AppendFormatted<T>(T value, int alignment, string? format)
			{
				if (alignment == 0)
				{
					AppendFormatted(value, format);
				}
				else if (alignment < 0)
				{
					int length = _stringBuilder.Length;
					AppendFormatted(value, format);
					int num = -alignment - (_stringBuilder.Length - length);
					if (num > 0)
					{
						_stringBuilder.Append(' ', num);
					}
				}
				else
				{
					AppendFormattedWithTempSpace(value, alignment, format);
				}
			}

			private void AppendFormattedWithTempSpace<T>(T value, int alignment, string format)
			{
				IFormatProvider provider = _provider;
				Span<char> initialBuffer = stackalloc char[256];
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(0, 0, provider, initialBuffer);
				defaultInterpolatedStringHandler.AppendFormatted(value, format);
				AppendFormatted(defaultInterpolatedStringHandler.Text, alignment);
				defaultInterpolatedStringHandler.Clear();
			}

			public void AppendFormatted(ReadOnlySpan<char> value)
			{
				_stringBuilder.Append(value);
			}

			public void AppendFormatted(ReadOnlySpan<char> value, int alignment = 0, string? format = null)
			{
				if (alignment == 0)
				{
					_stringBuilder.Append(value);
					return;
				}
				bool flag = false;
				if (alignment < 0)
				{
					flag = true;
					alignment = -alignment;
				}
				int num = alignment - value.Length;
				if (num <= 0)
				{
					_stringBuilder.Append(value);
				}
				else if (flag)
				{
					_stringBuilder.Append(value);
					_stringBuilder.Append(' ', num);
				}
				else
				{
					_stringBuilder.Append(' ', num);
					_stringBuilder.Append(value);
				}
			}

			public void AppendFormatted(string? value)
			{
				if (!_hasCustomFormatter)
				{
					_stringBuilder.Append(value);
				}
				else
				{
					this.AppendFormatted<string>(value);
				}
			}

			public void AppendFormatted(string? value, int alignment = 0, string? format = null)
			{
				this.AppendFormatted<string>(value, alignment, format);
			}

			public void AppendFormatted(object? value, int alignment = 0, string? format = null)
			{
				this.AppendFormatted<object>(value, alignment, format);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private void AppendCustomFormatter<T>(T value, string format)
			{
				ICustomFormatter customFormatter = (ICustomFormatter)_provider.GetFormat(typeof(ICustomFormatter));
				if (customFormatter != null)
				{
					_stringBuilder.Append(customFormatter.Format(format, value, _provider));
				}
			}
		}

		internal char[] m_ChunkChars;

		internal StringBuilder m_ChunkPrevious;

		internal int m_ChunkLength;

		internal int m_ChunkOffset;

		internal int m_MaxCapacity;

		public int Capacity
		{
			get
			{
				return m_ChunkChars.Length + m_ChunkOffset;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_NegativeCapacity);
				}
				if (value > MaxCapacity)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_Capacity);
				}
				if (value < Length)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_SmallCapacity);
				}
				if (Capacity != value)
				{
					int length = value - m_ChunkOffset;
					char[] array = GC.AllocateUninitializedArray<char>(length);
					Array.Copy(m_ChunkChars, array, m_ChunkLength);
					m_ChunkChars = array;
				}
			}
		}

		public int MaxCapacity => m_MaxCapacity;

		public int Length
		{
			get
			{
				return m_ChunkOffset + m_ChunkLength;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_NegativeLength);
				}
				if (value > MaxCapacity)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_SmallCapacity);
				}
				if (value == 0 && m_ChunkPrevious == null)
				{
					m_ChunkLength = 0;
					m_ChunkOffset = 0;
					return;
				}
				int num = value - Length;
				if (num > 0)
				{
					Append('\0', num);
					return;
				}
				StringBuilder stringBuilder = FindChunkForIndex(value);
				if (stringBuilder != this)
				{
					int num2 = Math.Min(Capacity, Math.Max(Length * 6 / 5, m_ChunkChars.Length));
					int num3 = num2 - stringBuilder.m_ChunkOffset;
					if (num3 > stringBuilder.m_ChunkChars.Length)
					{
						char[] array = GC.AllocateUninitializedArray<char>(num3);
						Array.Copy(stringBuilder.m_ChunkChars, array, stringBuilder.m_ChunkLength);
						m_ChunkChars = array;
					}
					else
					{
						m_ChunkChars = stringBuilder.m_ChunkChars;
					}
					m_ChunkPrevious = stringBuilder.m_ChunkPrevious;
					m_ChunkOffset = stringBuilder.m_ChunkOffset;
				}
				m_ChunkLength = value - stringBuilder.m_ChunkOffset;
			}
		}

		[IndexerName("Chars")]
		public char this[int index]
		{
			get
			{
				StringBuilder stringBuilder = this;
				do
				{
					int num = index - stringBuilder.m_ChunkOffset;
					if (num >= 0)
					{
						if (num >= stringBuilder.m_ChunkLength)
						{
							throw new IndexOutOfRangeException();
						}
						return stringBuilder.m_ChunkChars[num];
					}
					stringBuilder = stringBuilder.m_ChunkPrevious;
				}
				while (stringBuilder != null);
				throw new IndexOutOfRangeException();
			}
			set
			{
				StringBuilder stringBuilder = this;
				do
				{
					int num = index - stringBuilder.m_ChunkOffset;
					if (num >= 0)
					{
						if (num >= stringBuilder.m_ChunkLength)
						{
							throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
						}
						stringBuilder.m_ChunkChars[num] = value;
						return;
					}
					stringBuilder = stringBuilder.m_ChunkPrevious;
				}
				while (stringBuilder != null);
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
		}

		private Span<char> RemainingCurrentChunk
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return new Span<char>(m_ChunkChars, m_ChunkLength, m_ChunkChars.Length - m_ChunkLength);
			}
		}

		private int GetReplaceBufferCapacity(int requiredCapacity)
		{
			int num = Capacity;
			if (num < requiredCapacity)
			{
				num = (requiredCapacity + 1) & -2;
			}
			return num;
		}

		internal unsafe void ReplaceBufferInternal(char* newBuffer, int newLength)
		{
			if (newLength > m_MaxCapacity)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_Capacity);
			}
			if (newLength > m_ChunkChars.Length)
			{
				m_ChunkChars = new char[GetReplaceBufferCapacity(newLength)];
			}
			new Span<char>(newBuffer, newLength).CopyTo(m_ChunkChars);
			m_ChunkLength = newLength;
			m_ChunkPrevious = null;
			m_ChunkOffset = 0;
		}

		internal void ReplaceBufferUtf8Internal(ReadOnlySpan<byte> source)
		{
			if (source.Length > m_MaxCapacity)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_Capacity);
			}
			int charCount = Encoding.UTF8.GetCharCount(source);
			if (charCount > m_ChunkChars.Length)
			{
				m_ChunkChars = new char[GetReplaceBufferCapacity(charCount)];
			}
			m_ChunkLength = Encoding.UTF8.GetChars(source, m_ChunkChars);
			m_ChunkPrevious = null;
			m_ChunkOffset = 0;
		}

		internal unsafe void ReplaceBufferAnsiInternal(sbyte* newBuffer, int newLength)
		{
			if (newLength > m_MaxCapacity)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_Capacity);
			}
			if (newLength > m_ChunkChars.Length)
			{
				m_ChunkChars = new char[GetReplaceBufferCapacity(newLength)];
			}
			int chunkLength;
			fixed (char* lpWideCharStr = m_ChunkChars)
			{
				chunkLength = Interop.Kernel32.MultiByteToWideChar(0u, 1u, (byte*)newBuffer, newLength, lpWideCharStr, newLength);
			}
			m_ChunkOffset = 0;
			m_ChunkLength = chunkLength;
			m_ChunkPrevious = null;
		}

		internal unsafe void InternalCopy(IntPtr dest, int charLen)
		{
			CopyTo(0, new Span<char>((void*)dest, charLen), charLen);
		}

		public StringBuilder()
		{
			m_MaxCapacity = int.MaxValue;
			m_ChunkChars = new char[16];
		}

		public StringBuilder(int capacity)
			: this(capacity, int.MaxValue)
		{
		}

		public StringBuilder(string? value)
			: this(value, 16)
		{
		}

		public StringBuilder(string? value, int capacity)
			: this(value, 0, value?.Length ?? 0, capacity)
		{
		}

		public StringBuilder(string? value, int startIndex, int length, int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.Format(SR.ArgumentOutOfRange_MustBePositive, "capacity"));
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.Format(SR.ArgumentOutOfRange_MustBeNonNegNum, "length"));
			}
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (value == null)
			{
				value = string.Empty;
			}
			if (startIndex > value.Length - length)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_IndexLength);
			}
			m_MaxCapacity = int.MaxValue;
			if (capacity == 0)
			{
				capacity = 16;
			}
			capacity = Math.Max(capacity, length);
			m_ChunkChars = GC.AllocateUninitializedArray<char>(capacity);
			m_ChunkLength = length;
			value.AsSpan(startIndex, length).CopyTo(m_ChunkChars);
		}

		public StringBuilder(int capacity, int maxCapacity)
		{
			if (capacity > maxCapacity)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_Capacity);
			}
			if (maxCapacity < 1)
			{
				throw new ArgumentOutOfRangeException("maxCapacity", SR.ArgumentOutOfRange_SmallMaxCapacity);
			}
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.Format(SR.ArgumentOutOfRange_MustBePositive, "capacity"));
			}
			if (capacity == 0)
			{
				capacity = Math.Min(16, maxCapacity);
			}
			m_MaxCapacity = maxCapacity;
			m_ChunkChars = GC.AllocateUninitializedArray<char>(capacity);
		}

		private StringBuilder(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			int num = 0;
			string text = null;
			int num2 = int.MaxValue;
			bool flag = false;
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (enumerator.MoveNext())
			{
				switch (enumerator.Name)
				{
				case "m_MaxCapacity":
					num2 = info.GetInt32("m_MaxCapacity");
					break;
				case "m_StringValue":
					text = info.GetString("m_StringValue");
					break;
				case "Capacity":
					num = info.GetInt32("Capacity");
					flag = true;
					break;
				}
			}
			if (text == null)
			{
				text = string.Empty;
			}
			if (num2 < 1 || text.Length > num2)
			{
				throw new SerializationException(SR.Serialization_StringBuilderMaxCapacity);
			}
			if (!flag)
			{
				num = Math.Min(Math.Max(16, text.Length), num2);
			}
			if (num < 0 || num < text.Length || num > num2)
			{
				throw new SerializationException(SR.Serialization_StringBuilderCapacity);
			}
			m_MaxCapacity = num2;
			m_ChunkChars = GC.AllocateUninitializedArray<char>(num);
			text.CopyTo(0, m_ChunkChars, 0, text.Length);
			m_ChunkLength = text.Length;
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("m_MaxCapacity", m_MaxCapacity);
			info.AddValue("Capacity", Capacity);
			info.AddValue("m_StringValue", ToString());
			info.AddValue("m_currentThread", 0);
		}

		public int EnsureCapacity(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_NegativeCapacity);
			}
			if (Capacity < capacity)
			{
				Capacity = capacity;
			}
			return Capacity;
		}

		public override string ToString()
		{
			if (Length == 0)
			{
				return string.Empty;
			}
			string text = string.FastAllocateString(Length);
			StringBuilder stringBuilder = this;
			do
			{
				if (stringBuilder.m_ChunkLength > 0)
				{
					char[] chunkChars = stringBuilder.m_ChunkChars;
					int chunkOffset = stringBuilder.m_ChunkOffset;
					int chunkLength = stringBuilder.m_ChunkLength;
					if ((uint)(chunkLength + chunkOffset) > (uint)text.Length || (uint)chunkLength > (uint)chunkChars.Length)
					{
						throw new ArgumentOutOfRangeException("chunkLength", SR.ArgumentOutOfRange_Index);
					}
					Buffer.Memmove(ref Unsafe.Add(ref text.GetRawStringData(), chunkOffset), ref MemoryMarshal.GetArrayDataReference(chunkChars), (nuint)chunkLength);
				}
				stringBuilder = stringBuilder.m_ChunkPrevious;
			}
			while (stringBuilder != null);
			return text;
		}

		public unsafe string ToString(int startIndex, int length)
		{
			int length2 = Length;
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (startIndex > length2)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndexLargerThanLength);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NegativeLength);
			}
			if (startIndex > length2 - length)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_IndexLength);
			}
			string text = string.FastAllocateString(length);
			fixed (char* pointer = text)
			{
				CopyTo(startIndex, new Span<char>(pointer, length), length);
				return text;
			}
		}

		public StringBuilder Clear()
		{
			Length = 0;
			return this;
		}

		public ChunkEnumerator GetChunks()
		{
			return new ChunkEnumerator(this);
		}

		public StringBuilder Append(char value, int repeatCount)
		{
			if (repeatCount < 0)
			{
				throw new ArgumentOutOfRangeException("repeatCount", SR.ArgumentOutOfRange_NegativeCount);
			}
			if (repeatCount == 0)
			{
				return this;
			}
			int num = Length + repeatCount;
			if (num > m_MaxCapacity || num < repeatCount)
			{
				throw new ArgumentOutOfRangeException("repeatCount", SR.ArgumentOutOfRange_LengthGreaterThanCapacity);
			}
			int num2 = m_ChunkLength;
			while (repeatCount > 0)
			{
				if (num2 < m_ChunkChars.Length)
				{
					m_ChunkChars[num2++] = value;
					repeatCount--;
				}
				else
				{
					m_ChunkLength = num2;
					ExpandByABlock(repeatCount);
					num2 = 0;
				}
			}
			m_ChunkLength = num2;
			return this;
		}

		public unsafe StringBuilder Append(char[]? value, int startIndex, int charCount)
		{
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (charCount < 0)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (value == null)
			{
				if (startIndex == 0 && charCount == 0)
				{
					return this;
				}
				throw new ArgumentNullException("value");
			}
			if (charCount > value.Length - startIndex)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_Index);
			}
			if (charCount == 0)
			{
				return this;
			}
			fixed (char* value2 = &value[startIndex])
			{
				Append(value2, charCount);
				return this;
			}
		}

		public StringBuilder Append(string? value)
		{
			if (value != null)
			{
				char[] chunkChars = m_ChunkChars;
				int chunkLength = m_ChunkLength;
				int length = value.Length;
				if ((uint)(chunkLength + length) < (uint)chunkChars.Length)
				{
					if (length <= 2)
					{
						if (length > 0)
						{
							chunkChars[chunkLength] = value[0];
						}
						if (length > 1)
						{
							chunkChars[chunkLength + 1] = value[1];
						}
					}
					else
					{
						Buffer.Memmove(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength), ref value.GetRawStringData(), (nuint)length);
					}
					m_ChunkLength = chunkLength + length;
				}
				else
				{
					AppendHelper(value);
				}
			}
			return this;
		}

		private unsafe void AppendHelper(string value)
		{
			fixed (char* value2 = value)
			{
				Append(value2, value.Length);
			}
		}

		public unsafe StringBuilder Append(string? value, int startIndex, int count)
		{
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (value == null)
			{
				if (startIndex == 0 && count == 0)
				{
					return this;
				}
				throw new ArgumentNullException("value");
			}
			if (count == 0)
			{
				return this;
			}
			if (startIndex > value.Length - count)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			fixed (char* ptr = value)
			{
				Append(ptr + startIndex, count);
				return this;
			}
		}

		public StringBuilder Append(StringBuilder? value)
		{
			if (value != null && value.Length != 0)
			{
				return AppendCore(value, 0, value.Length);
			}
			return this;
		}

		public StringBuilder Append(StringBuilder? value, int startIndex, int count)
		{
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (value == null)
			{
				if (startIndex == 0 && count == 0)
				{
					return this;
				}
				throw new ArgumentNullException("value");
			}
			if (count == 0)
			{
				return this;
			}
			if (count > value.Length - startIndex)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			return AppendCore(value, startIndex, count);
		}

		private StringBuilder AppendCore(StringBuilder value, int startIndex, int count)
		{
			if (value == this)
			{
				return Append(value.ToString(startIndex, count));
			}
			int num = Length + count;
			if ((uint)num > (uint)m_MaxCapacity)
			{
				throw new ArgumentOutOfRangeException("Capacity", SR.ArgumentOutOfRange_Capacity);
			}
			while (count > 0)
			{
				int num2 = Math.Min(m_ChunkChars.Length - m_ChunkLength, count);
				if (num2 == 0)
				{
					ExpandByABlock(count);
					num2 = Math.Min(m_ChunkChars.Length - m_ChunkLength, count);
				}
				value.CopyTo(startIndex, new Span<char>(m_ChunkChars, m_ChunkLength, num2), num2);
				m_ChunkLength += num2;
				startIndex += num2;
				count -= num2;
			}
			return this;
		}

		public StringBuilder AppendLine()
		{
			return Append(Environment.NewLine);
		}

		public StringBuilder AppendLine(string? value)
		{
			Append(value);
			return Append(Environment.NewLine);
		}

		public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			if (destinationIndex < 0)
			{
				throw new ArgumentOutOfRangeException("destinationIndex", SR.Format(SR.ArgumentOutOfRange_MustBeNonNegNum, "destinationIndex"));
			}
			if (destinationIndex > destination.Length - count)
			{
				throw new ArgumentException(SR.ArgumentOutOfRange_OffsetOut);
			}
			CopyTo(sourceIndex, new Span<char>(destination).Slice(destinationIndex), count);
		}

		public void CopyTo(int sourceIndex, Span<char> destination, int count)
		{
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.Arg_NegativeArgCount);
			}
			if ((uint)sourceIndex > (uint)Length)
			{
				throw new ArgumentOutOfRangeException("sourceIndex", SR.ArgumentOutOfRange_Index);
			}
			if (sourceIndex > Length - count)
			{
				throw new ArgumentException(SR.Arg_LongerThanSrcString);
			}
			StringBuilder stringBuilder = this;
			int num = sourceIndex + count;
			int num2 = count;
			while (count > 0)
			{
				int num3 = num - stringBuilder.m_ChunkOffset;
				if (num3 >= 0)
				{
					num3 = Math.Min(num3, stringBuilder.m_ChunkLength);
					int num4 = count;
					int num5 = num3 - count;
					if (num5 < 0)
					{
						num4 += num5;
						num5 = 0;
					}
					num2 -= num4;
					count -= num4;
					new ReadOnlySpan<char>(stringBuilder.m_ChunkChars, num5, num4).CopyTo(destination.Slice(num2));
				}
				stringBuilder = stringBuilder.m_ChunkPrevious;
			}
		}

		public unsafe StringBuilder Insert(int index, string? value, int count)
		{
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			int length = Length;
			if ((uint)index > (uint)length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (string.IsNullOrEmpty(value) || count == 0)
			{
				return this;
			}
			long num = (long)value.Length * (long)count;
			if (num > MaxCapacity - Length)
			{
				throw new OutOfMemoryException();
			}
			MakeRoom(index, (int)num, out var chunk, out var indexInChunk, doNotMoveFollowingChars: false);
			fixed (char* value2 = value)
			{
				while (count > 0)
				{
					ReplaceInPlaceAtChunk(ref chunk, ref indexInChunk, value2, value.Length);
					count--;
				}
				return this;
			}
		}

		public StringBuilder Remove(int startIndex, int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NegativeLength);
			}
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (length > Length - startIndex)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_Index);
			}
			if (Length == length && startIndex == 0)
			{
				Length = 0;
				return this;
			}
			if (length > 0)
			{
				Remove(startIndex, length, out var _, out var _);
			}
			return this;
		}

		public StringBuilder Append(bool value)
		{
			return Append(value.ToString());
		}

		public StringBuilder Append(char value)
		{
			int chunkLength = m_ChunkLength;
			char[] chunkChars = m_ChunkChars;
			if ((uint)chunkChars.Length > (uint)chunkLength)
			{
				chunkChars[chunkLength] = value;
				m_ChunkLength++;
			}
			else
			{
				Append(value, 1);
			}
			return this;
		}

		[CLSCompliant(false)]
		public StringBuilder Append(sbyte value)
		{
			return AppendSpanFormattable(value);
		}

		public StringBuilder Append(byte value)
		{
			return AppendSpanFormattable(value);
		}

		public StringBuilder Append(short value)
		{
			return AppendSpanFormattable(value);
		}

		public StringBuilder Append(int value)
		{
			return AppendSpanFormattable(value);
		}

		public StringBuilder Append(long value)
		{
			return AppendSpanFormattable(value);
		}

		public StringBuilder Append(float value)
		{
			return AppendSpanFormattable(value);
		}

		public StringBuilder Append(double value)
		{
			return AppendSpanFormattable(value);
		}

		public StringBuilder Append(decimal value)
		{
			return AppendSpanFormattable(value);
		}

		[CLSCompliant(false)]
		public StringBuilder Append(ushort value)
		{
			return AppendSpanFormattable(value);
		}

		[CLSCompliant(false)]
		public StringBuilder Append(uint value)
		{
			return AppendSpanFormattable(value);
		}

		[CLSCompliant(false)]
		public StringBuilder Append(ulong value)
		{
			return AppendSpanFormattable(value);
		}

		private StringBuilder AppendSpanFormattable<T>(T value) where T : ISpanFormattable
		{
			if (value.TryFormat(RemainingCurrentChunk, out var charsWritten, default(ReadOnlySpan<char>), null))
			{
				m_ChunkLength += charsWritten;
				return this;
			}
			return Append(value.ToString());
		}

		internal StringBuilder AppendSpanFormattable<T>(T value, string format, IFormatProvider provider) where T : ISpanFormattable
		{
			if (value.TryFormat(RemainingCurrentChunk, out var charsWritten, format, provider))
			{
				m_ChunkLength += charsWritten;
				return this;
			}
			return Append(value.ToString(format, provider));
		}

		public StringBuilder Append(object? value)
		{
			if (value != null)
			{
				return Append(value.ToString());
			}
			return this;
		}

		public unsafe StringBuilder Append(char[]? value)
		{
			if (value != null && value.Length != 0)
			{
				fixed (char* value2 = &value[0])
				{
					Append(value2, value.Length);
				}
			}
			return this;
		}

		public unsafe StringBuilder Append(ReadOnlySpan<char> value)
		{
			if (value.Length > 0)
			{
				fixed (char* value2 = &MemoryMarshal.GetReference(value))
				{
					Append(value2, value.Length);
				}
			}
			return this;
		}

		public StringBuilder Append(ReadOnlyMemory<char> value)
		{
			return Append(value.Span);
		}

		public StringBuilder Append([InterpolatedStringHandlerArgument("")] ref AppendInterpolatedStringHandler handler)
		{
			return this;
		}

		public StringBuilder Append(IFormatProvider? provider, [InterpolatedStringHandlerArgument(new string[] { "", "provider" })] ref AppendInterpolatedStringHandler handler)
		{
			return this;
		}

		public StringBuilder AppendLine([InterpolatedStringHandlerArgument("")] ref AppendInterpolatedStringHandler handler)
		{
			return AppendLine();
		}

		public StringBuilder AppendLine(IFormatProvider? provider, [InterpolatedStringHandlerArgument(new string[] { "", "provider" })] ref AppendInterpolatedStringHandler handler)
		{
			return AppendLine();
		}

		public unsafe StringBuilder AppendJoin(string? separator, params object?[] values)
		{
			if (separator == null)
			{
				separator = string.Empty;
			}
			fixed (char* separator2 = separator)
			{
				return AppendJoinCore(separator2, separator.Length, values);
			}
		}

		public unsafe StringBuilder AppendJoin<T>(string? separator, IEnumerable<T> values)
		{
			if (separator == null)
			{
				separator = string.Empty;
			}
			fixed (char* separator2 = separator)
			{
				return AppendJoinCore(separator2, separator.Length, values);
			}
		}

		public unsafe StringBuilder AppendJoin(string? separator, params string?[] values)
		{
			if (separator == null)
			{
				separator = string.Empty;
			}
			fixed (char* separator2 = separator)
			{
				return AppendJoinCore(separator2, separator.Length, values);
			}
		}

		public unsafe StringBuilder AppendJoin(char separator, params object?[] values)
		{
			return AppendJoinCore(&separator, 1, values);
		}

		public unsafe StringBuilder AppendJoin<T>(char separator, IEnumerable<T> values)
		{
			return AppendJoinCore(&separator, 1, values);
		}

		public unsafe StringBuilder AppendJoin(char separator, params string?[] values)
		{
			return AppendJoinCore(&separator, 1, values);
		}

		private unsafe StringBuilder AppendJoinCore<T>(char* separator, int separatorLength, IEnumerable<T> values)
		{
			if (values == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.values);
			}
			using IEnumerator<T> enumerator = values.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				return this;
			}
			T current = enumerator.Current;
			if (current != null)
			{
				Append(current.ToString());
			}
			while (enumerator.MoveNext())
			{
				Append(separator, separatorLength);
				current = enumerator.Current;
				if (current != null)
				{
					Append(current.ToString());
				}
			}
			return this;
		}

		private unsafe StringBuilder AppendJoinCore<T>(char* separator, int separatorLength, T[] values)
		{
			if (values == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.values);
			}
			if (values.Length == 0)
			{
				return this;
			}
			if (values[0] != null)
			{
				Append(values[0].ToString());
			}
			for (int i = 1; i < values.Length; i++)
			{
				Append(separator, separatorLength);
				if (values[i] != null)
				{
					Append(values[i].ToString());
				}
			}
			return this;
		}

		public unsafe StringBuilder Insert(int index, string? value)
		{
			if ((uint)index > (uint)Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (value != null)
			{
				fixed (char* value2 = value)
				{
					Insert(index, value2, value.Length);
				}
			}
			return this;
		}

		public StringBuilder Insert(int index, bool value)
		{
			return Insert(index, value.ToString(), 1);
		}

		[CLSCompliant(false)]
		public StringBuilder Insert(int index, sbyte value)
		{
			return Insert(index, value.ToString(), 1);
		}

		public StringBuilder Insert(int index, byte value)
		{
			return Insert(index, value.ToString(), 1);
		}

		public StringBuilder Insert(int index, short value)
		{
			return Insert(index, value.ToString(), 1);
		}

		public unsafe StringBuilder Insert(int index, char value)
		{
			Insert(index, &value, 1);
			return this;
		}

		public StringBuilder Insert(int index, char[]? value)
		{
			if ((uint)index > (uint)Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (value != null)
			{
				Insert(index, value, 0, value.Length);
			}
			return this;
		}

		public unsafe StringBuilder Insert(int index, char[]? value, int startIndex, int charCount)
		{
			int length = Length;
			if ((uint)index > (uint)length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (value == null)
			{
				if (startIndex == 0 && charCount == 0)
				{
					return this;
				}
				throw new ArgumentNullException("value", SR.ArgumentNull_String);
			}
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (charCount < 0)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (startIndex > value.Length - charCount)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (charCount > 0)
			{
				fixed (char* value2 = &value[startIndex])
				{
					Insert(index, value2, charCount);
				}
			}
			return this;
		}

		public StringBuilder Insert(int index, int value)
		{
			return Insert(index, value.ToString(), 1);
		}

		public StringBuilder Insert(int index, long value)
		{
			return Insert(index, value.ToString(), 1);
		}

		public StringBuilder Insert(int index, float value)
		{
			return Insert(index, value.ToString(), 1);
		}

		public StringBuilder Insert(int index, double value)
		{
			return Insert(index, value.ToString(), 1);
		}

		public StringBuilder Insert(int index, decimal value)
		{
			return Insert(index, value.ToString(), 1);
		}

		[CLSCompliant(false)]
		public StringBuilder Insert(int index, ushort value)
		{
			return Insert(index, value.ToString(), 1);
		}

		[CLSCompliant(false)]
		public StringBuilder Insert(int index, uint value)
		{
			return Insert(index, value.ToString(), 1);
		}

		[CLSCompliant(false)]
		public StringBuilder Insert(int index, ulong value)
		{
			return Insert(index, value.ToString(), 1);
		}

		public StringBuilder Insert(int index, object? value)
		{
			if (value != null)
			{
				return Insert(index, value.ToString(), 1);
			}
			return this;
		}

		public unsafe StringBuilder Insert(int index, ReadOnlySpan<char> value)
		{
			if ((uint)index > (uint)Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (value.Length > 0)
			{
				fixed (char* value2 = &MemoryMarshal.GetReference(value))
				{
					Insert(index, value2, value.Length);
				}
			}
			return this;
		}

		public StringBuilder AppendFormat(string format, object? arg0)
		{
			return AppendFormatHelper(null, format, new ParamsArray(arg0));
		}

		public StringBuilder AppendFormat(string format, object? arg0, object? arg1)
		{
			return AppendFormatHelper(null, format, new ParamsArray(arg0, arg1));
		}

		public StringBuilder AppendFormat(string format, object? arg0, object? arg1, object? arg2)
		{
			return AppendFormatHelper(null, format, new ParamsArray(arg0, arg1, arg2));
		}

		public StringBuilder AppendFormat(string format, params object?[] args)
		{
			if (args == null)
			{
				string paramName = ((format == null) ? "format" : "args");
				throw new ArgumentNullException(paramName);
			}
			return AppendFormatHelper(null, format, new ParamsArray(args));
		}

		public StringBuilder AppendFormat(IFormatProvider? provider, string format, object? arg0)
		{
			return AppendFormatHelper(provider, format, new ParamsArray(arg0));
		}

		public StringBuilder AppendFormat(IFormatProvider? provider, string format, object? arg0, object? arg1)
		{
			return AppendFormatHelper(provider, format, new ParamsArray(arg0, arg1));
		}

		public StringBuilder AppendFormat(IFormatProvider? provider, string format, object? arg0, object? arg1, object? arg2)
		{
			return AppendFormatHelper(provider, format, new ParamsArray(arg0, arg1, arg2));
		}

		public StringBuilder AppendFormat(IFormatProvider? provider, string format, params object?[] args)
		{
			if (args == null)
			{
				string paramName = ((format == null) ? "format" : "args");
				throw new ArgumentNullException(paramName);
			}
			return AppendFormatHelper(provider, format, new ParamsArray(args));
		}

		private static void FormatError()
		{
			throw new FormatException(SR.Format_InvalidString);
		}

		internal StringBuilder AppendFormatHelper(IFormatProvider provider, string format, ParamsArray args)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			int length = format.Length;
			char c = '\0';
			ICustomFormatter customFormatter = null;
			if (provider != null)
			{
				customFormatter = (ICustomFormatter)provider.GetFormat(typeof(ICustomFormatter));
			}
			while (true)
			{
				if (num < length)
				{
					c = format[num];
					num++;
					if (c == '}')
					{
						if (num < length && format[num] == '}')
						{
							num++;
						}
						else
						{
							FormatError();
						}
					}
					else if (c == '{')
					{
						if (num >= length || format[num] != '{')
						{
							num--;
							goto IL_008f;
						}
						num++;
					}
					Append(c);
					continue;
				}
				goto IL_008f;
				IL_008f:
				if (num == length)
				{
					break;
				}
				num++;
				if (num == length || (c = format[num]) < '0' || c > '9')
				{
					FormatError();
				}
				int num2 = 0;
				do
				{
					num2 = num2 * 10 + c - 48;
					num++;
					if (num == length)
					{
						FormatError();
					}
					c = format[num];
				}
				while (c >= '0' && c <= '9' && num2 < 1000000);
				if (num2 >= args.Length)
				{
					throw new FormatException(SR.Format_IndexOutOfRange);
				}
				for (; num < length; num++)
				{
					if ((c = format[num]) != ' ')
					{
						break;
					}
				}
				bool flag = false;
				int num3 = 0;
				if (c == ',')
				{
					for (num++; num < length && format[num] == ' '; num++)
					{
					}
					if (num == length)
					{
						FormatError();
					}
					c = format[num];
					if (c == '-')
					{
						flag = true;
						num++;
						if (num == length)
						{
							FormatError();
						}
						c = format[num];
					}
					if (c < '0' || c > '9')
					{
						FormatError();
					}
					do
					{
						num3 = num3 * 10 + c - 48;
						num++;
						if (num == length)
						{
							FormatError();
						}
						c = format[num];
					}
					while (c >= '0' && c <= '9' && num3 < 1000000);
				}
				for (; num < length; num++)
				{
					if ((c = format[num]) != ' ')
					{
						break;
					}
				}
				object obj = args[num2];
				ReadOnlySpan<char> readOnlySpan = default(ReadOnlySpan<char>);
				switch (c)
				{
				case ':':
				{
					num++;
					int num4 = num;
					while (true)
					{
						if (num == length)
						{
							FormatError();
						}
						c = format[num];
						switch (c)
						{
						case '{':
							FormatError();
							goto IL_0205;
						default:
							goto IL_0205;
						case '}':
							break;
						}
						break;
						IL_0205:
						num++;
					}
					if (num > num4)
					{
						readOnlySpan = format.AsSpan(num4, num - num4);
					}
					break;
				}
				default:
					FormatError();
					break;
				case '}':
					break;
				}
				num++;
				string text = null;
				string text2 = null;
				if (customFormatter != null)
				{
					if (readOnlySpan.Length != 0)
					{
						text2 = new string(readOnlySpan);
					}
					text = customFormatter.Format(text2, obj, provider);
				}
				if (text == null)
				{
					if (obj is ISpanFormattable spanFormattable && (flag || num3 == 0) && spanFormattable.TryFormat(RemainingCurrentChunk, out var charsWritten, readOnlySpan, provider))
					{
						if ((uint)charsWritten > (uint)RemainingCurrentChunk.Length)
						{
							FormatError();
						}
						m_ChunkLength += charsWritten;
						int num5 = num3 - charsWritten;
						if (flag && num5 > 0)
						{
							Append(' ', num5);
						}
						continue;
					}
					if (obj is IFormattable formattable)
					{
						if (readOnlySpan.Length != 0 && text2 == null)
						{
							text2 = new string(readOnlySpan);
						}
						text = formattable.ToString(text2, provider);
					}
					else if (obj != null)
					{
						text = obj.ToString();
					}
				}
				if (text == null)
				{
					text = string.Empty;
				}
				int num6 = num3 - text.Length;
				if (!flag && num6 > 0)
				{
					Append(' ', num6);
				}
				Append(text);
				if (flag && num6 > 0)
				{
					Append(' ', num6);
				}
			}
			return this;
		}

		public StringBuilder Replace(string oldValue, string? newValue)
		{
			return Replace(oldValue, newValue, 0, Length);
		}

		public bool Equals([NotNullWhen(true)] StringBuilder? sb)
		{
			if (sb == null)
			{
				return false;
			}
			if (Length != sb.Length)
			{
				return false;
			}
			if (sb == this)
			{
				return true;
			}
			StringBuilder stringBuilder = this;
			int num = stringBuilder.m_ChunkLength;
			StringBuilder stringBuilder2 = sb;
			int num2 = stringBuilder2.m_ChunkLength;
			do
			{
				num--;
				num2--;
				while (num < 0)
				{
					stringBuilder = stringBuilder.m_ChunkPrevious;
					if (stringBuilder == null)
					{
						break;
					}
					num = stringBuilder.m_ChunkLength + num;
				}
				while (num2 < 0)
				{
					stringBuilder2 = stringBuilder2.m_ChunkPrevious;
					if (stringBuilder2 == null)
					{
						break;
					}
					num2 = stringBuilder2.m_ChunkLength + num2;
				}
				if (num < 0)
				{
					return num2 < 0;
				}
				if (num2 < 0)
				{
					return false;
				}
			}
			while (stringBuilder.m_ChunkChars[num] == stringBuilder2.m_ChunkChars[num2]);
			return false;
		}

		public bool Equals(ReadOnlySpan<char> span)
		{
			if (span.Length != Length)
			{
				return false;
			}
			StringBuilder stringBuilder = this;
			int num = 0;
			do
			{
				int chunkLength = stringBuilder.m_ChunkLength;
				num += chunkLength;
				ReadOnlySpan<char> span2 = new ReadOnlySpan<char>(stringBuilder.m_ChunkChars, 0, chunkLength);
				if (!span2.EqualsOrdinal(span.Slice(span.Length - num, chunkLength)))
				{
					return false;
				}
				stringBuilder = stringBuilder.m_ChunkPrevious;
			}
			while (stringBuilder != null);
			return true;
		}

		public StringBuilder Replace(string oldValue, string? newValue, int startIndex, int count)
		{
			int length = Length;
			if ((uint)startIndex > (uint)length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (count < 0 || startIndex > length - count)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Index);
			}
			if (oldValue == null)
			{
				throw new ArgumentNullException("oldValue");
			}
			if (oldValue.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "oldValue");
			}
			if (newValue == null)
			{
				newValue = string.Empty;
			}
			int[] array = null;
			int num = 0;
			StringBuilder stringBuilder = FindChunkForIndex(startIndex);
			int num2 = startIndex - stringBuilder.m_ChunkOffset;
			while (count > 0)
			{
				if (StartsWith(stringBuilder, num2, count, oldValue))
				{
					if (array == null)
					{
						array = new int[5];
					}
					else if (num >= array.Length)
					{
						Array.Resize(ref array, array.Length * 3 / 2 + 4);
					}
					array[num++] = num2;
					num2 += oldValue.Length;
					count -= oldValue.Length;
				}
				else
				{
					num2++;
					count--;
				}
				if (num2 >= stringBuilder.m_ChunkLength || count == 0)
				{
					int num3 = num2 + stringBuilder.m_ChunkOffset;
					ReplaceAllInChunk(array, num, stringBuilder, oldValue.Length, newValue);
					num3 += (newValue.Length - oldValue.Length) * num;
					num = 0;
					stringBuilder = FindChunkForIndex(num3);
					num2 = num3 - stringBuilder.m_ChunkOffset;
				}
			}
			return this;
		}

		public StringBuilder Replace(char oldChar, char newChar)
		{
			return Replace(oldChar, newChar, 0, Length);
		}

		public StringBuilder Replace(char oldChar, char newChar, int startIndex, int count)
		{
			int length = Length;
			if ((uint)startIndex > (uint)length)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (count < 0 || startIndex > length - count)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Index);
			}
			int num = startIndex + count;
			StringBuilder stringBuilder = this;
			while (true)
			{
				int num2 = num - stringBuilder.m_ChunkOffset;
				int num3 = startIndex - stringBuilder.m_ChunkOffset;
				if (num2 >= 0)
				{
					int i = Math.Max(num3, 0);
					for (int num4 = Math.Min(stringBuilder.m_ChunkLength, num2); i < num4; i++)
					{
						if (stringBuilder.m_ChunkChars[i] == oldChar)
						{
							stringBuilder.m_ChunkChars[i] = newChar;
						}
					}
				}
				if (num3 >= 0)
				{
					break;
				}
				stringBuilder = stringBuilder.m_ChunkPrevious;
			}
			return this;
		}

		[CLSCompliant(false)]
		public unsafe StringBuilder Append(char* value, int valueCount)
		{
			if (valueCount < 0)
			{
				throw new ArgumentOutOfRangeException("valueCount", SR.ArgumentOutOfRange_NegativeCount);
			}
			int num = Length + valueCount;
			if (num > m_MaxCapacity || num < valueCount)
			{
				throw new ArgumentOutOfRangeException("valueCount", SR.ArgumentOutOfRange_LengthGreaterThanCapacity);
			}
			int num2 = valueCount + m_ChunkLength;
			if (num2 <= m_ChunkChars.Length)
			{
				new ReadOnlySpan<char>(value, valueCount).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));
				m_ChunkLength = num2;
			}
			else
			{
				int num3 = m_ChunkChars.Length - m_ChunkLength;
				if (num3 > 0)
				{
					new ReadOnlySpan<char>(value, num3).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));
					m_ChunkLength = m_ChunkChars.Length;
				}
				int num4 = valueCount - num3;
				ExpandByABlock(num4);
				new ReadOnlySpan<char>(value + num3, num4).CopyTo(m_ChunkChars);
				m_ChunkLength = num4;
			}
			return this;
		}

		private unsafe void Insert(int index, char* value, int valueCount)
		{
			if ((uint)index > (uint)Length)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (valueCount > 0)
			{
				MakeRoom(index, valueCount, out var chunk, out var indexInChunk, doNotMoveFollowingChars: false);
				ReplaceInPlaceAtChunk(ref chunk, ref indexInChunk, value, valueCount);
			}
		}

		private unsafe void ReplaceAllInChunk(int[] replacements, int replacementsCount, StringBuilder sourceChunk, int removeCount, string value)
		{
			if (replacementsCount <= 0)
			{
				return;
			}
			fixed (char* value2 = value)
			{
				long num = (long)(value.Length - removeCount) * (long)replacementsCount;
				int num2 = (int)num;
				if (num2 != num)
				{
					throw new OutOfMemoryException();
				}
				StringBuilder chunk = sourceChunk;
				int indexInChunk = replacements[0];
				if (num2 > 0)
				{
					MakeRoom(chunk.m_ChunkOffset + indexInChunk, num2, out chunk, out indexInChunk, doNotMoveFollowingChars: true);
				}
				int num3 = 0;
				while (true)
				{
					ReplaceInPlaceAtChunk(ref chunk, ref indexInChunk, value2, value.Length);
					int num4 = replacements[num3] + removeCount;
					num3++;
					if (num3 >= replacementsCount)
					{
						break;
					}
					int num5 = replacements[num3];
					if (num2 != 0)
					{
						fixed (char* value3 = &sourceChunk.m_ChunkChars[num4])
						{
							ReplaceInPlaceAtChunk(ref chunk, ref indexInChunk, value3, num5 - num4);
						}
					}
					else
					{
						indexInChunk += num5 - num4;
					}
				}
				if (num2 < 0)
				{
					Remove(chunk.m_ChunkOffset + indexInChunk, -num2, out chunk, out indexInChunk);
				}
			}
		}

		private bool StartsWith(StringBuilder chunk, int indexInChunk, int count, string value)
		{
			for (int i = 0; i < value.Length; i++)
			{
				if (count == 0)
				{
					return false;
				}
				if (indexInChunk >= chunk.m_ChunkLength)
				{
					chunk = Next(chunk);
					if (chunk == null)
					{
						return false;
					}
					indexInChunk = 0;
				}
				if (value[i] != chunk.m_ChunkChars[indexInChunk])
				{
					return false;
				}
				indexInChunk++;
				count--;
			}
			return true;
		}

		private unsafe void ReplaceInPlaceAtChunk(ref StringBuilder chunk, ref int indexInChunk, char* value, int count)
		{
			if (count == 0)
			{
				return;
			}
			while (true)
			{
				int val = chunk.m_ChunkLength - indexInChunk;
				int num = Math.Min(val, count);
				new ReadOnlySpan<char>(value, num).CopyTo(chunk.m_ChunkChars.AsSpan(indexInChunk));
				indexInChunk += num;
				if (indexInChunk >= chunk.m_ChunkLength)
				{
					chunk = Next(chunk);
					indexInChunk = 0;
				}
				count -= num;
				if (count != 0)
				{
					value += num;
					continue;
				}
				break;
			}
		}

		private StringBuilder FindChunkForIndex(int index)
		{
			StringBuilder stringBuilder = this;
			while (stringBuilder.m_ChunkOffset > index)
			{
				stringBuilder = stringBuilder.m_ChunkPrevious;
			}
			return stringBuilder;
		}

		private StringBuilder Next(StringBuilder chunk)
		{
			if (chunk != this)
			{
				return FindChunkForIndex(chunk.m_ChunkOffset + chunk.m_ChunkLength);
			}
			return null;
		}

		private void ExpandByABlock(int minBlockCharCount)
		{
			if (minBlockCharCount + Length > m_MaxCapacity || minBlockCharCount + Length < minBlockCharCount)
			{
				throw new ArgumentOutOfRangeException("requiredLength", SR.ArgumentOutOfRange_SmallCapacity);
			}
			int num = Math.Max(minBlockCharCount, Math.Min(Length, 8000));
			if (m_ChunkOffset + m_ChunkLength + num < num)
			{
				throw new OutOfMemoryException();
			}
			char[] chunkChars = GC.AllocateUninitializedArray<char>(num);
			m_ChunkPrevious = new StringBuilder(this);
			m_ChunkOffset += m_ChunkLength;
			m_ChunkLength = 0;
			m_ChunkChars = chunkChars;
		}

		private StringBuilder(StringBuilder from)
		{
			m_ChunkLength = from.m_ChunkLength;
			m_ChunkOffset = from.m_ChunkOffset;
			m_ChunkChars = from.m_ChunkChars;
			m_ChunkPrevious = from.m_ChunkPrevious;
			m_MaxCapacity = from.m_MaxCapacity;
		}

		private void MakeRoom(int index, int count, out StringBuilder chunk, out int indexInChunk, bool doNotMoveFollowingChars)
		{
			if (count + Length > m_MaxCapacity || count + Length < count)
			{
				throw new ArgumentOutOfRangeException("requiredLength", SR.ArgumentOutOfRange_SmallCapacity);
			}
			chunk = this;
			while (chunk.m_ChunkOffset > index)
			{
				chunk.m_ChunkOffset += count;
				chunk = chunk.m_ChunkPrevious;
			}
			indexInChunk = index - chunk.m_ChunkOffset;
			if (!doNotMoveFollowingChars && chunk.m_ChunkLength <= 32 && chunk.m_ChunkChars.Length - chunk.m_ChunkLength >= count)
			{
				int num = chunk.m_ChunkLength;
				while (num > indexInChunk)
				{
					num--;
					chunk.m_ChunkChars[num + count] = chunk.m_ChunkChars[num];
				}
				chunk.m_ChunkLength += count;
				return;
			}
			StringBuilder stringBuilder = new StringBuilder(Math.Max(count, 16), chunk.m_MaxCapacity, chunk.m_ChunkPrevious);
			stringBuilder.m_ChunkLength = count;
			int num2 = Math.Min(count, indexInChunk);
			if (num2 > 0)
			{
				new ReadOnlySpan<char>(chunk.m_ChunkChars, 0, num2).CopyTo(stringBuilder.m_ChunkChars);
				int num3 = indexInChunk - num2;
				if (num3 >= 0)
				{
					new ReadOnlySpan<char>(chunk.m_ChunkChars, num2, num3).CopyTo(chunk.m_ChunkChars);
					indexInChunk = num3;
				}
			}
			chunk.m_ChunkPrevious = stringBuilder;
			chunk.m_ChunkOffset += count;
			if (num2 < count)
			{
				chunk = stringBuilder;
				indexInChunk = num2;
			}
		}

		private StringBuilder(int size, int maxCapacity, StringBuilder previousBlock)
		{
			m_ChunkChars = GC.AllocateUninitializedArray<char>(size);
			m_MaxCapacity = maxCapacity;
			m_ChunkPrevious = previousBlock;
			if (previousBlock != null)
			{
				m_ChunkOffset = previousBlock.m_ChunkOffset + previousBlock.m_ChunkLength;
			}
		}

		private void Remove(int startIndex, int count, out StringBuilder chunk, out int indexInChunk)
		{
			int num = startIndex + count;
			chunk = this;
			StringBuilder stringBuilder = null;
			int num2 = 0;
			while (true)
			{
				if (num - chunk.m_ChunkOffset >= 0)
				{
					if (stringBuilder == null)
					{
						stringBuilder = chunk;
						num2 = num - stringBuilder.m_ChunkOffset;
					}
					if (startIndex - chunk.m_ChunkOffset >= 0)
					{
						break;
					}
				}
				else
				{
					chunk.m_ChunkOffset -= count;
				}
				chunk = chunk.m_ChunkPrevious;
			}
			indexInChunk = startIndex - chunk.m_ChunkOffset;
			int num3 = indexInChunk;
			int length = stringBuilder.m_ChunkLength - num2;
			if (stringBuilder != chunk)
			{
				num3 = 0;
				chunk.m_ChunkLength = indexInChunk;
				stringBuilder.m_ChunkPrevious = chunk;
				stringBuilder.m_ChunkOffset = chunk.m_ChunkOffset + chunk.m_ChunkLength;
				if (indexInChunk == 0)
				{
					stringBuilder.m_ChunkPrevious = chunk.m_ChunkPrevious;
					chunk = stringBuilder;
				}
			}
			stringBuilder.m_ChunkLength -= num2 - num3;
			if (num3 != num2)
			{
				new ReadOnlySpan<char>(stringBuilder.m_ChunkChars, num2, length).CopyTo(stringBuilder.m_ChunkChars.AsSpan(num3));
			}
		}
	}
	public class ASCIIEncoding : Encoding
	{
		internal sealed class ASCIIEncodingSealed : ASCIIEncoding
		{
			public override object Clone()
			{
				return new ASCIIEncoding
				{
					IsReadOnly = false
				};
			}
		}

		internal static readonly ASCIIEncodingSealed s_default = new ASCIIEncodingSealed();

		public override bool IsSingleByte => true;

		public ASCIIEncoding()
			: base(20127)
		{
		}

		internal sealed override void SetDefaultFallbacks()
		{
			encoderFallback = System.Text.EncoderFallback.ReplacementFallback;
			decoderFallback = System.Text.DecoderFallback.ReplacementFallback;
		}

		public unsafe override int GetByteCount(char[] chars, int index, int count)
		{
			if (chars == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			fixed (char* ptr = chars)
			{
				return GetByteCountCommon(ptr + index, count);
			}
		}

		public unsafe override int GetByteCount(string chars)
		{
			if (chars == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars);
			}
			fixed (char* pChars = chars)
			{
				return GetByteCountCommon(pChars, chars.Length);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetByteCount(char* chars, int count)
		{
			if (chars == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars);
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetByteCountCommon(chars, count);
		}

		public unsafe override int GetByteCount(ReadOnlySpan<char> chars)
		{
			fixed (char* pChars = &MemoryMarshal.GetReference(chars))
			{
				return GetByteCountCommon(pChars, chars.Length);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetByteCountCommon(char* pChars, int charCount)
		{
			int charsConsumed;
			int num = GetByteCountFast(pChars, charCount, base.EncoderFallback, out charsConsumed);
			if (charsConsumed != charCount)
			{
				num += GetByteCountWithFallback(pChars, charCount, charsConsumed);
				if (num < 0)
				{
					Encoding.ThrowConversionOverflow();
				}
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetByteCountFast(char* pChars, int charsLength, EncoderFallback fallback, out int charsConsumed)
		{
			int num = charsLength;
			if (!(fallback is EncoderReplacementFallback encoderReplacementFallback) || encoderReplacementFallback.MaxCharCount != 1 || encoderReplacementFallback.DefaultString[0] > '\u007f')
			{
				num = (int)ASCIIUtility.GetIndexOfFirstNonAsciiChar(pChars, (uint)charsLength);
			}
			charsConsumed = num;
			return num;
		}

		public unsafe override int GetBytes(string chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (chars == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((chars == null) ? ExceptionArgument.chars : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charIndex | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charIndex < 0) ? ExceptionArgument.charIndex : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCount);
			}
			if ((uint)byteIndex > bytes.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (char* ptr2 = chars)
			{
				fixed (byte[] array = bytes)
				{
					byte* ptr = (byte*)((bytes != null && array.Length != 0) ? System.Runtime.CompilerServices.Unsafe.AsPointer(ref array[0]) : null);
					return GetBytesCommon(ptr2 + charIndex, charCount, ptr + byteIndex, bytes.Length - byteIndex);
				}
			}
		}

		public unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (chars == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((chars == null) ? ExceptionArgument.chars : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charIndex | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charIndex < 0) ? ExceptionArgument.charIndex : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCount);
			}
			if ((uint)byteIndex > bytes.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (char* ptr = chars)
			{
				fixed (byte* ptr2 = bytes)
				{
					return GetBytesCommon(ptr + charIndex, charCount, ptr2 + byteIndex, bytes.Length - byteIndex);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			if (chars == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((chars == null) ? ExceptionArgument.chars : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charCount | byteCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charCount < 0) ? ExceptionArgument.charCount : ExceptionArgument.byteCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetBytesCommon(chars, charCount, bytes, byteCount);
		}

		public unsafe override int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes)
		{
			fixed (char* pChars = &MemoryMarshal.GetReference(chars))
			{
				fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
				{
					return GetBytesCommon(pChars, chars.Length, pBytes, bytes.Length);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetBytesCommon(char* pChars, int charCount, byte* pBytes, int byteCount)
		{
			int charsConsumed;
			int bytesFast = GetBytesFast(pChars, charCount, pBytes, byteCount, out charsConsumed);
			if (charsConsumed == charCount)
			{
				return bytesFast;
			}
			return GetBytesWithFallback(pChars, charCount, pBytes, byteCount, charsConsumed, bytesFast);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetBytesFast(char* pChars, int charsLength, byte* pBytes, int bytesLength, out int charsConsumed)
		{
			return charsConsumed = (int)ASCIIUtility.NarrowUtf16ToAscii(pChars, pBytes, (uint)Math.Min(charsLength, bytesLength));
		}

		private protected unsafe sealed override int GetBytesWithFallback(ReadOnlySpan<char> chars, int originalCharsLength, Span<byte> bytes, int originalBytesLength, EncoderNLS encoder)
		{
			if (((encoder == null) ? base.EncoderFallback : encoder.Fallback) is EncoderReplacementFallback encoderReplacementFallback && encoderReplacementFallback.MaxCharCount == 1 && encoderReplacementFallback.DefaultString[0] <= '\u007f')
			{
				byte b = (byte)encoderReplacementFallback.DefaultString[0];
				int num = Math.Min(chars.Length, bytes.Length);
				int num2 = 0;
				fixed (char* ptr2 = &MemoryMarshal.GetReference(chars))
				{
					fixed (byte* ptr = &MemoryMarshal.GetReference(bytes))
					{
						while (num2 < num)
						{
							ptr[num2++] = b;
							if (num2 < num)
							{
								num2 += (int)ASCIIUtility.NarrowUtf16ToAscii(ptr2 + num2, ptr + num2, (uint)(num - num2));
							}
						}
					}
				}
				chars = chars.Slice(num);
				bytes = bytes.Slice(num);
			}
			if (chars.IsEmpty)
			{
				return originalBytesLength - bytes.Length;
			}
			return base.GetBytesWithFallback(chars, originalCharsLength, bytes, originalBytesLength, encoder);
		}

		public unsafe override int GetCharCount(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			fixed (byte* ptr = bytes)
			{
				return GetCharCountCommon(ptr + index, count);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetCharCount(byte* bytes, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetCharCountCommon(bytes, count);
		}

		public unsafe override int GetCharCount(ReadOnlySpan<byte> bytes)
		{
			fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
			{
				return GetCharCountCommon(pBytes, bytes.Length);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetCharCountCommon(byte* pBytes, int byteCount)
		{
			int bytesConsumed;
			int num = GetCharCountFast(pBytes, byteCount, base.DecoderFallback, out bytesConsumed);
			if (bytesConsumed != byteCount)
			{
				num += GetCharCountWithFallback(pBytes, byteCount, bytesConsumed);
				if (num < 0)
				{
					Encoding.ThrowConversionOverflow();
				}
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetCharCountFast(byte* pBytes, int bytesLength, DecoderFallback fallback, out int bytesConsumed)
		{
			int num = bytesLength;
			if (!(fallback is DecoderReplacementFallback decoderReplacementFallback) || decoderReplacementFallback.MaxCharCount != 1)
			{
				num = (int)ASCIIUtility.GetIndexOfFirstNonAsciiByte(pBytes, (uint)bytesLength);
			}
			bytesConsumed = num;
			return num;
		}

		public unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
		{
			if (bytes == null || chars == null)
			{
				ThrowHelper.ThrowArgumentNullException((bytes == null) ? ExceptionArgument.bytes : ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((byteIndex | byteCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((byteIndex < 0) ? ExceptionArgument.byteIndex : ExceptionArgument.byteCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			if ((uint)charIndex > (uint)chars.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.charIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (byte* ptr = bytes)
			{
				fixed (char* ptr2 = chars)
				{
					return GetCharsCommon(ptr + byteIndex, byteCount, ptr2 + charIndex, chars.Length - charIndex);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			if (bytes == null || chars == null)
			{
				ThrowHelper.ThrowArgumentNullException((bytes == null) ? ExceptionArgument.bytes : ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((byteCount | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((byteCount < 0) ? ExceptionArgument.byteCount : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetCharsCommon(bytes, byteCount, chars, charCount);
		}

		public unsafe override int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars)
		{
			fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
			{
				fixed (char* pChars = &MemoryMarshal.GetReference(chars))
				{
					return GetCharsCommon(pBytes, bytes.Length, pChars, chars.Length);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetCharsCommon(byte* pBytes, int byteCount, char* pChars, int charCount)
		{
			int bytesConsumed;
			int charsFast = GetCharsFast(pBytes, byteCount, pChars, charCount, out bytesConsumed);
			if (bytesConsumed == byteCount)
			{
				return charsFast;
			}
			return GetCharsWithFallback(pBytes, byteCount, pChars, charCount, bytesConsumed, charsFast);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetCharsFast(byte* pBytes, int bytesLength, char* pChars, int charsLength, out int bytesConsumed)
		{
			return bytesConsumed = (int)ASCIIUtility.WidenAsciiToUtf16(pBytes, pChars, (uint)Math.Min(bytesLength, charsLength));
		}

		private protected unsafe sealed override int GetCharsWithFallback(ReadOnlySpan<byte> bytes, int originalBytesLength, Span<char> chars, int originalCharsLength, DecoderNLS decoder)
		{
			if (((decoder == null) ? base.DecoderFallback : decoder.Fallback) is DecoderReplacementFallback decoderReplacementFallback && decoderReplacementFallback.MaxCharCount == 1)
			{
				char c = decoderReplacementFallback.DefaultString[0];
				int num = Math.Min(bytes.Length, chars.Length);
				int num2 = 0;
				fixed (byte* ptr2 = &MemoryMarshal.GetReference(bytes))
				{
					fixed (char* ptr = &MemoryMarshal.GetReference(chars))
					{
						while (num2 < num)
						{
							ptr[num2++] = c;
							if (num2 < num)
							{
								num2 += (int)ASCIIUtility.WidenAsciiToUtf16(ptr2 + num2, ptr + num2, (uint)(num - num2));
							}
						}
					}
				}
				bytes = bytes.Slice(num);
				chars = chars.Slice(num);
			}
			if (bytes.IsEmpty)
			{
				return originalCharsLength - chars.Length;
			}
			return base.GetCharsWithFallback(bytes, originalBytesLength, chars, originalCharsLength, decoder);
		}

		public unsafe override string GetString(byte[] bytes, int byteIndex, int byteCount)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((byteIndex | byteCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((byteIndex < 0) ? ExceptionArgument.byteIndex : ExceptionArgument.byteCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (byteCount == 0)
			{
				return string.Empty;
			}
			fixed (byte* ptr = bytes)
			{
				return string.CreateStringFromEncoding(ptr + byteIndex, byteCount, this);
			}
		}

		internal sealed override bool TryGetByteCount(Rune value, out int byteCount)
		{
			if (value.IsAscii)
			{
				byteCount = 1;
				return true;
			}
			byteCount = 0;
			return false;
		}

		internal sealed override OperationStatus EncodeRune(Rune value, Span<byte> bytes, out int bytesWritten)
		{
			if (value.IsAscii)
			{
				if (!bytes.IsEmpty)
				{
					bytes[0] = (byte)value.Value;
					bytesWritten = 1;
					return OperationStatus.Done;
				}
				bytesWritten = 0;
				return OperationStatus.DestinationTooSmall;
			}
			bytesWritten = 0;
			return OperationStatus.InvalidData;
		}

		internal sealed override OperationStatus DecodeFirstRune(ReadOnlySpan<byte> bytes, out Rune value, out int bytesConsumed)
		{
			if (!bytes.IsEmpty)
			{
				byte b = bytes[0];
				if (b <= 127)
				{
					value = new Rune(b);
					bytesConsumed = 1;
					return OperationStatus.Done;
				}
				value = Rune.ReplacementChar;
				bytesConsumed = 1;
				return OperationStatus.InvalidData;
			}
			value = Rune.ReplacementChar;
			bytesConsumed = 0;
			return OperationStatus.NeedMoreData;
		}

		public override int GetMaxByteCount(int charCount)
		{
			if (charCount < 0)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = (long)charCount + 1L;
			if (base.EncoderFallback.MaxCharCount > 1)
			{
				num *= base.EncoderFallback.MaxCharCount;
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			return (int)num;
		}

		public override int GetMaxCharCount(int byteCount)
		{
			if (byteCount < 0)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = byteCount;
			if (base.DecoderFallback.MaxCharCount > 1)
			{
				num *= base.DecoderFallback.MaxCharCount;
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_GetCharCountOverflow);
			}
			return (int)num;
		}

		public override Decoder GetDecoder()
		{
			return new DecoderNLS(this);
		}

		public override Encoder GetEncoder()
		{
			return new EncoderNLS(this);
		}
	}
	internal static class ASCIIUtility
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool AllCharsInUInt32AreAscii(uint value)
		{
			return (value & 0xFF80FF80u) == 0;
		}

		private static bool FirstCharInUInt32IsAscii(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((value & 0xFF80u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static nuint GetIndexOfFirstNonAsciiByte(byte* pBuffer, nuint bufferLength)
		{
			if (!Sse2.IsSupported)
			{
				if (AdvSimd.Arm64.IsSupported)
				{
				}
				return GetIndexOfFirstNonAsciiByte_Default(pBuffer, bufferLength);
			}
			return GetIndexOfFirstNonAsciiByte_Intrinsified(pBuffer, bufferLength);
		}

		private unsafe static nuint GetIndexOfFirstNonAsciiByte_Default(byte* pBuffer, nuint bufferLength)
		{
			byte* ptr = pBuffer;
			if (Vector.IsHardwareAccelerated && bufferLength >= (uint)(2 * Vector<sbyte>.Count))
			{
				uint count = (uint)Vector<sbyte>.Count;
				if (Vector.GreaterThanOrEqualAll(Unsafe.ReadUnaligned<Vector<sbyte>>(pBuffer), Vector<sbyte>.Zero))
				{
					byte* ptr2 = pBuffer + bufferLength - count;
					pBuffer = (byte*)((nuint)(pBuffer + count) & ~(nuint)(count - 1));
					while (!Vector.LessThanAny(Unsafe.Read<Vector<sbyte>>(pBuffer), Vector<sbyte>.Zero))
					{
						pBuffer += count;
						if (pBuffer > ptr2)
						{
							break;
						}
					}
					bufferLength -= (nuint)pBuffer;
					bufferLength = (nuint)(bufferLength + ptr);
				}
			}
			while (true)
			{
				uint num;
				if (bufferLength >= 8)
				{
					num = Unsafe.ReadUnaligned<uint>(pBuffer);
					uint num2 = Unsafe.ReadUnaligned<uint>(pBuffer + 4);
					if (!AllBytesInUInt32AreAscii(num | num2))
					{
						if (AllBytesInUInt32AreAscii(num))
						{
							num = num2;
							pBuffer += 4;
						}
						goto IL_0100;
					}
					pBuffer += 8;
					bufferLength -= 8;
					continue;
				}
				if ((bufferLength & 4) != 0)
				{
					num = Unsafe.ReadUnaligned<uint>(pBuffer);
					if (!AllBytesInUInt32AreAscii(num))
					{
						goto IL_0100;
					}
					pBuffer += 4;
				}
				if ((bufferLength & 2) != 0)
				{
					num = Unsafe.ReadUnaligned<ushort>(pBuffer);
					if (!AllBytesInUInt32AreAscii(num) && BitConverter.IsLittleEndian)
					{
						goto IL_0100;
					}
					pBuffer += 2;
				}
				if ((bufferLength & 1) != 0 && *pBuffer >= 0)
				{
					pBuffer++;
				}
				break;
				IL_0100:
				pBuffer += CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(num);
				break;
			}
			return (nuint)(pBuffer - (nuint)ptr);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ContainsNonAsciiByte_Sse2(uint sseMask)
		{
			return sseMask != 0;
		}

		private unsafe static nuint GetIndexOfFirstNonAsciiByte_Intrinsified(byte* pBuffer, nuint bufferLength)
		{
			uint num = (uint)Unsafe.SizeOf<Vector128<byte>>();
			nuint num2 = num - 1;
			if (!BitConverter.IsLittleEndian)
			{
			}
			Vector128<byte> vector = Vector128.Create((ushort)4097).AsByte();
			uint num3 = uint.MaxValue;
			uint num4 = uint.MaxValue;
			uint num5 = uint.MaxValue;
			uint num6 = uint.MaxValue;
			byte* ptr = pBuffer;
			if (bufferLength >= num)
			{
				if (Sse2.IsSupported)
				{
					num3 = (uint)Sse2.MoveMask(Sse2.LoadVector128(pBuffer));
					if (!ContainsNonAsciiByte_Sse2(num3))
					{
						if (bufferLength < 2 * num)
						{
							goto IL_0122;
						}
						pBuffer = (byte*)((nuint)(pBuffer + num) & ~num2);
						bufferLength = (nuint)(bufferLength + ptr);
						bufferLength -= (nuint)pBuffer;
						if (bufferLength < 2 * num)
						{
							goto IL_00ef;
						}
						byte* ptr2 = pBuffer + bufferLength - 2 * num;
						while (true)
						{
							if (Sse2.IsSupported)
							{
								Vector128<byte> value = Sse2.LoadAlignedVector128(pBuffer);
								Vector128<byte> value2 = Sse2.LoadAlignedVector128(pBuffer + num);
								num3 = (uint)Sse2.MoveMask(value);
								num4 = (uint)Sse2.MoveMask(value2);
								if (ContainsNonAsciiByte_Sse2(num3 | num4))
								{
									break;
								}
								pBuffer += 2 * num;
								if (pBuffer <= ptr2)
								{
									continue;
								}
								goto IL_00ef;
							}
							if (AdvSimd.Arm64.IsSupported)
							{
							}
							throw new PlatformNotSupportedException();
						}
						if (!Sse2.IsSupported)
						{
							if (AdvSimd.IsSupported)
							{
							}
							throw new PlatformNotSupportedException();
						}
						if (!ContainsNonAsciiByte_Sse2(num3))
						{
							pBuffer += num;
							num3 = num4;
						}
					}
					goto IL_0197;
				}
				if (AdvSimd.Arm64.IsSupported)
				{
				}
				throw new PlatformNotSupportedException();
			}
			uint num7;
			if ((bufferLength & 8) != 0)
			{
				if (UIntPtr.Size == 8)
				{
				}
				num7 = Unsafe.ReadUnaligned<uint>(pBuffer);
				uint num8 = Unsafe.ReadUnaligned<uint>(pBuffer + 4);
				if (!AllBytesInUInt32AreAscii(num7 | num8))
				{
					if (AllBytesInUInt32AreAscii(num7))
					{
						num7 = num8;
						pBuffer += 4;
					}
					goto IL_01b8;
				}
				pBuffer += 8;
			}
			if ((bufferLength & 4) != 0)
			{
				num7 = Unsafe.ReadUnaligned<uint>(pBuffer);
				if (!AllBytesInUInt32AreAscii(num7))
				{
					goto IL_01b8;
				}
				pBuffer += 4;
			}
			if ((bufferLength & 2) != 0)
			{
				num7 = Unsafe.ReadUnaligned<ushort>(pBuffer);
				if (!AllBytesInUInt32AreAscii(num7))
				{
					pBuffer += (nuint)(((nint)(sbyte)num7 >> 7) + 1);
					goto IL_016b;
				}
				pBuffer += 2;
			}
			if ((bufferLength & 1) != 0 && *pBuffer >= 0)
			{
				pBuffer++;
			}
			goto IL_016b;
			IL_0122:
			pBuffer += num;
			goto IL_0128;
			IL_016b:
			return (nuint)(pBuffer - (nuint)ptr);
			IL_00ef:
			if ((bufferLength & num) == 0)
			{
				goto IL_0128;
			}
			if (Sse2.IsSupported)
			{
				num3 = (uint)Sse2.MoveMask(Sse2.LoadAlignedVector128(pBuffer));
				if (!ContainsNonAsciiByte_Sse2(num3))
				{
					goto IL_0122;
				}
				goto IL_0197;
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			throw new PlatformNotSupportedException();
			IL_0197:
			if (Sse2.IsSupported)
			{
				pBuffer += (uint)BitOperations.TrailingZeroCount(num3);
				goto IL_016b;
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			throw new PlatformNotSupportedException();
			IL_0128:
			if (((byte)bufferLength & num2) != 0)
			{
				pBuffer += (bufferLength & num2) - num;
				if (!Sse2.IsSupported)
				{
					if (AdvSimd.Arm64.IsSupported)
					{
					}
					throw new PlatformNotSupportedException();
				}
				num3 = (uint)Sse2.MoveMask(Sse2.LoadVector128(pBuffer));
				if (ContainsNonAsciiByte_Sse2(num3))
				{
					goto IL_0197;
				}
				pBuffer += num;
			}
			goto IL_016b;
			IL_01b8:
			pBuffer += CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(num7);
			goto IL_016b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static nuint GetIndexOfFirstNonAsciiChar(char* pBuffer, nuint bufferLength)
		{
			if (!Sse2.IsSupported)
			{
				return GetIndexOfFirstNonAsciiChar_Default(pBuffer, bufferLength);
			}
			return GetIndexOfFirstNonAsciiChar_Sse2(pBuffer, bufferLength);
		}

		private unsafe static nuint GetIndexOfFirstNonAsciiChar_Default(char* pBuffer, nuint bufferLength)
		{
			char* ptr = pBuffer;
			if (Vector.IsHardwareAccelerated && bufferLength >= (uint)(2 * Vector<ushort>.Count))
			{
				uint count = (uint)Vector<ushort>.Count;
				uint count2 = (uint)Vector<byte>.Count;
				Vector<ushort> right = new Vector<ushort>(127);
				if (Vector.LessThanOrEqualAll(Unsafe.ReadUnaligned<Vector<ushort>>(pBuffer), right))
				{
					char* ptr2 = pBuffer + bufferLength - count;
					pBuffer = (char*)((nuint)((byte*)pBuffer + count2) & ~(nuint)(count2 - 1));
					while (!Vector.GreaterThanAny(Unsafe.Read<Vector<ushort>>(pBuffer), right))
					{
						pBuffer += count;
						if (pBuffer > ptr2)
						{
							break;
						}
					}
					bufferLength -= (nuint)(nint)(pBuffer - ptr);
				}
			}
			while (true)
			{
				uint num;
				if (bufferLength >= 4)
				{
					num = Unsafe.ReadUnaligned<uint>(pBuffer);
					uint num2 = Unsafe.ReadUnaligned<uint>(pBuffer + 2);
					if (!AllCharsInUInt32AreAscii(num | num2))
					{
						if (AllCharsInUInt32AreAscii(num))
						{
							num = num2;
							pBuffer += 2;
						}
						goto IL_0109;
					}
					pBuffer += 4;
					bufferLength -= 4;
					continue;
				}
				if ((bufferLength & 2) != 0)
				{
					num = Unsafe.ReadUnaligned<uint>(pBuffer);
					if (!AllCharsInUInt32AreAscii(num))
					{
						goto IL_0109;
					}
					pBuffer += 2;
				}
				if ((bufferLength & 1) != 0 && *pBuffer <= '\u007f')
				{
					pBuffer++;
				}
				break;
				IL_0109:
				if (FirstCharInUInt32IsAscii(num))
				{
					pBuffer++;
				}
				break;
			}
			nuint num3 = (nuint)((byte*)pBuffer - (nuint)ptr);
			return num3 / 2;
		}

		private unsafe static nuint GetIndexOfFirstNonAsciiChar_Sse2(char* pBuffer, nuint bufferLength)
		{
			if (bufferLength == 0)
			{
				return 0u;
			}
			uint num = (uint)Unsafe.SizeOf<Vector128<byte>>();
			uint num2 = num / 2;
			char* ptr = pBuffer;
			Vector128<ushort> right;
			Vector128<ushort> right2;
			Vector128<ushort> left;
			uint num3;
			if (bufferLength >= num2)
			{
				right = Vector128.Create((ushort)65408);
				right2 = Vector128.Create((ushort)32640);
				left = Sse2.LoadVector128((ushort*)pBuffer);
				num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
				if ((num3 & 0xAAAA) == 0)
				{
					bufferLength <<= 1;
					if (bufferLength < 2 * num)
					{
						goto IL_013e;
					}
					pBuffer = (char*)((nuint)((byte*)pBuffer + num) & ~(nuint)(num - 1));
					bufferLength = (nuint)(bufferLength + (byte*)ptr);
					bufferLength -= (nuint)pBuffer;
					if (bufferLength < 2 * num)
					{
						goto IL_00fa;
					}
					char* ptr2 = (char*)((byte*)pBuffer + bufferLength - 2 * num);
					Vector128<ushort> vector;
					while (true)
					{
						left = Sse2.LoadAlignedVector128((ushort*)pBuffer);
						vector = Sse2.LoadAlignedVector128((ushort*)(pBuffer + num2));
						Vector128<ushort> left2 = Sse2.Or(left, vector);
						if (Sse41.IsSupported)
						{
							if (!Sse41.TestZ(left2, right))
							{
								break;
							}
						}
						else
						{
							num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left2, right2).AsByte());
							if ((num3 & 0xAAAAu) != 0)
							{
								break;
							}
						}
						pBuffer += 2 * num2;
						if (pBuffer <= ptr2)
						{
							continue;
						}
						goto IL_00fa;
					}
					if (Sse41.IsSupported)
					{
						if (!Sse41.TestZ(left, right))
						{
							goto IL_01e6;
						}
					}
					else
					{
						num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
						if ((num3 & 0xAAAAu) != 0)
						{
							goto IL_01fa;
						}
					}
					pBuffer += num2;
					left = vector;
					goto IL_01e6;
				}
				goto IL_01fa;
			}
			uint num4;
			if ((bufferLength & 4) != 0)
			{
				if (UIntPtr.Size == 8)
				{
				}
				num4 = Unsafe.ReadUnaligned<uint>(pBuffer);
				uint num5 = Unsafe.ReadUnaligned<uint>(pBuffer + 2);
				if (!AllCharsInUInt32AreAscii(num4 | num5))
				{
					if (AllCharsInUInt32AreAscii(num4))
					{
						num4 = num5;
						pBuffer += 2;
					}
					goto IL_0214;
				}
				pBuffer += 4;
			}
			if ((bufferLength & 2) != 0)
			{
				num4 = Unsafe.ReadUnaligned<uint>(pBuffer);
				if (!AllCharsInUInt32AreAscii(num4))
				{
					goto IL_0214;
				}
				pBuffer += 2;
			}
			if ((bufferLength & 1) != 0 && *pBuffer <= '\u007f')
			{
				pBuffer++;
			}
			goto IL_01a1;
			IL_01a1:
			return (nuint)(pBuffer - ptr);
			IL_0148:
			if (((byte)bufferLength & (num - 1)) != 0)
			{
				pBuffer = (char*)((byte*)pBuffer + (bufferLength & (num - 1)) - num);
				left = Sse2.LoadVector128((ushort*)pBuffer);
				if (Sse41.IsSupported)
				{
					if (!Sse41.TestZ(left, right))
					{
						goto IL_01e6;
					}
				}
				else
				{
					num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
					if ((num3 & 0xAAAAu) != 0)
					{
						goto IL_01fa;
					}
				}
				pBuffer += num2;
			}
			goto IL_01a1;
			IL_0214:
			if (FirstCharInUInt32IsAscii(num4))
			{
				pBuffer++;
			}
			goto IL_01a1;
			IL_01fa:
			num3 &= 0xAAAAu;
			pBuffer = (char*)((byte*)pBuffer + (uint)BitOperations.TrailingZeroCount(num3) - 1);
			goto IL_01a1;
			IL_013e:
			pBuffer += num2;
			goto IL_0148;
			IL_01e6:
			num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
			goto IL_01fa;
			IL_00fa:
			if ((bufferLength & num) != 0)
			{
				left = Sse2.LoadAlignedVector128((ushort*)pBuffer);
				if (Sse41.IsSupported)
				{
					if (!Sse41.TestZ(left, right))
					{
						goto IL_01e6;
					}
				}
				else
				{
					num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
					if ((num3 & 0xAAAAu) != 0)
					{
						goto IL_01fa;
					}
				}
				goto IL_013e;
			}
			goto IL_0148;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void NarrowTwoUtf16CharsToAsciiAndWriteToBuffer(ref byte outputBuffer, uint value)
		{
			_ = BitConverter.IsLittleEndian;
			outputBuffer = (byte)value;
			Unsafe.Add(ref outputBuffer, 1) = (byte)(value >> 16);
		}

		public unsafe static nuint NarrowUtf16ToAscii(char* pUtf16Buffer, byte* pAsciiBuffer, nuint elementCount)
		{
			nuint num = 0u;
			uint num2 = 0u;
			uint num3 = 0u;
			ulong num4 = 0uL;
			if (Sse2.IsSupported)
			{
				if (elementCount >= (uint)(2 * Unsafe.SizeOf<Vector128<byte>>()))
				{
					if (IntPtr.Size >= 8)
					{
					}
					num2 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer);
					num3 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + 2);
					if (!AllCharsInUInt32AreAscii(num2 | num3))
					{
						goto IL_01c7;
					}
					num = NarrowUtf16ToAscii_Sse2(pUtf16Buffer, pAsciiBuffer, elementCount);
				}
			}
			else if (Vector.IsHardwareAccelerated)
			{
				uint num5 = (uint)Unsafe.SizeOf<Vector<byte>>();
				if (elementCount >= 2 * num5)
				{
					if (IntPtr.Size >= 8)
					{
					}
					num2 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer);
					num3 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + 2);
					if (!AllCharsInUInt32AreAscii(num2 | num3))
					{
						goto IL_01c7;
					}
					Vector<ushort> right = new Vector<ushort>(127);
					nuint num6 = elementCount - 2 * num5;
					do
					{
						Vector<ushort> vector = Unsafe.ReadUnaligned<Vector<ushort>>(pUtf16Buffer + num);
						Vector<ushort> vector2 = Unsafe.ReadUnaligned<Vector<ushort>>(pUtf16Buffer + num + Vector<ushort>.Count);
						if (Vector.GreaterThanAny(Vector.BitwiseOr(vector, vector2), right))
						{
							break;
						}
						Vector<byte> value = Vector.Narrow(vector, vector2);
						Unsafe.WriteUnaligned(pAsciiBuffer + num, value);
						num += num5;
					}
					while (num <= num6);
				}
			}
			nuint num7 = elementCount - num;
			if (num7 < 4)
			{
				goto IL_0173;
			}
			nuint num8 = num + num7 - 4;
			while (true)
			{
				if (IntPtr.Size >= 8)
				{
				}
				num2 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + num);
				num3 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + num + 2);
				if (!AllCharsInUInt32AreAscii(num2 | num3))
				{
					break;
				}
				NarrowTwoUtf16CharsToAsciiAndWriteToBuffer(ref pAsciiBuffer[num], num2);
				NarrowTwoUtf16CharsToAsciiAndWriteToBuffer(ref pAsciiBuffer[num + 2], num3);
				num += 4;
				if (num <= num8)
				{
					continue;
				}
				goto IL_0173;
			}
			goto IL_01c7;
			IL_01e9:
			if (FirstCharInUInt32IsAscii(num2))
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				pAsciiBuffer[num] = (byte)num2;
				num++;
			}
			goto IL_01c5;
			IL_0173:
			if (((uint)(int)num7 & 2u) != 0)
			{
				num2 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + num);
				if (!AllCharsInUInt32AreAscii(num2))
				{
					goto IL_01e9;
				}
				NarrowTwoUtf16CharsToAsciiAndWriteToBuffer(ref pAsciiBuffer[num], num2);
				num += 2;
			}
			if (((uint)(int)num7 & (true ? 1u : 0u)) != 0)
			{
				num2 = pUtf16Buffer[num];
				if (num2 <= 127)
				{
					pAsciiBuffer[num] = (byte)num2;
					num++;
				}
			}
			goto IL_01c5;
			IL_01c7:
			if (IntPtr.Size >= 8)
			{
			}
			if (AllCharsInUInt32AreAscii(num2))
			{
				NarrowTwoUtf16CharsToAsciiAndWriteToBuffer(ref pAsciiBuffer[num], num2);
				num2 = num3;
				num += 2;
			}
			goto IL_01e9;
			IL_01c5:
			return num;
		}

		private unsafe static nuint NarrowUtf16ToAscii_Sse2(char* pUtf16Buffer, byte* pAsciiBuffer, nuint elementCount)
		{
			uint num = (uint)Unsafe.SizeOf<Vector128<byte>>();
			nuint num2 = num - 1;
			Vector128<short> right = Vector128.Create((short)(-128));
			Vector128<ushort> right2 = Vector128.Create((ushort)32640);
			Vector128<short> vector = Sse2.LoadVector128((short*)pUtf16Buffer);
			if (Sse41.IsSupported)
			{
				if (!Sse41.TestZ(vector, right))
				{
					return 0u;
				}
			}
			else if (((uint)Sse2.MoveMask(Sse2.AddSaturate(vector.AsUInt16(), right2).AsByte()) & 0xAAAAu) != 0)
			{
				return 0u;
			}
			Vector128<byte> vector2 = Sse2.PackUnsignedSaturate(vector, vector);
			Sse2.StoreScalar((ulong*)pAsciiBuffer, vector2.AsUInt64());
			nuint num3 = num / 2;
			if (((uint)(int)pAsciiBuffer & (num / 2)) != 0)
			{
				goto IL_00e7;
			}
			vector = Sse2.LoadVector128((short*)(pUtf16Buffer + num3));
			if (Sse41.IsSupported)
			{
				if (Sse41.TestZ(vector, right))
				{
					goto IL_00ca;
				}
			}
			else if ((Sse2.MoveMask(Sse2.AddSaturate(vector.AsUInt16(), right2).AsByte()) & 0xAAAA) == 0)
			{
				goto IL_00ca;
			}
			goto IL_0183;
			IL_0183:
			return num3;
			IL_00e7:
			num3 = num - ((nuint)pAsciiBuffer & num2);
			nuint num4 = elementCount - num;
			do
			{
				vector = Sse2.LoadVector128((short*)(pUtf16Buffer + num3));
				Vector128<short> right3 = Sse2.LoadVector128((short*)(pUtf16Buffer + num3 + num / 2));
				Vector128<short> vector3 = Sse2.Or(vector, right3);
				if (Sse41.IsSupported)
				{
					if (Sse41.TestZ(vector3, right))
					{
						goto IL_015b;
					}
				}
				else if ((Sse2.MoveMask(Sse2.AddSaturate(vector3.AsUInt16(), right2).AsByte()) & 0xAAAA) == 0)
				{
					goto IL_015b;
				}
				if (Sse41.IsSupported)
				{
					if (!Sse41.TestZ(vector, right))
					{
						break;
					}
				}
				else if (((uint)Sse2.MoveMask(Sse2.AddSaturate(vector.AsUInt16(), right2).AsByte()) & 0xAAAAu) != 0)
				{
					break;
				}
				vector2 = Sse2.PackUnsignedSaturate(vector, vector);
				Sse2.StoreScalar((ulong*)(pAsciiBuffer + num3), vector2.AsUInt64());
				num3 += num / 2;
				break;
				IL_015b:
				vector2 = Sse2.PackUnsignedSaturate(vector, right3);
				Sse2.StoreAligned(pAsciiBuffer + num3, vector2);
				num3 += num;
			}
			while (num3 <= num4);
			goto IL_0183;
			IL_00ca:
			vector2 = Sse2.PackUnsignedSaturate(vector, vector);
			Sse2.StoreScalar((ulong*)(pAsciiBuffer + num3), vector2.AsUInt64());
			goto IL_00e7;
		}

		public unsafe static nuint WidenAsciiToUtf16(byte* pAsciiBuffer, char* pUtf16Buffer, nuint elementCount)
		{
			nuint num = 0u;
			_ = BitConverter.IsLittleEndian;
			if (Sse2.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				if (elementCount >= (uint)(2 * Unsafe.SizeOf<Vector128<byte>>()))
				{
					num = WidenAsciiToUtf16_Intrinsified(pAsciiBuffer, pUtf16Buffer, elementCount);
				}
			}
			else if (Vector.IsHardwareAccelerated)
			{
				uint num2 = (uint)Unsafe.SizeOf<Vector<byte>>();
				if (elementCount >= num2)
				{
					nuint num3 = elementCount - num2;
					do
					{
						Vector<sbyte> vector = Unsafe.ReadUnaligned<Vector<sbyte>>(pAsciiBuffer + num);
						if (Vector.LessThanAny(vector, Vector<sbyte>.Zero))
						{
							break;
						}
						Vector.Widen(Vector.AsVectorByte(vector), out var low, out var high);
						Unsafe.WriteUnaligned(pUtf16Buffer + num, low);
						Unsafe.WriteUnaligned(pUtf16Buffer + num + Vector<ushort>.Count, high);
						num += num2;
					}
					while (num <= num3);
				}
			}
			nuint num4 = elementCount - num;
			if (num4 < 4)
			{
				goto IL_00df;
			}
			nuint num5 = num + num4 - 4;
			uint num6;
			while (true)
			{
				num6 = Unsafe.ReadUnaligned<uint>(pAsciiBuffer + num);
				if (!AllBytesInUInt32AreAscii(num6))
				{
					break;
				}
				WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref pUtf16Buffer[num], num6);
				num += 4;
				if (num <= num5)
				{
					continue;
				}
				goto IL_00df;
			}
			goto IL_014f;
			IL_014d:
			return num;
			IL_014f:
			_ = BitConverter.IsLittleEndian;
			while (((byte)num6 & 0x80) == 0)
			{
				pUtf16Buffer[num] = (char)(byte)num6;
				num++;
				num6 >>= 8;
			}
			goto IL_014d;
			IL_00df:
			if (((uint)(int)num4 & 2u) != 0)
			{
				num6 = Unsafe.ReadUnaligned<ushort>(pAsciiBuffer + num);
				if (!AllBytesInUInt32AreAscii(num6) && BitConverter.IsLittleEndian)
				{
					goto IL_014f;
				}
				_ = BitConverter.IsLittleEndian;
				pUtf16Buffer[num] = (char)(byte)num6;
				pUtf16Buffer[num + 1] = (char)(num6 >> 8);
				num += 2;
			}
			if (((uint)(int)num4 & (true ? 1u : 0u)) != 0)
			{
				num6 = pAsciiBuffer[num];
				if (((byte)num6 & 0x80) == 0)
				{
					pUtf16Buffer[num] = (char)num6;
					num++;
				}
			}
			goto IL_014d;
		}

		private unsafe static nuint WidenAsciiToUtf16_Intrinsified(byte* pAsciiBuffer, char* pUtf16Buffer, nuint elementCount)
		{
			uint num = (uint)Unsafe.SizeOf<Vector128<byte>>();
			nuint num2 = num - 1;
			if (Sse2.IsSupported)
			{
				Vector128<byte> vector = Sse2.LoadVector128(pAsciiBuffer);
				if (Sse2.MoveMask(vector) != 0)
				{
					return 0u;
				}
				Vector128<byte> zero = Vector128<byte>.Zero;
				if (Sse2.IsSupported)
				{
					Vector128<byte> source = Sse2.UnpackLow(vector, zero);
					Sse2.Store((byte*)pUtf16Buffer, source);
					nuint num3 = (num >> 1) - (((nuint)pUtf16Buffer >> 1) & (num2 >> 1));
					nuint num4 = elementCount - num;
					char* ptr = pUtf16Buffer + num3;
					while (true)
					{
						if (Sse2.IsSupported)
						{
							vector = Sse2.LoadVector128(pAsciiBuffer + num3);
							bool flag = Sse2.MoveMask(vector) != 0;
							if (!flag)
							{
								if (!Sse2.IsSupported)
								{
									if (AdvSimd.Arm64.IsSupported)
									{
									}
									throw new PlatformNotSupportedException();
								}
								Vector128<byte> source2 = Sse2.UnpackLow(vector, zero);
								Sse2.StoreAligned((byte*)ptr, source2);
								Vector128<byte> source3 = Sse2.UnpackHigh(vector, zero);
								Sse2.StoreAligned((byte*)ptr + num, source3);
								num3 += num;
								ptr += num;
								if (num3 <= num4)
								{
									continue;
								}
							}
							else if (!flag)
							{
								if (!Sse2.IsSupported)
								{
									break;
								}
								source = Sse2.UnpackLow(vector, zero);
								Sse2.StoreAligned((byte*)(pUtf16Buffer + num3), source);
								num3 += num / 2;
							}
							return num3;
						}
						if (AdvSimd.Arm64.IsSupported)
						{
						}
						throw new PlatformNotSupportedException();
					}
					if (AdvSimd.Arm64.IsSupported)
					{
					}
					throw new PlatformNotSupportedException();
				}
				if (AdvSimd.IsSupported)
				{
				}
				throw new PlatformNotSupportedException();
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref char outputBuffer, uint value)
		{
			if (Sse2.X64.IsSupported)
			{
				Vector128<byte> left = Sse2.ConvertScalarToVector128UInt32(value).AsByte();
				Vector128<ulong> value2 = Sse2.UnpackLow(left, Vector128<byte>.Zero).AsUInt64();
				Unsafe.WriteUnaligned(ref Unsafe.As<char, byte>(ref outputBuffer), Sse2.X64.ConvertToUInt64(value2));
				return;
			}
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			_ = BitConverter.IsLittleEndian;
			outputBuffer = (char)(byte)value;
			value >>= 8;
			Unsafe.Add(ref outputBuffer, 1) = (char)(byte)value;
			value >>= 8;
			Unsafe.Add(ref outputBuffer, 2) = (char)(byte)value;
			value >>= 8;
			Unsafe.Add(ref outputBuffer, 3) = (char)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool AllBytesInUInt32AreAscii(uint value)
		{
			return (value & 0x80808080u) == 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			return (uint)BitOperations.TrailingZeroCount(value & 0x80808080u) >> 3;
		}
	}
	internal sealed class CodePageDataItem
	{
		public int UIFamilyCodePage { get; }

		public string WebName { get; }

		public string HeaderName { get; }

		public string BodyName { get; }

		public string DisplayName { get; }

		public uint Flags { get; }

		internal CodePageDataItem(int uiFamilyCodePage, string webName, string headerName, string bodyName, string displayName, uint flags)
		{
			UIFamilyCodePage = uiFamilyCodePage;
			WebName = webName;
			HeaderName = headerName;
			BodyName = bodyName;
			DisplayName = displayName;
			Flags = flags;
		}
	}
	public abstract class Decoder
	{
		internal DecoderFallback _fallback;

		internal DecoderFallbackBuffer _fallbackBuffer;

		public DecoderFallback? Fallback
		{
			get
			{
				return _fallback;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (_fallbackBuffer != null && _fallbackBuffer.Remaining > 0)
				{
					throw new ArgumentException(SR.Argument_FallbackBufferNotEmpty, "value");
				}
				_fallback = value;
				_fallbackBuffer = null;
			}
		}

		public DecoderFallbackBuffer FallbackBuffer
		{
			get
			{
				if (_fallbackBuffer == null)
				{
					if (_fallback != null)
					{
						_fallbackBuffer = _fallback.CreateFallbackBuffer();
					}
					else
					{
						_fallbackBuffer = DecoderFallback.ReplacementFallback.CreateFallbackBuffer();
					}
				}
				return _fallbackBuffer;
			}
		}

		internal bool InternalHasFallbackBuffer => _fallbackBuffer != null;

		public virtual void Reset()
		{
			byte[] bytes = Array.Empty<byte>();
			char[] chars = new char[GetCharCount(bytes, 0, 0, flush: true)];
			GetChars(bytes, 0, 0, chars, 0, flush: true);
			_fallbackBuffer?.Reset();
		}

		public abstract int GetCharCount(byte[] bytes, int index, int count);

		public virtual int GetCharCount(byte[] bytes, int index, int count, bool flush)
		{
			return GetCharCount(bytes, index, count);
		}

		[CLSCompliant(false)]
		public unsafe virtual int GetCharCount(byte* bytes, int count, bool flush)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			byte[] array = new byte[count];
			for (int i = 0; i < count; i++)
			{
				array[i] = bytes[i];
			}
			return GetCharCount(array, 0, count);
		}

		public unsafe virtual int GetCharCount(ReadOnlySpan<byte> bytes, bool flush)
		{
			fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
			{
				return GetCharCount(bytes2, bytes.Length, flush);
			}
		}

		public abstract int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex);

		public virtual int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, bool flush)
		{
			return GetChars(bytes, byteIndex, byteCount, chars, charIndex);
		}

		[CLSCompliant(false)]
		public unsafe virtual int GetChars(byte* bytes, int byteCount, char* chars, int charCount, bool flush)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (byteCount < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteCount < 0) ? "byteCount" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			byte[] array = new byte[byteCount];
			for (int i = 0; i < byteCount; i++)
			{
				array[i] = bytes[i];
			}
			char[] array2 = new char[charCount];
			int chars2 = GetChars(array, 0, byteCount, array2, 0, flush);
			if (chars2 < charCount)
			{
				charCount = chars2;
			}
			for (int i = 0; i < charCount; i++)
			{
				chars[i] = array2[i];
			}
			return charCount;
		}

		public unsafe virtual int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars, bool flush)
		{
			fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
			{
				fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
				{
					return GetChars(bytes2, bytes.Length, chars2, chars.Length, flush);
				}
			}
		}

		public virtual void Convert(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, int charCount, bool flush, out int bytesUsed, out int charsUsed, out bool completed)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (byteIndex < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (chars.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			for (bytesUsed = byteCount; bytesUsed > 0; bytesUsed /= 2)
			{
				if (GetCharCount(bytes, byteIndex, bytesUsed, flush) <= charCount)
				{
					charsUsed = GetChars(bytes, byteIndex, bytesUsed, chars, charIndex, flush);
					completed = bytesUsed == byteCount && (_fallbackBuffer == null || _fallbackBuffer.Remaining == 0);
					return;
				}
				flush = false;
			}
			throw new ArgumentException(SR.Argument_ConversionOverflow);
		}

		[CLSCompliant(false)]
		public unsafe virtual void Convert(byte* bytes, int byteCount, char* chars, int charCount, bool flush, out int bytesUsed, out int charsUsed, out bool completed)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (byteCount < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteCount < 0) ? "byteCount" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			for (bytesUsed = byteCount; bytesUsed > 0; bytesUsed /= 2)
			{
				if (GetCharCount(bytes, bytesUsed, flush) <= charCount)
				{
					charsUsed = GetChars(bytes, bytesUsed, chars, charCount, flush);
					completed = bytesUsed == byteCount && (_fallbackBuffer == null || _fallbackBuffer.Remaining == 0);
					return;
				}
				flush = false;
			}
			throw new ArgumentException(SR.Argument_ConversionOverflow);
		}

		public unsafe virtual void Convert(ReadOnlySpan<byte> bytes, Span<char> chars, bool flush, out int bytesUsed, out int charsUsed, out bool completed)
		{
			fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
			{
				fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
				{
					Convert(bytes2, bytes.Length, chars2, chars.Length, flush, out bytesUsed, out charsUsed, out completed);
				}
			}
		}
	}
	public sealed class DecoderExceptionFallback : DecoderFallback
	{
		internal static readonly DecoderExceptionFallback s_default = new DecoderExceptionFallback();

		public override int MaxCharCount => 0;

		public override DecoderFallbackBuffer CreateFallbackBuffer()
		{
			return new DecoderExceptionFallbackBuffer();
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			return value is DecoderExceptionFallback;
		}

		public override int GetHashCode()
		{
			return 879;
		}
	}
	public sealed class DecoderExceptionFallbackBuffer : DecoderFallbackBuffer
	{
		public override int Remaining => 0;

		public override bool Fallback(byte[] bytesUnknown, int index)
		{
			Throw(bytesUnknown, index);
			return true;
		}

		public override char GetNextChar()
		{
			return '\0';
		}

		public override bool MovePrevious()
		{
			return false;
		}

		[DoesNotReturn]
		private static void Throw(byte[] bytesUnknown, int index)
		{
			if (bytesUnknown == null)
			{
				bytesUnknown = Array.Empty<byte>();
			}
			StringBuilder stringBuilder = new StringBuilder(bytesUnknown.Length * 4);
			for (int i = 0; i < bytesUnknown.Length && i < 20; i++)
			{
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(2, 1, stringBuilder2);
				handler.AppendLiteral("[");
				handler.AppendFormatted(bytesUnknown[i], "X2");
				handler.AppendLiteral("]");
				stringBuilder2.Append(ref handler);
			}
			if (bytesUnknown.Length > 20)
			{
				stringBuilder.Append(" ...");
			}
			throw new DecoderFallbackException(SR.Format(SR.Argument_InvalidCodePageBytesIndex, stringBuilder, index), bytesUnknown, index);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class DecoderFallbackException : ArgumentException
	{
		private readonly byte[] _bytesUnknown;

		private readonly int _index;

		public byte[]? BytesUnknown => _bytesUnknown;

		public int Index => _index;

		public DecoderFallbackException()
			: base(SR.Arg_ArgumentException)
		{
			base.HResult = -2147024809;
		}

		public DecoderFallbackException(string? message)
			: base(message)
		{
			base.HResult = -2147024809;
		}

		public DecoderFallbackException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024809;
		}

		public DecoderFallbackException(string? message, byte[]? bytesUnknown, int index)
			: base(message)
		{
			_bytesUnknown = bytesUnknown;
			_index = index;
		}

		private DecoderFallbackException(SerializationInfo serializationInfo, StreamingContext streamingContext)
			: base(serializationInfo, streamingContext)
		{
		}
	}
	public abstract class DecoderFallback
	{
		public static DecoderFallback ReplacementFallback => DecoderReplacementFallback.s_default;

		public static DecoderFallback ExceptionFallback => DecoderExceptionFallback.s_default;

		public abstract int MaxCharCount { get; }

		public abstract DecoderFallbackBuffer CreateFallbackBuffer();
	}
	public abstract class DecoderFallbackBuffer
	{
		internal unsafe byte* byteStart;

		internal unsafe char* charEnd;

		internal Encoding _encoding;

		internal DecoderNLS _decoder;

		private int _originalByteCount;

		public abstract int Remaining { get; }

		public abstract bool Fallback(byte[] bytesUnknown, int index);

		public abstract char GetNextChar();

		public abstract bool MovePrevious();

		public virtual void Reset()
		{
			while (GetNextChar() != 0)
			{
			}
		}

		internal unsafe void InternalReset()
		{
			byteStart = null;
			Reset();
		}

		internal unsafe void InternalInitialize(byte* byteStart, char* charEnd)
		{
			this.byteStart = byteStart;
			this.charEnd = charEnd;
		}

		internal static DecoderFallbackBuffer CreateAndInitialize(Encoding encoding, DecoderNLS decoder, int originalByteCount)
		{
			DecoderFallbackBuffer decoderFallbackBuffer = ((decoder == null) ? encoding.DecoderFallback.CreateFallbackBuffer() : decoder.FallbackBuffer);
			decoderFallbackBuffer._encoding = encoding;
			decoderFallbackBuffer._decoder = decoder;
			decoderFallbackBuffer._originalByteCount = originalByteCount;
			return decoderFallbackBuffer;
		}

		internal unsafe virtual bool InternalFallback(byte[] bytes, byte* pBytes, ref char* chars)
		{
			if (Fallback(bytes, (int)(pBytes - byteStart - bytes.Length)))
			{
				char* ptr = chars;
				bool flag = false;
				char nextChar;
				while ((nextChar = GetNextChar()) != 0)
				{
					if (char.IsSurrogate(nextChar))
					{
						if (char.IsHighSurrogate(nextChar))
						{
							if (flag)
							{
								throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
							}
							flag = true;
						}
						else
						{
							if (!flag)
							{
								throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
							}
							flag = false;
						}
					}
					if (ptr >= charEnd)
					{
						return false;
					}
					*(ptr++) = nextChar;
				}
				if (flag)
				{
					throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
				}
				chars = ptr;
			}
			return true;
		}

		internal unsafe virtual int InternalFallback(byte[] bytes, byte* pBytes)
		{
			if (Fallback(bytes, (int)(pBytes - byteStart - bytes.Length)))
			{
				int num = 0;
				bool flag = false;
				char nextChar;
				while ((nextChar = GetNextChar()) != 0)
				{
					if (char.IsSurrogate(nextChar))
					{
						if (char.IsHighSurrogate(nextChar))
						{
							if (flag)
							{
								throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
							}
							flag = true;
						}
						else
						{
							if (!flag)
							{
								throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
							}
							flag = false;
						}
					}
					num++;
				}
				if (flag)
				{
					throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
				}
				return num;
			}
			return 0;
		}

		internal int InternalFallbackGetCharCount(ReadOnlySpan<byte> remainingBytes, int fallbackLength)
		{
			if (!Fallback(remainingBytes.Slice(0, fallbackLength).ToArray(), _originalByteCount - remainingBytes.Length))
			{
				return 0;
			}
			return DrainRemainingDataForGetCharCount();
		}

		internal bool TryInternalFallbackGetChars(ReadOnlySpan<byte> remainingBytes, int fallbackLength, Span<char> chars, out int charsWritten)
		{
			if (Fallback(remainingBytes.Slice(0, fallbackLength).ToArray(), _originalByteCount - remainingBytes.Length))
			{
				return TryDrainRemainingDataForGetChars(chars, out charsWritten);
			}
			charsWritten = 0;
			return true;
		}

		private Rune GetNextRune()
		{
			char nextChar = GetNextChar();
			if (!Rune.TryCreate(nextChar, out var result) && !Rune.TryCreate(nextChar, GetNextChar(), out result))
			{
				throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
			}
			return result;
		}

		internal int DrainRemainingDataForGetCharCount()
		{
			int num = 0;
			while (true)
			{
				Rune nextRune;
				Rune rune = (nextRune = GetNextRune());
				if (rune.Value == 0)
				{
					break;
				}
				num += nextRune.Utf16SequenceLength;
				if (num < 0)
				{
					InternalReset();
					Encoding.ThrowConversionOverflow();
				}
			}
			return num;
		}

		internal bool TryDrainRemainingDataForGetChars(Span<char> chars, out int charsWritten)
		{
			int length = chars.Length;
			while (true)
			{
				Rune nextRune;
				Rune rune = (nextRune = GetNextRune());
				if (rune.Value == 0)
				{
					break;
				}
				if (nextRune.TryEncodeToUtf16(chars, out var charsWritten2))
				{
					chars = chars.Slice(charsWritten2);
					continue;
				}
				InternalReset();
				charsWritten = 0;
				return false;
			}
			charsWritten = length - chars.Length;
			return true;
		}

		[DoesNotReturn]
		internal static void ThrowLastBytesRecursive(byte[] bytesUnknown)
		{
			if (bytesUnknown == null)
			{
				bytesUnknown = Array.Empty<byte>();
			}
			StringBuilder stringBuilder = new StringBuilder(bytesUnknown.Length * 3);
			int i;
			for (i = 0; i < bytesUnknown.Length && i < 20; i++)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(' ');
				}
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(2, 1, stringBuilder2);
				handler.AppendLiteral("\\x");
				handler.AppendFormatted(bytesUnknown[i], "X2");
				stringBuilder2.Append(ref handler);
			}
			if (i == 20)
			{
				stringBuilder.Append(" ...");
			}
			throw new ArgumentException(SR.Format(SR.Argument_RecursiveFallbackBytes, stringBuilder.ToString()), "bytesUnknown");
		}
	}
	internal class DecoderNLS : Decoder
	{
		private readonly Encoding _encoding;

		private bool _mustFlush;

		internal bool _throwOnOverflow;

		internal int _bytesUsed;

		private int _leftoverBytes;

		private int _leftoverByteCount;

		public bool MustFlush => _mustFlush;

		internal virtual bool HasState => _leftoverByteCount != 0;

		internal bool HasLeftoverData => _leftoverByteCount != 0;

		internal DecoderNLS(Encoding encoding)
		{
			_encoding = encoding;
			_fallback = _encoding.DecoderFallback;
			Reset();
		}

		public override void Reset()
		{
			ClearLeftoverData();
			_fallbackBuffer?.Reset();
		}

		public override int GetCharCount(byte[] bytes, int index, int count)
		{
			return GetCharCount(bytes, index, count, flush: false);
		}

		public unsafe override int GetCharCount(byte[] bytes, int index, int count, bool flush)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			fixed (byte* ptr = &MemoryMarshal.GetReference<byte>(bytes))
			{
				return GetCharCount(ptr + index, count, flush);
			}
		}

		public unsafe override int GetCharCount(byte* bytes, int count, bool flush)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_mustFlush = flush;
			_throwOnOverflow = true;
			return _encoding.GetCharCount(bytes, count, this);
		}

		public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
		{
			return GetChars(bytes, byteIndex, byteCount, chars, charIndex, flush: false);
		}

		public unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, bool flush)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (byteIndex < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (charIndex < 0 || charIndex > chars.Length)
			{
				throw new ArgumentOutOfRangeException("charIndex", SR.ArgumentOutOfRange_Index);
			}
			int charCount = chars.Length - charIndex;
			fixed (byte* ptr = &MemoryMarshal.GetReference<byte>(bytes))
			{
				fixed (char* ptr2 = &MemoryMarshal.GetReference<char>(chars))
				{
					return GetChars(ptr + byteIndex, byteCount, ptr2 + charIndex, charCount, flush);
				}
			}
		}

		public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, bool flush)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (byteCount < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteCount < 0) ? "byteCount" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_mustFlush = flush;
			_throwOnOverflow = true;
			return _encoding.GetChars(bytes, byteCount, chars, charCount, this);
		}

		public unsafe override void Convert(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, int charCount, bool flush, out int bytesUsed, out int charsUsed, out bool completed)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (byteIndex < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (chars.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			fixed (byte* ptr = &MemoryMarshal.GetReference<byte>(bytes))
			{
				fixed (char* ptr2 = &MemoryMarshal.GetReference<char>(chars))
				{
					Convert(ptr + byteIndex, byteCount, ptr2 + charIndex, charCount, flush, out bytesUsed, out charsUsed, out completed);
				}
			}
		}

		public unsafe override void Convert(byte* bytes, int byteCount, char* chars, int charCount, bool flush, out int bytesUsed, out int charsUsed, out bool completed)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (byteCount < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteCount < 0) ? "byteCount" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_mustFlush = flush;
			_throwOnOverflow = false;
			_bytesUsed = 0;
			charsUsed = _encoding.GetChars(bytes, byteCount, chars, charCount, this);
			bytesUsed = _bytesUsed;
			completed = bytesUsed == byteCount && (!flush || !HasState) && (_fallbackBuffer == null || _fallbackBuffer.Remaining == 0);
		}

		internal void ClearMustFlush()
		{
			_mustFlush = false;
		}

		internal ReadOnlySpan<byte> GetLeftoverData()
		{
			return MemoryMarshal.AsBytes(new ReadOnlySpan<int>(ref _leftoverBytes, 1)).Slice(0, _leftoverByteCount);
		}

		internal void SetLeftoverData(ReadOnlySpan<byte> bytes)
		{
			bytes.CopyTo(MemoryMarshal.AsBytes(new Span<int>(ref _leftoverBytes, 1)));
			_leftoverByteCount = bytes.Length;
		}

		internal void ClearLeftoverData()
		{
			_leftoverByteCount = 0;
		}

		internal int DrainLeftoverDataForGetCharCount(ReadOnlySpan<byte> bytes, out int bytesConsumed)
		{
			Span<byte> span = stackalloc byte[4];
			span = span.Slice(0, ConcatInto(GetLeftoverData(), bytes, span));
			int result = 0;
			Rune value;
			int bytesConsumed2;
			switch (_encoding.DecodeFirstRune(span, out value, out bytesConsumed2))
			{
			case OperationStatus.Done:
				result = value.Utf16SequenceLength;
				break;
			case OperationStatus.NeedMoreData:
				if (!MustFlush)
				{
					break;
				}
				goto default;
			default:
				if (base.FallbackBuffer.Fallback(span.Slice(0, bytesConsumed2).ToArray(), -_leftoverByteCount))
				{
					result = _fallbackBuffer.DrainRemainingDataForGetCharCount();
				}
				break;
			}
			bytesConsumed = bytesConsumed2 - _leftoverByteCount;
			return result;
		}

		internal int DrainLeftoverDataForGetChars(ReadOnlySpan<byte> bytes, Span<char> chars, out int bytesConsumed)
		{
			Span<byte> span = stackalloc byte[4];
			span = span.Slice(0, ConcatInto(GetLeftoverData(), bytes, span));
			int charsWritten = 0;
			bool flag = false;
			Rune value;
			int bytesConsumed2;
			switch (_encoding.DecodeFirstRune(span, out value, out bytesConsumed2))
			{
			case OperationStatus.Done:
				if (!value.TryEncodeToUtf16(chars, out charsWritten))
				{
					break;
				}
				goto IL_00aa;
			case OperationStatus.NeedMoreData:
				if (MustFlush)
				{
					goto default;
				}
				flag = true;
				goto IL_00aa;
			default:
				{
					if (base.FallbackBuffer.Fallback(span.Slice(0, bytesConsumed2).ToArray(), -_leftoverByteCount) && !_fallbackBuffer.TryDrainRemainingDataForGetChars(chars, out charsWritten))
					{
						break;
					}
					goto IL_00aa;
				}
				IL_00aa:
				bytesConsumed = bytesConsumed2 - _leftoverByteCount;
				if (flag)
				{
					SetLeftoverData(span);
				}
				else
				{
					ClearLeftoverData();
				}
				return charsWritten;
			}
			_encoding.ThrowCharsOverflow(this, nothingDecoded: true);
			throw null;
		}

		private static int ConcatInto(ReadOnlySpan<byte> srcLeft, ReadOnlySpan<byte> srcRight, Span<byte> dest)
		{
			int num = 0;
			int num2 = 0;
			while (true)
			{
				if (num2 < srcLeft.Length)
				{
					if ((uint)num >= (uint)dest.Length)
					{
						break;
					}
					dest[num++] = srcLeft[num2];
					num2++;
					continue;
				}
				for (int i = 0; i < srcRight.Length; i++)
				{
					if ((uint)num >= (uint)dest.Length)
					{
						break;
					}
					dest[num++] = srcRight[i];
				}
				break;
			}
			return num;
		}
	}
	public sealed class DecoderReplacementFallback : DecoderFallback
	{
		internal static readonly DecoderReplacementFallback s_default = new DecoderReplacementFallback();

		private readonly string _strDefault;

		public string DefaultString => _strDefault;

		public override int MaxCharCount => _strDefault.Length;

		public DecoderReplacementFallback()
			: this("?")
		{
		}

		public DecoderReplacementFallback(string replacement)
		{
			if (replacement == null)
			{
				throw new ArgumentNullException("replacement");
			}
			bool flag = false;
			foreach (char c in replacement)
			{
				if (char.IsSurrogate(c))
				{
					if (char.IsHighSurrogate(c))
					{
						if (flag)
						{
							break;
						}
						flag = true;
						continue;
					}
					if (!flag)
					{
						flag = true;
						break;
					}
					flag = false;
				}
				else if (flag)
				{
					break;
				}
			}
			if (flag)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequenceNoIndex, "replacement"));
			}
			_strDefault = replacement;
		}

		public override DecoderFallbackBuffer CreateFallbackBuffer()
		{
			return new DecoderReplacementFallbackBuffer(this);
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is DecoderReplacementFallback decoderReplacementFallback)
			{
				return _strDefault == decoderReplacementFallback._strDefault;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _strDefault.GetHashCode();
		}
	}
	public sealed class DecoderReplacementFallbackBuffer : DecoderFallbackBuffer
	{
		private readonly string _strDefault;

		private int _fallbackCount = -1;

		private int _fallbackIndex = -1;

		public override int Remaining
		{
			get
			{
				if (_fallbackCount >= 0)
				{
					return _fallbackCount;
				}
				return 0;
			}
		}

		public DecoderReplacementFallbackBuffer(DecoderReplacementFallback fallback)
		{
			_strDefault = fallback.DefaultString;
		}

		public override bool Fallback(byte[] bytesUnknown, int index)
		{
			if (_fallbackCount >= 1)
			{
				DecoderFallbackBuffer.ThrowLastBytesRecursive(bytesUnknown);
			}
			if (_strDefault.Length == 0)
			{
				return false;
			}
			_fallbackCount = _strDefault.Length;
			_fallbackIndex = -1;
			return true;
		}

		public override char GetNextChar()
		{
			_fallbackCount--;
			_fallbackIndex++;
			if (_fallbackCount < 0)
			{
				return '\0';
			}
			if (_fallbackCount == int.MaxValue)
			{
				_fallbackCount = -1;
				return '\0';
			}
			return _strDefault[_fallbackIndex];
		}

		public override bool MovePrevious()
		{
			if (_fallbackCount >= -1 && _fallbackIndex >= 0)
			{
				_fallbackIndex--;
				_fallbackCount++;
				return true;
			}
			return false;
		}

		public unsafe override void Reset()
		{
			_fallbackCount = -1;
			_fallbackIndex = -1;
			byteStart = null;
		}

		internal unsafe override int InternalFallback(byte[] bytes, byte* pBytes)
		{
			return _strDefault.Length;
		}
	}
	public abstract class Encoder
	{
		internal EncoderFallback _fallback;

		internal EncoderFallbackBuffer _fallbackBuffer;

		public EncoderFallback? Fallback
		{
			get
			{
				return _fallback;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				if (_fallbackBuffer != null && _fallbackBuffer.Remaining > 0)
				{
					throw new ArgumentException(SR.Argument_FallbackBufferNotEmpty, "value");
				}
				_fallback = value;
				_fallbackBuffer = null;
			}
		}

		public EncoderFallbackBuffer FallbackBuffer
		{
			get
			{
				if (_fallbackBuffer == null)
				{
					if (_fallback != null)
					{
						_fallbackBuffer = _fallback.CreateFallbackBuffer();
					}
					else
					{
						_fallbackBuffer = EncoderFallback.ReplacementFallback.CreateFallbackBuffer();
					}
				}
				return _fallbackBuffer;
			}
		}

		internal bool InternalHasFallbackBuffer => _fallbackBuffer != null;

		public virtual void Reset()
		{
			char[] chars = Array.Empty<char>();
			byte[] bytes = new byte[GetByteCount(chars, 0, 0, flush: true)];
			GetBytes(chars, 0, 0, bytes, 0, flush: true);
			if (_fallbackBuffer != null)
			{
				_fallbackBuffer.Reset();
			}
		}

		public abstract int GetByteCount(char[] chars, int index, int count, bool flush);

		[CLSCompliant(false)]
		public unsafe virtual int GetByteCount(char* chars, int count, bool flush)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			char[] array = new char[count];
			for (int i = 0; i < count; i++)
			{
				array[i] = chars[i];
			}
			return GetByteCount(array, 0, count, flush);
		}

		public unsafe virtual int GetByteCount(ReadOnlySpan<char> chars, bool flush)
		{
			fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
			{
				return GetByteCount(chars2, chars.Length, flush);
			}
		}

		public abstract int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush);

		[CLSCompliant(false)]
		public unsafe virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			char[] array = new char[charCount];
			for (int i = 0; i < charCount; i++)
			{
				array[i] = chars[i];
			}
			byte[] array2 = new byte[byteCount];
			int bytes2 = GetBytes(array, 0, charCount, array2, 0, flush);
			if (bytes2 < byteCount)
			{
				byteCount = bytes2;
			}
			for (int i = 0; i < byteCount; i++)
			{
				bytes[i] = array2[i];
			}
			return byteCount;
		}

		public unsafe virtual int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes, bool flush)
		{
			fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
			{
				fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
				{
					return GetBytes(chars2, chars.Length, bytes2, bytes.Length, flush);
				}
			}
		}

		public virtual void Convert(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, int byteCount, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (byteIndex < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			for (charsUsed = charCount; charsUsed > 0; charsUsed /= 2)
			{
				if (GetByteCount(chars, charIndex, charsUsed, flush) <= byteCount)
				{
					bytesUsed = GetBytes(chars, charIndex, charsUsed, bytes, byteIndex, flush);
					completed = charsUsed == charCount && (_fallbackBuffer == null || _fallbackBuffer.Remaining == 0);
					return;
				}
				flush = false;
			}
			throw new ArgumentException(SR.Argument_ConversionOverflow);
		}

		[CLSCompliant(false)]
		public unsafe virtual void Convert(char* chars, int charCount, byte* bytes, int byteCount, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			for (charsUsed = charCount; charsUsed > 0; charsUsed /= 2)
			{
				if (GetByteCount(chars, charsUsed, flush) <= byteCount)
				{
					bytesUsed = GetBytes(chars, charsUsed, bytes, byteCount, flush);
					completed = charsUsed == charCount && (_fallbackBuffer == null || _fallbackBuffer.Remaining == 0);
					return;
				}
				flush = false;
			}
			throw new ArgumentException(SR.Argument_ConversionOverflow);
		}

		public unsafe virtual void Convert(ReadOnlySpan<char> chars, Span<byte> bytes, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
		{
			fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
			{
				fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
				{
					Convert(chars2, chars.Length, bytes2, bytes.Length, flush, out charsUsed, out bytesUsed, out completed);
				}
			}
		}
	}
	public sealed class EncoderExceptionFallback : EncoderFallback
	{
		internal static readonly EncoderExceptionFallback s_default = new EncoderExceptionFallback();

		public override int MaxCharCount => 0;

		public override EncoderFallbackBuffer CreateFallbackBuffer()
		{
			return new EncoderExceptionFallbackBuffer();
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			return value is EncoderExceptionFallback;
		}

		public override int GetHashCode()
		{
			return 654;
		}
	}
	public sealed class EncoderExceptionFallbackBuffer : EncoderFallbackBuffer
	{
		public override int Remaining => 0;

		public override bool Fallback(char charUnknown, int index)
		{
			throw new EncoderFallbackException(SR.Format(SR.Argument_InvalidCodePageConversionIndex, (int)charUnknown, index), charUnknown, index);
		}

		public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
		{
			if (!char.IsHighSurrogate(charUnknownHigh))
			{
				throw new ArgumentOutOfRangeException("charUnknownHigh", SR.Format(SR.ArgumentOutOfRange_Range, 55296, 56319));
			}
			if (!char.IsLowSurrogate(charUnknownLow))
			{
				throw new ArgumentOutOfRangeException("charUnknownLow", SR.Format(SR.ArgumentOutOfRange_Range, 56320, 57343));
			}
			int num = char.ConvertToUtf32(charUnknownHigh, charUnknownLow);
			throw new EncoderFallbackException(SR.Format(SR.Argument_InvalidCodePageConversionIndex, num, index), charUnknownHigh, charUnknownLow, index);
		}

		public override char GetNextChar()
		{
			return '\0';
		}

		public override bool MovePrevious()
		{
			return false;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class EncoderFallbackException : ArgumentException
	{
		private readonly char _charUnknown;

		private readonly char _charUnknownHigh;

		private readonly char _charUnknownLow;

		private readonly int _index;

		public char CharUnknown => _charUnknown;

		public char CharUnknownHigh => _charUnknownHigh;

		public char CharUnknownLow => _charUnknownLow;

		public int Index => _index;

		public EncoderFallbackException()
			: base(SR.Arg_ArgumentException)
		{
			base.HResult = -2147024809;
		}

		public EncoderFallbackException(string? message)
			: base(message)
		{
			base.HResult = -2147024809;
		}

		public EncoderFallbackException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024809;
		}

		internal EncoderFallbackException(string message, char charUnknown, int index)
			: base(message)
		{
			_charUnknown = charUnknown;
			_index = index;
		}

		internal EncoderFallbackException(string message, char charUnknownHigh, char charUnknownLow, int index)
			: base(message)
		{
			if (!char.IsHighSurrogate(charUnknownHigh))
			{
				throw new ArgumentOutOfRangeException("charUnknownHigh", SR.Format(SR.ArgumentOutOfRange_Range, 55296, 56319));
			}
			if (!char.IsLowSurrogate(charUnknownLow))
			{
				throw new ArgumentOutOfRangeException("CharUnknownLow", SR.Format(SR.ArgumentOutOfRange_Range, 56320, 57343));
			}
			_charUnknownHigh = charUnknownHigh;
			_charUnknownLow = charUnknownLow;
			_index = index;
		}

		private EncoderFallbackException(SerializationInfo serializationInfo, StreamingContext streamingContext)
			: base(serializationInfo, streamingContext)
		{
		}

		public bool IsUnknownSurrogate()
		{
			return _charUnknownHigh != '\0';
		}
	}
	public abstract class EncoderFallback
	{
		public static EncoderFallback ReplacementFallback => EncoderReplacementFallback.s_default;

		public static EncoderFallback ExceptionFallback => EncoderExceptionFallback.s_default;

		public abstract int MaxCharCount { get; }

		public abstract EncoderFallbackBuffer CreateFallbackBuffer();
	}
	public abstract class EncoderFallbackBuffer
	{
		internal unsafe char* charStart;

		internal unsafe char* charEnd;

		internal EncoderNLS encoder;

		internal bool setEncoder;

		internal bool bUsedEncoder;

		internal bool bFallingBack;

		internal int iRecursionCount;

		private Encoding encoding;

		private int originalCharCount;

		public abstract int Remaining { get; }

		public abstract bool Fallback(char charUnknown, int index);

		public abstract bool Fallback(char charUnknownHigh, char charUnknownLow, int index);

		public abstract char GetNextChar();

		public abstract bool MovePrevious();

		public virtual void Reset()
		{
			while (GetNextChar() != 0)
			{
			}
		}

		internal unsafe void InternalReset()
		{
			charStart = null;
			bFallingBack = false;
			iRecursionCount = 0;
			Reset();
		}

		internal unsafe void InternalInitialize(char* charStart, char* charEnd, EncoderNLS encoder, bool setEncoder)
		{
			this.charStart = charStart;
			this.charEnd = charEnd;
			this.encoder = encoder;
			this.setEncoder = setEncoder;
			bUsedEncoder = false;
			bFallingBack = false;
			iRecursionCount = 0;
		}

		internal static EncoderFallbackBuffer CreateAndInitialize(Encoding encoding, EncoderNLS encoder, int originalCharCount)
		{
			EncoderFallbackBuffer encoderFallbackBuffer = ((encoder == null) ? encoding.EncoderFallback.CreateFallbackBuffer() : encoder.FallbackBuffer);
			encoderFallbackBuffer.encoding = encoding;
			encoderFallbackBuffer.encoder = encoder;
			encoderFallbackBuffer.originalCharCount = originalCharCount;
			return encoderFallbackBuffer;
		}

		internal char InternalGetNextChar()
		{
			char nextChar = GetNextChar();
			bFallingBack = nextChar != '\0';
			if (nextChar == '\0')
			{
				iRecursionCount = 0;
			}
			return nextChar;
		}

		private bool InternalFallback(ReadOnlySpan<char> chars, out int charsConsumed)
		{
			char c = chars[0];
			char c2 = '\0';
			if (!chars.IsEmpty)
			{
				c = chars[0];
				if (chars.Length > 1)
				{
					c2 = chars[1];
				}
			}
			int index = originalCharCount - chars.Length;
			if (!char.IsSurrogatePair(c, c2))
			{
				charsConsumed = 1;
				return Fallback(c, index);
			}
			charsConsumed = 2;
			return Fallback(c, c2, index);
		}

		internal int InternalFallbackGetByteCount(ReadOnlySpan<char> chars, out int charsConsumed)
		{
			int result = 0;
			if (InternalFallback(chars, out charsConsumed))
			{
				result = DrainRemainingDataForGetByteCount();
			}
			return result;
		}

		internal bool TryInternalFallbackGetBytes(ReadOnlySpan<char> chars, Span<byte> bytes, out int charsConsumed, out int bytesWritten)
		{
			if (InternalFallback(chars, out charsConsumed))
			{
				return TryDrainRemainingDataForGetBytes(bytes, out bytesWritten);
			}
			bytesWritten = 0;
			return true;
		}

		internal bool TryDrainRemainingDataForGetBytes(Span<byte> bytes, out int bytesWritten)
		{
			int length = bytes.Length;
			while (true)
			{
				Rune nextRune;
				Rune rune = (nextRune = GetNextRune());
				if (rune.Value == 0)
				{
					break;
				}
				int bytesWritten2;
				switch (encoding.EncodeRune(nextRune, bytes, out bytesWritten2))
				{
				case OperationStatus.Done:
					bytes = bytes.Slice(bytesWritten2);
					break;
				case OperationStatus.DestinationTooSmall:
				{
					for (int i = 0; i < nextRune.Utf16SequenceLength; i++)
					{
						MovePrevious();
					}
					bytesWritten = length - bytes.Length;
					return false;
				}
				case OperationStatus.InvalidData:
					ThrowLastCharRecursive(nextRune.Value);
					break;
				}
			}
			bytesWritten = length - bytes.Length;
			return true;
		}

		internal int DrainRemainingDataForGetByteCount()
		{
			int num = 0;
			while (true)
			{
				Rune nextRune;
				Rune rune = (nextRune = GetNextRune());
				if (rune.Value == 0)
				{
					break;
				}
				if (!encoding.TryGetByteCount(nextRune, out var byteCount))
				{
					ThrowLastCharRecursive(nextRune.Value);
				}
				num += byteCount;
				if (num < 0)
				{
					InternalReset();
					Encoding.ThrowConversionOverflow();
				}
			}
			return num;
		}

		private Rune GetNextRune()
		{
			char nextChar = GetNextChar();
			if (Rune.TryCreate(nextChar, out var result) || Rune.TryCreate(nextChar, GetNextChar(), out result))
			{
				return result;
			}
			throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
		}

		internal unsafe virtual bool InternalFallback(char ch, ref char* chars)
		{
			int index = (int)(chars - charStart) - 1;
			if (char.IsHighSurrogate(ch))
			{
				if (chars >= charEnd)
				{
					if (encoder != null && !encoder.MustFlush)
					{
						if (setEncoder)
						{
							bUsedEncoder = true;
							encoder._charLeftOver = ch;
						}
						bFallingBack = false;
						return false;
					}
				}
				else
				{
					char c = *chars;
					if (char.IsLowSurrogate(c))
					{
						if (bFallingBack && iRecursionCount++ > 250)
						{
							ThrowLastCharRecursive(char.ConvertToUtf32(ch, c));
						}
						chars++;
						bFallingBack = Fallback(ch, c, index);
						return bFallingBack;
					}
				}
			}
			if (bFallingBack && iRecursionCount++ > 250)
			{
				ThrowLastCharRecursive(ch);
			}
			bFallingBack = Fallback(ch, index);
			return bFallingBack;
		}

		[DoesNotReturn]
		internal static void ThrowLastCharRecursive(int charRecursive)
		{
			throw new ArgumentException(SR.Format(SR.Argument_RecursiveFallback, charRecursive), "chars");
		}
	}
	internal sealed class EncoderLatin1BestFitFallback : EncoderFallback
	{
		internal static readonly EncoderLatin1BestFitFallback SingletonInstance = new EncoderLatin1BestFitFallback();

		public override int MaxCharCount => 1;

		private EncoderLatin1BestFitFallback()
		{
		}

		public override EncoderFallbackBuffer CreateFallbackBuffer()
		{
			return new EncoderLatin1BestFitFallbackBuffer();
		}
	}
	internal sealed class EncoderLatin1BestFitFallbackBuffer : EncoderFallbackBuffer
	{
		private char _cBestFit;

		private int _iCount = -1;

		private int _iSize;

		private static readonly char[] s_arrayCharBestFit = new char[604]
		{
			'Ā', 'A', 'ā', 'a', 'Ă', 'A', 'ă', 'a', 'Ą', 'A',
			'ą', 'a', 'Ć', 'C', 'ć', 'c', 'Ĉ', 'C', 'ĉ', 'c',
			'Ċ', 'C', 'ċ', 'c', 'Č', 'C', 'č', 'c', 'Ď', 'D',
			'ď', 'd', 'Đ', 'D', 'đ', 'd', 'Ē', 'E', 'ē', 'e',
			'Ĕ', 'E', 'ĕ', 'e', 'Ė', 'E', 'ė', 'e', 'Ę', 'E',
			'ę', 'e', 'Ě', 'E', 'ě', 'e', 'Ĝ', 'G', 'ĝ', 'g',
			'Ğ', 'G', 'ğ', 'g', 'Ġ', 'G', 'ġ', 'g', 'Ģ', 'G',
			'ģ', 'g', 'Ĥ', 'H', 'ĥ', 'h', 'Ħ', 'H', 'ħ', 'h',
			'Ĩ', 'I', 'ĩ', 'i', 'Ī', 'I', 'ī', 'i', 'Ĭ', 'I',
			'ĭ', 'i', 'Į', 'I', 'į', 'i', 'İ', 'I', 'ı', 'i',
			'Ĵ', 'J', 'ĵ', 'j', 'Ķ', 'K', 'ķ', 'k', 'Ĺ', 'L',
			'ĺ', 'l', 'Ļ', 'L', 'ļ', 'l', 'Ľ', 'L', 'ľ', 'l',
			'Ł', 'L', 'ł', 'l', 'Ń', 'N', 'ń', 'n', 'Ņ', 'N',
			'ņ', 'n', 'Ň', 'N', 'ň', 'n', 'Ō', 'O', 'ō', 'o',
			'Ŏ', 'O', 'ŏ', 'o', 'Ő', 'O', 'ő', 'o', 'Œ', 'O',
			'œ', 'o', 'Ŕ', 'R', 'ŕ', 'r', 'Ŗ', 'R', 'ŗ', 'r',
			'Ř', 'R', 'ř', 'r', 'Ś', 'S', 'ś', 's', 'Ŝ', 'S',
			'ŝ', 's', 'Ş', 'S', 'ş', 's', 'Š', 'S', 'š', 's',
			'Ţ', 'T', 'ţ', 't', 'Ť', 'T', 'ť', 't', 'Ŧ', 'T',
			'ŧ', 't', 'Ũ', 'U', 'ũ', 'u', 'Ū', 'U', 'ū', 'u',
			'Ŭ', 'U', 'ŭ', 'u', 'Ů', 'U', 'ů', 'u', 'Ű', 'U',
			'ű', 'u', 'Ų', 'U', 'ų', 'u', 'Ŵ', 'W', 'ŵ', 'w',
			'Ŷ', 'Y', 'ŷ', 'y', 'Ÿ', 'Y', 'Ź', 'Z', 'ź', 'z',
			'Ż', 'Z', 'ż', 'z', 'Ž', 'Z', 'ž', 'z', 'ƀ', 'b',
			'Ɖ', 'D', 'Ƒ', 'F', 'ƒ', 'f', 'Ɨ', 'I', 'ƚ', 'l',
			'Ɵ', 'O', 'Ơ', 'O', 'ơ', 'o', 'ƫ', 't', 'Ʈ', 'T',
			'Ư', 'U', 'ư', 'u', 'ƶ', 'z', 'Ǎ', 'A', 'ǎ', 'a',
			'Ǐ', 'I', 'ǐ', 'i', 'Ǒ', 'O', 'ǒ', 'o', 'Ǔ', 'U',
			'ǔ', 'u', 'Ǖ', 'U', 'ǖ', 'u', 'Ǘ', 'U', 'ǘ', 'u',
			'Ǚ', 'U', 'ǚ', 'u', 'Ǜ', 'U', 'ǜ', 'u', 'Ǟ', 'A',
			'ǟ', 'a', 'Ǥ', 'G', 'ǥ', 'g', 'Ǧ', 'G', 'ǧ', 'g',
			'Ǩ', 'K', 'ǩ', 'k', 'Ǫ', 'O', 'ǫ', 'o', 'Ǭ', 'O',
			'ǭ', 'o', 'ǰ', 'j', 'ɡ', 'g', 'ʹ', '\'', 'ʺ', '"',
			'ʼ', '\'', '\u02c4', '^', 'ˆ', '^', 'ˈ', '\'', 'ˉ', '?',
			'ˊ', '?', 'ˋ', '`', 'ˍ', '_', '\u02da', '?', '\u02dc', '~',
			'\u0300', '`', '\u0302', '^', '\u0303', '~', '\u030e', '"', '\u0331', '_',
			'\u0332', '_', '\u2000', ' ', '\u2001', ' ', '\u2002', ' ', '\u2003', ' ',
			'\u2004', ' ', '\u2005', ' ', '\u2006', ' ', '‐', '-', '‑', '-',
			'–', '-', '—', '-', '‘', '\'', '’', '\'', '‚', ',',
			'“', '"', '”', '"', '„', '"', '†', '?', '‡', '?',
			'•', '.', '…', '.', '‰', '?', '′', '\'', '‵', '`',
			'‹', '<', '›', '>', '™', 'T', '！', '!', '＂', '"',
			'＃', '#', '＄', '$', '％', '%', '＆', '&', '＇', '\'',
			'（', '(', '）', ')', '＊', '*', '＋', '+', '，', ',',
			'－', '-', '．', '.', '／', '/', '０', '0', '１', '1',
			'２', '2', '３', '3', '４', '4', '５', '5', '６', '6',
			'７', '7', '８', '8', '９', '9', '：', ':', '；', ';',
			'＜', '<', '＝', '=', '＞', '>', '？', '?', '＠', '@',
			'Ａ', 'A', 'Ｂ', 'B', 'Ｃ', 'C', 'Ｄ', 'D', 'Ｅ', 'E',
			'Ｆ', 'F', 'Ｇ', 'G', 'Ｈ', 'H', 'Ｉ', 'I', 'Ｊ', 'J',
			'Ｋ', 'K', 'Ｌ', 'L', 'Ｍ', 'M', 'Ｎ', 'N', 'Ｏ', 'O',
			'Ｐ', 'P', 'Ｑ', 'Q', 'Ｒ', 'R', 'Ｓ', 'S', 'Ｔ', 'T',
			'Ｕ', 'U', 'Ｖ', 'V', 'Ｗ', 'W', 'Ｘ', 'X', 'Ｙ', 'Y',
			'Ｚ', 'Z', '［', '[', '＼', '\\', '］', ']', '\uff3e', '^',
			'\uff3f', '_', '\uff40', '`', 'ａ', 'a', 'ｂ', 'b', 'ｃ', 'c',
			'ｄ', 'd', 'ｅ', 'e', 'ｆ', 'f', 'ｇ', 'g', 'ｈ', 'h',
			'ｉ', 'i', 'ｊ', 'j', 'ｋ', 'k', 'ｌ', 'l', 'ｍ', 'm',
			'ｎ', 'n', 'ｏ', 'o', 'ｐ', 'p', 'ｑ', 'q', 'ｒ', 'r',
			'ｓ', 's', 'ｔ', 't', 'ｕ', 'u', 'ｖ', 'v', 'ｗ', 'w',
			'ｘ', 'x', 'ｙ', 'y', 'ｚ', 'z', '｛', '{', '｜', '|',
			'｝', '}', '～', '~'
		};

		public override int Remaining
		{
			get
			{
				if (_iCount <= 0)
				{
					return 0;
				}
				return _iCount;
			}
		}

		public override bool Fallback(char charUnknown, int index)
		{
			_iCount = (_iSize = 1);
			_cBestFit = TryBestFit(charUnknown);
			if (_cBestFit == '\0')
			{
				_cBestFit = '?';
			}
			return true;
		}

		public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
		{
			if (!char.IsHighSurrogate(charUnknownHigh))
			{
				throw new ArgumentOutOfRangeException("charUnknownHigh", SR.Format(SR.ArgumentOutOfRange_Range, 55296, 56319));
			}
			if (!char.IsLowSurrogate(charUnknownLow))
			{
				throw new ArgumentOutOfRangeException("charUnknownLow", SR.Format(SR.ArgumentOutOfRange_Range, 56320, 57343));
			}
			_cBestFit = '?';
			_iCount = (_iSize = 2);
			return true;
		}

		public override char GetNextChar()
		{
			_iCount--;
			if (_iCount < 0)
			{
				return '\0';
			}
			if (_iCount == int.MaxValue)
			{
				_iCount = -1;
				return '\0';
			}
			return _cBestFit;
		}

		public override bool MovePrevious()
		{
			if (_iCount >= 0)
			{
				_iCount++;
			}
			if (_iCount >= 0)
			{
				return _iCount <= _iSize;
			}
			return false;
		}

		public unsafe override void Reset()
		{
			_iCount = -1;
			charStart = null;
			bFallingBack = false;
		}

		private static char TryBestFit(char cUnknown)
		{
			int num = 0;
			int num2 = s_arrayCharBestFit.Length;
			int num3;
			while ((num3 = num2 - num) > 6)
			{
				int num4 = (num3 / 2 + num) & 0xFFFE;
				char c = s_arrayCharBestFit[num4];
				if (c == cUnknown)
				{
					return s_arrayCharBestFit[num4 + 1];
				}
				if (c < cUnknown)
				{
					num = num4;
				}
				else
				{
					num2 = num4;
				}
			}
			for (int num4 = num; num4 < num2; num4 += 2)
			{
				if (s_arrayCharBestFit[num4] == cUnknown)
				{
					return s_arrayCharBestFit[num4 + 1];
				}
			}
			return '\0';
		}
	}
	internal class EncoderNLS : Encoder
	{
		internal char _charLeftOver;

		private readonly Encoding _encoding;

		private bool _mustFlush;

		internal bool _throwOnOverflow;

		internal int _charsUsed;

		public Encoding Encoding => _encoding;

		public bool MustFlush => _mustFlush;

		internal bool HasLeftoverData
		{
			get
			{
				if (_charLeftOver == '\0')
				{
					if (_fallbackBuffer != null)
					{
						return _fallbackBuffer.Remaining > 0;
					}
					return false;
				}
				return true;
			}
		}

		internal virtual bool HasState => _charLeftOver != '\0';

		internal EncoderNLS(Encoding encoding)
		{
			_encoding = encoding;
			_fallback = _encoding.EncoderFallback;
			Reset();
		}

		public override void Reset()
		{
			_charLeftOver = '\0';
			if (_fallbackBuffer != null)
			{
				_fallbackBuffer.Reset();
			}
		}

		public unsafe override int GetByteCount(char[] chars, int index, int count, bool flush)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			int num = -1;
			fixed (char* ptr = &MemoryMarshal.GetReference<char>(chars))
			{
				num = GetByteCount(ptr + index, count, flush);
			}
			return num;
		}

		public unsafe override int GetByteCount(char* chars, int count, bool flush)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_mustFlush = flush;
			_throwOnOverflow = true;
			return _encoding.GetByteCount(chars, count, this);
		}

		public unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (byteIndex < 0 || byteIndex > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("byteIndex", SR.ArgumentOutOfRange_Index);
			}
			int byteCount = bytes.Length - byteIndex;
			fixed (char* ptr = &MemoryMarshal.GetReference<char>(chars))
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference<byte>(bytes))
				{
					return GetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, byteCount, flush);
				}
			}
		}

		public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (byteCount < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteCount < 0) ? "byteCount" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_mustFlush = flush;
			_throwOnOverflow = true;
			return _encoding.GetBytes(chars, charCount, bytes, byteCount, this);
		}

		public unsafe override void Convert(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, int byteCount, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (byteIndex < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			fixed (char* ptr = &MemoryMarshal.GetReference<char>(chars))
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference<byte>(bytes))
				{
					Convert(ptr + charIndex, charCount, ptr2 + byteIndex, byteCount, flush, out charsUsed, out bytesUsed, out completed);
				}
			}
		}

		public unsafe override void Convert(char* chars, int charCount, byte* bytes, int byteCount, bool flush, out int charsUsed, out int bytesUsed, out bool completed)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_mustFlush = flush;
			_throwOnOverflow = false;
			_charsUsed = 0;
			bytesUsed = _encoding.GetBytes(chars, charCount, bytes, byteCount, this);
			charsUsed = _charsUsed;
			completed = charsUsed == charCount && (!flush || !HasState) && (_fallbackBuffer == null || _fallbackBuffer.Remaining == 0);
		}

		internal void ClearMustFlush()
		{
			_mustFlush = false;
		}

		internal int DrainLeftoverDataForGetByteCount(ReadOnlySpan<char> chars, out int charsConsumed)
		{
			if (_fallbackBuffer != null && _fallbackBuffer.Remaining > 0)
			{
				throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty, Encoding.EncodingName, _fallbackBuffer.GetType()));
			}
			charsConsumed = 0;
			if (_charLeftOver == '\0')
			{
				return 0;
			}
			char c = '\0';
			if (chars.IsEmpty)
			{
				if (!MustFlush)
				{
					return 0;
				}
			}
			else
			{
				c = chars[0];
			}
			if (Rune.TryCreate(_charLeftOver, c, out var result))
			{
				charsConsumed = 1;
				if (_encoding.TryGetByteCount(result, out var byteCount))
				{
					return byteCount;
				}
				bool flag = base.FallbackBuffer.Fallback(_charLeftOver, c, -1);
			}
			else
			{
				bool flag = base.FallbackBuffer.Fallback(_charLeftOver, -1);
			}
			return _fallbackBuffer.DrainRemainingDataForGetByteCount();
		}

		internal bool TryDrainLeftoverDataForGetBytes(ReadOnlySpan<char> chars, Span<byte> bytes, out int charsConsumed, out int bytesWritten)
		{
			charsConsumed = 0;
			bytesWritten = 0;
			if (_charLeftOver != 0)
			{
				char c = '\0';
				if (chars.IsEmpty)
				{
					if (!MustFlush)
					{
						charsConsumed = 0;
						bytesWritten = 0;
						return true;
					}
				}
				else
				{
					c = chars[0];
				}
				char charLeftOver = _charLeftOver;
				_charLeftOver = '\0';
				if (Rune.TryCreate(charLeftOver, c, out var result))
				{
					charsConsumed = 1;
					switch (_encoding.EncodeRune(result, bytes, out bytesWritten))
					{
					case OperationStatus.Done:
						return true;
					case OperationStatus.DestinationTooSmall:
						_encoding.ThrowBytesOverflow(this, nothingEncoded: true);
						break;
					case OperationStatus.InvalidData:
						base.FallbackBuffer.Fallback(charLeftOver, c, -1);
						break;
					}
				}
				else
				{
					base.FallbackBuffer.Fallback(charLeftOver, -1);
				}
			}
			if (_fallbackBuffer != null && _fallbackBuffer.Remaining > 0)
			{
				return _fallbackBuffer.TryDrainRemainingDataForGetBytes(bytes, out bytesWritten);
			}
			return true;
		}
	}
	public sealed class EncoderReplacementFallback : EncoderFallback
	{
		internal static readonly EncoderReplacementFallback s_default = new EncoderReplacementFallback();

		private readonly string _strDefault;

		public string DefaultString => _strDefault;

		public override int MaxCharCount => _strDefault.Length;

		public EncoderReplacementFallback()
			: this("?")
		{
		}

		public EncoderReplacementFallback(string replacement)
		{
			if (replacement == null)
			{
				throw new ArgumentNullException("replacement");
			}
			bool flag = false;
			foreach (char c in replacement)
			{
				if (char.IsSurrogate(c))
				{
					if (char.IsHighSurrogate(c))
					{
						if (flag)
						{
							break;
						}
						flag = true;
						continue;
					}
					if (!flag)
					{
						flag = true;
						break;
					}
					flag = false;
				}
				else if (flag)
				{
					break;
				}
			}
			if (flag)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidCharSequenceNoIndex, "replacement"));
			}
			_strDefault = replacement;
		}

		public override EncoderFallbackBuffer CreateFallbackBuffer()
		{
			return new EncoderReplacementFallbackBuffer(this);
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is EncoderReplacementFallback encoderReplacementFallback)
			{
				return _strDefault == encoderReplacementFallback._strDefault;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _strDefault.GetHashCode();
		}
	}
	public sealed class EncoderReplacementFallbackBuffer : EncoderFallbackBuffer
	{
		private readonly string _strDefault;

		private int _fallbackCount = -1;

		private int _fallbackIndex = -1;

		public override int Remaining
		{
			get
			{
				if (_fallbackCount >= 0)
				{
					return _fallbackCount;
				}
				return 0;
			}
		}

		public EncoderReplacementFallbackBuffer(EncoderReplacementFallback fallback)
		{
			_strDefault = fallback.DefaultString + fallback.DefaultString;
		}

		public override bool Fallback(char charUnknown, int index)
		{
			if (_fallbackCount >= 1)
			{
				if (char.IsHighSurrogate(charUnknown) && _fallbackCount >= 0 && char.IsLowSurrogate(_strDefault[_fallbackIndex + 1]))
				{
					EncoderFallbackBuffer.ThrowLastCharRecursive(char.ConvertToUtf32(charUnknown, _strDefault[_fallbackIndex + 1]));
				}
				EncoderFallbackBuffer.ThrowLastCharRecursive(charUnknown);
			}
			_fallbackCount = _strDefault.Length / 2;
			_fallbackIndex = -1;
			return _fallbackCount != 0;
		}

		public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
		{
			if (!char.IsHighSurrogate(charUnknownHigh))
			{
				throw new ArgumentOutOfRangeException("charUnknownHigh", SR.Format(SR.ArgumentOutOfRange_Range, 55296, 56319));
			}
			if (!char.IsLowSurrogate(charUnknownLow))
			{
				throw new ArgumentOutOfRangeException("charUnknownLow", SR.Format(SR.ArgumentOutOfRange_Range, 56320, 57343));
			}
			if (_fallbackCount >= 1)
			{
				EncoderFallbackBuffer.ThrowLastCharRecursive(char.ConvertToUtf32(charUnknownHigh, charUnknownLow));
			}
			_fallbackCount = _strDefault.Length;
			_fallbackIndex = -1;
			return _fallbackCount != 0;
		}

		public override char GetNextChar()
		{
			_fallbackCount--;
			_fallbackIndex++;
			if (_fallbackCount < 0)
			{
				return '\0';
			}
			if (_fallbackCount == int.MaxValue)
			{
				_fallbackCount = -1;
				return '\0';
			}
			return _strDefault[_fallbackIndex];
		}

		public override bool MovePrevious()
		{
			if (_fallbackCount >= -1 && _fallbackIndex >= 0)
			{
				_fallbackIndex--;
				_fallbackCount++;
				return true;
			}
			return false;
		}

		public unsafe override void Reset()
		{
			_fallbackCount = -1;
			_fallbackIndex = 0;
			charStart = null;
			bFallingBack = false;
		}
	}
	public abstract class Encoding : ICloneable
	{
		internal sealed class DefaultEncoder : Encoder, IObjectReference
		{
			private readonly Encoding _encoding;

			public DefaultEncoder(Encoding encoding)
			{
				_encoding = encoding;
			}

			public object GetRealObject(StreamingContext context)
			{
				throw new PlatformNotSupportedException();
			}

			public override int GetByteCount(char[] chars, int index, int count, bool flush)
			{
				return _encoding.GetByteCount(chars, index, count);
			}

			public unsafe override int GetByteCount(char* chars, int count, bool flush)
			{
				return _encoding.GetByteCount(chars, count);
			}

			public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush)
			{
				return _encoding.GetBytes(chars, charIndex, charCount, bytes, byteIndex);
			}

			public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
			{
				return _encoding.GetBytes(chars, charCount, bytes, byteCount);
			}
		}

		internal sealed class DefaultDecoder : Decoder, IObjectReference
		{
			private readonly Encoding _encoding;

			public DefaultDecoder(Encoding encoding)
			{
				_encoding = encoding;
			}

			public object GetRealObject(StreamingContext context)
			{
				throw new PlatformNotSupportedException();
			}

			public override int GetCharCount(byte[] bytes, int index, int count)
			{
				return GetCharCount(bytes, index, count, flush: false);
			}

			public override int GetCharCount(byte[] bytes, int index, int count, bool flush)
			{
				return _encoding.GetCharCount(bytes, index, count);
			}

			public unsafe override int GetCharCount(byte* bytes, int count, bool flush)
			{
				return _encoding.GetCharCount(bytes, count);
			}

			public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
			{
				return GetChars(bytes, byteIndex, byteCount, chars, charIndex, flush: false);
			}

			public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, bool flush)
			{
				return _encoding.GetChars(bytes, byteIndex, byteCount, chars, charIndex);
			}

			public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, bool flush)
			{
				return _encoding.GetChars(bytes, byteCount, chars, charCount);
			}
		}

		internal sealed class EncodingCharBuffer
		{
			private unsafe char* _chars;

			private unsafe readonly char* _charStart;

			private unsafe readonly char* _charEnd;

			private int _charCountResult;

			private readonly Encoding _enc;

			private readonly DecoderNLS _decoder;

			private unsafe readonly byte* _byteStart;

			private unsafe readonly byte* _byteEnd;

			private unsafe byte* _bytes;

			private readonly DecoderFallbackBuffer _fallbackBuffer;

			internal unsafe bool MoreData => _bytes < _byteEnd;

			internal unsafe int BytesUsed => (int)(_bytes - _byteStart);

			internal int Count => _charCountResult;

			internal unsafe EncodingCharBuffer(Encoding enc, DecoderNLS decoder, char* charStart, int charCount, byte* byteStart, int byteCount)
			{
				_enc = enc;
				_decoder = decoder;
				_chars = charStart;
				_charStart = charStart;
				_charEnd = charStart + charCount;
				_byteStart = byteStart;
				_bytes = byteStart;
				_byteEnd = byteStart + byteCount;
				if (_decoder == null)
				{
					_fallbackBuffer = enc.DecoderFallback.CreateFallbackBuffer();
				}
				else
				{
					_fallbackBuffer = _decoder.FallbackBuffer;
				}
				_fallbackBuffer.InternalInitialize(_bytes, _charEnd);
			}

			internal unsafe bool AddChar(char ch, int numBytes)
			{
				if (_chars != null)
				{
					if (_chars >= _charEnd)
					{
						_bytes -= numBytes;
						_enc.ThrowCharsOverflow(_decoder, _bytes <= _byteStart);
						return false;
					}
					*(_chars++) = ch;
				}
				_charCountResult++;
				return true;
			}

			internal bool AddChar(char ch)
			{
				return AddChar(ch, 1);
			}

			internal unsafe void AdjustBytes(int count)
			{
				_bytes += count;
			}

			internal unsafe byte GetNextByte()
			{
				if (_bytes >= _byteEnd)
				{
					return 0;
				}
				return *(_bytes++);
			}

			internal bool Fallback(byte fallbackByte)
			{
				byte[] byteBuffer = new byte[1] { fallbackByte };
				return Fallback(byteBuffer);
			}

			internal unsafe bool Fallback(byte[] byteBuffer)
			{
				if (_chars != null)
				{
					char* chars = _chars;
					if (!_fallbackBuffer.InternalFallback(byteBuffer, _bytes, ref _chars))
					{
						_bytes -= byteBuffer.Length;
						_fallbackBuffer.InternalReset();
						_enc.ThrowCharsOverflow(_decoder, _chars == _charStart);
						return false;
					}
					_charCountResult += (int)(_chars - chars);
				}
				else
				{
					_charCountResult += _fallbackBuffer.InternalFallback(byteBuffer, _bytes);
				}
				return true;
			}
		}

		internal sealed class EncodingByteBuffer
		{
			private unsafe byte* _bytes;

			private unsafe readonly byte* _byteStart;

			private unsafe readonly byte* _byteEnd;

			private unsafe char* _chars;

			private unsafe readonly char* _charStart;

			private unsafe readonly char* _charEnd;

			private int _byteCountResult;

			private readonly Encoding _enc;

			private readonly EncoderNLS _encoder;

			internal EncoderFallbackBuffer fallbackBuffer;

			internal unsafe bool MoreData
			{
				get
				{
					if (fallbackBuffer.Remaining <= 0)
					{
						return _chars < _charEnd;
					}
					return true;
				}
			}

			internal unsafe int CharsUsed => (int)(_chars - _charStart);

			internal int Count => _byteCountResult;

			internal unsafe EncodingByteBuffer(Encoding inEncoding, EncoderNLS inEncoder, byte* inByteStart, int inByteCount, char* inCharStart, int inCharCount)
			{
				_enc = inEncoding;
				_encoder = inEncoder;
				_charStart = inCharStart;
				_chars = inCharStart;
				_charEnd = inCharStart + inCharCount;
				_bytes = inByteStart;
				_byteStart = inByteStart;
				_byteEnd = inByteStart + inByteCount;
				if (_encoder == null)
				{
					fallbackBuffer = _enc.EncoderFallback.CreateFallbackBuffer();
				}
				else
				{
					fallbackBuffer = _encoder.FallbackBuffer;
					if (_encoder._throwOnOverflow && _encoder.InternalHasFallbackBuffer && fallbackBuffer.Remaining > 0)
					{
						throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty, _encoder.Encoding.EncodingName, _encoder.Fallback.GetType()));
					}
				}
				fallbackBuffer.InternalInitialize(_chars, _charEnd, _encoder, _bytes != null);
			}

			internal unsafe bool AddByte(byte b, int moreBytesExpected)
			{
				if (_bytes != null)
				{
					if (_bytes >= _byteEnd - moreBytesExpected)
					{
						MovePrevious(bThrow: true);
						return false;
					}
					*(_bytes++) = b;
				}
				_byteCountResult++;
				return true;
			}

			internal bool AddByte(byte b1)
			{
				return AddByte(b1, 0);
			}

			internal bool AddByte(byte b1, byte b2)
			{
				return AddByte(b1, b2, 0);
			}

			internal bool AddByte(byte b1, byte b2, int moreBytesExpected)
			{
				if (AddByte(b1, 1 + moreBytesExpected))
				{
					return AddByte(b2, moreBytesExpected);
				}
				return false;
			}

			internal unsafe void MovePrevious(bool bThrow)
			{
				if (fallbackBuffer.bFallingBack)
				{
					fallbackBuffer.MovePrevious();
				}
				else if (_chars > _charStart)
				{
					_chars--;
				}
				if (bThrow)
				{
					_enc.ThrowBytesOverflow(_encoder, _bytes == _byteStart);
				}
			}

			internal unsafe char GetNextChar()
			{
				char c = fallbackBuffer.InternalGetNextChar();
				if (c == '\0' && _chars < _charEnd)
				{
					c = *(_chars++);
				}
				return c;
			}
		}

		private static readonly UTF8Encoding.UTF8EncodingSealed s_defaultEncoding = new UTF8Encoding.UTF8EncodingSealed(encoderShouldEmitUTF8Identifier: false);

		internal int _codePage;

		internal CodePageDataItem _dataItem;

		[OptionalField(VersionAdded = 2)]
		private bool _isReadOnly = true;

		internal EncoderFallback encoderFallback;

		internal DecoderFallback decoderFallback;

		public static Encoding Default => s_defaultEncoding;

		public virtual ReadOnlySpan<byte> Preamble => GetPreamble();

		public virtual string BodyName
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return _dataItem.BodyName;
			}
		}

		public virtual string EncodingName
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return _dataItem.DisplayName;
			}
		}

		public virtual string HeaderName
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return _dataItem.HeaderName;
			}
		}

		public virtual string WebName
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return _dataItem.WebName;
			}
		}

		public virtual int WindowsCodePage
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return _dataItem.UIFamilyCodePage;
			}
		}

		public virtual bool IsBrowserDisplay
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return (_dataItem.Flags & 2) != 0;
			}
		}

		public virtual bool IsBrowserSave
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return (_dataItem.Flags & 0x200) != 0;
			}
		}

		public virtual bool IsMailNewsDisplay
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return (_dataItem.Flags & 1) != 0;
			}
		}

		public virtual bool IsMailNewsSave
		{
			get
			{
				if (_dataItem == null)
				{
					GetDataItem();
				}
				return (_dataItem.Flags & 0x100) != 0;
			}
		}

		public virtual bool IsSingleByte => false;

		public EncoderFallback EncoderFallback
		{
			get
			{
				return encoderFallback;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				encoderFallback = value;
			}
		}

		public DecoderFallback DecoderFallback
		{
			get
			{
				return decoderFallback;
			}
			set
			{
				if (IsReadOnly)
				{
					throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
				}
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				decoderFallback = value;
			}
		}

		public bool IsReadOnly
		{
			get
			{
				return _isReadOnly;
			}
			private protected set
			{
				_isReadOnly = value;
			}
		}

		public static Encoding ASCII => ASCIIEncoding.s_default;

		public static Encoding Latin1 => Latin1Encoding.s_default;

		public virtual int CodePage => _codePage;

		internal bool IsUTF8CodePage => CodePage == 65001;

		public static Encoding Unicode => UnicodeEncoding.s_littleEndianDefault;

		public static Encoding BigEndianUnicode => UnicodeEncoding.s_bigEndianDefault;

		[Obsolete("The UTF-7 encoding is insecure and should not be used. Consider using UTF-8 instead.", DiagnosticId = "SYSLIB0001", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static Encoding UTF7 => UTF7Encoding.s_default;

		public static Encoding UTF8 => UTF8Encoding.s_default;

		public static Encoding UTF32 => UTF32Encoding.s_default;

		private static Encoding BigEndianUTF32 => UTF32Encoding.s_bigEndianDefault;

		protected Encoding()
			: this(0)
		{
		}

		protected Encoding(int codePage)
		{
			if (codePage < 0)
			{
				throw new ArgumentOutOfRangeException("codePage");
			}
			_codePage = codePage;
			SetDefaultFallbacks();
		}

		protected Encoding(int codePage, EncoderFallback? encoderFallback, DecoderFallback? decoderFallback)
		{
			if (codePage < 0)
			{
				throw new ArgumentOutOfRangeException("codePage");
			}
			_codePage = codePage;
			this.encoderFallback = encoderFallback ?? System.Text.EncoderFallback.ReplacementFallback;
			this.decoderFallback = decoderFallback ?? System.Text.DecoderFallback.ReplacementFallback;
		}

		[MemberNotNull("encoderFallback")]
		[MemberNotNull("decoderFallback")]
		internal virtual void SetDefaultFallbacks()
		{
			encoderFallback = System.Text.EncoderFallback.ReplacementFallback;
			decoderFallback = System.Text.DecoderFallback.ReplacementFallback;
		}

		public static byte[] Convert(Encoding srcEncoding, Encoding dstEncoding, byte[] bytes)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes");
			}
			return Convert(srcEncoding, dstEncoding, bytes, 0, bytes.Length);
		}

		public static byte[] Convert(Encoding srcEncoding, Encoding dstEncoding, byte[] bytes, int index, int count)
		{
			if (srcEncoding == null || dstEncoding == null)
			{
				throw new ArgumentNullException((srcEncoding == null) ? "srcEncoding" : "dstEncoding", SR.ArgumentNull_Array);
			}
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			return dstEncoding.GetBytes(srcEncoding.GetChars(bytes, index, count));
		}

		public static void RegisterProvider(EncodingProvider provider)
		{
			EncodingProvider.AddProvider(provider);
		}

		public static Encoding GetEncoding(int codepage)
		{
			Encoding encoding = FilterDisallowedEncodings(EncodingProvider.GetEncodingFromProvider(codepage));
			if (encoding != null)
			{
				return encoding;
			}
			switch (codepage)
			{
			case 0:
				return Default;
			case 1200:
				return Unicode;
			case 1201:
				return BigEndianUnicode;
			case 12000:
				return UTF32;
			case 12001:
				return BigEndianUTF32;
			case 65001:
				return UTF8;
			case 20127:
				return ASCII;
			case 28591:
				return Latin1;
			case 1:
			case 2:
			case 3:
			case 42:
				throw new ArgumentException(SR.Format(SR.Argument_CodepageNotSupported, codepage), "codepage");
			case 65000:
			{
				if (LocalAppContextSwitches.EnableUnsafeUTF7Encoding)
				{
					return UTF7;
				}
				string p = string.Format(CultureInfo.InvariantCulture, "https://aka.ms/dotnet-warnings/{0}", "SYSLIB0001");
				string message = SR.Format(SR.Encoding_UTF7_Disabled, p);
				throw new NotSupportedException(message);
			}
			default:
				if (codepage < 0 || codepage > 65535)
				{
					throw new ArgumentOutOfRangeException("codepage", SR.Format(SR.ArgumentOutOfRange_Range, 0, 65535));
				}
				throw new NotSupportedException(SR.Format(SR.NotSupported_NoCodepageData, codepage));
			}
		}

		public static Encoding GetEncoding(int codepage, EncoderFallback encoderFallback, DecoderFallback decoderFallback)
		{
			Encoding encoding = FilterDisallowedEncodings(EncodingProvider.GetEncodingFromProvider(codepage, encoderFallback, decoderFallback));
			if (encoding != null)
			{
				return encoding;
			}
			encoding = GetEncoding(codepage);
			Encoding encoding2 = (Encoding)encoding.Clone();
			encoding2.EncoderFallback = encoderFallback;
			encoding2.DecoderFallback = decoderFallback;
			return encoding2;
		}

		public static Encoding GetEncoding(string name)
		{
			return FilterDisallowedEncodings(EncodingProvider.GetEncodingFromProvider(name)) ?? GetEncoding(EncodingTable.GetCodePageFromName(name));
		}

		public static Encoding GetEncoding(string name, EncoderFallback encoderFallback, DecoderFallback decoderFallback)
		{
			return FilterDisallowedEncodings(EncodingProvider.GetEncodingFromProvider(name, encoderFallback, decoderFallback)) ?? GetEncoding(EncodingTable.GetCodePageFromName(name), encoderFallback, decoderFallback);
		}

		private static Encoding FilterDisallowedEncodings(Encoding encoding)
		{
			if (LocalAppContextSwitches.EnableUnsafeUTF7Encoding)
			{
				return encoding;
			}
			if (encoding == null || encoding.CodePage != 65000)
			{
				return encoding;
			}
			return null;
		}

		public static EncodingInfo[] GetEncodings()
		{
			Dictionary<int, EncodingInfo> encodingListFromProviders = EncodingProvider.GetEncodingListFromProviders();
			if (encodingListFromProviders != null)
			{
				return EncodingTable.GetEncodings(encodingListFromProviders);
			}
			return EncodingTable.GetEncodings();
		}

		public virtual byte[] GetPreamble()
		{
			return Array.Empty<byte>();
		}

		private void GetDataItem()
		{
			if (_dataItem == null)
			{
				_dataItem = EncodingTable.GetCodePageDataItem(_codePage);
				if (_dataItem == null)
				{
					throw new NotSupportedException(SR.Format(SR.NotSupported_NoCodepageData, _codePage));
				}
			}
		}

		public virtual object Clone()
		{
			Encoding encoding = (Encoding)MemberwiseClone();
			encoding._isReadOnly = false;
			return encoding;
		}

		public virtual int GetByteCount(char[] chars)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			return GetByteCount(chars, 0, chars.Length);
		}

		public virtual int GetByteCount(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			char[] array = s.ToCharArray();
			return GetByteCount(array, 0, array.Length);
		}

		public abstract int GetByteCount(char[] chars, int index, int count);

		public unsafe int GetByteCount(string s, int index, int count)
		{
			if (s == null)
			{
				throw new ArgumentNullException("s", SR.ArgumentNull_String);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (index > s.Length - count)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_IndexCount);
			}
			fixed (char* ptr = s)
			{
				return GetByteCount(ptr + index, count);
			}
		}

		[CLSCompliant(false)]
		public unsafe virtual int GetByteCount(char* chars, int count)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			char[] chars2 = new ReadOnlySpan<char>(chars, count).ToArray();
			return GetByteCount(chars2, 0, count);
		}

		public unsafe virtual int GetByteCount(ReadOnlySpan<char> chars)
		{
			fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
			{
				return GetByteCount(chars2, chars.Length);
			}
		}

		public virtual byte[] GetBytes(char[] chars)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			return GetBytes(chars, 0, chars.Length);
		}

		public virtual byte[] GetBytes(char[] chars, int index, int count)
		{
			byte[] array = new byte[GetByteCount(chars, index, count)];
			GetBytes(chars, index, count, array, 0);
			return array;
		}

		public abstract int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex);

		public virtual byte[] GetBytes(string s)
		{
			if (s == null)
			{
				throw new ArgumentNullException("s", SR.ArgumentNull_String);
			}
			int byteCount = GetByteCount(s);
			byte[] array = new byte[byteCount];
			int bytes = GetBytes(s, 0, s.Length, array, 0);
			return array;
		}

		public unsafe byte[] GetBytes(string s, int index, int count)
		{
			if (s == null)
			{
				throw new ArgumentNullException("s", SR.ArgumentNull_String);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (index > s.Length - count)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_IndexCount);
			}
			fixed (char* ptr = s)
			{
				int byteCount = GetByteCount(ptr + index, count);
				if (byteCount == 0)
				{
					return Array.Empty<byte>();
				}
				byte[] array = new byte[byteCount];
				fixed (byte* bytes = &array[0])
				{
					int bytes2 = GetBytes(ptr + index, count, bytes, byteCount);
				}
				return array;
			}
		}

		public virtual int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return GetBytes(s.ToCharArray(), charIndex, charCount, bytes, byteIndex);
		}

		[CLSCompliant(false)]
		public unsafe virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			char[] chars2 = new ReadOnlySpan<char>(chars, charCount).ToArray();
			byte[] array = new byte[byteCount];
			int bytes2 = GetBytes(chars2, 0, charCount, array, 0);
			if (bytes2 < byteCount)
			{
				byteCount = bytes2;
			}
			new ReadOnlySpan<byte>(array, 0, byteCount).CopyTo(new Span<byte>(bytes, byteCount));
			return byteCount;
		}

		public unsafe virtual int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes)
		{
			fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
			{
				fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
				{
					return GetBytes(chars2, chars.Length, bytes2, bytes.Length);
				}
			}
		}

		public virtual int GetCharCount(byte[] bytes)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			return GetCharCount(bytes, 0, bytes.Length);
		}

		public abstract int GetCharCount(byte[] bytes, int index, int count);

		[CLSCompliant(false)]
		public unsafe virtual int GetCharCount(byte* bytes, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			byte[] bytes2 = new ReadOnlySpan<byte>(bytes, count).ToArray();
			return GetCharCount(bytes2, 0, count);
		}

		public unsafe virtual int GetCharCount(ReadOnlySpan<byte> bytes)
		{
			fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
			{
				return GetCharCount(bytes2, bytes.Length);
			}
		}

		public virtual char[] GetChars(byte[] bytes)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			return GetChars(bytes, 0, bytes.Length);
		}

		public virtual char[] GetChars(byte[] bytes, int index, int count)
		{
			char[] array = new char[GetCharCount(bytes, index, count)];
			GetChars(bytes, index, count, array, 0);
			return array;
		}

		public abstract int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex);

		[CLSCompliant(false)]
		public unsafe virtual int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (byteCount < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteCount < 0) ? "byteCount" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			byte[] bytes2 = new ReadOnlySpan<byte>(bytes, byteCount).ToArray();
			char[] array = new char[charCount];
			int chars2 = GetChars(bytes2, 0, byteCount, array, 0);
			if (chars2 < charCount)
			{
				charCount = chars2;
			}
			new ReadOnlySpan<char>(array, 0, charCount).CopyTo(new Span<char>(chars, charCount));
			return charCount;
		}

		public unsafe virtual int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars)
		{
			fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
			{
				fixed (char* chars2 = &MemoryMarshal.GetNonNullPinnableReference(chars))
				{
					return GetChars(bytes2, bytes.Length, chars2, chars.Length);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe string GetString(byte* bytes, int byteCount)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (byteCount < 0)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return string.CreateStringFromEncoding(bytes, byteCount, this);
		}

		public unsafe string GetString(ReadOnlySpan<byte> bytes)
		{
			fixed (byte* bytes2 = &MemoryMarshal.GetNonNullPinnableReference(bytes))
			{
				return string.CreateStringFromEncoding(bytes2, bytes.Length, this);
			}
		}

		public bool IsAlwaysNormalized()
		{
			return IsAlwaysNormalized(NormalizationForm.FormC);
		}

		public virtual bool IsAlwaysNormalized(NormalizationForm form)
		{
			return false;
		}

		public virtual Decoder GetDecoder()
		{
			return new DefaultDecoder(this);
		}

		public virtual Encoder GetEncoder()
		{
			return new DefaultEncoder(this);
		}

		public abstract int GetMaxByteCount(int charCount);

		public abstract int GetMaxCharCount(int byteCount);

		public virtual string GetString(byte[] bytes)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			return GetString(bytes, 0, bytes.Length);
		}

		public virtual string GetString(byte[] bytes, int index, int count)
		{
			return new string(GetChars(bytes, index, count));
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is Encoding encoding && _codePage == encoding._codePage && EncoderFallback.Equals(encoding.EncoderFallback))
			{
				return DecoderFallback.Equals(encoding.DecoderFallback);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _codePage + EncoderFallback.GetHashCode() + DecoderFallback.GetHashCode();
		}

		public static Stream CreateTranscodingStream(Stream innerStream, Encoding innerStreamEncoding, Encoding outerStreamEncoding, bool leaveOpen = false)
		{
			if (innerStream == null)
			{
				throw new ArgumentNullException("innerStream");
			}
			if (innerStreamEncoding == null)
			{
				throw new ArgumentNullException("innerStreamEncoding");
			}
			if (outerStreamEncoding == null)
			{
				throw new ArgumentNullException("outerStreamEncoding");
			}
			return new TranscodingStream(innerStream, innerStreamEncoding, outerStreamEncoding, leaveOpen);
		}

		[DoesNotReturn]
		internal void ThrowBytesOverflow()
		{
			throw new ArgumentException(SR.Format(SR.Argument_EncodingConversionOverflowBytes, EncodingName, EncoderFallback.GetType()), "bytes");
		}

		internal void ThrowBytesOverflow(EncoderNLS encoder, bool nothingEncoded)
		{
			if ((encoder?._throwOnOverflow ?? true) || nothingEncoded)
			{
				if (encoder != null && encoder.InternalHasFallbackBuffer)
				{
					encoder.FallbackBuffer.InternalReset();
				}
				ThrowBytesOverflow();
			}
			encoder.ClearMustFlush();
		}

		[DoesNotReturn]
		[StackTraceHidden]
		internal static void ThrowConversionOverflow()
		{
			throw new ArgumentException(SR.Argument_ConversionOverflow);
		}

		[DoesNotReturn]
		[StackTraceHidden]
		internal void ThrowCharsOverflow()
		{
			throw new ArgumentException(SR.Format(SR.Argument_EncodingConversionOverflowChars, EncodingName, DecoderFallback.GetType()), "chars");
		}

		internal void ThrowCharsOverflow(DecoderNLS decoder, bool nothingDecoded)
		{
			if ((decoder?._throwOnOverflow ?? true) || nothingDecoded)
			{
				if (decoder != null && decoder.InternalHasFallbackBuffer)
				{
					decoder.FallbackBuffer.InternalReset();
				}
				ThrowCharsOverflow();
			}
			decoder.ClearMustFlush();
		}

		internal virtual OperationStatus DecodeFirstRune(ReadOnlySpan<byte> bytes, out Rune value, out int bytesConsumed)
		{
			throw NotImplemented.ByDesign;
		}

		internal virtual OperationStatus EncodeRune(Rune value, Span<byte> bytes, out int bytesWritten)
		{
			throw NotImplemented.ByDesign;
		}

		internal virtual bool TryGetByteCount(Rune value, out int byteCount)
		{
			throw NotImplemented.ByDesign;
		}

		internal unsafe virtual int GetByteCount(char* pChars, int charCount, EncoderNLS encoder)
		{
			int num = 0;
			int charsConsumed = 0;
			if (!encoder.HasLeftoverData)
			{
				num = GetByteCountFast(pChars, charCount, encoder.Fallback, out charsConsumed);
				if (charsConsumed == charCount)
				{
					return num;
				}
			}
			num += GetByteCountWithFallback(pChars, charCount, charsConsumed, encoder);
			if (num < 0)
			{
				ThrowConversionOverflow();
			}
			return num;
		}

		private protected unsafe virtual int GetByteCountFast(char* pChars, int charsLength, EncoderFallback fallback, out int charsConsumed)
		{
			throw NotImplemented.ByDesign;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private protected unsafe int GetByteCountWithFallback(char* pCharsOriginal, int originalCharCount, int charsConsumedSoFar)
		{
			return GetByteCountWithFallback(new ReadOnlySpan<char>(pCharsOriginal, originalCharCount).Slice(charsConsumedSoFar), originalCharCount, null);
		}

		private unsafe int GetByteCountWithFallback(char* pOriginalChars, int originalCharCount, int charsConsumedSoFar, EncoderNLS encoder)
		{
			ReadOnlySpan<char> readOnlySpan = new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar);
			int num = encoder.DrainLeftoverDataForGetByteCount(readOnlySpan, out var charsConsumed);
			readOnlySpan = readOnlySpan.Slice(charsConsumed);
			num += GetByteCountFast((char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(readOnlySpan)), readOnlySpan.Length, encoder.Fallback, out charsConsumed);
			if (num < 0)
			{
				ThrowConversionOverflow();
			}
			readOnlySpan = readOnlySpan.Slice(charsConsumed);
			if (!readOnlySpan.IsEmpty)
			{
				num += GetByteCountWithFallback(readOnlySpan, originalCharCount, encoder);
				if (num < 0)
				{
					ThrowConversionOverflow();
				}
			}
			return num;
		}

		private protected unsafe virtual int GetByteCountWithFallback(ReadOnlySpan<char> chars, int originalCharsLength, EncoderNLS encoder)
		{
			fixed (char* ptr = &MemoryMarshal.GetReference(chars))
			{
				EncoderFallbackBuffer encoderFallbackBuffer = EncoderFallbackBuffer.CreateAndInitialize(this, encoder, originalCharsLength);
				int num = 0;
				Rune result;
				int charsConsumed;
				while (Rune.DecodeFromUtf16(chars, out result, out charsConsumed) != OperationStatus.NeedMoreData || encoder == null || encoder.MustFlush)
				{
					int num2 = encoderFallbackBuffer.InternalFallbackGetByteCount(chars, out charsConsumed);
					num += num2;
					if (num < 0)
					{
						ThrowConversionOverflow();
					}
					chars = chars.Slice(charsConsumed);
					if (!chars.IsEmpty)
					{
						num2 = GetByteCountFast((char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)), chars.Length, null, out charsConsumed);
						num += num2;
						if (num < 0)
						{
							ThrowConversionOverflow();
						}
						chars = chars.Slice(charsConsumed);
					}
					if (chars.IsEmpty)
					{
						break;
					}
				}
				return num;
			}
		}

		internal unsafe virtual int GetBytes(char* pChars, int charCount, byte* pBytes, int byteCount, EncoderNLS encoder)
		{
			int num = 0;
			int charsConsumed = 0;
			if (!encoder.HasLeftoverData)
			{
				num = GetBytesFast(pChars, charCount, pBytes, byteCount, out charsConsumed);
				if (charsConsumed == charCount)
				{
					encoder._charsUsed = charCount;
					return num;
				}
			}
			return GetBytesWithFallback(pChars, charCount, pBytes, byteCount, charsConsumed, num, encoder);
		}

		private protected unsafe virtual int GetBytesFast(char* pChars, int charsLength, byte* pBytes, int bytesLength, out int charsConsumed)
		{
			throw NotImplemented.ByDesign;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private protected unsafe int GetBytesWithFallback(char* pOriginalChars, int originalCharCount, byte* pOriginalBytes, int originalByteCount, int charsConsumedSoFar, int bytesWrittenSoFar)
		{
			return GetBytesWithFallback(new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar), originalCharCount, new Span<byte>(pOriginalBytes, originalByteCount).Slice(bytesWrittenSoFar), originalByteCount, null);
		}

		private unsafe int GetBytesWithFallback(char* pOriginalChars, int originalCharCount, byte* pOriginalBytes, int originalByteCount, int charsConsumedSoFar, int bytesWrittenSoFar, EncoderNLS encoder)
		{
			ReadOnlySpan<char> readOnlySpan = new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar);
			Span<byte> span = new Span<byte>(pOriginalBytes, originalByteCount).Slice(bytesWrittenSoFar);
			int charsConsumed;
			int bytesWritten;
			bool flag = encoder.TryDrainLeftoverDataForGetBytes(readOnlySpan, span, out charsConsumed, out bytesWritten);
			readOnlySpan = readOnlySpan.Slice(charsConsumed);
			span = span.Slice(bytesWritten);
			if (!flag)
			{
				ThrowBytesOverflow(encoder, span.Length == originalByteCount);
			}
			else
			{
				bytesWritten = GetBytesFast((char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(readOnlySpan)), readOnlySpan.Length, (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(span)), span.Length, out charsConsumed);
				readOnlySpan = readOnlySpan.Slice(charsConsumed);
				span = span.Slice(bytesWritten);
				if (!readOnlySpan.IsEmpty)
				{
					encoder._charsUsed = originalCharCount;
					return GetBytesWithFallback(readOnlySpan, originalCharCount, span, originalByteCount, encoder);
				}
			}
			encoder._charsUsed = originalCharCount - readOnlySpan.Length;
			return originalByteCount - span.Length;
		}

		private protected unsafe virtual int GetBytesWithFallback(ReadOnlySpan<char> chars, int originalCharsLength, Span<byte> bytes, int originalBytesLength, EncoderNLS encoder)
		{
			fixed (char* ptr2 = &MemoryMarshal.GetReference(chars))
			{
				fixed (byte* ptr = &MemoryMarshal.GetReference(bytes))
				{
					EncoderFallbackBuffer encoderFallbackBuffer = EncoderFallbackBuffer.CreateAndInitialize(this, encoder, originalCharsLength);
					do
					{
						Rune result;
						int charsConsumed;
						OperationStatus operationStatus = Rune.DecodeFromUtf16(chars, out result, out charsConsumed);
						if (operationStatus != OperationStatus.NeedMoreData)
						{
							if (operationStatus != OperationStatus.InvalidData && EncodeRune(result, bytes, out var _) == OperationStatus.DestinationTooSmall)
							{
								break;
							}
						}
						else if (encoder != null && !encoder.MustFlush)
						{
							encoder._charLeftOver = chars[0];
							chars = ReadOnlySpan<char>.Empty;
							break;
						}
						int bytesWritten2;
						bool flag = encoderFallbackBuffer.TryInternalFallbackGetBytes(chars, bytes, out charsConsumed, out bytesWritten2);
						chars = chars.Slice(charsConsumed);
						bytes = bytes.Slice(bytesWritten2);
						if (!flag)
						{
							break;
						}
						if (!chars.IsEmpty)
						{
							bytesWritten2 = GetBytesFast((char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)), chars.Length, (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)), bytes.Length, out charsConsumed);
							chars = chars.Slice(charsConsumed);
							bytes = bytes.Slice(bytesWritten2);
						}
					}
					while (!chars.IsEmpty);
					if (!chars.IsEmpty || encoderFallbackBuffer.Remaining > 0)
					{
						ThrowBytesOverflow(encoder, bytes.Length == originalBytesLength);
					}
					if (encoder != null)
					{
						encoder._charsUsed = originalCharsLength - chars.Length;
					}
					return originalBytesLength - bytes.Length;
				}
			}
		}

		internal unsafe virtual int GetCharCount(byte* pBytes, int byteCount, DecoderNLS decoder)
		{
			int num = 0;
			int bytesConsumed = 0;
			if (!decoder.HasLeftoverData)
			{
				num = GetCharCountFast(pBytes, byteCount, decoder.Fallback, out bytesConsumed);
				if (bytesConsumed == byteCount)
				{
					return num;
				}
			}
			num += GetCharCountWithFallback(pBytes, byteCount, bytesConsumed, decoder);
			if (num < 0)
			{
				ThrowConversionOverflow();
			}
			return num;
		}

		private protected unsafe virtual int GetCharCountFast(byte* pBytes, int bytesLength, DecoderFallback fallback, out int bytesConsumed)
		{
			throw NotImplemented.ByDesign;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private protected unsafe int GetCharCountWithFallback(byte* pBytesOriginal, int originalByteCount, int bytesConsumedSoFar)
		{
			return GetCharCountWithFallback(new ReadOnlySpan<byte>(pBytesOriginal, originalByteCount).Slice(bytesConsumedSoFar), originalByteCount, null);
		}

		private unsafe int GetCharCountWithFallback(byte* pOriginalBytes, int originalByteCount, int bytesConsumedSoFar, DecoderNLS decoder)
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar);
			int num = 0;
			int bytesConsumed;
			if (decoder.HasLeftoverData)
			{
				num = decoder.DrainLeftoverDataForGetCharCount(readOnlySpan, out bytesConsumed);
				readOnlySpan = readOnlySpan.Slice(bytesConsumed);
			}
			num += GetCharCountFast((byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(readOnlySpan)), readOnlySpan.Length, decoder.Fallback, out bytesConsumed);
			if (num < 0)
			{
				ThrowConversionOverflow();
			}
			readOnlySpan = readOnlySpan.Slice(bytesConsumed);
			if (!readOnlySpan.IsEmpty)
			{
				num += GetCharCountWithFallback(readOnlySpan, originalByteCount, decoder);
				if (num < 0)
				{
					ThrowConversionOverflow();
				}
			}
			return num;
		}

		private unsafe int GetCharCountWithFallback(ReadOnlySpan<byte> bytes, int originalBytesLength, DecoderNLS decoder)
		{
			fixed (byte* ptr = &MemoryMarshal.GetReference(bytes))
			{
				DecoderFallbackBuffer decoderFallbackBuffer = DecoderFallbackBuffer.CreateAndInitialize(this, decoder, originalBytesLength);
				int num = 0;
				Rune value;
				int bytesConsumed;
				while (DecodeFirstRune(bytes, out value, out bytesConsumed) != OperationStatus.NeedMoreData || decoder == null || decoder.MustFlush)
				{
					int num2 = decoderFallbackBuffer.InternalFallbackGetCharCount(bytes, bytesConsumed);
					num += num2;
					if (num < 0)
					{
						ThrowConversionOverflow();
					}
					bytes = bytes.Slice(bytesConsumed);
					if (!bytes.IsEmpty)
					{
						num2 = GetCharCountFast((byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)), bytes.Length, null, out bytesConsumed);
						num += num2;
						if (num < 0)
						{
							ThrowConversionOverflow();
						}
						bytes = bytes.Slice(bytesConsumed);
					}
					if (bytes.IsEmpty)
					{
						break;
					}
				}
				return num;
			}
		}

		internal unsafe virtual int GetChars(byte* pBytes, int byteCount, char* pChars, int charCount, DecoderNLS decoder)
		{
			int num = 0;
			int bytesConsumed = 0;
			if (!decoder.HasLeftoverData)
			{
				num = GetCharsFast(pBytes, byteCount, pChars, charCount, out bytesConsumed);
				if (bytesConsumed == byteCount)
				{
					decoder._bytesUsed = byteCount;
					return num;
				}
			}
			return GetCharsWithFallback(pBytes, byteCount, pChars, charCount, bytesConsumed, num, decoder);
		}

		private protected unsafe virtual int GetCharsFast(byte* pBytes, int bytesLength, char* pChars, int charsLength, out int bytesConsumed)
		{
			throw NotImplemented.ByDesign;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private protected unsafe int GetCharsWithFallback(byte* pOriginalBytes, int originalByteCount, char* pOriginalChars, int originalCharCount, int bytesConsumedSoFar, int charsWrittenSoFar)
		{
			return GetCharsWithFallback(new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar), originalByteCount, new Span<char>(pOriginalChars, originalCharCount).Slice(charsWrittenSoFar), originalCharCount, null);
		}

		private protected unsafe int GetCharsWithFallback(byte* pOriginalBytes, int originalByteCount, char* pOriginalChars, int originalCharCount, int bytesConsumedSoFar, int charsWrittenSoFar, DecoderNLS decoder)
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar);
			Span<char> span = new Span<char>(pOriginalChars, originalCharCount).Slice(charsWrittenSoFar);
			int bytesConsumed;
			int start;
			if (decoder.HasLeftoverData)
			{
				start = decoder.DrainLeftoverDataForGetChars(readOnlySpan, span, out bytesConsumed);
				readOnlySpan = readOnlySpan.Slice(bytesConsumed);
				span = span.Slice(start);
			}
			start = GetCharsFast((byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(readOnlySpan)), readOnlySpan.Length, (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(span)), span.Length, out bytesConsumed);
			readOnlySpan = readOnlySpan.Slice(bytesConsumed);
			span = span.Slice(start);
			decoder._bytesUsed = originalByteCount;
			if (readOnlySpan.IsEmpty)
			{
				return originalCharCount - span.Length;
			}
			return GetCharsWithFallback(readOnlySpan, originalByteCount, span, originalCharCount, decoder);
		}

		private protected unsafe virtual int GetCharsWithFallback(ReadOnlySpan<byte> bytes, int originalBytesLength, Span<char> chars, int originalCharsLength, DecoderNLS decoder)
		{
			fixed (byte* ptr2 = &MemoryMarshal.GetReference(bytes))
			{
				fixed (char* ptr = &MemoryMarshal.GetReference(chars))
				{
					DecoderFallbackBuffer decoderFallbackBuffer = DecoderFallbackBuffer.CreateAndInitialize(this, decoder, originalBytesLength);
					do
					{
						Rune value;
						int bytesConsumed;
						OperationStatus operationStatus = DecodeFirstRune(bytes, out value, out bytesConsumed);
						if (operationStatus != OperationStatus.NeedMoreData)
						{
							if (operationStatus != OperationStatus.InvalidData)
							{
								break;
							}
						}
						else if (decoder != null && !decoder.MustFlush)
						{
							decoder.SetLeftoverData(bytes);
							bytes = ReadOnlySpan<byte>.Empty;
							break;
						}
						if (!decoderFallbackBuffer.TryInternalFallbackGetChars(bytes, bytesConsumed, chars, out var charsWritten))
						{
							break;
						}
						bytes = bytes.Slice(bytesConsumed);
						chars = chars.Slice(charsWritten);
						if (!bytes.IsEmpty)
						{
							charsWritten = GetCharsFast((byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)), bytes.Length, (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)), chars.Length, out bytesConsumed);
							bytes = bytes.Slice(bytesConsumed);
							chars = chars.Slice(charsWritten);
						}
					}
					while (!bytes.IsEmpty);
					if (!bytes.IsEmpty)
					{
						ThrowCharsOverflow(decoder, chars.Length == originalCharsLength);
					}
					if (decoder != null)
					{
						decoder._bytesUsed = originalBytesLength - bytes.Length;
					}
					return originalCharsLength - chars.Length;
				}
			}
		}
	}
	internal static class EncodingTable
	{
		private static readonly int[] s_encodingNameIndices = new int[43]
		{
			0, 14, 28, 33, 38, 43, 50, 61, 76, 82,
			88, 103, 113, 123, 131, 140, 149, 165, 175, 190,
			192, 198, 203, 210, 227, 244, 261, 278, 289, 291,
			299, 305, 313, 321, 327, 335, 343, 348, 353, 372,
			391, 410, 429
		};

		private static readonly ushort[] s_codePagesByName = new ushort[42]
		{
			20127, 20127, 20127, 20127, 28591, 20127, 28591, 65000, 20127, 28591,
			1200, 28591, 28591, 20127, 20127, 28591, 20127, 28591, 28591, 28591,
			28591, 1200, 1200, 65000, 65001, 65000, 65001, 1201, 20127, 20127,
			1200, 1201, 1200, 12000, 12001, 12000, 65000, 65001, 65000, 65001,
			65000, 65001
		};

		private static readonly ushort[] s_mappedCodePages = new ushort[8] { 1200, 1201, 12000, 12001, 20127, 28591, 65000, 65001 };

		private static readonly int[] s_uiFamilyCodePages = new int[8] { 1200, 1200, 1200, 1200, 1252, 1252, 1200, 1200 };

		private static readonly int[] s_webNameIndices = new int[9] { 0, 6, 14, 20, 28, 36, 46, 51, 56 };

		private static readonly int[] s_englishNameIndices = new int[9] { 0, 7, 27, 43, 70, 78, 100, 115, 130 };

		private static readonly uint[] s_flags = new uint[8] { 512u, 0u, 0u, 0u, 257u, 771u, 257u, 771u };

		private static readonly Hashtable s_nameToCodePage = Hashtable.Synchronized(new Hashtable(StringComparer.OrdinalIgnoreCase));

		private static CodePageDataItem[] s_codePageToCodePageData;

		internal static int GetCodePageFromName(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			object obj = s_nameToCodePage[name];
			if (obj != null)
			{
				return (int)obj;
			}
			int num = InternalGetCodePageFromName(name);
			s_nameToCodePage[name] = num;
			return num;
		}

		private static int InternalGetCodePageFromName(string name)
		{
			int i = 0;
			int num = s_encodingNameIndices.Length - 2;
			ReadOnlySpan<char> strA = name.ToLowerInvariant().AsSpan();
			while (num - i > 3)
			{
				int num2 = (num - i) / 2 + i;
				int num3 = string.CompareOrdinal(strA, "ansi_x3.4-1968ansi_x3.4-1986asciicp367cp819csasciicsisolatin1csunicode11utf7ibm367ibm819iso-10646-ucs-2iso-8859-1iso-ir-100iso-ir-6iso646-usiso8859-1iso_646.irv:1991iso_8859-1iso_8859-1:1987l1latin1ucs-2unicodeunicode-1-1-utf-7unicode-1-1-utf-8unicode-2-0-utf-7unicode-2-0-utf-8unicodefffeusus-asciiutf-16utf-16beutf-16leutf-32utf-32beutf-32leutf-7utf-8x-unicode-1-1-utf-7x-unicode-1-1-utf-8x-unicode-2-0-utf-7x-unicode-2-0-utf-8".AsSpan(s_encodingNameIndices[num2], s_encodingNameIndices[num2 + 1] - s_encodingNameIndices[num2]));
				if (num3 == 0)
				{
					return s_codePagesByName[num2];
				}
				if (num3 < 0)
				{
					num = num2;
				}
				else
				{
					i = num2;
				}
			}
			for (; i <= num; i++)
			{
				if (string.CompareOrdinal(strA, "ansi_x3.4-1968ansi_x3.4-1986asciicp367cp819csasciicsisolatin1csunicode11utf7ibm367ibm819iso-10646-ucs-2iso-8859-1iso-ir-100iso-ir-6iso646-usiso8859-1iso_646.irv:1991iso_8859-1iso_8859-1:1987l1latin1ucs-2unicodeunicode-1-1-utf-7unicode-1-1-utf-8unicode-2-0-utf-7unicode-2-0-utf-8unicodefffeusus-asciiutf-16utf-16beutf-16leutf-32utf-32beutf-32leutf-7utf-8x-unicode-1-1-utf-7x-unicode-1-1-utf-8x-unicode-2-0-utf-7x-unicode-2-0-utf-8".AsSpan(s_encodingNameIndices[i], s_encodingNameIndices[i + 1] - s_encodingNameIndices[i])) == 0)
				{
					return s_codePagesByName[i];
				}
			}
			throw new ArgumentException(SR.Format(SR.Argument_EncodingNotSupported, name), "name");
		}

		internal static EncodingInfo[] GetEncodings()
		{
			ushort[] array = s_mappedCodePages;
			EncodingInfo[] array2 = new EncodingInfo[LocalAppContextSwitches.EnableUnsafeUTF7Encoding ? array.Length : (array.Length - 1)];
			string text = "utf-16utf-16BEutf-32utf-32BEus-asciiiso-8859-1utf-7utf-8";
			int[] array3 = s_webNameIndices;
			int num = 0;
			for (int i = 0; i < array.Length; i++)
			{
				int num2 = array[i];
				if (num2 != 65000 || LocalAppContextSwitches.EnableUnsafeUTF7Encoding)
				{
					array2[num++] = new EncodingInfo(num2, text[array3[i]..array3[i + 1]], GetDisplayName(num2, i));
				}
			}
			return array2;
		}

		internal static EncodingInfo[] GetEncodings(Dictionary<int, EncodingInfo> encodingInfoList)
		{
			ushort[] array = s_mappedCodePages;
			string text = "utf-16utf-16BEutf-32utf-32BEus-asciiiso-8859-1utf-7utf-8";
			int[] array2 = s_webNameIndices;
			for (int i = 0; i < array.Length; i++)
			{
				int num = array[i];
				if (!encodingInfoList.ContainsKey(num) && (num != 65000 || LocalAppContextSwitches.EnableUnsafeUTF7Encoding))
				{
					encodingInfoList[num] = new EncodingInfo(num, text[array2[i]..array2[i + 1]], GetDisplayName(num, i));
				}
			}
			if (!LocalAppContextSwitches.EnableUnsafeUTF7Encoding)
			{
				encodingInfoList.Remove(65000);
			}
			EncodingInfo[] array3 = new EncodingInfo[encodingInfoList.Count];
			int num2 = 0;
			foreach (KeyValuePair<int, EncodingInfo> encodingInfo in encodingInfoList)
			{
				array3[num2++] = encodingInfo.Value;
			}
			return array3;
		}

		internal static CodePageDataItem GetCodePageDataItem(int codePage)
		{
			if (s_codePageToCodePageData == null)
			{
				Interlocked.CompareExchange(ref s_codePageToCodePageData, new CodePageDataItem[s_mappedCodePages.Length], null);
			}
			int num;
			switch (codePage)
			{
			case 1200:
				num = 0;
				break;
			case 1201:
				num = 1;
				break;
			case 12000:
				num = 2;
				break;
			case 12001:
				num = 3;
				break;
			case 20127:
				num = 4;
				break;
			case 28591:
				num = 5;
				break;
			case 65000:
				num = 6;
				break;
			case 65001:
				num = 7;
				break;
			default:
				return null;
			}
			CodePageDataItem codePageDataItem = s_codePageToCodePageData[num];
			if (codePageDataItem == null)
			{
				Interlocked.CompareExchange(ref s_codePageToCodePageData[num], InternalGetCodePageDataItem(codePage, num), null);
				codePageDataItem = s_codePageToCodePageData[num];
			}
			return codePageDataItem;
		}

		private static CodePageDataItem InternalGetCodePageDataItem(int codePage, int index)
		{
			int uiFamilyCodePage = s_uiFamilyCodePages[index];
			string text = "utf-16utf-16BEutf-32utf-32BEus-asciiiso-8859-1utf-7utf-8"[s_webNameIndices[index]..s_webNameIndices[index + 1]];
			string headerName = text;
			string bodyName = text;
			string displayName = GetDisplayName(codePage, index);
			uint flags = s_flags[index];
			return new CodePageDataItem(uiFamilyCodePage, text, headerName, bodyName, displayName, flags);
		}

		private static string GetDisplayName(int codePage, int englishNameIndex)
		{
			string text = SR.GetResourceString("Globalization_cp_" + codePage);
			if (string.IsNullOrEmpty(text))
			{
				text = "UnicodeUnicode (Big-Endian)Unicode (UTF-32)Unicode (UTF-32 Big-Endian)US-ASCIIWestern European (ISO)Unicode (UTF-7)Unicode (UTF-8)"[s_englishNameIndices[englishNameIndex]..s_englishNameIndices[englishNameIndex + 1]];
			}
			return text;
		}
	}
	public sealed class EncodingInfo
	{
		public int CodePage { get; }

		public string Name { get; }

		public string DisplayName { get; }

		internal EncodingProvider? Provider { get; }

		public EncodingInfo(EncodingProvider provider, int codePage, string name, string displayName)
			: this(codePage, name, displayName)
		{
			if (name == null || displayName == null || provider == null)
			{
				throw new ArgumentNullException((name == null) ? "name" : ((displayName == null) ? "displayName" : "provider"));
			}
			Provider = provider;
		}

		internal EncodingInfo(int codePage, string name, string displayName)
		{
			CodePage = codePage;
			Name = name;
			DisplayName = displayName;
		}

		public Encoding GetEncoding()
		{
			return Provider?.GetEncoding(CodePage) ?? Encoding.GetEncoding(CodePage);
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is EncodingInfo encodingInfo)
			{
				return CodePage == encodingInfo.CodePage;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return CodePage;
		}
	}
	public abstract class EncodingProvider
	{
		private static volatile EncodingProvider[] s_providers;

		public EncodingProvider()
		{
		}

		public abstract Encoding? GetEncoding(string name);

		public abstract Encoding? GetEncoding(int codepage);

		public virtual Encoding? GetEncoding(string name, EncoderFallback encoderFallback, DecoderFallback decoderFallback)
		{
			Encoding encoding = GetEncoding(name);
			if (encoding != null)
			{
				encoding = (Encoding)encoding.Clone();
				encoding.EncoderFallback = encoderFallback;
				encoding.DecoderFallback = decoderFallback;
			}
			return encoding;
		}

		public virtual Encoding? GetEncoding(int codepage, EncoderFallback encoderFallback, DecoderFallback decoderFallback)
		{
			Encoding encoding = GetEncoding(codepage);
			if (encoding != null)
			{
				encoding = (Encoding)encoding.Clone();
				encoding.EncoderFallback = encoderFallback;
				encoding.DecoderFallback = decoderFallback;
			}
			return encoding;
		}

		public virtual IEnumerable<EncodingInfo> GetEncodings()
		{
			return Array.Empty<EncodingInfo>();
		}

		internal static void AddProvider(EncodingProvider provider)
		{
			if (provider == null)
			{
				throw new ArgumentNullException("provider");
			}
			if (s_providers == null && Interlocked.CompareExchange(ref s_providers, new EncodingProvider[1] { provider }, null) == null)
			{
				return;
			}
			EncodingProvider[] array;
			EncodingProvider[] array2;
			do
			{
				array = s_providers;
				if (Array.IndexOf(array, provider) >= 0)
				{
					break;
				}
				array2 = new EncodingProvider[array.Length + 1];
				Array.Copy(array, array2, array.Length);
				array2[^1] = provider;
			}
			while (Interlocked.CompareExchange(ref s_providers, array2, array) != array);
		}

		internal static Encoding GetEncodingFromProvider(int codepage)
		{
			EncodingProvider[] array = s_providers;
			if (array == null)
			{
				return null;
			}
			EncodingProvider[] array2 = array;
			foreach (EncodingProvider encodingProvider in array2)
			{
				Encoding encoding = encodingProvider.GetEncoding(codepage);
				if (encoding != null)
				{
					return encoding;
				}
			}
			return null;
		}

		internal static Dictionary<int, EncodingInfo> GetEncodingListFromProviders()
		{
			EncodingProvider[] array = s_providers;
			if (array == null)
			{
				return null;
			}
			Dictionary<int, EncodingInfo> dictionary = new Dictionary<int, EncodingInfo>();
			EncodingProvider[] array2 = array;
			foreach (EncodingProvider encodingProvider in array2)
			{
				IEnumerable<EncodingInfo> encodings = encodingProvider.GetEncodings();
				if (encodings == null)
				{
					continue;
				}
				foreach (EncodingInfo item in encodings)
				{
					dictionary.TryAdd(item.CodePage, item);
				}
			}
			return dictionary;
		}

		internal static Encoding GetEncodingFromProvider(string encodingName)
		{
			if (s_providers == null)
			{
				return null;
			}
			EncodingProvider[] array = s_providers;
			EncodingProvider[] array2 = array;
			foreach (EncodingProvider encodingProvider in array2)
			{
				Encoding encoding = encodingProvider.GetEncoding(encodingName);
				if (encoding != null)
				{
					return encoding;
				}
			}
			return null;
		}

		internal static Encoding GetEncodingFromProvider(int codepage, EncoderFallback enc, DecoderFallback dec)
		{
			if (s_providers == null)
			{
				return null;
			}
			EncodingProvider[] array = s_providers;
			EncodingProvider[] array2 = array;
			foreach (EncodingProvider encodingProvider in array2)
			{
				Encoding encoding = encodingProvider.GetEncoding(codepage, enc, dec);
				if (encoding != null)
				{
					return encoding;
				}
			}
			return null;
		}

		internal static Encoding GetEncodingFromProvider(string encodingName, EncoderFallback enc, DecoderFallback dec)
		{
			if (s_providers == null)
			{
				return null;
			}
			EncodingProvider[] array = s_providers;
			EncodingProvider[] array2 = array;
			foreach (EncodingProvider encodingProvider in array2)
			{
				Encoding encoding = encodingProvider.GetEncoding(encodingName, enc, dec);
				if (encoding != null)
				{
					return encoding;
				}
			}
			return null;
		}
	}
	internal class Latin1Encoding : Encoding
	{
		internal sealed class Latin1EncodingSealed : Latin1Encoding
		{
			public override object Clone()
			{
				return new Latin1Encoding
				{
					IsReadOnly = false
				};
			}
		}

		internal static readonly Latin1EncodingSealed s_default = new Latin1EncodingSealed();

		public override ReadOnlySpan<byte> Preamble => default(ReadOnlySpan<byte>);

		public override bool IsSingleByte => true;

		public Latin1Encoding()
			: base(28591)
		{
		}

		internal override void SetDefaultFallbacks()
		{
			encoderFallback = EncoderLatin1BestFitFallback.SingletonInstance;
			decoderFallback = System.Text.DecoderFallback.ReplacementFallback;
		}

		public unsafe override int GetByteCount(char* chars, int count)
		{
			if (chars == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars);
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetByteCountCommon(chars, count);
		}

		public unsafe override int GetByteCount(char[] chars, int index, int count)
		{
			if (chars == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			fixed (char* ptr = chars)
			{
				return GetByteCountCommon(ptr + index, count);
			}
		}

		public unsafe override int GetByteCount(ReadOnlySpan<char> chars)
		{
			fixed (char* pChars = &MemoryMarshal.GetReference(chars))
			{
				return GetByteCountCommon(pChars, chars.Length);
			}
		}

		public unsafe override int GetByteCount(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			fixed (char* pChars = s)
			{
				return GetByteCountCommon(pChars, s.Length);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetByteCountCommon(char* pChars, int charCount)
		{
			int charsConsumed;
			int num = GetByteCountFast(pChars, charCount, null, out charsConsumed);
			if (charsConsumed != charCount)
			{
				num += GetByteCountWithFallback(pChars, charCount, charsConsumed);
				if (num < 0)
				{
					Encoding.ThrowConversionOverflow();
				}
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetByteCountFast(char* pChars, int charsLength, EncoderFallback fallback, out int charsConsumed)
		{
			int num = charsLength;
			if (!FallbackSupportsFastGetByteCount(fallback))
			{
				num = (int)Latin1Utility.GetIndexOfFirstNonLatin1Char(pChars, (uint)charsLength);
			}
			charsConsumed = num;
			return num;
		}

		public override int GetMaxByteCount(int charCount)
		{
			if (charCount < 0)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = (long)charCount + 1L;
			if (base.EncoderFallback.MaxCharCount > 1)
			{
				num *= base.EncoderFallback.MaxCharCount;
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			return (int)num;
		}

		public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			if (chars == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((chars == null) ? ExceptionArgument.chars : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charCount | byteCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charCount < 0) ? ExceptionArgument.charCount : ExceptionArgument.byteCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetBytesCommon(chars, charCount, bytes, byteCount);
		}

		public unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (chars == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((chars == null) ? ExceptionArgument.chars : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charIndex | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charIndex < 0) ? ExceptionArgument.charIndex : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCount);
			}
			if ((uint)byteIndex > bytes.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (char* ptr = chars)
			{
				fixed (byte* ptr2 = bytes)
				{
					return GetBytesCommon(ptr + charIndex, charCount, ptr2 + byteIndex, bytes.Length - byteIndex);
				}
			}
		}

		public unsafe override int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes)
		{
			fixed (char* pChars = &MemoryMarshal.GetReference(chars))
			{
				fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
				{
					return GetBytesCommon(pChars, chars.Length, pBytes, bytes.Length);
				}
			}
		}

		public unsafe override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (s == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((s == null) ? ExceptionArgument.s : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charIndex | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charIndex < 0) ? ExceptionArgument.charIndex : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (s.Length - charIndex < charCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.s, ExceptionResource.ArgumentOutOfRange_IndexCount);
			}
			if ((uint)byteIndex > bytes.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (char* ptr2 = s)
			{
				fixed (byte[] array = bytes)
				{
					byte* ptr = (byte*)((bytes != null && array.Length != 0) ? System.Runtime.CompilerServices.Unsafe.AsPointer(ref array[0]) : null);
					return GetBytesCommon(ptr2 + charIndex, charCount, ptr + byteIndex, bytes.Length - byteIndex);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetBytesCommon(char* pChars, int charCount, byte* pBytes, int byteCount)
		{
			int charsConsumed;
			int bytesFast = GetBytesFast(pChars, charCount, pBytes, byteCount, out charsConsumed);
			if (charsConsumed == charCount)
			{
				return bytesFast;
			}
			return GetBytesWithFallback(pChars, charCount, pBytes, byteCount, charsConsumed, bytesFast);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetBytesFast(char* pChars, int charsLength, byte* pBytes, int bytesLength, out int charsConsumed)
		{
			return charsConsumed = (int)Latin1Utility.NarrowUtf16ToLatin1(pChars, pBytes, (uint)Math.Min(charsLength, bytesLength));
		}

		public unsafe override int GetCharCount(byte* bytes, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes);
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return count;
		}

		public override int GetCharCount(byte[] bytes)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes);
			}
			return bytes.Length;
		}

		public override int GetCharCount(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			return count;
		}

		public override int GetCharCount(ReadOnlySpan<byte> bytes)
		{
			return bytes.Length;
		}

		private protected unsafe override int GetCharCountFast(byte* pBytes, int bytesLength, DecoderFallback fallback, out int bytesConsumed)
		{
			bytesConsumed = bytesLength;
			return bytesLength;
		}

		public override int GetMaxCharCount(int byteCount)
		{
			if (byteCount < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return byteCount;
		}

		public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			if (bytes == null || chars == null)
			{
				ThrowHelper.ThrowArgumentNullException((bytes == null) ? ExceptionArgument.bytes : ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((byteCount | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((byteCount < 0) ? ExceptionArgument.byteCount : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetCharsCommon(bytes, byteCount, chars, charCount);
		}

		public unsafe override char[] GetChars(byte[] bytes)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes);
			}
			if (bytes.Length == 0)
			{
				return Array.Empty<char>();
			}
			char[] array = new char[bytes.Length];
			fixed (byte* pBytes = bytes)
			{
				fixed (char* pChars = array)
				{
					GetCharsCommon(pBytes, bytes.Length, pChars, array.Length);
				}
			}
			return array;
		}

		public unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
		{
			if (bytes == null || chars == null)
			{
				ThrowHelper.ThrowArgumentNullException((bytes == null) ? ExceptionArgument.bytes : ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((byteIndex | byteCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((byteIndex < 0) ? ExceptionArgument.byteIndex : ExceptionArgument.byteCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			if ((uint)charIndex > (uint)chars.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.charIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (byte* ptr = bytes)
			{
				fixed (char* ptr2 = chars)
				{
					return GetCharsCommon(ptr + byteIndex, byteCount, ptr2 + charIndex, chars.Length - charIndex);
				}
			}
		}

		public unsafe override char[] GetChars(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			char[] array = new char[count];
			fixed (byte* ptr = bytes)
			{
				fixed (char* pChars = array)
				{
					GetCharsCommon(ptr + index, count, pChars, array.Length);
				}
			}
			return array;
		}

		public unsafe override int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars)
		{
			fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
			{
				fixed (char* pChars = &MemoryMarshal.GetReference(chars))
				{
					return GetCharsCommon(pBytes, bytes.Length, pChars, chars.Length);
				}
			}
		}

		public unsafe override string GetString(byte[] bytes)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes);
			}
			return string.Create(bytes.Length, (this, bytes), delegate(Span<char> chars, (Latin1Encoding encoding, byte[] bytes) args)
			{
				fixed (byte* pBytes = args.bytes)
				{
					fixed (char* pChars = chars)
					{
						args.encoding.GetCharsCommon(pBytes, args.bytes.Length, pChars, chars.Length);
					}
				}
			});
		}

		public unsafe override string GetString(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			return string.Create(count, (this, bytes, index), delegate(Span<char> chars, (Latin1Encoding encoding, byte[] bytes, int index) args)
			{
				fixed (byte* ptr = args.bytes)
				{
					fixed (char* pChars = chars)
					{
						args.encoding.GetCharsCommon(ptr + args.index, chars.Length, pChars, chars.Length);
					}
				}
			});
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetCharsCommon(byte* pBytes, int byteCount, char* pChars, int charCount)
		{
			if (byteCount > charCount)
			{
				ThrowCharsOverflow();
			}
			Latin1Utility.WidenLatin1ToUtf16(pBytes, pChars, (uint)byteCount);
			return byteCount;
		}

		private protected unsafe sealed override int GetCharsFast(byte* pBytes, int bytesLength, char* pChars, int charsLength, out int bytesConsumed)
		{
			int num = Math.Min(bytesLength, charsLength);
			Latin1Utility.WidenLatin1ToUtf16(pBytes, pChars, (uint)num);
			bytesConsumed = num;
			return num;
		}

		public override Decoder GetDecoder()
		{
			return new DecoderNLS(this);
		}

		public override Encoder GetEncoder()
		{
			return new EncoderNLS(this);
		}

		internal sealed override bool TryGetByteCount(Rune value, out int byteCount)
		{
			if (value.Value <= 255)
			{
				byteCount = 1;
				return true;
			}
			byteCount = 0;
			return false;
		}

		internal sealed override OperationStatus EncodeRune(Rune value, Span<byte> bytes, out int bytesWritten)
		{
			if (value.Value <= 255)
			{
				if (!bytes.IsEmpty)
				{
					bytes[0] = (byte)value.Value;
					bytesWritten = 1;
					return OperationStatus.Done;
				}
				bytesWritten = 0;
				return OperationStatus.DestinationTooSmall;
			}
			bytesWritten = 0;
			return OperationStatus.InvalidData;
		}

		internal sealed override OperationStatus DecodeFirstRune(ReadOnlySpan<byte> bytes, out Rune value, out int bytesConsumed)
		{
			if (!bytes.IsEmpty)
			{
				byte b = bytes[0];
				if (b <= byte.MaxValue)
				{
					value = new Rune(b);
					bytesConsumed = 1;
					return OperationStatus.Done;
				}
				value = Rune.ReplacementChar;
				bytesConsumed = 1;
				return OperationStatus.InvalidData;
			}
			value = Rune.ReplacementChar;
			bytesConsumed = 0;
			return OperationStatus.NeedMoreData;
		}

		public override bool IsAlwaysNormalized(NormalizationForm form)
		{
			return form == NormalizationForm.FormC;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool FallbackSupportsFastGetByteCount(EncoderFallback fallback)
		{
			if (fallback == null)
			{
				return false;
			}
			if (fallback is EncoderLatin1BestFitFallback)
			{
				return true;
			}
			if (fallback is EncoderReplacementFallback encoderReplacementFallback && encoderReplacementFallback.MaxCharCount == 1 && encoderReplacementFallback.DefaultString[0] <= 'ÿ')
			{
				return true;
			}
			return false;
		}
	}
	internal static class Latin1Utility
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static nuint GetIndexOfFirstNonLatin1Char(char* pBuffer, nuint bufferLength)
		{
			if (!Sse2.IsSupported)
			{
				return GetIndexOfFirstNonLatin1Char_Default(pBuffer, bufferLength);
			}
			return GetIndexOfFirstNonLatin1Char_Sse2(pBuffer, bufferLength);
		}

		private unsafe static nuint GetIndexOfFirstNonLatin1Char_Default(char* pBuffer, nuint bufferLength)
		{
			char* ptr = pBuffer;
			if (Vector.IsHardwareAccelerated && bufferLength >= (uint)(2 * Vector<ushort>.Count))
			{
				uint count = (uint)Vector<ushort>.Count;
				uint count2 = (uint)Vector<byte>.Count;
				Vector<ushort> right = new Vector<ushort>(255);
				if (Vector.LessThanOrEqualAll(Unsafe.ReadUnaligned<Vector<ushort>>(pBuffer), right))
				{
					char* ptr2 = pBuffer + bufferLength - count;
					pBuffer = (char*)((nuint)((byte*)pBuffer + count2) & ~(nuint)(count2 - 1));
					while (!Vector.GreaterThanAny(Unsafe.Read<Vector<ushort>>(pBuffer), right))
					{
						pBuffer += count;
						if (pBuffer > ptr2)
						{
							break;
						}
					}
					bufferLength -= (nuint)(nint)(pBuffer - ptr);
				}
			}
			while (true)
			{
				uint num;
				if (bufferLength >= 4)
				{
					num = Unsafe.ReadUnaligned<uint>(pBuffer);
					uint num2 = Unsafe.ReadUnaligned<uint>(pBuffer + 2);
					if (!AllCharsInUInt32AreLatin1(num | num2))
					{
						if (AllCharsInUInt32AreLatin1(num))
						{
							num = num2;
							pBuffer += 2;
						}
						goto IL_010f;
					}
					pBuffer += 4;
					bufferLength -= 4;
					continue;
				}
				if ((bufferLength & 2) != 0)
				{
					num = Unsafe.ReadUnaligned<uint>(pBuffer);
					if (!AllCharsInUInt32AreLatin1(num))
					{
						goto IL_010f;
					}
					pBuffer += 2;
				}
				if ((bufferLength & 1) != 0 && *pBuffer <= 'ÿ')
				{
					pBuffer++;
				}
				break;
				IL_010f:
				if (FirstCharInUInt32IsLatin1(num))
				{
					pBuffer++;
				}
				break;
			}
			nuint num3 = (nuint)((byte*)pBuffer - (nuint)ptr);
			return num3 / 2;
		}

		private unsafe static nuint GetIndexOfFirstNonLatin1Char_Sse2(char* pBuffer, nuint bufferLength)
		{
			if (bufferLength == 0)
			{
				return 0u;
			}
			uint num = (uint)Unsafe.SizeOf<Vector128<byte>>();
			uint num2 = num / 2;
			char* ptr = pBuffer;
			Vector128<ushort> right;
			Vector128<ushort> right2;
			Vector128<ushort> left;
			uint num3;
			if (bufferLength >= num2)
			{
				right = Vector128.Create((ushort)65280);
				right2 = Vector128.Create((ushort)32512);
				left = Sse2.LoadVector128((ushort*)pBuffer);
				num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
				if ((num3 & 0xAAAA) == 0)
				{
					bufferLength <<= 1;
					if (bufferLength < 2 * num)
					{
						goto IL_013e;
					}
					pBuffer = (char*)((nuint)((byte*)pBuffer + num) & ~(nuint)(num - 1));
					bufferLength = (nuint)(bufferLength + (byte*)ptr);
					bufferLength -= (nuint)pBuffer;
					if (bufferLength < 2 * num)
					{
						goto IL_00fa;
					}
					char* ptr2 = (char*)((byte*)pBuffer + bufferLength - 2 * num);
					Vector128<ushort> vector;
					while (true)
					{
						left = Sse2.LoadAlignedVector128((ushort*)pBuffer);
						vector = Sse2.LoadAlignedVector128((ushort*)(pBuffer + num2));
						Vector128<ushort> left2 = Sse2.Or(left, vector);
						if (Sse41.IsSupported)
						{
							if (!Sse41.TestZ(left2, right))
							{
								break;
							}
						}
						else
						{
							num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left2, right2).AsByte());
							if ((num3 & 0xAAAAu) != 0)
							{
								break;
							}
						}
						pBuffer += 2 * num2;
						if (pBuffer <= ptr2)
						{
							continue;
						}
						goto IL_00fa;
					}
					if (Sse41.IsSupported)
					{
						if (!Sse41.TestZ(left, right))
						{
							goto IL_01e6;
						}
					}
					else
					{
						num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
						if ((num3 & 0xAAAAu) != 0)
						{
							goto IL_01fa;
						}
					}
					pBuffer += num2;
					left = vector;
					goto IL_01e6;
				}
				goto IL_01fa;
			}
			uint num5;
			if ((bufferLength & 4) != 0)
			{
				if (Bmi1.X64.IsSupported)
				{
					ulong num4 = Unsafe.ReadUnaligned<ulong>(pBuffer);
					if (!AllCharsInUInt64AreLatin1(num4))
					{
						num4 &= 0xFF00FF00FF00FF00uL;
						pBuffer = (char*)((byte*)pBuffer + (nuint)((nint)(Bmi1.X64.TrailingZeroCount(num4) / 8) & ~(nint)1));
						goto IL_01a1;
					}
				}
				else
				{
					num5 = Unsafe.ReadUnaligned<uint>(pBuffer);
					uint num6 = Unsafe.ReadUnaligned<uint>(pBuffer + 2);
					if (!AllCharsInUInt32AreLatin1(num5 | num6))
					{
						if (AllCharsInUInt32AreLatin1(num5))
						{
							num5 = num6;
							pBuffer += 2;
						}
						goto IL_0214;
					}
				}
				pBuffer += 4;
			}
			if ((bufferLength & 2) != 0)
			{
				num5 = Unsafe.ReadUnaligned<uint>(pBuffer);
				if (!AllCharsInUInt32AreLatin1(num5))
				{
					goto IL_0214;
				}
				pBuffer += 2;
			}
			if ((bufferLength & 1) != 0 && *pBuffer <= 'ÿ')
			{
				pBuffer++;
			}
			goto IL_01a1;
			IL_01a1:
			return (nuint)(pBuffer - ptr);
			IL_0148:
			if (((byte)bufferLength & (num - 1)) != 0)
			{
				pBuffer = (char*)((byte*)pBuffer + (bufferLength & (num - 1)) - num);
				left = Sse2.LoadVector128((ushort*)pBuffer);
				if (Sse41.IsSupported)
				{
					if (!Sse41.TestZ(left, right))
					{
						goto IL_01e6;
					}
				}
				else
				{
					num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
					if ((num3 & 0xAAAAu) != 0)
					{
						goto IL_01fa;
					}
				}
				pBuffer += num2;
			}
			goto IL_01a1;
			IL_0214:
			if (FirstCharInUInt32IsLatin1(num5))
			{
				pBuffer++;
			}
			goto IL_01a1;
			IL_01fa:
			num3 &= 0xAAAAu;
			pBuffer = (char*)((byte*)pBuffer + (uint)BitOperations.TrailingZeroCount(num3) - 1);
			goto IL_01a1;
			IL_013e:
			pBuffer += num2;
			goto IL_0148;
			IL_01e6:
			num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
			goto IL_01fa;
			IL_00fa:
			if ((bufferLength & num) != 0)
			{
				left = Sse2.LoadAlignedVector128((ushort*)pBuffer);
				if (Sse41.IsSupported)
				{
					if (!Sse41.TestZ(left, right))
					{
						goto IL_01e6;
					}
				}
				else
				{
					num3 = (uint)Sse2.MoveMask(Sse2.AddSaturate(left, right2).AsByte());
					if ((num3 & 0xAAAAu) != 0)
					{
						goto IL_01fa;
					}
				}
				goto IL_013e;
			}
			goto IL_0148;
		}

		public unsafe static nuint NarrowUtf16ToLatin1(char* pUtf16Buffer, byte* pLatin1Buffer, nuint elementCount)
		{
			nuint num = 0u;
			uint num2 = 0u;
			uint num3 = 0u;
			ulong num4 = 0uL;
			if (Sse2.IsSupported)
			{
				if (elementCount >= (uint)(2 * Unsafe.SizeOf<Vector128<byte>>()))
				{
					if (IntPtr.Size >= 8)
					{
					}
					num2 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer);
					num3 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + 2);
					if (!AllCharsInUInt32AreLatin1(num2 | num3))
					{
						goto IL_01cd;
					}
					num = NarrowUtf16ToLatin1_Sse2(pUtf16Buffer, pLatin1Buffer, elementCount);
				}
			}
			else if (Vector.IsHardwareAccelerated)
			{
				uint num5 = (uint)Unsafe.SizeOf<Vector<byte>>();
				if (elementCount >= 2 * num5)
				{
					if (IntPtr.Size >= 8)
					{
					}
					num2 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer);
					num3 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + 2);
					if (!AllCharsInUInt32AreLatin1(num2 | num3))
					{
						goto IL_01cd;
					}
					Vector<ushort> right = new Vector<ushort>(255);
					nuint num6 = elementCount - 2 * num5;
					do
					{
						Vector<ushort> vector = Unsafe.ReadUnaligned<Vector<ushort>>(pUtf16Buffer + num);
						Vector<ushort> vector2 = Unsafe.ReadUnaligned<Vector<ushort>>(pUtf16Buffer + num + Vector<ushort>.Count);
						if (Vector.GreaterThanAny(Vector.BitwiseOr(vector, vector2), right))
						{
							break;
						}
						Vector<byte> value = Vector.Narrow(vector, vector2);
						Unsafe.WriteUnaligned(pLatin1Buffer + num, value);
						num += num5;
					}
					while (num <= num6);
				}
			}
			nuint num7 = elementCount - num;
			if (num7 < 4)
			{
				goto IL_0176;
			}
			nuint num8 = num + num7 - 4;
			while (true)
			{
				if (IntPtr.Size >= 8)
				{
				}
				num2 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + num);
				num3 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + num + 2);
				if (!AllCharsInUInt32AreLatin1(num2 | num3))
				{
					break;
				}
				NarrowTwoUtf16CharsToLatin1AndWriteToBuffer(ref pLatin1Buffer[num], num2);
				NarrowTwoUtf16CharsToLatin1AndWriteToBuffer(ref pLatin1Buffer[num + 2], num3);
				num += 4;
				if (num <= num8)
				{
					continue;
				}
				goto IL_0176;
			}
			goto IL_01cd;
			IL_01ef:
			if (FirstCharInUInt32IsLatin1(num2))
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				pLatin1Buffer[num] = (byte)num2;
				num++;
			}
			goto IL_01cb;
			IL_0176:
			if (((uint)(int)num7 & 2u) != 0)
			{
				num2 = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + num);
				if (!AllCharsInUInt32AreLatin1(num2))
				{
					goto IL_01ef;
				}
				NarrowTwoUtf16CharsToLatin1AndWriteToBuffer(ref pLatin1Buffer[num], num2);
				num += 2;
			}
			if (((uint)(int)num7 & (true ? 1u : 0u)) != 0)
			{
				num2 = pUtf16Buffer[num];
				if (num2 <= 255)
				{
					pLatin1Buffer[num] = (byte)num2;
					num++;
				}
			}
			goto IL_01cb;
			IL_01cd:
			if (IntPtr.Size >= 8)
			{
			}
			if (AllCharsInUInt32AreLatin1(num2))
			{
				NarrowTwoUtf16CharsToLatin1AndWriteToBuffer(ref pLatin1Buffer[num], num2);
				num2 = num3;
				num += 2;
			}
			goto IL_01ef;
			IL_01cb:
			return num;
		}

		private unsafe static nuint NarrowUtf16ToLatin1_Sse2(char* pUtf16Buffer, byte* pLatin1Buffer, nuint elementCount)
		{
			uint num = (uint)Unsafe.SizeOf<Vector128<byte>>();
			nuint num2 = num - 1;
			Vector128<short> right = Vector128.Create((short)(-256));
			Vector128<ushort> right2 = Vector128.Create((ushort)32512);
			Vector128<short> vector = Sse2.LoadVector128((short*)pUtf16Buffer);
			if (Sse41.IsSupported)
			{
				if (!Sse41.TestZ(vector, right))
				{
					return 0u;
				}
			}
			else if (((uint)Sse2.MoveMask(Sse2.AddSaturate(vector.AsUInt16(), right2).AsByte()) & 0xAAAAu) != 0)
			{
				return 0u;
			}
			Vector128<byte> vector2 = Sse2.PackUnsignedSaturate(vector, vector);
			Sse2.StoreScalar((ulong*)pLatin1Buffer, vector2.AsUInt64());
			nuint num3 = num / 2;
			if (((uint)(int)pLatin1Buffer & (num / 2)) != 0)
			{
				goto IL_00ea;
			}
			vector = Sse2.LoadVector128((short*)(pUtf16Buffer + num3));
			if (Sse41.IsSupported)
			{
				if (Sse41.TestZ(vector, right))
				{
					goto IL_00cd;
				}
			}
			else if ((Sse2.MoveMask(Sse2.AddSaturate(vector.AsUInt16(), right2).AsByte()) & 0xAAAA) == 0)
			{
				goto IL_00cd;
			}
			goto IL_0186;
			IL_0186:
			return num3;
			IL_00ea:
			num3 = num - ((nuint)pLatin1Buffer & num2);
			nuint num4 = elementCount - num;
			do
			{
				vector = Sse2.LoadVector128((short*)(pUtf16Buffer + num3));
				Vector128<short> right3 = Sse2.LoadVector128((short*)(pUtf16Buffer + num3 + num / 2));
				Vector128<short> vector3 = Sse2.Or(vector, right3);
				if (Sse41.IsSupported)
				{
					if (Sse41.TestZ(vector3, right))
					{
						goto IL_015e;
					}
				}
				else if ((Sse2.MoveMask(Sse2.AddSaturate(vector3.AsUInt16(), right2).AsByte()) & 0xAAAA) == 0)
				{
					goto IL_015e;
				}
				if (Sse41.IsSupported)
				{
					if (!Sse41.TestZ(vector, right))
					{
						break;
					}
				}
				else if (((uint)Sse2.MoveMask(Sse2.AddSaturate(vector.AsUInt16(), right2).AsByte()) & 0xAAAAu) != 0)
				{
					break;
				}
				vector2 = Sse2.PackUnsignedSaturate(vector, vector);
				Sse2.StoreScalar((ulong*)(pLatin1Buffer + num3), vector2.AsUInt64());
				num3 += num / 2;
				break;
				IL_015e:
				vector2 = Sse2.PackUnsignedSaturate(vector, right3);
				Sse2.StoreAligned(pLatin1Buffer + num3, vector2);
				num3 += num;
			}
			while (num3 <= num4);
			goto IL_0186;
			IL_00cd:
			vector2 = Sse2.PackUnsignedSaturate(vector, vector);
			Sse2.StoreScalar((ulong*)(pLatin1Buffer + num3), vector2.AsUInt64());
			goto IL_00ea;
		}

		public unsafe static void WidenLatin1ToUtf16(byte* pLatin1Buffer, char* pUtf16Buffer, nuint elementCount)
		{
			if (Sse2.IsSupported)
			{
				WidenLatin1ToUtf16_Sse2(pLatin1Buffer, pUtf16Buffer, elementCount);
			}
			else
			{
				WidenLatin1ToUtf16_Fallback(pLatin1Buffer, pUtf16Buffer, elementCount);
			}
		}

		private unsafe static void WidenLatin1ToUtf16_Sse2(byte* pLatin1Buffer, char* pUtf16Buffer, nuint elementCount)
		{
			uint num = (uint)Unsafe.SizeOf<Vector128<byte>>();
			nuint num2 = num - 1;
			nuint num3 = 0u;
			Vector128<byte> zero = Vector128<byte>.Zero;
			if (elementCount >= num)
			{
				Vector128<byte> left = Sse2.LoadScalarVector128((ulong*)pLatin1Buffer).AsByte();
				Sse2.Store((byte*)pUtf16Buffer, Sse2.UnpackLow(left, zero));
				num3 = (num >> 1) - (((nuint)pUtf16Buffer >> 1) & (num2 >> 1));
				char* ptr = pUtf16Buffer + num3;
				nuint num4 = elementCount - num;
				while (num3 <= num4)
				{
					left = Sse2.LoadVector128(pLatin1Buffer + num3);
					Vector128<byte> source = Sse2.UnpackLow(left, zero);
					Sse2.StoreAligned((byte*)ptr, source);
					Vector128<byte> source2 = Sse2.UnpackHigh(left, zero);
					Sse2.StoreAligned((byte*)ptr + num, source2);
					num3 += num;
					ptr += num;
				}
			}
			uint num5 = (uint)((int)elementCount - (int)num3);
			if ((num5 & 8u) != 0)
			{
				Vector128<byte> left = Sse2.LoadScalarVector128((ulong*)(pLatin1Buffer + num3)).AsByte();
				Sse2.Store((byte*)(pUtf16Buffer + num3), Sse2.UnpackLow(left, zero));
				num3 += 8;
			}
			if ((num5 & 4u) != 0)
			{
				Vector128<byte> left = Sse2.LoadScalarVector128((uint*)(pLatin1Buffer + num3)).AsByte();
				Sse2.StoreScalar((ulong*)(pUtf16Buffer + num3), Sse2.UnpackLow(left, zero).AsUInt64());
				num3 += 4;
			}
			if ((num5 & 3) == 0)
			{
				return;
			}
			pUtf16Buffer[num3] = (char)pLatin1Buffer[num3];
			if ((num5 & 2u) != 0)
			{
				pUtf16Buffer[num3 + 1] = (char)pLatin1Buffer[num3 + 1];
				if ((num5 & (true ? 1u : 0u)) != 0)
				{
					pUtf16Buffer[num3 + 2] = (char)pLatin1Buffer[num3 + 2];
				}
			}
		}

		private unsafe static void WidenLatin1ToUtf16_Fallback(byte* pLatin1Buffer, char* pUtf16Buffer, nuint elementCount)
		{
			nuint num = 0u;
			if (Vector.IsHardwareAccelerated)
			{
				uint count = (uint)Vector<byte>.Count;
				if (elementCount >= count)
				{
					nuint num2 = elementCount - count;
					do
					{
						Vector<byte> value = Unsafe.ReadUnaligned<Vector<byte>>(pLatin1Buffer + num);
						Vector.Widen(Vector.AsVectorByte(value), out var low, out var high);
						Unsafe.WriteUnaligned(pUtf16Buffer + num, low);
						Unsafe.WriteUnaligned(pUtf16Buffer + num + Vector<ushort>.Count, high);
						num += count;
					}
					while (num <= num2);
				}
			}
			for (; num < elementCount; num++)
			{
				pUtf16Buffer[num] = (char)pLatin1Buffer[num];
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool AllCharsInUInt32AreLatin1(uint value)
		{
			return (value & 0xFF00FF00u) == 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool AllCharsInUInt64AreLatin1(ulong value)
		{
			return (value & 0xFF00FF00FF00FF00uL) == 0;
		}

		private static bool FirstCharInUInt32IsLatin1(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((value & 0xFF00u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void NarrowTwoUtf16CharsToLatin1AndWriteToBuffer(ref byte outputBuffer, uint value)
		{
			_ = BitConverter.IsLittleEndian;
			outputBuffer = (byte)value;
			Unsafe.Add(ref outputBuffer, 1) = (byte)(value >> 16);
		}
	}
	public enum NormalizationForm
	{
		FormC = 1,
		FormD = 2,
		[UnsupportedOSPlatform("browser")]
		FormKC = 5,
		[UnsupportedOSPlatform("browser")]
		FormKD = 6
	}
	[DebuggerDisplay("{DebuggerDisplay,nq}")]
	public readonly struct Rune : IComparable, IComparable<Rune>, IEquatable<Rune>, ISpanFormattable, IFormattable
	{
		private readonly uint _value;

		private static ReadOnlySpan<byte> AsciiCharInfo => new byte[128]
		{
			14, 14, 14, 14, 14, 14, 14, 14, 14, 142,
			142, 142, 142, 142, 14, 14, 14, 14, 14, 14,
			14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
			14, 14, 139, 24, 24, 24, 26, 24, 24, 24,
			20, 21, 24, 25, 24, 19, 24, 24, 72, 72,
			72, 72, 72, 72, 72, 72, 72, 72, 24, 24,
			25, 25, 25, 24, 24, 64, 64, 64, 64, 64,
			64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
			64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
			64, 20, 24, 21, 27, 18, 27, 65, 65, 65,
			65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
			65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
			65, 65, 65, 20, 25, 21, 25, 14
		};

		private string DebuggerDisplay
		{
			get
			{
				IFormatProvider invariantCulture = CultureInfo.InvariantCulture;
				DefaultInterpolatedStringHandler handler = new DefaultInterpolatedStringHandler(5, 2, invariantCulture);
				handler.AppendLiteral("U+");
				handler.AppendFormatted(_value, "X4");
				handler.AppendLiteral(" '");
				handler.AppendFormatted(IsValid(_value) ? ToString() : "\ufffd");
				handler.AppendLiteral("'");
				return string.Create(invariantCulture, ref handler);
			}
		}

		public bool IsAscii => UnicodeUtility.IsAsciiCodePoint(_value);

		public bool IsBmp => UnicodeUtility.IsBmpCodePoint(_value);

		public int Plane => UnicodeUtility.GetPlane(_value);

		public static Rune ReplacementChar => UnsafeCreate(65533u);

		public int Utf16SequenceLength => UnicodeUtility.GetUtf16SequenceLength(_value);

		public int Utf8SequenceLength => UnicodeUtility.GetUtf8SequenceLength(_value);

		public int Value => (int)_value;

		public Rune(char ch)
		{
			if (UnicodeUtility.IsSurrogateCodePoint(ch))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.ch);
			}
			_value = ch;
		}

		public Rune(char highSurrogate, char lowSurrogate)
			: this((uint)char.ConvertToUtf32(highSurrogate, lowSurrogate), unused: false)
		{
		}

		public Rune(int value)
			: this((uint)value)
		{
		}

		[CLSCompliant(false)]
		public Rune(uint value)
		{
			if (!UnicodeUtility.IsValidUnicodeScalar(value))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value);
			}
			_value = value;
		}

		private Rune(uint scalarValue, bool unused)
		{
			_value = scalarValue;
		}

		public static bool operator ==(Rune left, Rune right)
		{
			return left._value == right._value;
		}

		public static bool operator !=(Rune left, Rune right)
		{
			return left._value != right._value;
		}

		public static bool operator <(Rune left, Rune right)
		{
			return left._value < right._value;
		}

		public static bool operator <=(Rune left, Rune right)
		{
			return left._value <= right._value;
		}

		public static bool operator >(Rune left, Rune right)
		{
			return left._value > right._value;
		}

		public static bool operator >=(Rune left, Rune right)
		{
			return left._value >= right._value;
		}

		public static explicit operator Rune(char ch)
		{
			return new Rune(ch);
		}

		[CLSCompliant(false)]
		public static explicit operator Rune(uint value)
		{
			return new Rune(value);
		}

		public static explicit operator Rune(int value)
		{
			return new Rune(value);
		}

		private static Rune ChangeCaseCultureAware(Rune rune, TextInfo textInfo, bool toUpper)
		{
			Span<char> span = stackalloc char[2];
			Span<char> destination = stackalloc char[2];
			int length = rune.EncodeToUtf16(span);
			span = span.Slice(0, length);
			destination = destination.Slice(0, length);
			if (toUpper)
			{
				textInfo.ChangeCaseToUpper(span, destination);
			}
			else
			{
				textInfo.ChangeCaseToLower(span, destination);
			}
			if (rune.IsBmp)
			{
				return UnsafeCreate(destination[0]);
			}
			return UnsafeCreate(UnicodeUtility.GetScalarFromUtf16SurrogatePair(destination[0], destination[1]));
		}

		public int CompareTo(Rune other)
		{
			return Value - other.Value;
		}

		public static OperationStatus DecodeFromUtf16(ReadOnlySpan<char> source, out Rune result, out int charsConsumed)
		{
			if (!source.IsEmpty)
			{
				char c = source[0];
				if (TryCreate(c, out result))
				{
					charsConsumed = 1;
					return OperationStatus.Done;
				}
				if (source.Length > 1)
				{
					char lowSurrogate = source[1];
					if (TryCreate(c, lowSurrogate, out result))
					{
						charsConsumed = 2;
						return OperationStatus.Done;
					}
				}
				else if (char.IsHighSurrogate(c))
				{
					goto IL_004c;
				}
				charsConsumed = 1;
				result = ReplacementChar;
				return OperationStatus.InvalidData;
			}
			goto IL_004c;
			IL_004c:
			charsConsumed = source.Length;
			result = ReplacementChar;
			return OperationStatus.NeedMoreData;
		}

		public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> source, out Rune result, out int bytesConsumed)
		{
			int num = 0;
			uint num2;
			if ((uint)num < (uint)source.Length)
			{
				num2 = source[num];
				if (UnicodeUtility.IsAsciiCodePoint(num2))
				{
					goto IL_0021;
				}
				if (UnicodeUtility.IsInRangeInclusive(num2, 194u, 244u))
				{
					num2 = num2 - 194 << 6;
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_0163;
					}
					int num3 = (sbyte)source[num];
					if (num3 < -64)
					{
						num2 += (uint)num3;
						num2 += 128;
						num2 += 128;
						if (num2 < 2048)
						{
							goto IL_0021;
						}
						if (UnicodeUtility.IsInRangeInclusive(num2, 2080u, 3343u) && !UnicodeUtility.IsInRangeInclusive(num2, 2912u, 2943u) && !UnicodeUtility.IsInRangeInclusive(num2, 3072u, 3087u))
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								goto IL_0163;
							}
							num3 = (sbyte)source[num];
							if (num3 < -64)
							{
								num2 <<= 6;
								num2 += (uint)num3;
								num2 += 128;
								num2 -= 131072;
								if (num2 > 65535)
								{
									num++;
									if ((uint)num >= (uint)source.Length)
									{
										goto IL_0163;
									}
									num3 = (sbyte)source[num];
									if (num3 >= -64)
									{
										goto IL_0153;
									}
									num2 <<= 6;
									num2 += (uint)num3;
									num2 += 128;
									num2 -= 4194304;
								}
								goto IL_0021;
							}
						}
					}
				}
				else
				{
					num = 1;
				}
				goto IL_0153;
			}
			goto IL_0163;
			IL_0021:
			bytesConsumed = num + 1;
			result = UnsafeCreate(num2);
			return OperationStatus.Done;
			IL_0153:
			bytesConsumed = num;
			result = ReplacementChar;
			return OperationStatus.InvalidData;
			IL_0163:
			bytesConsumed = num;
			result = ReplacementChar;
			return OperationStatus.NeedMoreData;
		}

		public static OperationStatus DecodeLastFromUtf16(ReadOnlySpan<char> source, out Rune result, out int charsConsumed)
		{
			int num = source.Length - 1;
			if ((uint)num < (uint)source.Length)
			{
				char c = source[num];
				if (TryCreate(c, out result))
				{
					charsConsumed = 1;
					return OperationStatus.Done;
				}
				if (char.IsLowSurrogate(c))
				{
					num--;
					if ((uint)num < (uint)source.Length)
					{
						char highSurrogate = source[num];
						if (TryCreate(highSurrogate, c, out result))
						{
							charsConsumed = 2;
							return OperationStatus.Done;
						}
					}
					charsConsumed = 1;
					result = ReplacementChar;
					return OperationStatus.InvalidData;
				}
			}
			charsConsumed = -source.Length >>> 31;
			result = ReplacementChar;
			return OperationStatus.NeedMoreData;
		}

		public static OperationStatus DecodeLastFromUtf8(ReadOnlySpan<byte> source, out Rune value, out int bytesConsumed)
		{
			int num = source.Length - 1;
			if ((uint)num < (uint)source.Length)
			{
				uint num2 = source[num];
				if (UnicodeUtility.IsAsciiCodePoint(num2))
				{
					bytesConsumed = 1;
					value = UnsafeCreate(num2);
					return OperationStatus.Done;
				}
				if (((byte)num2 & 0x40u) != 0)
				{
					return DecodeFromUtf8(source.Slice(num), out value, out bytesConsumed);
				}
				int num3 = 3;
				OperationStatus result2;
				Rune result;
				int bytesConsumed2;
				while (true)
				{
					if (num3 > 0)
					{
						num--;
						if ((uint)num < (uint)source.Length)
						{
							if ((sbyte)source[num] < -64)
							{
								num3--;
								continue;
							}
							source = source.Slice(num);
							result2 = DecodeFromUtf8(source, out result, out bytesConsumed2);
							if (bytesConsumed2 == source.Length)
							{
								break;
							}
						}
					}
					value = ReplacementChar;
					bytesConsumed = 1;
					return OperationStatus.InvalidData;
				}
				bytesConsumed = bytesConsumed2;
				value = result;
				return result2;
			}
			value = ReplacementChar;
			bytesConsumed = 0;
			return OperationStatus.NeedMoreData;
		}

		public int EncodeToUtf16(Span<char> destination)
		{
			if (!TryEncodeToUtf16(destination, out var charsWritten))
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			return charsWritten;
		}

		public int EncodeToUtf8(Span<byte> destination)
		{
			if (!TryEncodeToUtf8(destination, out var bytesWritten))
			{
				ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
			return bytesWritten;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Rune other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(Rune other)
		{
			return this == other;
		}

		public override int GetHashCode()
		{
			return Value;
		}

		public static Rune GetRuneAt(string input, int index)
		{
			int num = ReadRuneFromString(input, index);
			if (num < 0)
			{
				ThrowHelper.ThrowArgumentException_CannotExtractScalar(ExceptionArgument.index);
			}
			return UnsafeCreate((uint)num);
		}

		public static bool IsValid(int value)
		{
			return IsValid((uint)value);
		}

		[CLSCompliant(false)]
		public static bool IsValid(uint value)
		{
			return UnicodeUtility.IsValidUnicodeScalar(value);
		}

		internal static int ReadFirstRuneFromUtf16Buffer(ReadOnlySpan<char> input)
		{
			if (input.IsEmpty)
			{
				return -1;
			}
			uint num = input[0];
			if (UnicodeUtility.IsSurrogateCodePoint(num))
			{
				if (!UnicodeUtility.IsHighSurrogateCodePoint(num))
				{
					return -1;
				}
				if (input.Length <= 1)
				{
					return -1;
				}
				uint num2 = input[1];
				if (!UnicodeUtility.IsLowSurrogateCodePoint(num2))
				{
					return -1;
				}
				num = UnicodeUtility.GetScalarFromUtf16SurrogatePair(num, num2);
			}
			return (int)num;
		}

		private static int ReadRuneFromString(string input, int index)
		{
			if (input == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
			}
			if ((uint)index >= (uint)input.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			uint num = input[index];
			if (UnicodeUtility.IsSurrogateCodePoint(num))
			{
				if (!UnicodeUtility.IsHighSurrogateCodePoint(num))
				{
					return -1;
				}
				index++;
				if ((uint)index >= (uint)input.Length)
				{
					return -1;
				}
				uint num2 = input[index];
				if (!UnicodeUtility.IsLowSurrogateCodePoint(num2))
				{
					return -1;
				}
				num = UnicodeUtility.GetScalarFromUtf16SurrogatePair(num, num2);
			}
			return (int)num;
		}

		public override string ToString()
		{
			if (IsBmp)
			{
				return string.CreateFromChar((char)_value);
			}
			UnicodeUtility.GetUtf16SurrogatesFromSupplementaryPlaneScalar(_value, out var highSurrogateCodePoint, out var lowSurrogateCodePoint);
			return string.CreateFromChar(highSurrogateCodePoint, lowSurrogateCodePoint);
		}

		bool ISpanFormattable.TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			return TryEncodeToUtf16(destination, out charsWritten);
		}

		string IFormattable.ToString(string format, IFormatProvider formatProvider)
		{
			return ToString();
		}

		public static bool TryCreate(char ch, out Rune result)
		{
			if (!UnicodeUtility.IsSurrogateCodePoint(ch))
			{
				result = UnsafeCreate(ch);
				return true;
			}
			result = default(Rune);
			return false;
		}

		public static bool TryCreate(char highSurrogate, char lowSurrogate, out Rune result)
		{
			uint num = (uint)(highSurrogate - 55296);
			uint num2 = (uint)(lowSurrogate - 56320);
			if ((num | num2) <= 1023)
			{
				result = UnsafeCreate((uint)((int)(num << 10) + (lowSurrogate - 56320) + 65536));
				return true;
			}
			result = default(Rune);
			return false;
		}

		public static bool TryCreate(int value, out Rune result)
		{
			return TryCreate((uint)value, out result);
		}

		[CLSCompliant(false)]
		public static bool TryCreate(uint value, out Rune result)
		{
			if (UnicodeUtility.IsValidUnicodeScalar(value))
			{
				result = UnsafeCreate(value);
				return true;
			}
			result = default(Rune);
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryEncodeToUtf16(Span<char> destination, out int charsWritten)
		{
			return TryEncodeToUtf16(this, destination, out charsWritten);
		}

		private static bool TryEncodeToUtf16(Rune value, Span<char> destination, out int charsWritten)
		{
			if (!destination.IsEmpty)
			{
				if (value.IsBmp)
				{
					destination[0] = (char)value._value;
					charsWritten = 1;
					return true;
				}
				if (1u < (uint)destination.Length)
				{
					UnicodeUtility.GetUtf16SurrogatesFromSupplementaryPlaneScalar(value._value, out destination[0], out destination[1]);
					charsWritten = 2;
					return true;
				}
			}
			charsWritten = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryEncodeToUtf8(Span<byte> destination, out int bytesWritten)
		{
			return TryEncodeToUtf8(this, destination, out bytesWritten);
		}

		private static bool TryEncodeToUtf8(Rune value, Span<byte> destination, out int bytesWritten)
		{
			if (!destination.IsEmpty)
			{
				if (value.IsAscii)
				{
					destination[0] = (byte)value._value;
					bytesWritten = 1;
					return true;
				}
				if (1u < (uint)destination.Length)
				{
					if ((long)value.Value <= 2047L)
					{
						destination[0] = (byte)(value._value + 12288 >> 6);
						destination[1] = (byte)((value._value & 0x3F) + 128);
						bytesWritten = 2;
						return true;
					}
					if (2u < (uint)destination.Length)
					{
						if ((long)value.Value <= 65535L)
						{
							destination[0] = (byte)(value._value + 917504 >> 12);
							destination[1] = (byte)(((value._value & 0xFC0) >> 6) + 128);
							destination[2] = (byte)((value._value & 0x3F) + 128);
							bytesWritten = 3;
							return true;
						}
						if (3u < (uint)destination.Length)
						{
							destination[0] = (byte)(value._value + 62914560 >> 18);
							destination[1] = (byte)(((value._value & 0x3F000) >> 12) + 128);
							destination[2] = (byte)(((value._value & 0xFC0) >> 6) + 128);
							destination[3] = (byte)((value._value & 0x3F) + 128);
							bytesWritten = 4;
							return true;
						}
					}
				}
			}
			bytesWritten = 0;
			return false;
		}

		public static bool TryGetRuneAt(string input, int index, out Rune value)
		{
			int num = ReadRuneFromString(input, index);
			if (num >= 0)
			{
				value = UnsafeCreate((uint)num);
				return true;
			}
			value = default(Rune);
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Rune UnsafeCreate(uint scalarValue)
		{
			return new Rune(scalarValue, unused: false);
		}

		public static double GetNumericValue(Rune value)
		{
			if (value.IsAscii)
			{
				uint num = value._value - 48;
				if (num > 9)
				{
					return -1.0;
				}
				return num;
			}
			return CharUnicodeInfo.GetNumericValue(value.Value);
		}

		public static UnicodeCategory GetUnicodeCategory(Rune value)
		{
			if (value.IsAscii)
			{
				return (UnicodeCategory)(AsciiCharInfo[value.Value] & 0x1F);
			}
			return GetUnicodeCategoryNonAscii(value);
		}

		private static UnicodeCategory GetUnicodeCategoryNonAscii(Rune value)
		{
			return CharUnicodeInfo.GetUnicodeCategory(value.Value);
		}

		private static bool IsCategoryLetter(UnicodeCategory category)
		{
			return UnicodeUtility.IsInRangeInclusive((uint)category, 0u, 4u);
		}

		private static bool IsCategoryLetterOrDecimalDigit(UnicodeCategory category)
		{
			if (!UnicodeUtility.IsInRangeInclusive((uint)category, 0u, 4u))
			{
				return category == UnicodeCategory.DecimalDigitNumber;
			}
			return true;
		}

		private static bool IsCategoryNumber(UnicodeCategory category)
		{
			return UnicodeUtility.IsInRangeInclusive((uint)category, 8u, 10u);
		}

		private static bool IsCategoryPunctuation(UnicodeCategory category)
		{
			return UnicodeUtility.IsInRangeInclusive((uint)category, 18u, 24u);
		}

		private static bool IsCategorySeparator(UnicodeCategory category)
		{
			return UnicodeUtility.IsInRangeInclusive((uint)category, 11u, 13u);
		}

		private static bool IsCategorySymbol(UnicodeCategory category)
		{
			return UnicodeUtility.IsInRangeInclusive((uint)category, 25u, 28u);
		}

		public static bool IsControl(Rune value)
		{
			return ((value._value + 1) & 0xFFFFFF7Fu) <= 32;
		}

		public static bool IsDigit(Rune value)
		{
			if (value.IsAscii)
			{
				return UnicodeUtility.IsInRangeInclusive(value._value, 48u, 57u);
			}
			return GetUnicodeCategoryNonAscii(value) == UnicodeCategory.DecimalDigitNumber;
		}

		public static bool IsLetter(Rune value)
		{
			if (value.IsAscii)
			{
				return ((value._value - 65) & 0xFFFFFFDFu) <= 25;
			}
			return IsCategoryLetter(GetUnicodeCategoryNonAscii(value));
		}

		public static bool IsLetterOrDigit(Rune value)
		{
			if (value.IsAscii)
			{
				return (AsciiCharInfo[value.Value] & 0x40) != 0;
			}
			return IsCategoryLetterOrDecimalDigit(GetUnicodeCategoryNonAscii(value));
		}

		public static bool IsLower(Rune value)
		{
			if (value.IsAscii)
			{
				return UnicodeUtility.IsInRangeInclusive(value._value, 97u, 122u);
			}
			return GetUnicodeCategoryNonAscii(value) == UnicodeCategory.LowercaseLetter;
		}

		public static bool IsNumber(Rune value)
		{
			if (value.IsAscii)
			{
				return UnicodeUtility.IsInRangeInclusive(value._value, 48u, 57u);
			}
			return IsCategoryNumber(GetUnicodeCategoryNonAscii(value));
		}

		public static bool IsPunctuation(Rune value)
		{
			return IsCategoryPunctuation(GetUnicodeCategory(value));
		}

		public static bool IsSeparator(Rune value)
		{
			return IsCategorySeparator(GetUnicodeCategory(value));
		}

		public static bool IsSymbol(Rune value)
		{
			return IsCategorySymbol(GetUnicodeCategory(value));
		}

		public static bool IsUpper(Rune value)
		{
			if (value.IsAscii)
			{
				return UnicodeUtility.IsInRangeInclusive(value._value, 65u, 90u);
			}
			return GetUnicodeCategoryNonAscii(value) == UnicodeCategory.UppercaseLetter;
		}

		public static bool IsWhiteSpace(Rune value)
		{
			if (value.IsAscii)
			{
				return (AsciiCharInfo[value.Value] & 0x80) != 0;
			}
			if (value.IsBmp)
			{
				return CharUnicodeInfo.GetIsWhiteSpace((char)value._value);
			}
			return false;
		}

		public static Rune ToLower(Rune value, CultureInfo culture)
		{
			if (culture == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.culture);
			}
			if (GlobalizationMode.Invariant)
			{
				return ToLowerInvariant(value);
			}
			return ChangeCaseCultureAware(value, culture.TextInfo, toUpper: false);
		}

		public static Rune ToLowerInvariant(Rune value)
		{
			if (value.IsAscii)
			{
				return UnsafeCreate(Utf16Utility.ConvertAllAsciiCharsInUInt32ToLowercase(value._value));
			}
			if (GlobalizationMode.Invariant)
			{
				return UnsafeCreate(CharUnicodeInfo.ToLower(value._value));
			}
			return ChangeCaseCultureAware(value, TextInfo.Invariant, toUpper: false);
		}

		public static Rune ToUpper(Rune value, CultureInfo culture)
		{
			if (culture == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.culture);
			}
			if (GlobalizationMode.Invariant)
			{
				return ToUpperInvariant(value);
			}
			return ChangeCaseCultureAware(value, culture.TextInfo, toUpper: true);
		}

		public static Rune ToUpperInvariant(Rune value)
		{
			if (value.IsAscii)
			{
				return UnsafeCreate(Utf16Utility.ConvertAllAsciiCharsInUInt32ToUppercase(value._value));
			}
			if (GlobalizationMode.Invariant)
			{
				return UnsafeCreate(CharUnicodeInfo.ToUpper(value._value));
			}
			return ChangeCaseCultureAware(value, TextInfo.Invariant, toUpper: true);
		}

		int IComparable.CompareTo(object obj)
		{
			if (obj == null)
			{
				return 1;
			}
			if (obj is Rune other)
			{
				return CompareTo(other);
			}
			throw new ArgumentException(SR.Arg_MustBeRune);
		}
	}
	public ref struct SpanLineEnumerator
	{
		private ReadOnlySpan<char> _remaining;

		private ReadOnlySpan<char> _current;

		private bool _isEnumeratorActive;

		public ReadOnlySpan<char> Current => _current;

		internal SpanLineEnumerator(ReadOnlySpan<char> buffer)
		{
			_remaining = buffer;
			_current = default(ReadOnlySpan<char>);
			_isEnumeratorActive = true;
		}

		public SpanLineEnumerator GetEnumerator()
		{
			return this;
		}

		public bool MoveNext()
		{
			if (!_isEnumeratorActive)
			{
				return false;
			}
			int stride;
			int num = string.IndexOfNewlineChar(_remaining, out stride);
			if (num >= 0)
			{
				_current = _remaining.Slice(0, num);
				_remaining = _remaining.Slice(num + stride);
			}
			else
			{
				_current = _remaining;
				_remaining = default(ReadOnlySpan<char>);
				_isEnumeratorActive = false;
			}
			return true;
		}
	}
	public ref struct SpanRuneEnumerator
	{
		private ReadOnlySpan<char> _remaining;

		private Rune _current;

		public Rune Current => _current;

		internal SpanRuneEnumerator(ReadOnlySpan<char> buffer)
		{
			_remaining = buffer;
			_current = default(Rune);
		}

		public SpanRuneEnumerator GetEnumerator()
		{
			return this;
		}

		public bool MoveNext()
		{
			if (_remaining.IsEmpty)
			{
				_current = default(Rune);
				return false;
			}
			int num = Rune.ReadFirstRuneFromUtf16Buffer(_remaining);
			if (num < 0)
			{
				num = Rune.ReplacementChar.Value;
			}
			_current = Rune.UnsafeCreate((uint)num);
			_remaining = _remaining.Slice(_current.Utf16SequenceLength);
			return true;
		}
	}
	public struct StringRuneEnumerator : IEnumerable<Rune>, System.Collections.IEnumerable, IEnumerator<Rune>, IDisposable, System.Collections.IEnumerator
	{
		private readonly string _string;

		private Rune _current;

		private int _nextIndex;

		public Rune Current => _current;

		object? System.Collections.IEnumerator.Current => _current;

		internal StringRuneEnumerator(string value)
		{
			_string = value;
			_current = default(Rune);
			_nextIndex = 0;
		}

		public StringRuneEnumerator GetEnumerator()
		{
			return this;
		}

		public bool MoveNext()
		{
			if ((uint)_nextIndex >= _string.Length)
			{
				_current = default(Rune);
				return false;
			}
			if (!Rune.TryGetRuneAt(_string, _nextIndex, out _current))
			{
				_current = Rune.ReplacementChar;
			}
			_nextIndex += _current.Utf16SequenceLength;
			return true;
		}

		void IDisposable.Dispose()
		{
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return this;
		}

		IEnumerator<Rune> IEnumerable<Rune>.GetEnumerator()
		{
			return this;
		}

		void System.Collections.IEnumerator.Reset()
		{
			_current = default(Rune);
			_nextIndex = 0;
		}
	}
	internal sealed class TranscodingStream : Stream
	{
		private readonly Encoding _innerEncoding;

		private readonly Encoding _thisEncoding;

		private Stream _innerStream;

		private readonly bool _leaveOpen;

		private Encoder _innerEncoder;

		private Decoder _thisDecoder;

		private Encoder _thisEncoder;

		private Decoder _innerDecoder;

		private int _readCharBufferMaxSize;

		private byte[] _readBuffer;

		private int _readBufferOffset;

		private int _readBufferCount;

		public override bool CanRead => _innerStream?.CanRead ?? false;

		public override bool CanSeek => false;

		public override bool CanWrite => _innerStream?.CanWrite ?? false;

		public override long Length
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_UnseekableStream);
			}
		}

		public override long Position
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_UnseekableStream);
			}
			set
			{
				ThrowHelper.ThrowNotSupportedException_UnseekableStream();
			}
		}

		internal TranscodingStream(Stream innerStream, Encoding innerEncoding, Encoding thisEncoding, bool leaveOpen)
		{
			_innerStream = innerStream;
			_leaveOpen = leaveOpen;
			_innerEncoding = innerEncoding;
			_thisEncoding = thisEncoding;
		}

		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return TaskToApm.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state);
		}

		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);
		}

		protected override void Dispose(bool disposing)
		{
			if (_innerStream != null)
			{
				ArraySegment<byte> arraySegment = FinalFlushWriteBuffers();
				if (arraySegment.Count != 0)
				{
					_innerStream.Write(arraySegment);
				}
				Stream innerStream = _innerStream;
				_innerStream = null;
				if (!_leaveOpen)
				{
					innerStream.Dispose();
				}
			}
		}

		public override ValueTask DisposeAsync()
		{
			if (_innerStream == null)
			{
				return default(ValueTask);
			}
			ArraySegment<byte> pendingData2 = FinalFlushWriteBuffers();
			if (pendingData2.Count == 0)
			{
				Stream innerStream = _innerStream;
				_innerStream = null;
				if (!_leaveOpen)
				{
					return innerStream.DisposeAsync();
				}
				return default(ValueTask);
			}
			return DisposeAsyncCore(pendingData2);
			async ValueTask DisposeAsyncCore(ArraySegment<byte> pendingData)
			{
				Stream innerStream2 = _innerStream;
				_innerStream = null;
				await innerStream2.WriteAsync(pendingData.AsMemory()).ConfigureAwait(continueOnCapturedContext: false);
				if (!_leaveOpen)
				{
					await innerStream2.DisposeAsync().ConfigureAwait(continueOnCapturedContext: false);
				}
			}
		}

		public override int EndRead(IAsyncResult asyncResult)
		{
			return TaskToApm.End<int>(asyncResult);
		}

		public override void EndWrite(IAsyncResult asyncResult)
		{
			TaskToApm.End(asyncResult);
		}

		[MemberNotNull(new string[] { "_innerDecoder", "_thisEncoder", "_readBuffer" })]
		private void EnsurePreReadConditions()
		{
			ThrowIfDisposed();
			if (_innerDecoder == null)
			{
				InitializeReadDataStructures();
			}
			void InitializeReadDataStructures()
			{
				if (!CanRead)
				{
					ThrowHelper.ThrowNotSupportedException_UnreadableStream();
				}
				_innerDecoder = _innerEncoding.GetDecoder();
				_thisEncoder = _thisEncoding.GetEncoder();
				_readCharBufferMaxSize = _innerEncoding.GetMaxCharCount(4096);
				_readBuffer = GC.AllocateUninitializedArray<byte>(_thisEncoding.GetMaxByteCount(_readCharBufferMaxSize));
			}
		}

		[MemberNotNull(new string[] { "_thisDecoder", "_innerEncoder" })]
		private void EnsurePreWriteConditions()
		{
			ThrowIfDisposed();
			if (_innerEncoder == null)
			{
				InitializeReadDataStructures();
			}
			void InitializeReadDataStructures()
			{
				if (!CanWrite)
				{
					ThrowHelper.ThrowNotSupportedException_UnwritableStream();
				}
				_innerEncoder = _innerEncoding.GetEncoder();
				_thisDecoder = _thisEncoding.GetDecoder();
			}
		}

		private ArraySegment<byte> FinalFlushWriteBuffers()
		{
			if (_thisDecoder == null || _innerEncoder == null)
			{
				return default(ArraySegment<byte>);
			}
			char[] chars = Array.Empty<char>();
			int num = _thisDecoder.GetCharCount(Array.Empty<byte>(), 0, 0, flush: true);
			if (num > 0)
			{
				chars = new char[num];
				num = _thisDecoder.GetChars(Array.Empty<byte>(), 0, 0, chars, 0, flush: true);
			}
			byte[] array = Array.Empty<byte>();
			int num2 = _innerEncoder.GetByteCount(chars, 0, num, flush: true);
			if (num2 > 0)
			{
				array = new byte[num2];
				num2 = _innerEncoder.GetBytes(chars, 0, num, array, 0, flush: true);
			}
			return new ArraySegment<byte>(array, 0, num2);
		}

		public override void Flush()
		{
			ThrowIfDisposed();
			_innerStream.Flush();
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			ThrowIfDisposed();
			return _innerStream.FlushAsync(cancellationToken);
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			return Read(new Span<byte>(buffer, offset, count));
		}

		public override int Read(Span<byte> buffer)
		{
			EnsurePreReadConditions();
			if (_readBufferCount == 0)
			{
				byte[] array = ArrayPool<byte>.Shared.Rent(4096);
				char[] array2 = ArrayPool<char>.Shared.Rent(_readCharBufferMaxSize);
				try
				{
					bool flag;
					int bytes;
					do
					{
						int num = _innerStream.Read(array, 0, 4096);
						flag = num == 0;
						int chars = _innerDecoder.GetChars(array, 0, num, array2, 0, flag);
						bytes = _thisEncoder.GetBytes(array2, 0, chars, _readBuffer, 0, flag);
					}
					while (!flag && bytes == 0);
					_readBufferOffset = 0;
					_readBufferCount = bytes;
				}
				finally
				{
					ArrayPool<byte>.Shared.Return(array);
					ArrayPool<char>.Shared.Return(array2);
				}
			}
			int num2 = Math.Min(_readBufferCount, buffer.Length);
			_readBuffer.AsSpan(_readBufferOffset, num2).CopyTo(buffer);
			_readBufferOffset += num2;
			_readBufferCount -= num2;
			return num2;
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			return ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
		{
			EnsurePreReadConditions();
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			return ReadAsyncCore(buffer, cancellationToken);
			async ValueTask<int> ReadAsyncCore(Memory<byte> buffer, CancellationToken cancellationToken)
			{
				if (_readBufferCount == 0)
				{
					byte[] rentedBytes = ArrayPool<byte>.Shared.Rent(4096);
					char[] rentedChars = ArrayPool<char>.Shared.Rent(_readCharBufferMaxSize);
					try
					{
						bool flag;
						int bytes;
						do
						{
							int num = await _innerStream.ReadAsync(rentedBytes.AsMemory(0, 4096), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
							flag = num == 0;
							int chars = _innerDecoder.GetChars(rentedBytes, 0, num, rentedChars, 0, flag);
							bytes = _thisEncoder.GetBytes(rentedChars, 0, chars, _readBuffer, 0, flag);
						}
						while (!flag && bytes == 0);
						_readBufferOffset = 0;
						_readBufferCount = bytes;
					}
					finally
					{
						ArrayPool<byte>.Shared.Return(rentedBytes);
						ArrayPool<char>.Shared.Return(rentedChars);
					}
				}
				int num2 = Math.Min(_readBufferCount, buffer.Length);
				_readBuffer.AsSpan(_readBufferOffset, num2).CopyTo(buffer.Span);
				_readBufferOffset += num2;
				_readBufferCount -= num2;
				return num2;
			}
		}

		public unsafe override int ReadByte()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out byte result);
			if (Read(new Span<byte>(&result, 1)) == 0)
			{
				return -1;
			}
			return result;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			throw new NotSupportedException(SR.NotSupported_UnseekableStream);
		}

		public override void SetLength(long value)
		{
			ThrowHelper.ThrowNotSupportedException_UnseekableStream();
		}

		[StackTraceHidden]
		private void ThrowIfDisposed()
		{
			if (_innerStream == null)
			{
				ThrowObjectDisposedException();
			}
		}

		[DoesNotReturn]
		[StackTraceHidden]
		private void ThrowObjectDisposedException()
		{
			ThrowHelper.ThrowObjectDisposedException_StreamClosed(GetType().Name);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			Write(new ReadOnlySpan<byte>(buffer, offset, count));
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			EnsurePreWriteConditions();
			if (buffer.IsEmpty)
			{
				return;
			}
			int minimumLength = Math.Clamp(buffer.Length, 4096, 1048576);
			char[] array = ArrayPool<char>.Shared.Rent(minimumLength);
			byte[] array2 = ArrayPool<byte>.Shared.Rent(minimumLength);
			try
			{
				bool completed;
				do
				{
					_thisDecoder.Convert(buffer, array, flush: false, out var bytesUsed, out var charsUsed, out completed);
					buffer = buffer.Slice(bytesUsed);
					Span<char> span = array.AsSpan(0, charsUsed);
					bool completed2;
					do
					{
						_innerEncoder.Convert(span, array2, flush: false, out var charsUsed2, out var bytesUsed2, out completed2);
						span = span.Slice(charsUsed2);
						_innerStream.Write(array2, 0, bytesUsed2);
					}
					while (!completed2);
				}
				while (!completed);
			}
			finally
			{
				ArrayPool<char>.Shared.Return(array);
				ArrayPool<byte>.Shared.Return(array2);
			}
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			return WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
		{
			EnsurePreWriteConditions();
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled(cancellationToken);
			}
			if (buffer.IsEmpty)
			{
				return ValueTask.CompletedTask;
			}
			return WriteAsyncCore(buffer, cancellationToken);
			async ValueTask WriteAsyncCore(ReadOnlyMemory<byte> remainingOuterEncodedBytes, CancellationToken cancellationToken)
			{
				int minimumLength = Math.Clamp(remainingOuterEncodedBytes.Length, 4096, 1048576);
				char[] scratchChars = ArrayPool<char>.Shared.Rent(minimumLength);
				byte[] scratchBytes = ArrayPool<byte>.Shared.Rent(minimumLength);
				try
				{
					bool decoderFinished;
					do
					{
						_thisDecoder.Convert(remainingOuterEncodedBytes.Span, scratchChars, flush: false, out var bytesUsed, out var charsUsed, out decoderFinished);
						remainingOuterEncodedBytes = remainingOuterEncodedBytes.Slice(bytesUsed);
						ArraySegment<char> decodedChars = new ArraySegment<char>(scratchChars, 0, charsUsed);
						bool encoderFinished;
						do
						{
							_innerEncoder.Convert(decodedChars, scratchBytes, flush: false, out var charsUsed2, out var bytesUsed2, out encoderFinished);
							decodedChars = decodedChars.Slice(charsUsed2);
							await _innerStream.WriteAsync(new ReadOnlyMemory<byte>(scratchBytes, 0, bytesUsed2), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
						}
						while (!encoderFinished);
					}
					while (!decoderFinished);
				}
				finally
				{
					ArrayPool<char>.Shared.Return(scratchChars);
					ArrayPool<byte>.Shared.Return(scratchBytes);
				}
			}
		}

		public unsafe override void WriteByte(byte value)
		{
			Write(new ReadOnlySpan<byte>(&value, 1));
		}
	}
	[Flags]
	internal enum TrimType
	{
		Head = 1,
		Tail = 2,
		Both = 3
	}
	public class UnicodeEncoding : Encoding
	{
		private sealed class Decoder : DecoderNLS
		{
			internal int lastByte = -1;

			internal char lastChar;

			internal override bool HasState
			{
				get
				{
					if (lastByte == -1)
					{
						return lastChar != '\0';
					}
					return true;
				}
			}

			public Decoder(UnicodeEncoding encoding)
				: base(encoding)
			{
			}

			public override void Reset()
			{
				lastByte = -1;
				lastChar = '\0';
				if (_fallbackBuffer != null)
				{
					_fallbackBuffer.Reset();
				}
			}
		}

		internal static readonly UnicodeEncoding s_bigEndianDefault = new UnicodeEncoding(bigEndian: true, byteOrderMark: true);

		internal static readonly UnicodeEncoding s_littleEndianDefault = new UnicodeEncoding(bigEndian: false, byteOrderMark: true);

		private readonly bool isThrowException;

		private readonly bool bigEndian;

		private readonly bool byteOrderMark;

		public const int CharSize = 2;

		public override ReadOnlySpan<byte> Preamble
		{
			get
			{
				if (!(GetType() != typeof(UnicodeEncoding)))
				{
					if (byteOrderMark)
					{
						if (bigEndian)
						{
							return new byte[2] { 254, 255 };
						}
						return new byte[2] { 255, 254 };
					}
					return default(ReadOnlySpan<byte>);
				}
				return new ReadOnlySpan<byte>(GetPreamble());
			}
		}

		public UnicodeEncoding()
			: this(bigEndian: false, byteOrderMark: true)
		{
		}

		public UnicodeEncoding(bool bigEndian, bool byteOrderMark)
			: base(bigEndian ? 1201 : 1200)
		{
			this.bigEndian = bigEndian;
			this.byteOrderMark = byteOrderMark;
		}

		public UnicodeEncoding(bool bigEndian, bool byteOrderMark, bool throwOnInvalidBytes)
			: this(bigEndian, byteOrderMark)
		{
			isThrowException = throwOnInvalidBytes;
			if (isThrowException)
			{
				SetDefaultFallbacks();
			}
		}

		internal sealed override void SetDefaultFallbacks()
		{
			if (isThrowException)
			{
				encoderFallback = System.Text.EncoderFallback.ExceptionFallback;
				decoderFallback = System.Text.DecoderFallback.ExceptionFallback;
			}
			else
			{
				encoderFallback = new EncoderReplacementFallback("\ufffd");
				decoderFallback = new DecoderReplacementFallback("\ufffd");
			}
		}

		public unsafe override int GetByteCount(char[] chars, int index, int count)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return 0;
			}
			fixed (char* ptr = chars)
			{
				return GetByteCount(ptr + index, count, null);
			}
		}

		public unsafe override int GetByteCount(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			fixed (char* pChars = s)
			{
				return GetByteCount(pChars, s.Length, null);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetByteCount(char* chars, int count)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetByteCount(chars, count, null);
		}

		public unsafe override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (s == null || bytes == null)
			{
				throw new ArgumentNullException((s == null) ? "s" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (s.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("s", SR.ArgumentOutOfRange_IndexCount);
			}
			if (byteIndex < 0 || byteIndex > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("byteIndex", SR.ArgumentOutOfRange_Index);
			}
			int byteCount = bytes.Length - byteIndex;
			fixed (char* ptr = s)
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference<byte>(bytes))
				{
					return GetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, byteCount, null);
				}
			}
		}

		public unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (byteIndex < 0 || byteIndex > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("byteIndex", SR.ArgumentOutOfRange_Index);
			}
			if (charCount == 0)
			{
				return 0;
			}
			int byteCount = bytes.Length - byteIndex;
			fixed (char* ptr = chars)
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference<byte>(bytes))
				{
					return GetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, byteCount, null);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetBytes(chars, charCount, bytes, byteCount, null);
		}

		public unsafe override int GetCharCount(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return 0;
			}
			fixed (byte* ptr = bytes)
			{
				return GetCharCount(ptr + index, count, null);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetCharCount(byte* bytes, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetCharCount(bytes, count, null);
		}

		public unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (byteIndex < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (charIndex < 0 || charIndex > chars.Length)
			{
				throw new ArgumentOutOfRangeException("charIndex", SR.ArgumentOutOfRange_Index);
			}
			if (byteCount == 0)
			{
				return 0;
			}
			int charCount = chars.Length - charIndex;
			fixed (byte* ptr = bytes)
			{
				fixed (char* ptr2 = &MemoryMarshal.GetReference<char>(chars))
				{
					return GetChars(ptr + byteIndex, byteCount, ptr2 + charIndex, charCount, null);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetChars(bytes, byteCount, chars, charCount, null);
		}

		public unsafe override string GetString(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return string.Empty;
			}
			fixed (byte* ptr = bytes)
			{
				return string.CreateStringFromEncoding(ptr + index, count, this);
			}
		}

		internal unsafe sealed override int GetByteCount(char* chars, int count, EncoderNLS encoder)
		{
			int num = count << 1;
			if (num < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			char* charStart = chars;
			char* ptr = chars + count;
			char c = '\0';
			bool flag = false;
			EncoderFallbackBuffer encoderFallbackBuffer = null;
			if (encoder != null)
			{
				c = encoder._charLeftOver;
				if (c > '\0')
				{
					num += 2;
				}
				if (encoder.InternalHasFallbackBuffer)
				{
					encoderFallbackBuffer = encoder.FallbackBuffer;
					if (encoderFallbackBuffer.Remaining > 0)
					{
						throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty, EncodingName, encoder.Fallback?.GetType()));
					}
					encoderFallbackBuffer.InternalInitialize(charStart, ptr, encoder, setEncoder: false);
				}
			}
			while (true)
			{
				char num2 = encoderFallbackBuffer?.InternalGetNextChar() ?? '\0';
				char c2 = num2;
				char* chars2;
				if (num2 != 0 || chars < ptr)
				{
					if (c2 == '\0')
					{
						if ((bigEndian ^ BitConverter.IsLittleEndian) && ((int)chars & 3) == 0 && c == '\0')
						{
							ulong* ptr2 = (ulong*)(ptr - 3);
							ulong* ptr3;
							for (ptr3 = (ulong*)chars; ptr3 < ptr2; ptr3++)
							{
								if ((0x8000800080008000uL & *ptr3) == 0L)
								{
									continue;
								}
								ulong num3 = (0xF800F800F800F800uL & *ptr3) ^ 0xD800D800D800D800uL;
								if ((num3 & 0xFFFF000000000000uL) == 0L || (num3 & 0xFFFF00000000L) == 0L || (num3 & 0xFFFF0000u) == 0L || (num3 & 0xFFFF) == 0L)
								{
									long num4 = -287953294993589248L & (long)(*ptr3);
									if (!BitConverter.IsLittleEndian)
									{
									}
									if (num4 != -2593835887162763264L)
									{
										break;
									}
								}
							}
							chars = (char*)ptr3;
							if (chars >= ptr)
							{
								goto IL_0294;
							}
						}
						c2 = *chars;
						chars++;
					}
					else
					{
						num += 2;
					}
					if (c2 >= '\ud800' && c2 <= '\udfff')
					{
						if (c2 <= '\udbff')
						{
							if (c > '\0')
							{
								chars--;
								num -= 2;
								if (encoderFallbackBuffer == null)
								{
									encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
									encoderFallbackBuffer.InternalInitialize(charStart, ptr, encoder, setEncoder: false);
								}
								chars2 = chars;
								encoderFallbackBuffer.InternalFallback(c, ref chars2);
								chars = chars2;
								c = '\0';
							}
							else
							{
								c = c2;
							}
						}
						else if (c == '\0')
						{
							num -= 2;
							if (encoderFallbackBuffer == null)
							{
								encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
								encoderFallbackBuffer.InternalInitialize(charStart, ptr, encoder, setEncoder: false);
							}
							chars2 = chars;
							encoderFallbackBuffer.InternalFallback(c2, ref chars2);
							chars = chars2;
						}
						else
						{
							c = '\0';
						}
					}
					else if (c > '\0')
					{
						chars--;
						if (encoderFallbackBuffer == null)
						{
							encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
							encoderFallbackBuffer.InternalInitialize(charStart, ptr, encoder, setEncoder: false);
						}
						chars2 = chars;
						encoderFallbackBuffer.InternalFallback(c, ref chars2);
						chars = chars2;
						num -= 2;
						c = '\0';
					}
					continue;
				}
				goto IL_0294;
				IL_0294:
				if (c <= '\0')
				{
					break;
				}
				num -= 2;
				if (encoder != null && !encoder.MustFlush)
				{
					break;
				}
				if (flag)
				{
					throw new ArgumentException(SR.Format(SR.Argument_RecursiveFallback, c), "chars");
				}
				if (encoderFallbackBuffer == null)
				{
					encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
					encoderFallbackBuffer.InternalInitialize(charStart, ptr, encoder, setEncoder: false);
				}
				chars2 = chars;
				encoderFallbackBuffer.InternalFallback(c, ref chars2);
				chars = chars2;
				c = '\0';
				flag = true;
			}
			return num;
		}

		internal unsafe sealed override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS encoder)
		{
			char c = '\0';
			bool flag = false;
			byte* ptr = bytes + byteCount;
			char* ptr2 = chars + charCount;
			byte* ptr3 = bytes;
			char* ptr4 = chars;
			EncoderFallbackBuffer encoderFallbackBuffer = null;
			if (encoder != null)
			{
				c = encoder._charLeftOver;
				if (encoder.InternalHasFallbackBuffer)
				{
					encoderFallbackBuffer = encoder.FallbackBuffer;
					if (encoderFallbackBuffer.Remaining > 0 && encoder._throwOnOverflow)
					{
						throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty, EncodingName, encoder.Fallback?.GetType()));
					}
					encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: false);
				}
			}
			while (true)
			{
				char num = encoderFallbackBuffer?.InternalGetNextChar() ?? '\0';
				char c2 = num;
				char* chars2;
				if (num != 0 || chars < ptr2)
				{
					if (c2 == '\0')
					{
						if ((bigEndian ^ BitConverter.IsLittleEndian) && ((int)chars & 3) == 0 && c == '\0')
						{
							ulong* ptr5 = (ulong*)(chars - 3 + ((ptr - bytes >> 1 < ptr2 - chars) ? (ptr - bytes >> 1) : (ptr2 - chars)));
							ulong* ptr6 = (ulong*)chars;
							ulong* ptr7 = (ulong*)bytes;
							while (ptr6 < ptr5)
							{
								if ((0x8000800080008000uL & *ptr6) != 0L)
								{
									ulong num2 = (0xF800F800F800F800uL & *ptr6) ^ 0xD800D800D800D800uL;
									if ((num2 & 0xFFFF000000000000uL) == 0L || (num2 & 0xFFFF00000000L) == 0L || (num2 & 0xFFFF0000u) == 0L || (num2 & 0xFFFF) == 0L)
									{
										long num3 = -287953294993589248L & (long)(*ptr6);
										if (!BitConverter.IsLittleEndian)
										{
										}
										if (num3 != -2593835887162763264L)
										{
											break;
										}
									}
								}
								Unsafe.WriteUnaligned(ptr7, *ptr6);
								ptr6++;
								ptr7++;
							}
							chars = (char*)ptr6;
							bytes = (byte*)ptr7;
							if (chars >= ptr2)
							{
								goto IL_039e;
							}
						}
						c2 = *chars;
						chars++;
					}
					if (c2 >= '\ud800' && c2 <= '\udfff')
					{
						if (c2 <= '\udbff')
						{
							if (c > '\0')
							{
								chars--;
								if (encoderFallbackBuffer == null)
								{
									encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
									encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: true);
								}
								chars2 = chars;
								encoderFallbackBuffer.InternalFallback(c, ref chars2);
								chars = chars2;
								c = '\0';
							}
							else
							{
								c = c2;
							}
							continue;
						}
						if (c == '\0')
						{
							if (encoderFallbackBuffer == null)
							{
								encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
								encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: true);
							}
							chars2 = chars;
							encoderFallbackBuffer.InternalFallback(c2, ref chars2);
							chars = chars2;
							continue;
						}
						if (bytes + 3 >= ptr)
						{
							if (encoderFallbackBuffer != null && encoderFallbackBuffer.bFallingBack)
							{
								encoderFallbackBuffer.MovePrevious();
								encoderFallbackBuffer.MovePrevious();
							}
							else
							{
								chars -= 2;
							}
							ThrowBytesOverflow(encoder, bytes == ptr3);
							c = '\0';
							goto IL_039e;
						}
						if (bigEndian)
						{
							*(bytes++) = (byte)((int)c >> 8);
							*(bytes++) = (byte)c;
						}
						else
						{
							*(bytes++) = (byte)c;
							*(bytes++) = (byte)((int)c >> 8);
						}
						c = '\0';
					}
					else if (c > '\0')
					{
						chars--;
						if (encoderFallbackBuffer == null)
						{
							encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
							encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: true);
						}
						chars2 = chars;
						encoderFallbackBuffer.InternalFallback(c, ref chars2);
						chars = chars2;
						c = '\0';
						continue;
					}
					if (bytes + 1 < ptr)
					{
						if (bigEndian)
						{
							*(bytes++) = (byte)((int)c2 >> 8);
							*(bytes++) = (byte)c2;
						}
						else
						{
							*(bytes++) = (byte)c2;
							*(bytes++) = (byte)((int)c2 >> 8);
						}
						continue;
					}
					if (encoderFallbackBuffer != null && encoderFallbackBuffer.bFallingBack)
					{
						encoderFallbackBuffer.MovePrevious();
					}
					else
					{
						chars--;
					}
					ThrowBytesOverflow(encoder, bytes == ptr3);
				}
				goto IL_039e;
				IL_039e:
				if (c <= '\0' || (encoder != null && !encoder.MustFlush))
				{
					break;
				}
				if (flag)
				{
					throw new ArgumentException(SR.Format(SR.Argument_RecursiveFallback, c), "chars");
				}
				if (encoderFallbackBuffer == null)
				{
					encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
					encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: true);
				}
				chars2 = chars;
				encoderFallbackBuffer.InternalFallback(c, ref chars2);
				chars = chars2;
				c = '\0';
				flag = true;
			}
			if (encoder != null)
			{
				encoder._charLeftOver = c;
				encoder._charsUsed = (int)(chars - ptr4);
			}
			return (int)(bytes - ptr3);
		}

		internal unsafe sealed override int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
		{
			Decoder decoder = (Decoder)baseDecoder;
			byte* ptr = bytes + count;
			byte* byteStart = bytes;
			int num = -1;
			char c = '\0';
			int num2 = count >> 1;
			DecoderFallbackBuffer decoderFallbackBuffer = null;
			if (decoder != null)
			{
				num = decoder.lastByte;
				c = decoder.lastChar;
				if (c > '\0')
				{
					num2++;
				}
				if (num >= 0 && (count & 1) == 1)
				{
					num2++;
				}
			}
			while (bytes < ptr)
			{
				if ((bigEndian ^ BitConverter.IsLittleEndian) && ((int)bytes & 3) == 0 && num == -1 && c == '\0')
				{
					ulong* ptr2 = (ulong*)(ptr - 7);
					ulong* ptr3;
					for (ptr3 = (ulong*)bytes; ptr3 < ptr2; ptr3++)
					{
						if ((0x8000800080008000uL & *ptr3) == 0L)
						{
							continue;
						}
						ulong num3 = (0xF800F800F800F800uL & *ptr3) ^ 0xD800D800D800D800uL;
						if ((num3 & 0xFFFF000000000000uL) == 0L || (num3 & 0xFFFF00000000L) == 0L || (num3 & 0xFFFF0000u) == 0L || (num3 & 0xFFFF) == 0L)
						{
							long num4 = -287953294993589248L & (long)(*ptr3);
							if (!BitConverter.IsLittleEndian)
							{
							}
							if (num4 != -2593835887162763264L)
							{
								break;
							}
						}
					}
					bytes = (byte*)ptr3;
					if (bytes >= ptr)
					{
						break;
					}
				}
				if (num < 0)
				{
					num = *(bytes++);
					if (bytes >= ptr)
					{
						break;
					}
				}
				char c2 = ((!bigEndian) ? ((char)((*(bytes++) << 8) | num)) : ((char)((num << 8) | *(bytes++))));
				num = -1;
				if (c2 >= '\ud800' && c2 <= '\udfff')
				{
					if (c2 <= '\udbff')
					{
						if (c > '\0')
						{
							num2--;
							byte[] array = null;
							array = ((!bigEndian) ? new byte[2]
							{
								(byte)c,
								(byte)((int)c >> 8)
							} : new byte[2]
							{
								(byte)((int)c >> 8),
								(byte)c
							});
							if (decoderFallbackBuffer == null)
							{
								decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
								decoderFallbackBuffer.InternalInitialize(byteStart, null);
							}
							num2 += decoderFallbackBuffer.InternalFallback(array, bytes);
						}
						c = c2;
					}
					else if (c == '\0')
					{
						num2--;
						byte[] array2 = null;
						array2 = ((!bigEndian) ? new byte[2]
						{
							(byte)c2,
							(byte)((int)c2 >> 8)
						} : new byte[2]
						{
							(byte)((int)c2 >> 8),
							(byte)c2
						});
						if (decoderFallbackBuffer == null)
						{
							decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
							decoderFallbackBuffer.InternalInitialize(byteStart, null);
						}
						num2 += decoderFallbackBuffer.InternalFallback(array2, bytes);
					}
					else
					{
						c = '\0';
					}
				}
				else if (c > '\0')
				{
					num2--;
					byte[] array3 = null;
					array3 = ((!bigEndian) ? new byte[2]
					{
						(byte)c,
						(byte)((int)c >> 8)
					} : new byte[2]
					{
						(byte)((int)c >> 8),
						(byte)c
					});
					if (decoderFallbackBuffer == null)
					{
						decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
						decoderFallbackBuffer.InternalInitialize(byteStart, null);
					}
					num2 += decoderFallbackBuffer.InternalFallback(array3, bytes);
					c = '\0';
				}
			}
			if (decoder == null || decoder.MustFlush)
			{
				if (c > '\0')
				{
					num2--;
					byte[] array4 = null;
					array4 = ((!bigEndian) ? new byte[2]
					{
						(byte)c,
						(byte)((int)c >> 8)
					} : new byte[2]
					{
						(byte)((int)c >> 8),
						(byte)c
					});
					if (decoderFallbackBuffer == null)
					{
						decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
						decoderFallbackBuffer.InternalInitialize(byteStart, null);
					}
					num2 += decoderFallbackBuffer.InternalFallback(array4, bytes);
					c = '\0';
				}
				if (num >= 0)
				{
					if (decoderFallbackBuffer == null)
					{
						decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
						decoderFallbackBuffer.InternalInitialize(byteStart, null);
					}
					num2 += decoderFallbackBuffer.InternalFallback(new byte[1] { (byte)num }, bytes);
					num = -1;
				}
			}
			if (c > '\0')
			{
				num2--;
			}
			return num2;
		}

		internal unsafe sealed override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
		{
			Decoder decoder = (Decoder)baseDecoder;
			int num = -1;
			char c = '\0';
			if (decoder != null)
			{
				num = decoder.lastByte;
				c = decoder.lastChar;
			}
			DecoderFallbackBuffer decoderFallbackBuffer = null;
			byte* ptr = bytes + byteCount;
			char* ptr2 = chars + charCount;
			byte* ptr3 = bytes;
			char* ptr4 = chars;
			while (bytes < ptr)
			{
				if ((bigEndian ^ BitConverter.IsLittleEndian) && ((int)chars & 3) == 0 && num == -1 && c == '\0')
				{
					ulong* ptr5 = (ulong*)(bytes - 7 + ((ptr - bytes >> 1 < ptr2 - chars) ? (ptr - bytes) : (ptr2 - chars << 1)));
					ulong* ptr6 = (ulong*)bytes;
					ulong* ptr7 = (ulong*)chars;
					while (ptr6 < ptr5)
					{
						if ((0x8000800080008000uL & *ptr6) != 0L)
						{
							ulong num2 = (0xF800F800F800F800uL & *ptr6) ^ 0xD800D800D800D800uL;
							if ((num2 & 0xFFFF000000000000uL) == 0L || (num2 & 0xFFFF00000000L) == 0L || (num2 & 0xFFFF0000u) == 0L || (num2 & 0xFFFF) == 0L)
							{
								long num3 = -287953294993589248L & (long)(*ptr6);
								if (!BitConverter.IsLittleEndian)
								{
								}
								if (num3 != -2593835887162763264L)
								{
									break;
								}
							}
						}
						Unsafe.WriteUnaligned(ptr7, *ptr6);
						ptr6++;
						ptr7++;
					}
					chars = (char*)ptr7;
					bytes = (byte*)ptr6;
					if (bytes >= ptr)
					{
						break;
					}
				}
				if (num < 0)
				{
					num = *(bytes++);
					continue;
				}
				char c2 = ((!bigEndian) ? ((char)((*(bytes++) << 8) | num)) : ((char)((num << 8) | *(bytes++))));
				num = -1;
				if (c2 >= '\ud800' && c2 <= '\udfff')
				{
					if (c2 <= '\udbff')
					{
						if (c > '\0')
						{
							byte[] array = null;
							array = ((!bigEndian) ? new byte[2]
							{
								(byte)c,
								(byte)((int)c >> 8)
							} : new byte[2]
							{
								(byte)((int)c >> 8),
								(byte)c
							});
							if (decoderFallbackBuffer == null)
							{
								decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
								decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
							}
							char* chars2 = chars;
							bool flag = decoderFallbackBuffer.InternalFallback(array, bytes, ref chars2);
							chars = chars2;
							if (!flag)
							{
								bytes -= 2;
								decoderFallbackBuffer.InternalReset();
								ThrowCharsOverflow(decoder, chars == ptr4);
								break;
							}
						}
						c = c2;
						continue;
					}
					if (c == '\0')
					{
						byte[] array2 = null;
						array2 = ((!bigEndian) ? new byte[2]
						{
							(byte)c2,
							(byte)((int)c2 >> 8)
						} : new byte[2]
						{
							(byte)((int)c2 >> 8),
							(byte)c2
						});
						if (decoderFallbackBuffer == null)
						{
							decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
							decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
						}
						char* chars2 = chars;
						bool flag2 = decoderFallbackBuffer.InternalFallback(array2, bytes, ref chars2);
						chars = chars2;
						if (!flag2)
						{
							bytes -= 2;
							decoderFallbackBuffer.InternalReset();
							ThrowCharsOverflow(decoder, chars == ptr4);
							break;
						}
						continue;
					}
					if (chars >= ptr2 - 1)
					{
						bytes -= 2;
						ThrowCharsOverflow(decoder, chars == ptr4);
						break;
					}
					*(chars++) = c;
					c = '\0';
				}
				else if (c > '\0')
				{
					byte[] array3 = null;
					array3 = ((!bigEndian) ? new byte[2]
					{
						(byte)c,
						(byte)((int)c >> 8)
					} : new byte[2]
					{
						(byte)((int)c >> 8),
						(byte)c
					});
					if (decoderFallbackBuffer == null)
					{
						decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
						decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
					}
					char* chars2 = chars;
					bool flag3 = decoderFallbackBuffer.InternalFallback(array3, bytes, ref chars2);
					chars = chars2;
					if (!flag3)
					{
						bytes -= 2;
						decoderFallbackBuffer.InternalReset();
						ThrowCharsOverflow(decoder, chars == ptr4);
						break;
					}
					c = '\0';
				}
				if (chars >= ptr2)
				{
					bytes -= 2;
					ThrowCharsOverflow(decoder, chars == ptr4);
					break;
				}
				*(chars++) = c2;
			}
			if (decoder == null || decoder.MustFlush)
			{
				if (c > '\0')
				{
					byte[] array4 = null;
					array4 = ((!bigEndian) ? new byte[2]
					{
						(byte)c,
						(byte)((int)c >> 8)
					} : new byte[2]
					{
						(byte)((int)c >> 8),
						(byte)c
					});
					if (decoderFallbackBuffer == null)
					{
						decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
						decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
					}
					char* chars2 = chars;
					bool flag4 = decoderFallbackBuffer.InternalFallback(array4, bytes, ref chars2);
					chars = chars2;
					if (!flag4)
					{
						bytes -= 2;
						if (num >= 0)
						{
							bytes--;
						}
						decoderFallbackBuffer.InternalReset();
						ThrowCharsOverflow(decoder, chars == ptr4);
						bytes += 2;
						if (num >= 0)
						{
							bytes++;
						}
						goto IL_04de;
					}
					c = '\0';
				}
				if (num >= 0)
				{
					if (decoderFallbackBuffer == null)
					{
						decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
						decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
					}
					char* chars2 = chars;
					bool flag5 = decoderFallbackBuffer.InternalFallback(new byte[1] { (byte)num }, bytes, ref chars2);
					chars = chars2;
					if (!flag5)
					{
						bytes--;
						decoderFallbackBuffer.InternalReset();
						ThrowCharsOverflow(decoder, chars == ptr4);
						bytes++;
					}
					else
					{
						num = -1;
					}
				}
			}
			goto IL_04de;
			IL_04de:
			if (decoder != null)
			{
				decoder._bytesUsed = (int)(bytes - ptr3);
				decoder.lastChar = c;
				decoder.lastByte = num;
			}
			return (int)(chars - ptr4);
		}

		public override Encoder GetEncoder()
		{
			return new EncoderNLS(this);
		}

		public override System.Text.Decoder GetDecoder()
		{
			return new Decoder(this);
		}

		public override byte[] GetPreamble()
		{
			if (byteOrderMark)
			{
				if (!bigEndian)
				{
					return new byte[2] { 255, 254 };
				}
				return new byte[2] { 254, 255 };
			}
			return Array.Empty<byte>();
		}

		public override int GetMaxByteCount(int charCount)
		{
			if (charCount < 0)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = (long)charCount + 1L;
			if (base.EncoderFallback.MaxCharCount > 1)
			{
				num *= base.EncoderFallback.MaxCharCount;
			}
			num <<= 1;
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			return (int)num;
		}

		public override int GetMaxCharCount(int byteCount)
		{
			if (byteCount < 0)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = (long)(byteCount >> 1) + (long)(byteCount & 1) + 1;
			if (base.DecoderFallback.MaxCharCount > 1)
			{
				num *= base.DecoderFallback.MaxCharCount;
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_GetCharCountOverflow);
			}
			return (int)num;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is UnicodeEncoding unicodeEncoding)
			{
				if (CodePage == unicodeEncoding.CodePage && byteOrderMark == unicodeEncoding.byteOrderMark && bigEndian == unicodeEncoding.bigEndian && base.EncoderFallback.Equals(unicodeEncoding.EncoderFallback))
				{
					return base.DecoderFallback.Equals(unicodeEncoding.DecoderFallback);
				}
				return false;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return CodePage + base.EncoderFallback.GetHashCode() + base.DecoderFallback.GetHashCode() + (byteOrderMark ? 4 : 0) + (bigEndian ? 8 : 0);
		}
	}
	internal static class UnicodeUtility
	{
		public static int GetPlane(uint codePoint)
		{
			return (int)(codePoint >> 16);
		}

		public static uint GetScalarFromUtf16SurrogatePair(uint highSurrogateCodePoint, uint lowSurrogateCodePoint)
		{
			return (highSurrogateCodePoint << 10) + lowSurrogateCodePoint - 56613888;
		}

		public static int GetUtf16SequenceLength(uint value)
		{
			value -= 65536;
			value += 33554432;
			value >>= 24;
			return (int)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void GetUtf16SurrogatesFromSupplementaryPlaneScalar(uint value, out char highSurrogateCodePoint, out char lowSurrogateCodePoint)
		{
			highSurrogateCodePoint = (char)(value + 56557568 >> 10);
			lowSurrogateCodePoint = (char)((value & 0x3FF) + 56320);
		}

		public static int GetUtf8SequenceLength(uint value)
		{
			int num = (int)(value - 2048) >> 31;
			value ^= 0xF800u;
			value -= 63616;
			value += 67108864;
			value >>= 24;
			return (int)value + num * 2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsAsciiCodePoint(uint value)
		{
			return value <= 127;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsBmpCodePoint(uint value)
		{
			return value <= 65535;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsHighSurrogateCodePoint(uint value)
		{
			return IsInRangeInclusive(value, 55296u, 56319u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsInRangeInclusive(uint value, uint lowerBound, uint upperBound)
		{
			return value - lowerBound <= upperBound - lowerBound;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsLowSurrogateCodePoint(uint value)
		{
			return IsInRangeInclusive(value, 56320u, 57343u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsSurrogateCodePoint(uint value)
		{
			return IsInRangeInclusive(value, 55296u, 57343u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsValidCodePoint(uint codePoint)
		{
			return codePoint <= 1114111;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsValidUnicodeScalar(uint value)
		{
			return ((value - 1114112) ^ 0xD800) >= 4293855232u;
		}
	}
	public sealed class UTF32Encoding : Encoding
	{
		private sealed class UTF32Decoder : DecoderNLS
		{
			internal int iChar;

			internal int readByteCount;

			internal override bool HasState => readByteCount != 0;

			public UTF32Decoder(UTF32Encoding encoding)
				: base(encoding)
			{
			}

			public override void Reset()
			{
				iChar = 0;
				readByteCount = 0;
				if (_fallbackBuffer != null)
				{
					_fallbackBuffer.Reset();
				}
			}
		}

		internal static readonly UTF32Encoding s_default = new UTF32Encoding(bigEndian: false, byteOrderMark: true);

		internal static readonly UTF32Encoding s_bigEndianDefault = new UTF32Encoding(bigEndian: true, byteOrderMark: true);

		private readonly bool _emitUTF32ByteOrderMark;

		private readonly bool _isThrowException;

		private readonly bool _bigEndian;

		public override ReadOnlySpan<byte> Preamble
		{
			get
			{
				if (!(GetType() != typeof(UTF32Encoding)))
				{
					if (_emitUTF32ByteOrderMark)
					{
						if (_bigEndian)
						{
							return new byte[4] { 0, 0, 254, 255 };
						}
						return new byte[4] { 255, 254, 0, 0 };
					}
					return default(ReadOnlySpan<byte>);
				}
				return new ReadOnlySpan<byte>(GetPreamble());
			}
		}

		public UTF32Encoding()
			: this(bigEndian: false, byteOrderMark: true)
		{
		}

		public UTF32Encoding(bool bigEndian, bool byteOrderMark)
			: base(bigEndian ? 12001 : 12000)
		{
			_bigEndian = bigEndian;
			_emitUTF32ByteOrderMark = byteOrderMark;
		}

		public UTF32Encoding(bool bigEndian, bool byteOrderMark, bool throwOnInvalidCharacters)
			: this(bigEndian, byteOrderMark)
		{
			_isThrowException = throwOnInvalidCharacters;
			if (_isThrowException)
			{
				SetDefaultFallbacks();
			}
		}

		internal override void SetDefaultFallbacks()
		{
			if (_isThrowException)
			{
				encoderFallback = System.Text.EncoderFallback.ExceptionFallback;
				decoderFallback = System.Text.DecoderFallback.ExceptionFallback;
			}
			else
			{
				encoderFallback = new EncoderReplacementFallback("\ufffd");
				decoderFallback = new DecoderReplacementFallback("\ufffd");
			}
		}

		public unsafe override int GetByteCount(char[] chars, int index, int count)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return 0;
			}
			fixed (char* ptr = chars)
			{
				return GetByteCount(ptr + index, count, null);
			}
		}

		public unsafe override int GetByteCount(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			fixed (char* pChars = s)
			{
				return GetByteCount(pChars, s.Length, null);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetByteCount(char* chars, int count)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetByteCount(chars, count, null);
		}

		public unsafe override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (s == null || bytes == null)
			{
				throw new ArgumentNullException((s == null) ? "s" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (s.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("s", SR.ArgumentOutOfRange_IndexCount);
			}
			if (byteIndex < 0 || byteIndex > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("byteIndex", SR.ArgumentOutOfRange_Index);
			}
			int byteCount = bytes.Length - byteIndex;
			fixed (char* ptr = s)
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference<byte>(bytes))
				{
					return GetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, byteCount, null);
				}
			}
		}

		public unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (byteIndex < 0 || byteIndex > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("byteIndex", SR.ArgumentOutOfRange_Index);
			}
			if (charCount == 0)
			{
				return 0;
			}
			int byteCount = bytes.Length - byteIndex;
			fixed (char* ptr = chars)
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference<byte>(bytes))
				{
					return GetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, byteCount, null);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetBytes(chars, charCount, bytes, byteCount, null);
		}

		public unsafe override int GetCharCount(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return 0;
			}
			fixed (byte* ptr = bytes)
			{
				return GetCharCount(ptr + index, count, null);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetCharCount(byte* bytes, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetCharCount(bytes, count, null);
		}

		public unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (byteIndex < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (charIndex < 0 || charIndex > chars.Length)
			{
				throw new ArgumentOutOfRangeException("charIndex", SR.ArgumentOutOfRange_Index);
			}
			if (byteCount == 0)
			{
				return 0;
			}
			int charCount = chars.Length - charIndex;
			fixed (byte* ptr = bytes)
			{
				fixed (char* ptr2 = &MemoryMarshal.GetReference<char>(chars))
				{
					return GetChars(ptr + byteIndex, byteCount, ptr2 + charIndex, charCount, null);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetChars(bytes, byteCount, chars, charCount, null);
		}

		public unsafe override string GetString(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return string.Empty;
			}
			fixed (byte* ptr = bytes)
			{
				return string.CreateStringFromEncoding(ptr + index, count, this);
			}
		}

		internal unsafe override int GetByteCount(char* chars, int count, EncoderNLS encoder)
		{
			char* ptr = chars + count;
			char* charStart = chars;
			int num = 0;
			char c = '\0';
			EncoderFallbackBuffer encoderFallbackBuffer = null;
			if (encoder != null)
			{
				c = encoder._charLeftOver;
				encoderFallbackBuffer = encoder.FallbackBuffer;
				if (encoderFallbackBuffer.Remaining > 0)
				{
					throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty, EncodingName, encoder.Fallback?.GetType().ToString() ?? string.Empty));
				}
			}
			else
			{
				encoderFallbackBuffer = encoderFallback.CreateFallbackBuffer();
			}
			encoderFallbackBuffer.InternalInitialize(charStart, ptr, encoder, setEncoder: false);
			while (true)
			{
				char c2;
				if ((c2 = encoderFallbackBuffer.InternalGetNextChar()) != 0 || chars < ptr)
				{
					if (c2 == '\0')
					{
						c2 = *chars;
						chars++;
					}
					if (c != 0)
					{
						if (char.IsLowSurrogate(c2))
						{
							c = '\0';
							num += 4;
							continue;
						}
						chars--;
						char* chars2 = chars;
						encoderFallbackBuffer.InternalFallback(c, ref chars2);
						chars = chars2;
						c = '\0';
					}
					else if (char.IsHighSurrogate(c2))
					{
						c = c2;
					}
					else if (char.IsLowSurrogate(c2))
					{
						char* chars2 = chars;
						encoderFallbackBuffer.InternalFallback(c2, ref chars2);
						chars = chars2;
					}
					else
					{
						num += 4;
					}
				}
				else
				{
					if ((encoder != null && !encoder.MustFlush) || c <= '\0')
					{
						break;
					}
					char* chars2 = chars;
					encoderFallbackBuffer.InternalFallback(c, ref chars2);
					chars = chars2;
					c = '\0';
				}
			}
			if (num < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			return num;
		}

		internal unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS encoder)
		{
			char* ptr = chars;
			char* ptr2 = chars + charCount;
			byte* ptr3 = bytes;
			byte* ptr4 = bytes + byteCount;
			char c = '\0';
			EncoderFallbackBuffer encoderFallbackBuffer = null;
			if (encoder != null)
			{
				c = encoder._charLeftOver;
				encoderFallbackBuffer = encoder.FallbackBuffer;
				if (encoder._throwOnOverflow && encoderFallbackBuffer.Remaining > 0)
				{
					throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty, EncodingName, encoder.Fallback?.GetType()));
				}
			}
			else
			{
				encoderFallbackBuffer = encoderFallback.CreateFallbackBuffer();
			}
			encoderFallbackBuffer.InternalInitialize(ptr, ptr2, encoder, setEncoder: true);
			while (true)
			{
				char c2;
				char* chars2;
				if ((c2 = encoderFallbackBuffer.InternalGetNextChar()) != 0 || chars < ptr2)
				{
					if (c2 == '\0')
					{
						c2 = *chars;
						chars++;
					}
					if (c != 0)
					{
						if (!char.IsLowSurrogate(c2))
						{
							chars--;
							chars2 = chars;
							encoderFallbackBuffer.InternalFallback(c, ref chars2);
							chars = chars2;
							c = '\0';
							continue;
						}
						uint surrogate = GetSurrogate(c, c2);
						c = '\0';
						if (bytes + 3 < ptr4)
						{
							if (_bigEndian)
							{
								*(bytes++) = 0;
								*(bytes++) = (byte)(surrogate >> 16);
								*(bytes++) = (byte)(surrogate >> 8);
								*(bytes++) = (byte)surrogate;
							}
							else
							{
								*(bytes++) = (byte)surrogate;
								*(bytes++) = (byte)(surrogate >> 8);
								*(bytes++) = (byte)(surrogate >> 16);
								*(bytes++) = 0;
							}
							continue;
						}
						if (encoderFallbackBuffer.bFallingBack)
						{
							encoderFallbackBuffer.MovePrevious();
							encoderFallbackBuffer.MovePrevious();
						}
						else
						{
							chars -= 2;
						}
						ThrowBytesOverflow(encoder, bytes == ptr3);
						c = '\0';
					}
					else
					{
						if (char.IsHighSurrogate(c2))
						{
							c = c2;
							continue;
						}
						if (char.IsLowSurrogate(c2))
						{
							chars2 = chars;
							encoderFallbackBuffer.InternalFallback(c2, ref chars2);
							chars = chars2;
							continue;
						}
						if (bytes + 3 < ptr4)
						{
							if (_bigEndian)
							{
								*(bytes++) = 0;
								*(bytes++) = 0;
								*(bytes++) = (byte)((uint)c2 >> 8);
								*(bytes++) = (byte)c2;
							}
							else
							{
								*(bytes++) = (byte)c2;
								*(bytes++) = (byte)((uint)c2 >> 8);
								*(bytes++) = 0;
								*(bytes++) = 0;
							}
							continue;
						}
						if (encoderFallbackBuffer.bFallingBack)
						{
							encoderFallbackBuffer.MovePrevious();
						}
						else
						{
							chars--;
						}
						ThrowBytesOverflow(encoder, bytes == ptr3);
					}
				}
				if ((encoder != null && !encoder.MustFlush) || c <= '\0')
				{
					break;
				}
				chars2 = chars;
				encoderFallbackBuffer.InternalFallback(c, ref chars2);
				chars = chars2;
				c = '\0';
			}
			if (encoder != null)
			{
				encoder._charLeftOver = c;
				encoder._charsUsed = (int)(chars - ptr);
			}
			return (int)(bytes - ptr3);
		}

		internal unsafe override int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
		{
			UTF32Decoder uTF32Decoder = (UTF32Decoder)baseDecoder;
			int num = 0;
			byte* ptr = bytes + count;
			byte* byteStart = bytes;
			int num2 = 0;
			uint num3 = 0u;
			DecoderFallbackBuffer decoderFallbackBuffer = null;
			if (uTF32Decoder != null)
			{
				num2 = uTF32Decoder.readByteCount;
				num3 = (uint)uTF32Decoder.iChar;
				decoderFallbackBuffer = uTF32Decoder.FallbackBuffer;
			}
			else
			{
				decoderFallbackBuffer = decoderFallback.CreateFallbackBuffer();
			}
			decoderFallbackBuffer.InternalInitialize(byteStart, null);
			while (bytes < ptr && num >= 0)
			{
				if (_bigEndian)
				{
					num3 <<= 8;
					num3 += *(bytes++);
				}
				else
				{
					num3 >>= 8;
					num3 += (uint)(*(bytes++) << 24);
				}
				num2++;
				if (num2 < 4)
				{
					continue;
				}
				num2 = 0;
				if (num3 > 1114111 || (num3 >= 55296 && num3 <= 57343))
				{
					byte[] bytes2 = ((!_bigEndian) ? new byte[4]
					{
						(byte)num3,
						(byte)(num3 >> 8),
						(byte)(num3 >> 16),
						(byte)(num3 >> 24)
					} : new byte[4]
					{
						(byte)(num3 >> 24),
						(byte)(num3 >> 16),
						(byte)(num3 >> 8),
						(byte)num3
					});
					num += decoderFallbackBuffer.InternalFallback(bytes2, bytes);
					num3 = 0u;
				}
				else
				{
					if (num3 >= 65536)
					{
						num++;
					}
					num++;
					num3 = 0u;
				}
			}
			if (num2 > 0 && (uTF32Decoder == null || uTF32Decoder.MustFlush))
			{
				byte[] array = new byte[num2];
				if (_bigEndian)
				{
					while (num2 > 0)
					{
						array[--num2] = (byte)num3;
						num3 >>= 8;
					}
				}
				else
				{
					while (num2 > 0)
					{
						array[--num2] = (byte)(num3 >> 24);
						num3 <<= 8;
					}
				}
				num += decoderFallbackBuffer.InternalFallback(array, bytes);
			}
			if (num < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			return num;
		}

		internal unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
		{
			UTF32Decoder uTF32Decoder = (UTF32Decoder)baseDecoder;
			char* ptr = chars;
			char* ptr2 = chars + charCount;
			byte* ptr3 = bytes;
			byte* ptr4 = bytes + byteCount;
			int num = 0;
			uint num2 = 0u;
			DecoderFallbackBuffer decoderFallbackBuffer = null;
			if (uTF32Decoder != null)
			{
				num = uTF32Decoder.readByteCount;
				num2 = (uint)uTF32Decoder.iChar;
				decoderFallbackBuffer = baseDecoder.FallbackBuffer;
			}
			else
			{
				decoderFallbackBuffer = decoderFallback.CreateFallbackBuffer();
			}
			decoderFallbackBuffer.InternalInitialize(bytes, chars + charCount);
			while (bytes < ptr4)
			{
				if (_bigEndian)
				{
					num2 <<= 8;
					num2 += *(bytes++);
				}
				else
				{
					num2 >>= 8;
					num2 += (uint)(*(bytes++) << 24);
				}
				num++;
				if (num < 4)
				{
					continue;
				}
				num = 0;
				if (num2 > 1114111 || (num2 >= 55296 && num2 <= 57343))
				{
					byte[] bytes2 = ((!_bigEndian) ? new byte[4]
					{
						(byte)num2,
						(byte)(num2 >> 8),
						(byte)(num2 >> 16),
						(byte)(num2 >> 24)
					} : new byte[4]
					{
						(byte)(num2 >> 24),
						(byte)(num2 >> 16),
						(byte)(num2 >> 8),
						(byte)num2
					});
					char* chars2 = chars;
					bool flag = decoderFallbackBuffer.InternalFallback(bytes2, bytes, ref chars2);
					chars = chars2;
					if (!flag)
					{
						bytes -= 4;
						num2 = 0u;
						decoderFallbackBuffer.InternalReset();
						ThrowCharsOverflow(uTF32Decoder, chars == ptr);
						break;
					}
					num2 = 0u;
					continue;
				}
				if (num2 >= 65536)
				{
					if (chars >= ptr2 - 1)
					{
						bytes -= 4;
						num2 = 0u;
						ThrowCharsOverflow(uTF32Decoder, chars == ptr);
						break;
					}
					*(chars++) = GetHighSurrogate(num2);
					num2 = GetLowSurrogate(num2);
				}
				else if (chars >= ptr2)
				{
					bytes -= 4;
					num2 = 0u;
					ThrowCharsOverflow(uTF32Decoder, chars == ptr);
					break;
				}
				*(chars++) = (char)num2;
				num2 = 0u;
			}
			if (num > 0 && (uTF32Decoder == null || uTF32Decoder.MustFlush))
			{
				byte[] array = new byte[num];
				int num3 = num;
				if (_bigEndian)
				{
					while (num3 > 0)
					{
						array[--num3] = (byte)num2;
						num2 >>= 8;
					}
				}
				else
				{
					while (num3 > 0)
					{
						array[--num3] = (byte)(num2 >> 24);
						num2 <<= 8;
					}
				}
				char* chars2 = chars;
				bool flag2 = decoderFallbackBuffer.InternalFallback(array, bytes, ref chars2);
				chars = chars2;
				if (!flag2)
				{
					decoderFallbackBuffer.InternalReset();
					ThrowCharsOverflow(uTF32Decoder, chars == ptr);
				}
				else
				{
					num = 0;
					num2 = 0u;
				}
			}
			if (uTF32Decoder != null)
			{
				uTF32Decoder.iChar = (int)num2;
				uTF32Decoder.readByteCount = num;
				uTF32Decoder._bytesUsed = (int)(bytes - ptr3);
			}
			return (int)(chars - ptr);
		}

		private static uint GetSurrogate(char cHigh, char cLow)
		{
			return (uint)((cHigh - 55296) * 1024 + (cLow - 56320) + 65536);
		}

		private static char GetHighSurrogate(uint iChar)
		{
			return (char)((iChar - 65536) / 1024 + 55296);
		}

		private static char GetLowSurrogate(uint iChar)
		{
			return (char)((iChar - 65536) % 1024 + 56320);
		}

		public override Decoder GetDecoder()
		{
			return new UTF32Decoder(this);
		}

		public override Encoder GetEncoder()
		{
			return new EncoderNLS(this);
		}

		public override int GetMaxByteCount(int charCount)
		{
			if (charCount < 0)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = (long)charCount + 1L;
			if (base.EncoderFallback.MaxCharCount > 1)
			{
				num *= base.EncoderFallback.MaxCharCount;
			}
			num *= 4;
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			return (int)num;
		}

		public override int GetMaxCharCount(int byteCount)
		{
			if (byteCount < 0)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			int num = byteCount / 2 + 2;
			if (base.DecoderFallback.MaxCharCount > 2)
			{
				num *= base.DecoderFallback.MaxCharCount;
				num /= 2;
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_GetCharCountOverflow);
			}
			return num;
		}

		public override byte[] GetPreamble()
		{
			if (_emitUTF32ByteOrderMark)
			{
				if (!_bigEndian)
				{
					return new byte[4] { 255, 254, 0, 0 };
				}
				return new byte[4] { 0, 0, 254, 255 };
			}
			return Array.Empty<byte>();
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is UTF32Encoding uTF32Encoding)
			{
				if (_emitUTF32ByteOrderMark == uTF32Encoding._emitUTF32ByteOrderMark && _bigEndian == uTF32Encoding._bigEndian && base.EncoderFallback.Equals(uTF32Encoding.EncoderFallback))
				{
					return base.DecoderFallback.Equals(uTF32Encoding.DecoderFallback);
				}
				return false;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.EncoderFallback.GetHashCode() + base.DecoderFallback.GetHashCode() + CodePage + (_emitUTF32ByteOrderMark ? 4 : 0) + (_bigEndian ? 8 : 0);
		}
	}
	public class UTF7Encoding : Encoding
	{
		private sealed class Decoder : DecoderNLS
		{
			internal int bits;

			internal int bitCount;

			internal bool firstByte;

			internal override bool HasState => bitCount != -1;

			public Decoder(UTF7Encoding encoding)
				: base(encoding)
			{
			}

			public override void Reset()
			{
				bits = 0;
				bitCount = -1;
				firstByte = false;
				if (_fallbackBuffer != null)
				{
					_fallbackBuffer.Reset();
				}
			}
		}

		private sealed class Encoder : EncoderNLS
		{
			internal int bits;

			internal int bitCount;

			internal override bool HasState
			{
				get
				{
					if (bits == 0)
					{
						return bitCount != -1;
					}
					return true;
				}
			}

			public Encoder(UTF7Encoding encoding)
				: base(encoding)
			{
			}

			public override void Reset()
			{
				bitCount = -1;
				bits = 0;
				if (_fallbackBuffer != null)
				{
					_fallbackBuffer.Reset();
				}
			}
		}

		private sealed class DecoderUTF7Fallback : DecoderFallback
		{
			public override int MaxCharCount => 1;

			public override DecoderFallbackBuffer CreateFallbackBuffer()
			{
				return new DecoderUTF7FallbackBuffer();
			}

			public override bool Equals([NotNullWhen(true)] object value)
			{
				return value is DecoderUTF7Fallback;
			}

			public override int GetHashCode()
			{
				return 984;
			}
		}

		private sealed class DecoderUTF7FallbackBuffer : DecoderFallbackBuffer
		{
			private char cFallback;

			private int iCount = -1;

			private int iSize;

			public override int Remaining
			{
				get
				{
					if (iCount <= 0)
					{
						return 0;
					}
					return iCount;
				}
			}

			public override bool Fallback(byte[] bytesUnknown, int index)
			{
				cFallback = (char)bytesUnknown[0];
				if (cFallback == '\0')
				{
					return false;
				}
				iCount = (iSize = 1);
				return true;
			}

			public override char GetNextChar()
			{
				if (iCount-- > 0)
				{
					return cFallback;
				}
				return '\0';
			}

			public override bool MovePrevious()
			{
				if (iCount >= 0)
				{
					iCount++;
				}
				if (iCount >= 0)
				{
					return iCount <= iSize;
				}
				return false;
			}

			public unsafe override void Reset()
			{
				iCount = -1;
				byteStart = null;
			}

			internal unsafe override int InternalFallback(byte[] bytes, byte* pBytes)
			{
				if (bytes.Length != 1)
				{
					throw new ArgumentException(SR.Argument_InvalidCharSequenceNoIndex);
				}
				if (bytes[0] != 0)
				{
					return 1;
				}
				return 0;
			}
		}

		internal static readonly UTF7Encoding s_default = new UTF7Encoding();

		private byte[] _base64Bytes;

		private sbyte[] _base64Values;

		private bool[] _directEncode;

		private readonly bool _allowOptionals;

		[Obsolete("The UTF-7 encoding is insecure and should not be used. Consider using UTF-8 instead.", DiagnosticId = "SYSLIB0001", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public UTF7Encoding()
			: this(allowOptionals: false)
		{
		}

		[Obsolete("The UTF-7 encoding is insecure and should not be used. Consider using UTF-8 instead.", DiagnosticId = "SYSLIB0001", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public UTF7Encoding(bool allowOptionals)
			: base(65000)
		{
			_allowOptionals = allowOptionals;
			MakeTables();
		}

		[MemberNotNull("_base64Bytes")]
		[MemberNotNull("_base64Values")]
		[MemberNotNull("_directEncode")]
		private void MakeTables()
		{
			_base64Bytes = new byte[64];
			for (int i = 0; i < 64; i++)
			{
				_base64Bytes[i] = (byte)"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[i];
			}
			_base64Values = new sbyte[128];
			for (int j = 0; j < 128; j++)
			{
				_base64Values[j] = -1;
			}
			for (int k = 0; k < 64; k++)
			{
				_base64Values[_base64Bytes[k]] = (sbyte)k;
			}
			_directEncode = new bool[128];
			int length = "\t\n\r '(),-./0123456789:?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".Length;
			for (int l = 0; l < length; l++)
			{
				_directEncode[(uint)"\t\n\r '(),-./0123456789:?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"[l]] = true;
			}
			if (_allowOptionals)
			{
				length = "!\"#$%&*;<=>@[]^_`{|}".Length;
				for (int m = 0; m < length; m++)
				{
					_directEncode[(uint)"!\"#$%&*;<=>@[]^_`{|}"[m]] = true;
				}
			}
		}

		internal sealed override void SetDefaultFallbacks()
		{
			encoderFallback = new EncoderReplacementFallback(string.Empty);
			decoderFallback = new DecoderUTF7Fallback();
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is UTF7Encoding uTF7Encoding)
			{
				if (_allowOptionals == uTF7Encoding._allowOptionals && base.EncoderFallback.Equals(uTF7Encoding.EncoderFallback))
				{
					return base.DecoderFallback.Equals(uTF7Encoding.DecoderFallback);
				}
				return false;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return CodePage + base.EncoderFallback.GetHashCode() + base.DecoderFallback.GetHashCode();
		}

		public unsafe override int GetByteCount(char[] chars, int index, int count)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return 0;
			}
			fixed (char* ptr = chars)
			{
				return GetByteCount(ptr + index, count, null);
			}
		}

		public unsafe override int GetByteCount(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			fixed (char* pChars = s)
			{
				return GetByteCount(pChars, s.Length, null);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetByteCount(char* chars, int count)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetByteCount(chars, count, null);
		}

		public unsafe override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (s == null || bytes == null)
			{
				throw new ArgumentNullException((s == null) ? "s" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (s.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("s", SR.ArgumentOutOfRange_IndexCount);
			}
			if (byteIndex < 0 || byteIndex > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("byteIndex", SR.ArgumentOutOfRange_Index);
			}
			int byteCount = bytes.Length - byteIndex;
			fixed (char* ptr = s)
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference<byte>(bytes))
				{
					return GetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, byteCount, null);
				}
			}
		}

		public unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (chars == null || bytes == null)
			{
				throw new ArgumentNullException((chars == null) ? "chars" : "bytes", SR.ArgumentNull_Array);
			}
			if (charIndex < 0 || charCount < 0)
			{
				throw new ArgumentOutOfRangeException((charIndex < 0) ? "charIndex" : "charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				throw new ArgumentOutOfRangeException("chars", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (byteIndex < 0 || byteIndex > bytes.Length)
			{
				throw new ArgumentOutOfRangeException("byteIndex", SR.ArgumentOutOfRange_Index);
			}
			if (charCount == 0)
			{
				return 0;
			}
			int byteCount = bytes.Length - byteIndex;
			fixed (char* ptr = chars)
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference<byte>(bytes))
				{
					return GetBytes(ptr + charIndex, charCount, ptr2 + byteIndex, byteCount, null);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetBytes(chars, charCount, bytes, byteCount, null);
		}

		public unsafe override int GetCharCount(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return 0;
			}
			fixed (byte* ptr = bytes)
			{
				return GetCharCount(ptr + index, count, null);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetCharCount(byte* bytes, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetCharCount(bytes, count, null);
		}

		public unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (byteIndex < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((byteIndex < 0) ? "byteIndex" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (charIndex < 0 || charIndex > chars.Length)
			{
				throw new ArgumentOutOfRangeException("charIndex", SR.ArgumentOutOfRange_Index);
			}
			if (byteCount == 0)
			{
				return 0;
			}
			int charCount = chars.Length - charIndex;
			fixed (byte* ptr = bytes)
			{
				fixed (char* ptr2 = &MemoryMarshal.GetReference<char>(chars))
				{
					return GetChars(ptr + byteIndex, byteCount, ptr2 + charIndex, charCount, null);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			if (bytes == null || chars == null)
			{
				throw new ArgumentNullException((bytes == null) ? "bytes" : "chars", SR.ArgumentNull_Array);
			}
			if (charCount < 0 || byteCount < 0)
			{
				throw new ArgumentOutOfRangeException((charCount < 0) ? "charCount" : "byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetChars(bytes, byteCount, chars, charCount, null);
		}

		public unsafe override string GetString(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes", SR.ArgumentNull_Array);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				throw new ArgumentOutOfRangeException("bytes", SR.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return string.Empty;
			}
			fixed (byte* ptr = bytes)
			{
				return string.CreateStringFromEncoding(ptr + index, count, this);
			}
		}

		internal unsafe sealed override int GetByteCount(char* chars, int count, EncoderNLS baseEncoder)
		{
			return GetBytes(chars, count, null, 0, baseEncoder);
		}

		internal unsafe sealed override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS baseEncoder)
		{
			Encoder encoder = (Encoder)baseEncoder;
			int num = 0;
			int num2 = -1;
			EncodingByteBuffer encodingByteBuffer = new EncodingByteBuffer(this, encoder, bytes, byteCount, chars, charCount);
			if (encoder != null)
			{
				num = encoder.bits;
				num2 = encoder.bitCount;
				while (num2 >= 6)
				{
					num2 -= 6;
					if (!encodingByteBuffer.AddByte(_base64Bytes[(num >> num2) & 0x3F]))
					{
						ThrowBytesOverflow(encoder, encodingByteBuffer.Count == 0);
					}
				}
			}
			while (encodingByteBuffer.MoreData)
			{
				char nextChar = encodingByteBuffer.GetNextChar();
				if (nextChar < '\u0080' && _directEncode[(uint)nextChar])
				{
					if (num2 >= 0)
					{
						if (num2 > 0)
						{
							if (!encodingByteBuffer.AddByte(_base64Bytes[(num << 6 - num2) & 0x3F]))
							{
								break;
							}
							num2 = 0;
						}
						if (!encodingByteBuffer.AddByte(45))
						{
							break;
						}
						num2 = -1;
					}
					if (!encodingByteBuffer.AddByte((byte)nextChar))
					{
						break;
					}
					continue;
				}
				if (num2 < 0 && nextChar == '+')
				{
					if (!encodingByteBuffer.AddByte((byte)43, (byte)45))
					{
						break;
					}
					continue;
				}
				if (num2 < 0)
				{
					if (!encodingByteBuffer.AddByte(43))
					{
						break;
					}
					num2 = 0;
				}
				num = (num << 16) | nextChar;
				num2 += 16;
				while (num2 >= 6)
				{
					num2 -= 6;
					if (!encodingByteBuffer.AddByte(_base64Bytes[(num >> num2) & 0x3F]))
					{
						num2 += 6;
						encodingByteBuffer.GetNextChar();
						break;
					}
				}
				if (num2 >= 6)
				{
					break;
				}
			}
			if (num2 >= 0 && (encoder == null || encoder.MustFlush))
			{
				if (num2 > 0 && encodingByteBuffer.AddByte(_base64Bytes[(num << 6 - num2) & 0x3F]))
				{
					num2 = 0;
				}
				if (encodingByteBuffer.AddByte(45))
				{
					num = 0;
					num2 = -1;
				}
				else
				{
					encodingByteBuffer.GetNextChar();
				}
			}
			if (bytes != null && encoder != null)
			{
				encoder.bits = num;
				encoder.bitCount = num2;
				encoder._charsUsed = encodingByteBuffer.CharsUsed;
			}
			return encodingByteBuffer.Count;
		}

		internal unsafe sealed override int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
		{
			return GetChars(bytes, count, null, 0, baseDecoder);
		}

		internal unsafe sealed override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
		{
			Decoder decoder = (Decoder)baseDecoder;
			EncodingCharBuffer encodingCharBuffer = new EncodingCharBuffer(this, decoder, chars, charCount, bytes, byteCount);
			int num = 0;
			int num2 = -1;
			bool flag = false;
			if (decoder != null)
			{
				num = decoder.bits;
				num2 = decoder.bitCount;
				flag = decoder.firstByte;
			}
			if (num2 >= 16)
			{
				if (!encodingCharBuffer.AddChar((char)((uint)(num >> num2 - 16) & 0xFFFFu)))
				{
					ThrowCharsOverflow(decoder, nothingDecoded: true);
				}
				num2 -= 16;
			}
			while (encodingCharBuffer.MoreData)
			{
				byte nextByte = encodingCharBuffer.GetNextByte();
				int num3;
				if (num2 >= 0)
				{
					sbyte b;
					if (nextByte < 128 && (b = _base64Values[nextByte]) >= 0)
					{
						flag = false;
						num = (num << 6) | (byte)b;
						num2 += 6;
						if (num2 < 16)
						{
							continue;
						}
						num3 = (num >> num2 - 16) & 0xFFFF;
						num2 -= 16;
					}
					else
					{
						num2 = -1;
						if (nextByte != 45)
						{
							if (!encodingCharBuffer.Fallback(nextByte))
							{
								break;
							}
							continue;
						}
						if (!flag)
						{
							continue;
						}
						num3 = 43;
					}
				}
				else
				{
					if (nextByte == 43)
					{
						num2 = 0;
						flag = true;
						continue;
					}
					if (nextByte >= 128)
					{
						if (!encodingCharBuffer.Fallback(nextByte))
						{
							break;
						}
						continue;
					}
					num3 = nextByte;
				}
				if (num3 >= 0 && !encodingCharBuffer.AddChar((char)num3))
				{
					if (num2 >= 0)
					{
						encodingCharBuffer.AdjustBytes(1);
						num2 += 16;
					}
					break;
				}
			}
			if (chars != null && decoder != null)
			{
				if (decoder.MustFlush)
				{
					decoder.bits = 0;
					decoder.bitCount = -1;
					decoder.firstByte = false;
				}
				else
				{
					decoder.bits = num;
					decoder.bitCount = num2;
					decoder.firstByte = flag;
				}
				decoder._bytesUsed = encodingCharBuffer.BytesUsed;
			}
			return encodingCharBuffer.Count;
		}

		public override System.Text.Decoder GetDecoder()
		{
			return new Decoder(this);
		}

		public override System.Text.Encoder GetEncoder()
		{
			return new Encoder(this);
		}

		public override int GetMaxByteCount(int charCount)
		{
			if (charCount < 0)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = (long)charCount * 3L + 2;
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			return (int)num;
		}

		public override int GetMaxCharCount(int byteCount)
		{
			if (byteCount < 0)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			int num = byteCount;
			if (num == 0)
			{
				num = 1;
			}
			return num;
		}
	}
	public class UTF8Encoding : Encoding
	{
		internal sealed class UTF8EncodingSealed : UTF8Encoding
		{
			public override ReadOnlySpan<byte> Preamble
			{
				get
				{
					if (!_emitUTF8Identifier)
					{
						return default(ReadOnlySpan<byte>);
					}
					return PreambleSpan;
				}
			}

			public UTF8EncodingSealed(bool encoderShouldEmitUTF8Identifier)
				: base(encoderShouldEmitUTF8Identifier)
			{
			}

			public override object Clone()
			{
				return new UTF8Encoding(_emitUTF8Identifier)
				{
					IsReadOnly = false
				};
			}

			public override byte[] GetBytes(string s)
			{
				if (s != null && s.Length <= 32)
				{
					return GetBytesForSmallInput(s);
				}
				return base.GetBytes(s);
			}

			private unsafe byte[] GetBytesForSmallInput(string s)
			{
				byte* ptr = stackalloc byte[96];
				int length = s.Length;
				int bytesCommon;
				fixed (char* pChars = s)
				{
					bytesCommon = GetBytesCommon(pChars, length, ptr, 96);
				}
				return new Span<byte>(ref *ptr, bytesCommon).ToArray();
			}

			public override string GetString(byte[] bytes)
			{
				if (bytes != null && bytes.Length <= 32)
				{
					return GetStringForSmallInput(bytes);
				}
				return base.GetString(bytes);
			}

			private unsafe string GetStringForSmallInput(byte[] bytes)
			{
				char* ptr = stackalloc char[32];
				int byteCount = bytes.Length;
				int charsCommon;
				fixed (byte* pBytes = bytes)
				{
					charsCommon = GetCharsCommon(pBytes, byteCount, ptr, 32);
				}
				return new string(new ReadOnlySpan<char>(ref *ptr, charsCommon));
			}
		}

		internal static readonly UTF8EncodingSealed s_default = new UTF8EncodingSealed(encoderShouldEmitUTF8Identifier: true);

		private readonly bool _emitUTF8Identifier;

		private readonly bool _isThrowException;

		internal static ReadOnlySpan<byte> PreambleSpan => "\ufeff"u8;

		public override ReadOnlySpan<byte> Preamble
		{
			get
			{
				if (!(GetType() != typeof(UTF8Encoding)))
				{
					if (!_emitUTF8Identifier)
					{
						return default(ReadOnlySpan<byte>);
					}
					return PreambleSpan;
				}
				return new ReadOnlySpan<byte>(GetPreamble());
			}
		}

		public UTF8Encoding()
			: base(65001)
		{
		}

		public UTF8Encoding(bool encoderShouldEmitUTF8Identifier)
			: this()
		{
			_emitUTF8Identifier = encoderShouldEmitUTF8Identifier;
		}

		public UTF8Encoding(bool encoderShouldEmitUTF8Identifier, bool throwOnInvalidBytes)
			: this(encoderShouldEmitUTF8Identifier)
		{
			_isThrowException = throwOnInvalidBytes;
			if (_isThrowException)
			{
				SetDefaultFallbacks();
			}
		}

		internal sealed override void SetDefaultFallbacks()
		{
			if (_isThrowException)
			{
				encoderFallback = System.Text.EncoderFallback.ExceptionFallback;
				decoderFallback = System.Text.DecoderFallback.ExceptionFallback;
			}
			else
			{
				encoderFallback = new EncoderReplacementFallback("\ufffd");
				decoderFallback = new DecoderReplacementFallback("\ufffd");
			}
		}

		public unsafe override int GetByteCount(char[] chars, int index, int count)
		{
			if (chars == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			fixed (char* ptr = chars)
			{
				return GetByteCountCommon(ptr + index, count);
			}
		}

		public unsafe override int GetByteCount(string chars)
		{
			if (chars == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars);
			}
			fixed (char* pChars = chars)
			{
				return GetByteCountCommon(pChars, chars.Length);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetByteCount(char* chars, int count)
		{
			if (chars == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.chars);
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetByteCountCommon(chars, count);
		}

		public unsafe override int GetByteCount(ReadOnlySpan<char> chars)
		{
			fixed (char* pChars = &MemoryMarshal.GetReference(chars))
			{
				return GetByteCountCommon(pChars, chars.Length);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetByteCountCommon(char* pChars, int charCount)
		{
			int charsConsumed;
			int num = GetByteCountFast(pChars, charCount, null, out charsConsumed);
			if (charsConsumed != charCount)
			{
				num += GetByteCountWithFallback(pChars, charCount, charsConsumed);
				if (num < 0)
				{
					Encoding.ThrowConversionOverflow();
				}
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetByteCountFast(char* pChars, int charsLength, EncoderFallback fallback, out int charsConsumed)
		{
			long utf8CodeUnitCountAdjustment;
			int scalarCountAdjustment;
			char* pointerToFirstInvalidChar = Utf16Utility.GetPointerToFirstInvalidChar(pChars, charsLength, out utf8CodeUnitCountAdjustment, out scalarCountAdjustment);
			long num = (charsConsumed = (int)(pointerToFirstInvalidChar - pChars)) + utf8CodeUnitCountAdjustment;
			if ((ulong)num > 2147483647uL)
			{
				Encoding.ThrowConversionOverflow();
			}
			return (int)num;
		}

		public unsafe override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (s == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((s == null) ? ExceptionArgument.s : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charIndex | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charIndex < 0) ? ExceptionArgument.charIndex : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (s.Length - charIndex < charCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.s, ExceptionResource.ArgumentOutOfRange_IndexCount);
			}
			if ((uint)byteIndex > bytes.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (char* ptr2 = s)
			{
				fixed (byte[] array = bytes)
				{
					byte* ptr = (byte*)((bytes != null && array.Length != 0) ? System.Runtime.CompilerServices.Unsafe.AsPointer(ref array[0]) : null);
					return GetBytesCommon(ptr2 + charIndex, charCount, ptr + byteIndex, bytes.Length - byteIndex);
				}
			}
		}

		public unsafe override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			if (chars == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((chars == null) ? ExceptionArgument.chars : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charIndex | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charIndex < 0) ? ExceptionArgument.charIndex : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (chars.Length - charIndex < charCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.chars, ExceptionResource.ArgumentOutOfRange_IndexCount);
			}
			if ((uint)byteIndex > bytes.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.byteIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (char* ptr = chars)
			{
				fixed (byte* ptr2 = bytes)
				{
					return GetBytesCommon(ptr + charIndex, charCount, ptr2 + byteIndex, bytes.Length - byteIndex);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			if (chars == null || bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException((chars == null) ? ExceptionArgument.chars : ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((charCount | byteCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((charCount < 0) ? ExceptionArgument.charCount : ExceptionArgument.byteCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetBytesCommon(chars, charCount, bytes, byteCount);
		}

		public unsafe override int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes)
		{
			fixed (char* pChars = &MemoryMarshal.GetReference(chars))
			{
				fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
				{
					return GetBytesCommon(pChars, chars.Length, pBytes, bytes.Length);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetBytesCommon(char* pChars, int charCount, byte* pBytes, int byteCount)
		{
			int charsConsumed;
			int bytesFast = GetBytesFast(pChars, charCount, pBytes, byteCount, out charsConsumed);
			if (charsConsumed == charCount)
			{
				return bytesFast;
			}
			return GetBytesWithFallback(pChars, charCount, pBytes, byteCount, charsConsumed, bytesFast);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetBytesFast(char* pChars, int charsLength, byte* pBytes, int bytesLength, out int charsConsumed)
		{
			Utf8Utility.TranscodeToUtf8(pChars, charsLength, pBytes, bytesLength, out var pInputBufferRemaining, out var pOutputBufferRemaining);
			charsConsumed = (int)(pInputBufferRemaining - pChars);
			return (int)(pOutputBufferRemaining - pBytes);
		}

		public unsafe override int GetCharCount(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			fixed (byte* ptr = bytes)
			{
				return GetCharCountCommon(ptr + index, count);
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetCharCount(byte* bytes, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetCharCountCommon(bytes, count);
		}

		public unsafe override int GetCharCount(ReadOnlySpan<byte> bytes)
		{
			fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
			{
				return GetCharCountCommon(pBytes, bytes.Length);
			}
		}

		public unsafe override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
		{
			if (bytes == null || chars == null)
			{
				ThrowHelper.ThrowArgumentNullException((bytes == null) ? ExceptionArgument.bytes : ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((byteIndex | byteCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((byteIndex < 0) ? ExceptionArgument.byteIndex : ExceptionArgument.byteCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - byteIndex < byteCount)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			if ((uint)charIndex > (uint)chars.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.charIndex, ExceptionResource.ArgumentOutOfRange_Index);
			}
			fixed (byte* ptr = bytes)
			{
				fixed (char* ptr2 = chars)
				{
					return GetCharsCommon(ptr + byteIndex, byteCount, ptr2 + charIndex, chars.Length - charIndex);
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			if (bytes == null || chars == null)
			{
				ThrowHelper.ThrowArgumentNullException((bytes == null) ? ExceptionArgument.bytes : ExceptionArgument.chars, ExceptionResource.ArgumentNull_Array);
			}
			if ((byteCount | charCount) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((byteCount < 0) ? ExceptionArgument.byteCount : ExceptionArgument.charCount, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			return GetCharsCommon(bytes, byteCount, chars, charCount);
		}

		public unsafe override int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars)
		{
			fixed (byte* pBytes = &MemoryMarshal.GetReference(bytes))
			{
				fixed (char* pChars = &MemoryMarshal.GetReference(chars))
				{
					return GetCharsCommon(pBytes, bytes.Length, pChars, chars.Length);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetCharsCommon(byte* pBytes, int byteCount, char* pChars, int charCount)
		{
			int bytesConsumed;
			int charsFast = GetCharsFast(pBytes, byteCount, pChars, charCount, out bytesConsumed);
			if (bytesConsumed == byteCount)
			{
				return charsFast;
			}
			return GetCharsWithFallback(pBytes, byteCount, pChars, charCount, bytesConsumed, charsFast);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetCharsFast(byte* pBytes, int bytesLength, char* pChars, int charsLength, out int bytesConsumed)
		{
			Utf8Utility.TranscodeToUtf16(pBytes, bytesLength, pChars, charsLength, out var pInputBufferRemaining, out var pOutputBufferRemaining);
			bytesConsumed = (int)(pInputBufferRemaining - pBytes);
			return (int)(pOutputBufferRemaining - pChars);
		}

		private protected sealed override int GetCharsWithFallback(ReadOnlySpan<byte> bytes, int originalBytesLength, Span<char> chars, int originalCharsLength, DecoderNLS decoder)
		{
			if (((decoder == null) ? base.DecoderFallback : decoder.Fallback) is DecoderReplacementFallback decoderReplacementFallback && decoderReplacementFallback.MaxCharCount == 1 && decoderReplacementFallback.DefaultString[0] == '\ufffd')
			{
				Utf8.ToUtf16(bytes, chars, out var bytesRead, out var charsWritten, replaceInvalidSequences: true, decoder?.MustFlush ?? true);
				bytes = bytes.Slice(bytesRead);
				chars = chars.Slice(charsWritten);
			}
			if (bytes.IsEmpty)
			{
				return originalCharsLength - chars.Length;
			}
			return base.GetCharsWithFallback(bytes, originalBytesLength, chars, originalCharsLength, decoder);
		}

		public unsafe override string GetString(byte[] bytes, int index, int count)
		{
			if (bytes == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.bytes, ExceptionResource.ArgumentNull_Array);
			}
			if ((index | count) < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException((index < 0) ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (bytes.Length - index < count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.bytes, ExceptionResource.ArgumentOutOfRange_IndexCountBuffer);
			}
			if (count == 0)
			{
				return string.Empty;
			}
			fixed (byte* ptr = bytes)
			{
				return string.CreateStringFromEncoding(ptr + index, count, this);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe int GetCharCountCommon(byte* pBytes, int byteCount)
		{
			int bytesConsumed;
			int num = GetCharCountFast(pBytes, byteCount, null, out bytesConsumed);
			if (bytesConsumed != byteCount)
			{
				num += GetCharCountWithFallback(pBytes, byteCount, bytesConsumed);
				if (num < 0)
				{
					Encoding.ThrowConversionOverflow();
				}
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private protected unsafe sealed override int GetCharCountFast(byte* pBytes, int bytesLength, DecoderFallback fallback, out int bytesConsumed)
		{
			int utf16CodeUnitCountAdjustment;
			int scalarCountAdjustment;
			byte* pointerToFirstInvalidByte = Utf8Utility.GetPointerToFirstInvalidByte(pBytes, bytesLength, out utf16CodeUnitCountAdjustment, out scalarCountAdjustment);
			return (bytesConsumed = (int)(pointerToFirstInvalidByte - pBytes)) + utf16CodeUnitCountAdjustment;
		}

		public override Decoder GetDecoder()
		{
			return new DecoderNLS(this);
		}

		public override Encoder GetEncoder()
		{
			return new EncoderNLS(this);
		}

		internal sealed override bool TryGetByteCount(Rune value, out int byteCount)
		{
			byteCount = value.Utf8SequenceLength;
			return true;
		}

		internal sealed override OperationStatus EncodeRune(Rune value, Span<byte> bytes, out int bytesWritten)
		{
			if (!value.TryEncodeToUtf8(bytes, out bytesWritten))
			{
				return OperationStatus.DestinationTooSmall;
			}
			return OperationStatus.Done;
		}

		internal sealed override OperationStatus DecodeFirstRune(ReadOnlySpan<byte> bytes, out Rune value, out int bytesConsumed)
		{
			return Rune.DecodeFromUtf8(bytes, out value, out bytesConsumed);
		}

		public override int GetMaxByteCount(int charCount)
		{
			if (charCount < 0)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = (long)charCount + 1L;
			if (base.EncoderFallback.MaxCharCount > 1)
			{
				num *= base.EncoderFallback.MaxCharCount;
			}
			num *= 3;
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("charCount", SR.ArgumentOutOfRange_GetByteCountOverflow);
			}
			return (int)num;
		}

		public override int GetMaxCharCount(int byteCount)
		{
			if (byteCount < 0)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			long num = (long)byteCount + 1L;
			if (base.DecoderFallback.MaxCharCount > 1)
			{
				num *= base.DecoderFallback.MaxCharCount;
			}
			if (num > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("byteCount", SR.ArgumentOutOfRange_GetCharCountOverflow);
			}
			return (int)num;
		}

		public override byte[] GetPreamble()
		{
			if (_emitUTF8Identifier)
			{
				return new byte[3] { 239, 187, 191 };
			}
			return Array.Empty<byte>();
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is UTF8Encoding uTF8Encoding)
			{
				if (_emitUTF8Identifier == uTF8Encoding._emitUTF8Identifier && base.EncoderFallback.Equals(uTF8Encoding.EncoderFallback))
				{
					return base.DecoderFallback.Equals(uTF8Encoding.DecoderFallback);
				}
				return false;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.EncoderFallback.GetHashCode() + base.DecoderFallback.GetHashCode() + 65001 + (_emitUTF8Identifier ? 1 : 0);
		}
	}
	internal ref struct ValueStringBuilder
	{
		private char[] _arrayToReturnToPool;

		private Span<char> _chars;

		private int _pos;

		public int Length
		{
			get
			{
				return _pos;
			}
			set
			{
				_pos = value;
			}
		}

		public int Capacity => _chars.Length;

		public ref char this[int index] => ref _chars[index];

		public Span<char> RawChars => _chars;

		internal void AppendSpanFormattable<T>(T value, string format, IFormatProvider provider) where T : ISpanFormattable
		{
			if (value.TryFormat(_chars.Slice(_pos), out var charsWritten, format, provider))
			{
				_pos += charsWritten;
			}
			else
			{
				Append(value.ToString(format, provider));
			}
		}

		internal void AppendFormatHelper(IFormatProvider provider, string format, ParamsArray args)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			int length = format.Length;
			char c = '\0';
			ICustomFormatter customFormatter = (ICustomFormatter)(provider?.GetFormat(typeof(ICustomFormatter)));
			while (true)
			{
				if (num < length)
				{
					c = format[num];
					num++;
					if (c == '}')
					{
						if (num < length && format[num] == '}')
						{
							num++;
						}
						else
						{
							ThrowFormatError();
						}
					}
					else if (c == '{')
					{
						if (num >= length || format[num] != '{')
						{
							num--;
							goto IL_008f;
						}
						num++;
					}
					Append(c);
					continue;
				}
				goto IL_008f;
				IL_008f:
				if (num == length)
				{
					break;
				}
				num++;
				if (num == length || (c = format[num]) < '0' || c > '9')
				{
					ThrowFormatError();
				}
				int num2 = 0;
				do
				{
					num2 = num2 * 10 + c - 48;
					num++;
					if (num == length)
					{
						ThrowFormatError();
					}
					c = format[num];
				}
				while (c >= '0' && c <= '9' && num2 < 1000000);
				if (num2 >= args.Length)
				{
					throw new FormatException(SR.Format_IndexOutOfRange);
				}
				for (; num < length; num++)
				{
					if ((c = format[num]) != ' ')
					{
						break;
					}
				}
				bool flag = false;
				int num3 = 0;
				if (c == ',')
				{
					for (num++; num < length && format[num] == ' '; num++)
					{
					}
					if (num == length)
					{
						ThrowFormatError();
					}
					c = format[num];
					if (c == '-')
					{
						flag = true;
						num++;
						if (num == length)
						{
							ThrowFormatError();
						}
						c = format[num];
					}
					if (c < '0' || c > '9')
					{
						ThrowFormatError();
					}
					do
					{
						num3 = num3 * 10 + c - 48;
						num++;
						if (num == length)
						{
							ThrowFormatError();
						}
						c = format[num];
					}
					while (c >= '0' && c <= '9' && num3 < 1000000);
				}
				for (; num < length; num++)
				{
					if ((c = format[num]) != ' ')
					{
						break;
					}
				}
				object obj = args[num2];
				ReadOnlySpan<char> readOnlySpan = default(ReadOnlySpan<char>);
				switch (c)
				{
				case ':':
				{
					num++;
					int num4 = num;
					while (true)
					{
						if (num == length)
						{
							ThrowFormatError();
						}
						c = format[num];
						switch (c)
						{
						case '{':
							ThrowFormatError();
							goto IL_0205;
						default:
							goto IL_0205;
						case '}':
							break;
						}
						break;
						IL_0205:
						num++;
					}
					if (num > num4)
					{
						readOnlySpan = format.AsSpan(num4, num - num4);
					}
					break;
				}
				default:
					ThrowFormatError();
					break;
				case '}':
					break;
				}
				num++;
				string text = null;
				string text2 = null;
				if (customFormatter != null)
				{
					if (readOnlySpan.Length != 0)
					{
						text2 = new string(readOnlySpan);
					}
					text = customFormatter.Format(text2, obj, provider);
				}
				if (text == null)
				{
					if (obj is ISpanFormattable spanFormattable && (flag || num3 == 0) && spanFormattable.TryFormat(_chars.Slice(_pos), out var charsWritten, readOnlySpan, provider))
					{
						_pos += charsWritten;
						int num5 = num3 - charsWritten;
						if (flag && num5 > 0)
						{
							Append(' ', num5);
						}
						continue;
					}
					if (obj is IFormattable formattable)
					{
						if (readOnlySpan.Length != 0 && text2 == null)
						{
							text2 = new string(readOnlySpan);
						}
						text = formattable.ToString(text2, provider);
					}
					else if (obj != null)
					{
						text = obj.ToString();
					}
				}
				if (text == null)
				{
					text = string.Empty;
				}
				int num6 = num3 - text.Length;
				if (!flag && num6 > 0)
				{
					Append(' ', num6);
				}
				Append(text);
				if (flag && num6 > 0)
				{
					Append(' ', num6);
				}
			}
		}

		private static void ThrowFormatError()
		{
			throw new FormatException(SR.Format_InvalidString);
		}

		public ValueStringBuilder(Span<char> initialBuffer)
		{
			_arrayToReturnToPool = null;
			_chars = initialBuffer;
			_pos = 0;
		}

		public ValueStringBuilder(int initialCapacity)
		{
			_arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
			_chars = _arrayToReturnToPool;
			_pos = 0;
		}

		public void EnsureCapacity(int capacity)
		{
			if ((uint)capacity > (uint)_chars.Length)
			{
				Grow(capacity - _pos);
			}
		}

		public ref char GetPinnableReference()
		{
			return ref MemoryMarshal.GetReference(_chars);
		}

		public ref char GetPinnableReference(bool terminate)
		{
			if (terminate)
			{
				EnsureCapacity(Length + 1);
				_chars[Length] = '\0';
			}
			return ref MemoryMarshal.GetReference(_chars);
		}

		public override string ToString()
		{
			string result = _chars.Slice(0, _pos).ToString();
			Dispose();
			return result;
		}

		public ReadOnlySpan<char> AsSpan(bool terminate)
		{
			if (terminate)
			{
				EnsureCapacity(Length + 1);
				_chars[Length] = '\0';
			}
			return _chars.Slice(0, _pos);
		}

		public ReadOnlySpan<char> AsSpan()
		{
			return _chars.Slice(0, _pos);
		}

		public ReadOnlySpan<char> AsSpan(int start)
		{
			return _chars.Slice(start, _pos - start);
		}

		public ReadOnlySpan<char> AsSpan(int start, int length)
		{
			return _chars.Slice(start, length);
		}

		public bool TryCopyTo(Span<char> destination, out int charsWritten)
		{
			if (_chars.Slice(0, _pos).TryCopyTo(destination))
			{
				charsWritten = _pos;
				Dispose();
				return true;
			}
			charsWritten = 0;
			Dispose();
			return false;
		}

		public void Insert(int index, string s)
		{
			if (s != null)
			{
				int length = s.Length;
				if (_pos > _chars.Length - length)
				{
					Grow(length);
				}
				int length2 = _pos - index;
				_chars.Slice(index, length2).CopyTo(_chars.Slice(index + length));
				s.CopyTo(_chars.Slice(index));
				_pos += length;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(char c)
		{
			int pos = _pos;
			if ((uint)pos < (uint)_chars.Length)
			{
				_chars[pos] = c;
				_pos = pos + 1;
			}
			else
			{
				GrowAndAppend(c);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(string s)
		{
			if (s != null)
			{
				int pos = _pos;
				if (s.Length == 1 && (uint)pos < (uint)_chars.Length)
				{
					_chars[pos] = s[0];
					_pos = pos + 1;
				}
				else
				{
					AppendSlow(s);
				}
			}
		}

		private void AppendSlow(string s)
		{
			int pos = _pos;
			if (pos > _chars.Length - s.Length)
			{
				Grow(s.Length);
			}
			s.CopyTo(_chars.Slice(pos));
			_pos += s.Length;
		}

		public void Append(char c, int count)
		{
			if (_pos > _chars.Length - count)
			{
				Grow(count);
			}
			Span<char> span = _chars.Slice(_pos, count);
			for (int i = 0; i < span.Length; i++)
			{
				span[i] = c;
			}
			_pos += count;
		}

		public unsafe void Append(char* value, int length)
		{
			int pos = _pos;
			if (pos > _chars.Length - length)
			{
				Grow(length);
			}
			Span<char> span = _chars.Slice(_pos, length);
			for (int i = 0; i < span.Length; i++)
			{
				span[i] = *(value++);
			}
			_pos += length;
		}

		public void Append(ReadOnlySpan<char> value)
		{
			int pos = _pos;
			if (pos > _chars.Length - value.Length)
			{
				Grow(value.Length);
			}
			value.CopyTo(_chars.Slice(_pos));
			_pos += value.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span<char> AppendSpan(int length)
		{
			int pos = _pos;
			if (pos > _chars.Length - length)
			{
				Grow(length);
			}
			_pos = pos + length;
			return _chars.Slice(pos, length);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void GrowAndAppend(char c)
		{
			Grow(1);
			Append(c);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void Grow(int additionalCapacityBeyondPos)
		{
			char[] array = ArrayPool<char>.Shared.Rent((int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), (uint)(_chars.Length * 2)));
			_chars.Slice(0, _pos).CopyTo(array);
			char[] arrayToReturnToPool = _arrayToReturnToPool;
			_chars = (_arrayToReturnToPool = array);
			if (arrayToReturnToPool != null)
			{
				ArrayPool<char>.Shared.Return(arrayToReturnToPool);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Dispose()
		{
			char[] arrayToReturnToPool = _arrayToReturnToPool;
			this = default(ValueStringBuilder);
			if (arrayToReturnToPool != null)
			{
				ArrayPool<char>.Shared.Return(arrayToReturnToPool);
			}
		}
	}
	internal static class StringBuilderCache
	{
		[ThreadStatic]
		private static StringBuilder t_cachedInstance;

		public static StringBuilder Acquire(int capacity = 16)
		{
			if (capacity <= 360)
			{
				StringBuilder stringBuilder = t_cachedInstance;
				if (stringBuilder != null && capacity <= stringBuilder.Capacity)
				{
					t_cachedInstance = null;
					stringBuilder.Clear();
					return stringBuilder;
				}
			}
			return new StringBuilder(capacity);
		}

		public static void Release(StringBuilder sb)
		{
			if (sb.Capacity <= 360)
			{
				t_cachedInstance = sb;
			}
		}

		public static string GetStringAndRelease(StringBuilder sb)
		{
			string result = sb.ToString();
			Release(sb);
			return result;
		}
	}
}
namespace System.Text.Unicode
{
	internal enum GraphemeClusterBreakType
	{
		Other,
		CR,
		LF,
		Control,
		Extend,
		ZWJ,
		Regional_Indicator,
		Prepend,
		SpacingMark,
		L,
		V,
		T,
		LV,
		LVT,
		Extended_Pictograph
	}
	internal static class TextSegmentationUtility
	{
		private delegate OperationStatus DecodeFirstRune<T>(ReadOnlySpan<T> input, out Rune rune, out int elementsConsumed);

		[StructLayout(LayoutKind.Auto)]
		private ref struct Processor<T>
		{
			private readonly ReadOnlySpan<T> _buffer;

			private readonly DecodeFirstRune<T> _decoder;

			private int _codeUnitLengthOfCurrentScalar;

			public int CurrentCodeUnitOffset { get; private set; }

			public GraphemeClusterBreakType CurrentType { get; private set; }

			internal Processor(ReadOnlySpan<T> buffer, DecodeFirstRune<T> decoder)
			{
				_buffer = buffer;
				_decoder = decoder;
				_codeUnitLengthOfCurrentScalar = 0;
				CurrentType = GraphemeClusterBreakType.Other;
				CurrentCodeUnitOffset = 0;
			}

			public void MoveNext()
			{
				CurrentCodeUnitOffset += _codeUnitLengthOfCurrentScalar;
				_decoder(_buffer.Slice(CurrentCodeUnitOffset), out var rune, out _codeUnitLengthOfCurrentScalar);
				CurrentType = CharUnicodeInfo.GetGraphemeClusterBreakType(rune);
			}
		}

		private static readonly DecodeFirstRune<char> _utf16Decoder = Rune.DecodeFromUtf16;

		private static int GetLengthOfFirstExtendedGraphemeCluster<T>(ReadOnlySpan<T> input, DecodeFirstRune<T> decoder)
		{
			Processor<T> processor = new Processor<T>(input, decoder);
			processor.MoveNext();
			while (processor.CurrentType == GraphemeClusterBreakType.Prepend)
			{
				processor.MoveNext();
			}
			if (processor.CurrentCodeUnitOffset <= 0 || (processor.CurrentType != GraphemeClusterBreakType.Control && processor.CurrentType != GraphemeClusterBreakType.CR && processor.CurrentType != GraphemeClusterBreakType.LF))
			{
				GraphemeClusterBreakType currentType = processor.CurrentType;
				processor.MoveNext();
				switch (currentType)
				{
				case GraphemeClusterBreakType.CR:
					if (processor.CurrentType == GraphemeClusterBreakType.LF)
					{
						processor.MoveNext();
					}
					break;
				case GraphemeClusterBreakType.L:
					while (processor.CurrentType == GraphemeClusterBreakType.L)
					{
						processor.MoveNext();
					}
					if (processor.CurrentType == GraphemeClusterBreakType.V)
					{
						processor.MoveNext();
					}
					else
					{
						if (processor.CurrentType != GraphemeClusterBreakType.LV)
						{
							if (processor.CurrentType == GraphemeClusterBreakType.LVT)
							{
								processor.MoveNext();
								goto case GraphemeClusterBreakType.T;
							}
							goto default;
						}
						processor.MoveNext();
					}
					goto case GraphemeClusterBreakType.V;
				case GraphemeClusterBreakType.V:
				case GraphemeClusterBreakType.LV:
					while (processor.CurrentType == GraphemeClusterBreakType.V)
					{
						processor.MoveNext();
					}
					if (processor.CurrentType == GraphemeClusterBreakType.T)
					{
						processor.MoveNext();
						goto case GraphemeClusterBreakType.T;
					}
					goto default;
				case GraphemeClusterBreakType.T:
				case GraphemeClusterBreakType.LVT:
					while (processor.CurrentType == GraphemeClusterBreakType.T)
					{
						processor.MoveNext();
					}
					goto default;
				case GraphemeClusterBreakType.Extended_Pictograph:
					while (true)
					{
						if (processor.CurrentType == GraphemeClusterBreakType.Extend)
						{
							processor.MoveNext();
							continue;
						}
						if (processor.CurrentType != GraphemeClusterBreakType.ZWJ)
						{
							break;
						}
						processor.MoveNext();
						if (processor.CurrentType != GraphemeClusterBreakType.Extended_Pictograph)
						{
							break;
						}
						processor.MoveNext();
					}
					goto default;
				case GraphemeClusterBreakType.Regional_Indicator:
					if (processor.CurrentType == GraphemeClusterBreakType.Regional_Indicator)
					{
						processor.MoveNext();
					}
					goto default;
				default:
					while (processor.CurrentType == GraphemeClusterBreakType.Extend || processor.CurrentType == GraphemeClusterBreakType.ZWJ || processor.CurrentType == GraphemeClusterBreakType.SpacingMark)
					{
						processor.MoveNext();
					}
					break;
				case GraphemeClusterBreakType.LF:
				case GraphemeClusterBreakType.Control:
					break;
				}
			}
			return processor.CurrentCodeUnitOffset;
		}

		public static int GetLengthOfFirstUtf16ExtendedGraphemeCluster(ReadOnlySpan<char> input)
		{
			return GetLengthOfFirstExtendedGraphemeCluster(input, _utf16Decoder);
		}
	}
	internal static class Utf16Utility
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool AllCharsInUInt32AreAscii(uint value)
		{
			return (value & 0xFF80FF80u) == 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool AllCharsInUInt64AreAscii(ulong value)
		{
			return (value & 0xFF80FF80FF80FF80uL) == 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ConvertAllAsciiCharsInUInt32ToLowercase(uint value)
		{
			uint num = value + 8388736 - 4259905;
			uint num2 = value + 8388736 - 5963867;
			uint num3 = num ^ num2;
			uint num4 = (num3 & 0x800080) >> 2;
			return value ^ num4;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ConvertAllAsciiCharsInUInt32ToUppercase(uint value)
		{
			uint num = value + 8388736 - 6357089;
			uint num2 = value + 8388736 - 8061051;
			uint num3 = num ^ num2;
			uint num4 = (num3 & 0x800080) >> 2;
			return value ^ num4;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool UInt32ContainsAnyLowercaseAsciiChar(uint value)
		{
			uint num = value + 8388736 - 6357089;
			uint num2 = value + 8388736 - 8061051;
			uint num3 = num ^ num2;
			return (num3 & 0x800080) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool UInt32ContainsAnyUppercaseAsciiChar(uint value)
		{
			uint num = value + 8388736 - 4259905;
			uint num2 = value + 8388736 - 5963867;
			uint num3 = num ^ num2;
			return (num3 & 0x800080) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool UInt32OrdinalIgnoreCaseAscii(uint valueA, uint valueB)
		{
			uint num = (valueA ^ valueB) << 2;
			uint num2 = valueA + 327685;
			num2 |= 0xA000A0u;
			num2 += 1703962;
			num2 |= 0xFF7FFF7Fu;
			return (num & num2) == 0;
		}

		public unsafe static char* GetPointerToFirstInvalidChar(char* pInputBuffer, int inputLength, out long utf8CodeUnitCountAdjustment, out int scalarCountAdjustment)
		{
			int num = (int)ASCIIUtility.GetIndexOfFirstNonAsciiChar(pInputBuffer, (uint)inputLength);
			pInputBuffer += (uint)num;
			inputLength -= num;
			if (inputLength == 0)
			{
				utf8CodeUnitCountAdjustment = 0L;
				scalarCountAdjustment = 0;
				return pInputBuffer;
			}
			long num2 = 0L;
			int num3 = 0;
			char* ptr = pInputBuffer + (uint)inputLength;
			if (Sse41.IsSupported)
			{
				if (inputLength >= Vector128<ushort>.Count)
				{
					Vector128<ushort> right = Vector128.Create((ushort)128);
					Vector128<ushort> vector = Vector128.Create((ushort)30720);
					Vector128<ushort> right2 = Vector128.Create((ushort)40960);
					if (!BitConverter.IsLittleEndian)
					{
					}
					Vector128<byte> vector2 = Vector128.Create(9241421688590303745uL).AsByte();
					char* ptr2 = ptr - Vector128<ushort>.Count;
					do
					{
						if (AdvSimd.Arm64.IsSupported)
						{
						}
						Vector128<ushort> vector3 = Sse2.LoadVector128((ushort*)pInputBuffer);
						pInputBuffer += Vector128<ushort>.Count;
						if (AdvSimd.Arm64.IsSupported)
						{
						}
						Vector128<ushort> left = Sse41.Min(vector3, right);
						if (AdvSimd.IsSupported)
						{
						}
						Vector128<ushort> right3 = Sse2.AddSaturate(vector3, vector);
						uint value = (uint)Sse2.MoveMask(Sse2.Or(left, right3).AsByte());
						nuint num4 = (uint)BitOperations.PopCount(value);
						if (AdvSimd.Arm64.IsSupported)
						{
						}
						value = (uint)Sse2.MoveMask(Sse2.CompareLessThan(Sse2.Add(vector3, right2).AsInt16(), vector.AsInt16()).AsByte());
						while (value != 65535)
						{
							value = ~value;
							if (AdvSimd.Arm64.IsSupported)
							{
							}
							uint num5 = (uint)Sse2.MoveMask(Sse2.ShiftRightLogical(vector3, 3).AsByte());
							uint num6 = num5 & value;
							uint num7 = (num5 ^ 0x5555u) & value;
							num7 <<= 2;
							if ((ushort)num7 == num6)
							{
								if (num7 > 65535)
								{
									num7 = (ushort)num7;
									num4 -= 2;
									pInputBuffer--;
								}
								nuint num8 = (uint)BitOperations.PopCount(num7);
								num3 -= (int)num8;
								if (IntPtr.Size == 8)
								{
								}
								num2 -= (uint)(2 * (int)num8);
								value = 65535u;
								continue;
							}
							goto IL_01c3;
						}
						num2 += (long)num4;
						continue;
						IL_01c3:
						pInputBuffer -= Vector128<ushort>.Count;
						break;
					}
					while (pInputBuffer <= ptr2);
				}
			}
			else if (Vector.IsHardwareAccelerated && inputLength >= Vector<ushort>.Count)
			{
				Vector<ushort> right4 = new Vector<ushort>(128);
				Vector<ushort> right5 = new Vector<ushort>(1024);
				Vector<ushort> right6 = new Vector<ushort>(2048);
				Vector<ushort> vector4 = new Vector<ushort>(55296);
				char* ptr3 = ptr - Vector<ushort>.Count;
				while (true)
				{
					Vector<ushort> left2 = Unsafe.ReadUnaligned<Vector<ushort>>(pInputBuffer);
					Vector<ushort> vector5 = Vector.GreaterThanOrEqual(left2, right4);
					Vector<ushort> vector6 = Vector.GreaterThanOrEqual(left2, right6);
					Vector<UIntPtr> vector7 = (Vector<nuint>)(Vector<ushort>.Zero - vector5 - vector6);
					nuint num9 = 0u;
					for (int i = 0; i < Vector<UIntPtr>.Count; i++)
					{
						num9 += (nuint)(nint)(nuint)vector7[i];
					}
					uint num10 = (uint)num9;
					if (IntPtr.Size == 8)
					{
					}
					num10 = (ushort)num10 + (num10 >> 16);
					left2 -= vector4;
					Vector<ushort> vector8 = Vector.LessThan(left2, right6);
					if (vector8 != Vector<ushort>.Zero)
					{
						Vector<ushort> right7 = Vector.LessThan(left2, right5);
						Vector<ushort> vector9 = Vector.AndNot(vector8, right7);
						if (vector9[0] != 0)
						{
							break;
						}
						ushort num11 = 0;
						int num12 = 0;
						while (num12 < Vector<ushort>.Count - 1)
						{
							num11 -= right7[num12];
							if (right7[num12] == vector9[num12 + 1])
							{
								num12++;
								continue;
							}
							goto IL_03d4;
						}
						if (right7[Vector<ushort>.Count - 1] != 0)
						{
							pInputBuffer--;
							num10 -= 2;
						}
						nint num13 = num11;
						num3 -= (int)num13;
						num2 -= num13;
						num2 -= num13;
					}
					num2 += num10;
					pInputBuffer += Vector<ushort>.Count;
					if (pInputBuffer <= ptr3)
					{
						continue;
					}
					goto IL_03d4;
				}
				goto IL_03d8;
			}
			goto IL_03d4;
			IL_03d8:
			utf8CodeUnitCountAdjustment = num2;
			scalarCountAdjustment = num3;
			return pInputBuffer;
			IL_03d4:
			while (pInputBuffer < ptr)
			{
				uint num14 = *pInputBuffer;
				if (num14 > 127)
				{
					num2 += num14 + 129024 >> 16;
					if (UnicodeUtility.IsSurrogateCodePoint(num14))
					{
						num2 -= 2;
						if ((nuint)((byte*)ptr - (nuint)pInputBuffer) < (nuint)4u)
						{
							break;
						}
						num14 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
						uint num15 = num14;
						if (!BitConverter.IsLittleEndian)
						{
						}
						if (((num15 - 3691042816u) & 0xFC00FC00u) != 0)
						{
							break;
						}
						num3--;
						num2 += 2;
						pInputBuffer++;
					}
				}
				pInputBuffer++;
			}
			goto IL_03d8;
		}
	}
	public static class Utf8
	{
		public unsafe static OperationStatus FromUtf16(ReadOnlySpan<char> source, Span<byte> destination, out int charsRead, out int bytesWritten, bool replaceInvalidSequences = true, bool isFinalBlock = true)
		{
			_ = source.Length;
			_ = destination.Length;
			fixed (char* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (byte* ptr2 = &MemoryMarshal.GetReference(destination))
				{
					OperationStatus operationStatus = OperationStatus.Done;
					char* pInputBufferRemaining = ptr;
					byte* pOutputBufferRemaining = ptr2;
					while (!source.IsEmpty)
					{
						operationStatus = Utf8Utility.TranscodeToUtf8((char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source)), source.Length, (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination)), destination.Length, out pInputBufferRemaining, out pOutputBufferRemaining);
						if (operationStatus <= OperationStatus.DestinationTooSmall || (operationStatus == OperationStatus.NeedMoreData && !isFinalBlock))
						{
							break;
						}
						if (!replaceInvalidSequences)
						{
							operationStatus = OperationStatus.InvalidData;
							break;
						}
						destination = destination.Slice((int)(pOutputBufferRemaining - (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination))));
						if (destination.Length <= 2)
						{
							operationStatus = OperationStatus.DestinationTooSmall;
							break;
						}
						destination[0] = 239;
						destination[1] = 191;
						destination[2] = 189;
						destination = destination.Slice(3);
						source = source.Slice((int)(pInputBufferRemaining - (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source))) + 1);
						operationStatus = OperationStatus.Done;
						pInputBufferRemaining = (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source));
						pOutputBufferRemaining = (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination));
					}
					charsRead = (int)(pInputBufferRemaining - ptr);
					bytesWritten = (int)(pOutputBufferRemaining - ptr2);
					return operationStatus;
				}
			}
		}

		public unsafe static OperationStatus ToUtf16(ReadOnlySpan<byte> source, Span<char> destination, out int bytesRead, out int charsWritten, bool replaceInvalidSequences = true, bool isFinalBlock = true)
		{
			_ = source.Length;
			_ = destination.Length;
			fixed (byte* ptr = &MemoryMarshal.GetReference(source))
			{
				fixed (char* ptr2 = &MemoryMarshal.GetReference(destination))
				{
					OperationStatus operationStatus = OperationStatus.Done;
					byte* pInputBufferRemaining = ptr;
					char* pOutputBufferRemaining = ptr2;
					while (!source.IsEmpty)
					{
						operationStatus = Utf8Utility.TranscodeToUtf16((byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source)), source.Length, (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination)), destination.Length, out pInputBufferRemaining, out pOutputBufferRemaining);
						if (operationStatus <= OperationStatus.DestinationTooSmall || (operationStatus == OperationStatus.NeedMoreData && !isFinalBlock))
						{
							break;
						}
						if (!replaceInvalidSequences)
						{
							operationStatus = OperationStatus.InvalidData;
							break;
						}
						destination = destination.Slice((int)(pOutputBufferRemaining - (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination))));
						if (destination.IsEmpty)
						{
							operationStatus = OperationStatus.DestinationTooSmall;
							break;
						}
						destination[0] = '\ufffd';
						destination = destination.Slice(1);
						source = source.Slice((int)(pInputBufferRemaining - (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source))));
						Rune.DecodeFromUtf8(source, out var _, out var bytesConsumed);
						source = source.Slice(bytesConsumed);
						operationStatus = OperationStatus.Done;
						pInputBufferRemaining = (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source));
						pOutputBufferRemaining = (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(destination));
					}
					bytesRead = (int)(pInputBufferRemaining - ptr);
					charsWritten = (int)(pOutputBufferRemaining - ptr2);
					return operationStatus;
				}
			}
		}
	}
	internal static class Utf8Utility
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ExtractCharFromFirstThreeByteSequence(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			return ((value & 0x3F0000) >> 16) | ((value & 0x3F00) >> 2) | ((value & 0xF) << 12);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ExtractCharFromFirstTwoByteSequence(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			uint num = (uint)((byte)value << 6);
			return (byte)(value >> 8) + num - 12288 - 128;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ExtractCharsFromFourByteSequence(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			uint num = (uint)((byte)value << 8);
			num |= (value & 0x3F00) >> 6;
			num |= (value & 0x300000) >> 20;
			num |= (value & 0x3F000000) >> 8;
			num |= (value & 0xF0000) << 6;
			num -= 64;
			num -= 8192;
			num += 2048;
			return num + 3690987520u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ExtractFourUtf8BytesFromSurrogatePair(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			value += 64;
			uint value2 = BinaryPrimitives.ReverseEndianness(value & 0x3F0700u);
			value2 = BitOperations.RotateLeft(value2, 16);
			uint num = (value & 0xFC) << 6;
			uint num2 = (value >> 6) & 0xF0000u;
			num2 |= num;
			uint num3 = (value & 3) << 20;
			num3 |= 0x808080F0u;
			return num3 | value2 | num2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ExtractTwoCharsPackedFromTwoAdjacentTwoByteSequences(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			return ((value & 0x3F003F00) >> 8) | ((value & 0x1F001F) << 6);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ExtractTwoUtf8TwoByteSequencesFromTwoPackedUtf16Chars(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			return ((value >> 6) & 0x1F001F) + ((value << 8) & 0x3F003F00) + 2160099520u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ExtractUtf8TwoByteSequenceFromFirstUtf16Char(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			uint num = (value << 2) & 0x1F00u;
			value &= 0x3Fu;
			return BinaryPrimitives.ReverseEndianness((ushort)(num + value + 49280));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsFirstCharAscii(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((value & 0xFF80u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsFirstCharAtLeastThreeUtf8Bytes(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((value & 0xF800) == 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsFirstCharSurrogate(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (((value - 55296) & 0xF800u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsFirstCharTwoUtf8Bytes(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (((value - 128) & 0xFFFF) >= 1920)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsLowByteUtf8ContinuationByte(uint value)
		{
			return (uint)(byte)(value - 128) <= 63u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsSecondCharAscii(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (value >= 8388608)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsSecondCharAtLeastThreeUtf8Bytes(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((value & 0xF8000000u) == 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsSecondCharSurrogate(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((uint)((int)value - -671088640) >= 134217728u)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsSecondCharTwoUtf8Bytes(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (!UnicodeUtility.IsInRangeInclusive(value, 8388608u, 134217727u))
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsUtf8ContinuationByte(in byte value)
		{
			return (sbyte)value < -64;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsWellFormedUtf16SurrogatePair(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (((value - 3691042816u) & 0xFC00FC00u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static uint ToLittleEndian(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32BeginsWithOverlongUtf8TwoByteSequence(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((uint)(byte)value >= 194u)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32BeginsWithUtf8FourByteMask(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (((value - 2155905264u) & 0xC0C0C0F8u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32BeginsWithUtf8ThreeByteMask(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (((value - 8421600) & 0xC0C0F0u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32BeginsWithUtf8TwoByteMask(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (((value - 32960) & 0xC0E0u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (!UnicodeUtility.IsInRangeInclusive(value & 0xC0FFu, 32962u, 32991u))
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if (!UnicodeUtility.IsInRangeInclusive(value & 0xC0FF0000u, 2160197632u, 2162098176u))
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32FirstByteIsAscii(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((value & 0x80u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32FourthByteIsAscii(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((int)value < 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32SecondByteIsAscii(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((value & 0x8000u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool UInt32ThirdByteIsAscii(uint value)
		{
			_ = BitConverter.IsLittleEndian;
			if ((value & 0x800000u) != 0)
			{
				if (!BitConverter.IsLittleEndian)
				{
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteTwoUtf16CharsAsTwoUtf8ThreeByteSequences(ref byte outputBuffer, uint value)
		{
			_ = BitConverter.IsLittleEndian;
			uint num = ((value << 2) & 0x3F00u) | ((value & 0x3F) << 16);
			uint num2 = ((value >> 4) & 0xF000000u) | ((value >> 12) & 0xFu);
			Unsafe.WriteUnaligned(ref outputBuffer, num + num2 + 3766517984u);
			Unsafe.WriteUnaligned(ref Unsafe.Add(ref outputBuffer, 4), (ushort)(((value >> 22) & 0x3F) + ((value >> 8) & 0x3F00) + 32896));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteFirstUtf16CharAsUtf8ThreeByteSequence(ref byte outputBuffer, uint value)
		{
			_ = BitConverter.IsLittleEndian;
			uint num = (value << 2) & 0x3F00u;
			uint num2 = (uint)(ushort)value >> 12;
			Unsafe.WriteUnaligned(ref outputBuffer, (ushort)(num + num2 + 32992));
			Unsafe.Add(ref outputBuffer, 2) = (byte)((value & 0x3Fu) | 0xFFFFFF80u);
		}

		public unsafe static OperationStatus TranscodeToUtf16(byte* pInputBuffer, int inputLength, char* pOutputBuffer, int outputCharsRemaining, out byte* pInputBufferRemaining, out char* pOutputBufferRemaining)
		{
			nuint num = ASCIIUtility.WidenAsciiToUtf16(pInputBuffer, pOutputBuffer, (uint)Math.Min(inputLength, outputCharsRemaining));
			pInputBuffer += num;
			pOutputBuffer += num;
			if ((int)num == inputLength)
			{
				pInputBufferRemaining = pInputBuffer;
				pOutputBufferRemaining = pOutputBuffer;
				return OperationStatus.Done;
			}
			inputLength -= (int)num;
			outputCharsRemaining -= (int)num;
			if (inputLength < 4)
			{
				goto IL_0690;
			}
			byte* ptr = pInputBuffer + (uint)inputLength - 4;
			while (true)
			{
				IL_004a:
				uint num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
				while (true)
				{
					IL_0051:
					if (!ASCIIUtility.AllBytesInUInt32AreAscii(num2))
					{
						goto IL_0120;
					}
					int num4;
					uint num5;
					if (outputCharsRemaining >= 4)
					{
						ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref *pOutputBuffer, num2);
						pInputBuffer += 4;
						pOutputBuffer += 4;
						outputCharsRemaining -= 4;
						uint val = (uint)((int)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) + 4);
						uint num3 = Math.Min(val, (uint)outputCharsRemaining) / 8;
						num4 = 0;
						while ((uint)num4 < num3)
						{
							num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
							num5 = Unsafe.ReadUnaligned<uint>(pInputBuffer + 4);
							if (ASCIIUtility.AllBytesInUInt32AreAscii(num2 | num5))
							{
								pInputBuffer += 8;
								ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref *pOutputBuffer, num2);
								ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref pOutputBuffer[4], num5);
								pOutputBuffer += 8;
								num4++;
								continue;
							}
							goto IL_00f4;
						}
						outputCharsRemaining -= 8 * num4;
						goto IL_04aa;
					}
					goto IL_04b1;
					IL_04b1:
					inputLength = (int)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) + 4;
					goto IL_0690;
					IL_04aa:
					if (pInputBuffer <= ptr)
					{
						goto IL_004a;
					}
					goto IL_04b1;
					IL_0120:
					if (UInt32FirstByteIsAscii(num2))
					{
						if (outputCharsRemaining >= 3)
						{
							uint num6 = ToLittleEndian(num2);
							nuint num7 = 1u;
							*pOutputBuffer = (char)(byte)num6;
							if (UInt32SecondByteIsAscii(num2))
							{
								num7++;
								num6 >>= 8;
								pOutputBuffer[1] = (char)(byte)num6;
								if (UInt32ThirdByteIsAscii(num2))
								{
									num7++;
									num6 >>= 8;
									pOutputBuffer[2] = (char)(byte)num6;
								}
							}
							pInputBuffer += num7;
							pOutputBuffer += num7;
							outputCharsRemaining -= (int)num7;
						}
						else
						{
							if (outputCharsRemaining == 0)
							{
								break;
							}
							uint num8 = ToLittleEndian(num2);
							pInputBuffer++;
							*(pOutputBuffer++) = (char)(byte)num8;
							outputCharsRemaining--;
							if (UInt32SecondByteIsAscii(num2))
							{
								if (outputCharsRemaining == 0)
								{
									break;
								}
								pInputBuffer++;
								num8 >>= 8;
								*(pOutputBuffer++) = (char)(byte)num8;
								if (UInt32ThirdByteIsAscii(num2))
								{
									break;
								}
								outputCharsRemaining = 0;
							}
						}
						if (pInputBuffer > ptr)
						{
							goto IL_04b1;
						}
						num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
					}
					uint num9;
					while (UInt32BeginsWithUtf8TwoByteMask(num2))
					{
						if (!UInt32BeginsWithOverlongUtf8TwoByteSequence(num2))
						{
							while (true)
							{
								_ = BitConverter.IsLittleEndian;
								if (!UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian(num2) && BitConverter.IsLittleEndian)
								{
									break;
								}
								if (outputCharsRemaining >= 2)
								{
									Unsafe.WriteUnaligned(pOutputBuffer, ExtractTwoCharsPackedFromTwoAdjacentTwoByteSequences(num2));
									pInputBuffer += 4;
									pOutputBuffer += 2;
									outputCharsRemaining -= 2;
									if (pInputBuffer <= ptr)
									{
										num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
										_ = BitConverter.IsLittleEndian;
										if (!UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian(num2))
										{
											goto IL_0051;
										}
										continue;
									}
								}
								goto IL_04b1;
							}
							num9 = ExtractCharFromFirstTwoByteSequence(num2);
							if (UInt32ThirdByteIsAscii(num2))
							{
								if (UInt32FourthByteIsAscii(num2))
								{
									goto IL_0282;
								}
								if (outputCharsRemaining >= 2)
								{
									*pOutputBuffer = (char)num9;
									char* num10 = pOutputBuffer + 1;
									uint num11 = num2;
									if (!BitConverter.IsLittleEndian)
									{
									}
									*num10 = (char)(byte)(num11 >> 16);
									pInputBuffer += 3;
									pOutputBuffer += 2;
									outputCharsRemaining -= 2;
									if (ptr >= pInputBuffer)
									{
										num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
										continue;
									}
								}
							}
							else if (outputCharsRemaining != 0)
							{
								*pOutputBuffer = (char)num9;
								pInputBuffer += 2;
								pOutputBuffer++;
								outputCharsRemaining--;
								if (ptr >= pInputBuffer)
								{
									num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
									break;
								}
							}
							goto IL_04b1;
						}
						goto IL_06a3;
					}
					if (UInt32BeginsWithUtf8ThreeByteMask(num2))
					{
						while (true)
						{
							_ = BitConverter.IsLittleEndian;
							if ((num2 & 0x200F) == 0 || ((num2 - 8205) & 0x200F) == 0)
							{
								break;
							}
							if (outputCharsRemaining == 0)
							{
								goto end_IL_0051;
							}
							_ = BitConverter.IsLittleEndian;
							if ((((int)num2 - -536870912) & -268435456) == 0 && outputCharsRemaining > 1 && (nint)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) >= (nint)3)
							{
								uint num12 = Unsafe.ReadUnaligned<uint>(pInputBuffer + 3);
								if (UInt32BeginsWithUtf8ThreeByteMask(num12) && (num12 & 0x200Fu) != 0 && ((num12 - 8205) & 0x200Fu) != 0)
								{
									*pOutputBuffer = (char)ExtractCharFromFirstThreeByteSequence(num2);
									pOutputBuffer[1] = (char)ExtractCharFromFirstThreeByteSequence(num12);
									pInputBuffer += 6;
									pOutputBuffer += 2;
									outputCharsRemaining -= 2;
									goto IL_03ff;
								}
							}
							*pOutputBuffer = (char)ExtractCharFromFirstThreeByteSequence(num2);
							pInputBuffer += 3;
							pOutputBuffer++;
							outputCharsRemaining--;
							goto IL_03ff;
							IL_03ff:
							if (UInt32FourthByteIsAscii(num2))
							{
								if (outputCharsRemaining == 0)
								{
									goto end_IL_0051;
								}
								_ = BitConverter.IsLittleEndian;
								*pOutputBuffer = (char)(num2 >> 24);
								pInputBuffer++;
								pOutputBuffer++;
								outputCharsRemaining--;
							}
							if (pInputBuffer <= ptr)
							{
								num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
								if (!UInt32BeginsWithUtf8ThreeByteMask(num2))
								{
									goto IL_0051;
								}
								continue;
							}
							goto IL_04b1;
						}
					}
					else if (UInt32BeginsWithUtf8FourByteMask(num2))
					{
						_ = BitConverter.IsLittleEndian;
						uint value = num2 & 0xFFFFu;
						value = BitOperations.RotateRight(value, 8);
						if (UnicodeUtility.IsInRangeInclusive(value, 4026531984u, 4093640847u))
						{
							if (outputCharsRemaining < 2)
							{
								break;
							}
							Unsafe.WriteUnaligned(pOutputBuffer, ExtractCharsFromFourByteSequence(num2));
							pInputBuffer += 4;
							pOutputBuffer += 2;
							outputCharsRemaining -= 2;
							goto IL_04aa;
						}
					}
					goto IL_06a3;
					IL_0282:
					if (outputCharsRemaining >= 3)
					{
						*pOutputBuffer = (char)num9;
						_ = BitConverter.IsLittleEndian;
						num2 >>= 16;
						pOutputBuffer[1] = (char)(byte)num2;
						num2 >>= 8;
						pOutputBuffer[2] = (char)num2;
						pInputBuffer += 4;
						pOutputBuffer += 3;
						outputCharsRemaining -= 3;
						goto IL_04aa;
					}
					goto IL_04b1;
					IL_00f4:
					if (ASCIIUtility.AllBytesInUInt32AreAscii(num2))
					{
						ASCIIUtility.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref *pOutputBuffer, num2);
						num2 = num5;
						pInputBuffer += 4;
						pOutputBuffer += 4;
						outputCharsRemaining -= 4;
					}
					outputCharsRemaining -= 8 * num4;
					goto IL_0120;
					continue;
					end_IL_0051:
					break;
				}
				break;
			}
			goto IL_069f;
			IL_069f:
			OperationStatus result = OperationStatus.DestinationTooSmall;
			goto IL_06a5;
			IL_06a3:
			result = OperationStatus.InvalidData;
			goto IL_06a5;
			IL_06a5:
			pInputBufferRemaining = pInputBuffer;
			pOutputBufferRemaining = pOutputBuffer;
			return result;
			IL_0690:
			while (true)
			{
				if (inputLength > 0)
				{
					uint num13 = *pInputBuffer;
					if (num13 <= 127)
					{
						if (outputCharsRemaining != 0)
						{
							*pOutputBuffer = (char)num13;
							pInputBuffer++;
							pOutputBuffer++;
							inputLength--;
							outputCharsRemaining--;
							continue;
						}
						goto IL_069f;
					}
					num13 -= 194;
					if ((uint)(byte)num13 <= 29u)
					{
						if (inputLength < 2)
						{
							goto IL_069b;
						}
						uint num14 = pInputBuffer[1];
						if (IsLowByteUtf8ContinuationByte(num14))
						{
							if (outputCharsRemaining != 0)
							{
								uint num15 = (num13 << 6) + num14 + 128 - 128;
								*pOutputBuffer = (char)num15;
								pInputBuffer += 2;
								pOutputBuffer++;
								inputLength -= 2;
								outputCharsRemaining--;
								continue;
							}
							goto IL_069f;
						}
					}
					else if ((uint)(byte)num13 <= 45u)
					{
						if (inputLength >= 3)
						{
							uint num16 = pInputBuffer[1];
							uint num17 = pInputBuffer[2];
							if (IsLowByteUtf8ContinuationByte(num16) && IsLowByteUtf8ContinuationByte(num17))
							{
								uint num18 = (num13 << 12) + (num16 << 6);
								if (num18 >= 133120)
								{
									num18 -= 186368;
									if (num18 >= 2048)
									{
										if (outputCharsRemaining != 0)
										{
											num18 += num17;
											num18 += 55296;
											num18 -= 128;
											*pOutputBuffer = (char)num18;
											pInputBuffer += 3;
											pOutputBuffer++;
											inputLength -= 3;
											outputCharsRemaining--;
											continue;
										}
										goto IL_069f;
									}
								}
							}
						}
						else
						{
							if (inputLength < 2)
							{
								goto IL_069b;
							}
							uint num19 = pInputBuffer[1];
							if (IsLowByteUtf8ContinuationByte(num19))
							{
								uint num20 = (num13 << 6) + num19;
								if (num20 >= 2080 && !UnicodeUtility.IsInRangeInclusive(num20, 2912u, 2943u))
								{
									goto IL_069b;
								}
							}
						}
					}
					else if ((uint)(byte)num13 <= 50u)
					{
						if (inputLength < 2)
						{
							goto IL_069b;
						}
						uint num21 = pInputBuffer[1];
						if (IsLowByteUtf8ContinuationByte(num21))
						{
							uint value2 = (num13 << 6) + num21;
							if (UnicodeUtility.IsInRangeInclusive(value2, 3088u, 3343u))
							{
								if (inputLength < 3)
								{
									goto IL_069b;
								}
								if (IsLowByteUtf8ContinuationByte(pInputBuffer[2]))
								{
									if (inputLength < 4)
									{
										goto IL_069b;
									}
									if (IsLowByteUtf8ContinuationByte(pInputBuffer[3]))
									{
										goto IL_069f;
									}
								}
							}
						}
					}
					goto IL_06a3;
				}
				result = OperationStatus.Done;
				break;
				IL_069b:
				result = OperationStatus.NeedMoreData;
				break;
			}
			goto IL_06a5;
		}

		public unsafe static OperationStatus TranscodeToUtf8(char* pInputBuffer, int inputLength, byte* pOutputBuffer, int outputBytesRemaining, out char* pInputBufferRemaining, out byte* pOutputBufferRemaining)
		{
			nuint num = ASCIIUtility.NarrowUtf16ToAscii(pInputBuffer, pOutputBuffer, (uint)Math.Min(inputLength, outputBytesRemaining));
			pInputBuffer += num;
			pOutputBuffer += num;
			if ((int)num == inputLength)
			{
				pInputBufferRemaining = pInputBuffer;
				pOutputBufferRemaining = pOutputBuffer;
				return OperationStatus.Done;
			}
			inputLength -= (int)num;
			outputBytesRemaining -= (int)num;
			if (inputLength < 2)
			{
				goto IL_04f0;
			}
			char* ptr = pInputBuffer + (uint)inputLength - 2;
			Vector128<short> value;
			if (Sse41.X64.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				value = Vector128.Create((short)(-128));
			}
			uint num2;
			while (true)
			{
				IL_006d:
				num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
				while (true)
				{
					IL_0074:
					if (!Utf16Utility.AllCharsInUInt32AreAscii(num2))
					{
						goto IL_02e9;
					}
					if (outputBytesRemaining < 2)
					{
						break;
					}
					uint num3 = num2 | (num2 >> 8);
					Unsafe.WriteUnaligned(pOutputBuffer, (ushort)num3);
					pInputBuffer += 2;
					pOutputBuffer += 2;
					outputBytesRemaining -= 2;
					uint num4 = (uint)((int)(ptr - pInputBuffer) + 2);
					uint num5 = (uint)Math.Min(num4, outputBytesRemaining);
					int num7;
					ulong num8;
					Vector128<short> vector;
					int num10;
					uint num11;
					if (Sse41.X64.IsSupported || AdvSimd.Arm64.IsSupported)
					{
						uint num6 = num5 / 8;
						num7 = 0;
						while ((uint)num7 < num6)
						{
							Unsafe.SkipInit<Vector128<short>>(out value);
							vector = Unsafe.ReadUnaligned<Vector128<short>>(pInputBuffer);
							if (AdvSimd.IsSupported)
							{
							}
							if (Sse41.TestZ(vector, value))
							{
								Sse2.StoreScalar((ulong*)pOutputBuffer, Sse2.PackUnsignedSaturate(vector, vector).AsUInt64());
								pInputBuffer += 8;
								pOutputBuffer += 8;
								num7++;
								continue;
							}
							goto IL_019c;
						}
						outputBytesRemaining -= 8 * num7;
						if ((num5 & 4u) != 0)
						{
							num8 = Unsafe.ReadUnaligned<ulong>(pInputBuffer);
							if (!Utf16Utility.AllCharsInUInt64AreAscii(num8))
							{
								goto IL_0213;
							}
							vector = Vector128.CreateScalarUnsafe(num8).AsInt16();
							if (AdvSimd.IsSupported)
							{
							}
							Unsafe.WriteUnaligned(pOutputBuffer, Sse2.ConvertToUInt32(Sse2.PackUnsignedSaturate(vector, vector).AsUInt32()));
							pInputBuffer += 4;
							pOutputBuffer += 4;
							outputBytesRemaining -= 4;
						}
					}
					else
					{
						uint num9 = num5 / 4;
						num10 = 0;
						while ((uint)num10 < num9)
						{
							num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
							num11 = Unsafe.ReadUnaligned<uint>(pInputBuffer + 2);
							if (Utf16Utility.AllCharsInUInt32AreAscii(num2 | num11))
							{
								Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(num2 | (num2 >> 8)));
								Unsafe.WriteUnaligned(pOutputBuffer + 2, (ushort)(num11 | (num11 >> 8)));
								pInputBuffer += 4;
								pOutputBuffer += 4;
								num10++;
								continue;
							}
							goto IL_02b8;
						}
						outputBytesRemaining -= 4 * num10;
					}
					goto IL_04de;
					IL_04ae:
					if (IsWellFormedUtf16SurrogatePair(num2))
					{
						if (outputBytesRemaining >= 4)
						{
							Unsafe.WriteUnaligned(pOutputBuffer, ExtractFourUtf8BytesFromSurrogatePair(num2));
							pInputBuffer += 2;
							pOutputBuffer += 4;
							outputBytesRemaining -= 4;
							goto IL_04de;
						}
						goto IL_05a7;
					}
					goto IL_05ac;
					IL_038f:
					if (outputBytesRemaining >= 3)
					{
						_ = BitConverter.IsLittleEndian;
						num2 >>= 16;
						pOutputBuffer[2] = (byte)num2;
						pInputBuffer += 2;
						pOutputBuffer += 3;
						outputBytesRemaining -= 3;
						goto IL_04de;
					}
					pInputBuffer++;
					pOutputBuffer += 2;
					goto IL_05a7;
					IL_04de:
					if (pInputBuffer <= ptr)
					{
						goto IL_006d;
					}
					goto IL_04e5;
					IL_04e5:
					inputLength = (int)(ptr - pInputBuffer) + 2;
					goto IL_04f0;
					IL_0213:
					num2 = (uint)num8;
					if (Utf16Utility.AllCharsInUInt32AreAscii(num2))
					{
						Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(num2 | (num2 >> 8)));
						pInputBuffer += 2;
						pOutputBuffer += 2;
						outputBytesRemaining -= 2;
						num2 = (uint)(num8 >> 32);
					}
					goto IL_02e9;
					IL_019c:
					outputBytesRemaining -= 8 * num7;
					num8 = ((!Sse2.X64.IsSupported) ? vector.AsUInt64().ToScalar() : Sse2.X64.ConvertToUInt64(vector.AsUInt64()));
					if (Utf16Utility.AllCharsInUInt64AreAscii(num8))
					{
						if (AdvSimd.IsSupported)
						{
						}
						Unsafe.WriteUnaligned(pOutputBuffer, Sse2.ConvertToUInt32(Sse2.PackUnsignedSaturate(vector, vector).AsUInt32()));
						pInputBuffer += 4;
						pOutputBuffer += 4;
						outputBytesRemaining -= 4;
						num8 = vector.AsUInt64().GetElement(1);
					}
					goto IL_0213;
					IL_02b8:
					outputBytesRemaining -= 4 * num10;
					if (Utf16Utility.AllCharsInUInt32AreAscii(num2))
					{
						Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(num2 | (num2 >> 8)));
						pInputBuffer += 2;
						pOutputBuffer += 2;
						outputBytesRemaining -= 2;
						num2 = num11;
					}
					goto IL_02e9;
					IL_02e9:
					while (true)
					{
						if (IsFirstCharAscii(num2))
						{
							if (outputBytesRemaining == 0)
							{
								break;
							}
							_ = BitConverter.IsLittleEndian;
							*pOutputBuffer = (byte)num2;
							pInputBuffer++;
							pOutputBuffer++;
							outputBytesRemaining--;
							if (pInputBuffer > ptr)
							{
								goto IL_04e5;
							}
							num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
						}
						if (!IsFirstCharAtLeastThreeUtf8Bytes(num2))
						{
							while (IsSecondCharTwoUtf8Bytes(num2))
							{
								if (outputBytesRemaining < 4)
								{
									goto end_IL_0074;
								}
								Unsafe.WriteUnaligned(pOutputBuffer, ExtractTwoUtf8TwoByteSequencesFromTwoPackedUtf16Chars(num2));
								pInputBuffer += 2;
								pOutputBuffer += 4;
								outputBytesRemaining -= 4;
								if (pInputBuffer <= ptr)
								{
									num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
									if (!IsFirstCharTwoUtf8Bytes(num2))
									{
										goto IL_0074;
									}
									continue;
								}
								goto IL_04e5;
							}
							if (outputBytesRemaining < 2)
							{
								break;
							}
							Unsafe.WriteUnaligned(pOutputBuffer, (ushort)ExtractUtf8TwoByteSequenceFromFirstUtf16Char(num2));
							if (IsSecondCharAscii(num2))
							{
								goto IL_038f;
							}
							pInputBuffer++;
							pOutputBuffer += 2;
							outputBytesRemaining -= 2;
							if (pInputBuffer > ptr)
							{
								goto IL_04e5;
							}
							num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
						}
						while (!IsFirstCharSurrogate(num2))
						{
							if (IsSecondCharAtLeastThreeUtf8Bytes(num2) && !IsSecondCharSurrogate(num2) && outputBytesRemaining >= 6)
							{
								WriteTwoUtf16CharsAsTwoUtf8ThreeByteSequences(ref *pOutputBuffer, num2);
								pInputBuffer += 2;
								pOutputBuffer += 6;
								outputBytesRemaining -= 6;
								if (pInputBuffer <= ptr)
								{
									num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
									if (!IsFirstCharAtLeastThreeUtf8Bytes(num2))
									{
										goto IL_0074;
									}
									continue;
								}
							}
							else
							{
								if (outputBytesRemaining < 3)
								{
									goto end_IL_02e9;
								}
								WriteFirstUtf16CharAsUtf8ThreeByteSequence(ref *pOutputBuffer, num2);
								pInputBuffer++;
								pOutputBuffer += 3;
								outputBytesRemaining -= 3;
								if (!IsSecondCharAscii(num2))
								{
									goto IL_049e;
								}
								if (outputBytesRemaining == 0)
								{
									goto end_IL_02e9;
								}
								_ = BitConverter.IsLittleEndian;
								*pOutputBuffer = (byte)(num2 >> 16);
								pInputBuffer++;
								pOutputBuffer++;
								outputBytesRemaining--;
								if (pInputBuffer <= ptr)
								{
									num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
									if (!IsFirstCharAtLeastThreeUtf8Bytes(num2))
									{
										goto IL_0074;
									}
									continue;
								}
							}
							goto IL_04e5;
						}
						goto IL_04ae;
						IL_049e:
						if (pInputBuffer <= ptr)
						{
							num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
							continue;
						}
						goto IL_04e5;
						continue;
						end_IL_02e9:
						break;
					}
					goto IL_05a7;
					continue;
					end_IL_0074:
					break;
				}
				break;
			}
			_ = BitConverter.IsLittleEndian;
			uint num12 = num2 & 0xFFFFu;
			goto IL_050b;
			IL_0599:
			if (inputLength <= 1)
			{
				goto IL_059d;
			}
			goto IL_05a7;
			IL_04f0:
			if (inputLength != 0)
			{
				num12 = *pInputBuffer;
				goto IL_050b;
			}
			goto IL_059d;
			IL_05ac:
			OperationStatus result = OperationStatus.InvalidData;
			goto IL_05af;
			IL_05a7:
			result = OperationStatus.DestinationTooSmall;
			goto IL_05af;
			IL_05af:
			pInputBufferRemaining = pInputBuffer;
			pOutputBufferRemaining = pOutputBuffer;
			return result;
			IL_059d:
			result = OperationStatus.Done;
			goto IL_05af;
			IL_050b:
			if (num12 <= 127)
			{
				if (outputBytesRemaining != 0)
				{
					*pOutputBuffer = (byte)num12;
					pInputBuffer++;
					pOutputBuffer++;
					goto IL_0599;
				}
			}
			else if (num12 < 2048)
			{
				if (outputBytesRemaining >= 2)
				{
					pOutputBuffer[1] = (byte)((num12 & 0x3Fu) | 0xFFFFFF80u);
					*pOutputBuffer = (byte)((num12 >> 6) | 0xFFFFFFC0u);
					pInputBuffer++;
					pOutputBuffer += 2;
					goto IL_0599;
				}
			}
			else
			{
				if (UnicodeUtility.IsSurrogateCodePoint(num12))
				{
					if (num12 > 56319)
					{
						goto IL_05ac;
					}
					result = OperationStatus.NeedMoreData;
					goto IL_05af;
				}
				if (outputBytesRemaining >= 3)
				{
					pOutputBuffer[2] = (byte)((num12 & 0x3Fu) | 0xFFFFFF80u);
					pOutputBuffer[1] = (byte)(((num12 >> 6) & 0x3Fu) | 0xFFFFFF80u);
					*pOutputBuffer = (byte)((num12 >> 12) | 0xFFFFFFE0u);
					pInputBuffer++;
					pOutputBuffer += 3;
					goto IL_0599;
				}
			}
			goto IL_05a7;
		}

		public unsafe static byte* GetPointerToFirstInvalidByte(byte* pInputBuffer, int inputLength, out int utf16CodeUnitCountAdjustment, out int scalarCountAdjustment)
		{
			nuint indexOfFirstNonAsciiByte = ASCIIUtility.GetIndexOfFirstNonAsciiByte(pInputBuffer, (uint)inputLength);
			pInputBuffer += indexOfFirstNonAsciiByte;
			inputLength -= (int)indexOfFirstNonAsciiByte;
			if (inputLength == 0)
			{
				utf16CodeUnitCountAdjustment = 0;
				scalarCountAdjustment = 0;
				return pInputBuffer;
			}
			int num = 0;
			int num2 = 0;
			nuint num12;
			if (inputLength >= 4)
			{
				byte* ptr = pInputBuffer + (uint)inputLength - 4;
				while (pInputBuffer <= ptr)
				{
					uint num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
					while (true)
					{
						IL_0043:
						if (ASCIIUtility.AllBytesInUInt32AreAscii(num3))
						{
							pInputBuffer += 4;
							if ((nint)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) < (nint)16)
							{
								break;
							}
							num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
							if (ASCIIUtility.AllBytesInUInt32AreAscii(num3))
							{
								pInputBuffer = (byte*)((nuint)(pInputBuffer + 4) & ~(nuint)3u);
								byte* ptr2 = ptr - 12;
								if (AdvSimd.Arm64.IsSupported)
								{
								}
								uint num4;
								while (true)
								{
									if (Sse2.IsSupported)
									{
										num4 = (uint)Sse2.MoveMask(Sse2.LoadVector128(pInputBuffer));
										if (num4 != 0)
										{
											break;
										}
										goto IL_00da;
									}
									if (ASCIIUtility.AllBytesInUInt32AreAscii(*(uint*)pInputBuffer | *(uint*)(pInputBuffer + 4)))
									{
										if (ASCIIUtility.AllBytesInUInt32AreAscii(*(uint*)(pInputBuffer + (nint)2 * (nint)4) | *(uint*)(pInputBuffer + (nint)3 * (nint)4)))
										{
											goto IL_00da;
										}
										pInputBuffer += 8;
									}
									num3 = *(uint*)pInputBuffer;
									if (ASCIIUtility.AllBytesInUInt32AreAscii(num3))
									{
										pInputBuffer += 4;
										num3 = *(uint*)pInputBuffer;
									}
									goto IL_011e;
									IL_00da:
									pInputBuffer += 16;
									if (pInputBuffer > ptr2)
									{
										goto end_IL_0043;
									}
								}
								nuint num5 = (nuint)BitOperations.TrailingZeroCount(num4);
								pInputBuffer += num5;
								if (pInputBuffer > ptr)
								{
									goto end_IL_02e1;
								}
								num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
								goto IL_013d;
							}
						}
						goto IL_011e;
						IL_011e:
						uint num6 = ASCIIUtility.CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(num3);
						pInputBuffer += num6;
						if (ptr < pInputBuffer)
						{
							goto end_IL_02e1;
						}
						num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
						goto IL_013d;
						IL_013d:
						while (true)
						{
							uint num7 = num3;
							if (!BitConverter.IsLittleEndian)
							{
							}
							num3 = num7 - 32960;
							uint num8 = num3;
							if (!BitConverter.IsLittleEndian)
							{
							}
							if ((num8 & 0xC0E0u) != 0)
							{
								break;
							}
							_ = BitConverter.IsLittleEndian;
							if ((uint)(byte)num3 >= 2u)
							{
								if (!BitConverter.IsLittleEndian)
								{
								}
								while (true)
								{
									_ = BitConverter.IsLittleEndian;
									if (!UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian(num3) && BitConverter.IsLittleEndian)
									{
										break;
									}
									pInputBuffer += 4;
									num -= 2;
									if (pInputBuffer > ptr)
									{
										goto end_IL_02e1;
									}
									num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
									_ = BitConverter.IsLittleEndian;
									if (!UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian(num3))
									{
										goto IL_0043;
									}
								}
								num--;
								if (UInt32ThirdByteIsAscii(num3))
								{
									if (UInt32FourthByteIsAscii(num3))
									{
										pInputBuffer += 4;
										goto end_IL_0043;
									}
									pInputBuffer += 3;
									if (pInputBuffer > ptr)
									{
										goto end_IL_0043;
									}
									num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
									continue;
								}
								pInputBuffer += 2;
								goto end_IL_0043;
							}
							goto IL_03da;
						}
						uint num9 = num3;
						if (!BitConverter.IsLittleEndian)
						{
						}
						num3 = num9 - 8388640;
						uint num10 = num3;
						if (!BitConverter.IsLittleEndian)
						{
						}
						if ((num10 & 0xC0C0F0) == 0)
						{
							while (true)
							{
								_ = BitConverter.IsLittleEndian;
								if ((num3 & 0x200F) == 0 || ((num3 - 8205) & 0x200F) == 0)
								{
									break;
								}
								_ = BitConverter.IsLittleEndian;
								nint num11 = (int)num3 >> 31;
								pInputBuffer += 4;
								pInputBuffer += num11;
								num -= 2;
								if (IntPtr.Size >= 8)
								{
								}
								if (pInputBuffer > ptr)
								{
									goto end_IL_02e1;
								}
								num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
								if (!UInt32BeginsWithUtf8ThreeByteMask(num3))
								{
									goto IL_0043;
								}
							}
						}
						else
						{
							_ = BitConverter.IsLittleEndian;
							num3 &= 0xC0C0FFFFu;
							if ((int)num3 <= -2147467265)
							{
								num3 = BitOperations.RotateRight(num3, 8);
								if (UnicodeUtility.IsInRangeInclusive(num3, 276824080u, 343932943u))
								{
									pInputBuffer += 4;
									num -= 2;
									num2--;
									break;
								}
							}
						}
						goto IL_03da;
						continue;
						end_IL_0043:
						break;
					}
					continue;
					end_IL_02e1:
					break;
				}
				num12 = (nuint)((byte*)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) + 4);
			}
			else
			{
				num12 = (uint)inputLength;
			}
			while (num12 != 0)
			{
				uint num13 = *pInputBuffer;
				if ((uint)(byte)num13 < 128u)
				{
					pInputBuffer++;
					num12--;
					continue;
				}
				if (num12 < 2)
				{
					break;
				}
				uint value = pInputBuffer[1];
				if ((uint)(byte)num13 < 224u)
				{
					if ((uint)(byte)num13 < 194u || !IsLowByteUtf8ContinuationByte(value))
					{
						break;
					}
					pInputBuffer += 2;
					num--;
					num12 -= 2;
					continue;
				}
				if (num12 < 3 || (uint)(byte)num13 >= 240u)
				{
					break;
				}
				if ((byte)num13 == 224)
				{
					if (!UnicodeUtility.IsInRangeInclusive(value, 160u, 191u))
					{
						break;
					}
				}
				else if ((byte)num13 == 237)
				{
					if (!UnicodeUtility.IsInRangeInclusive(value, 128u, 159u))
					{
						break;
					}
				}
				else if (!IsLowByteUtf8ContinuationByte(value))
				{
					break;
				}
				if (!IsUtf8ContinuationByte(in pInputBuffer[2]))
				{
					break;
				}
				pInputBuffer += 3;
				num -= 2;
				num12 -= 3;
			}
			goto IL_03da;
			IL_03da:
			utf16CodeUnitCountAdjustment = num;
			scalarCountAdjustment = num2;
			return pInputBuffer;
		}
	}
}
namespace System.StubHelpers
{
	internal static class AnsiCharMarshaler
	{
		internal unsafe static byte[] DoAnsiConversion(string str, bool fBestFit, bool fThrowOnUnmappableChar, out int cbLength)
		{
			byte[] array = new byte[checked((str.Length + 1) * Marshal.SystemMaxDBCSCharSize)];
			fixed (byte* buffer = &array[0])
			{
				cbLength = Marshal.StringToAnsiString(str, buffer, array.Length, fBestFit, fThrowOnUnmappableChar);
			}
			return array;
		}

		internal unsafe static byte ConvertToNative(char managedChar, bool fBestFit, bool fThrowOnUnmappableChar)
		{
			int num = 2 * Marshal.SystemMaxDBCSCharSize;
			byte* ptr = stackalloc byte[(int)(uint)num];
			int num2 = Marshal.StringToAnsiString(managedChar.ToString(), ptr, num, fBestFit, fThrowOnUnmappableChar);
			return *ptr;
		}

		internal static char ConvertToManaged(byte nativeChar)
		{
			ReadOnlySpan<byte> bytes = new ReadOnlySpan<byte>(ref nativeChar, 1);
			string @string = Encoding.Default.GetString(bytes);
			return @string[0];
		}
	}
	internal static class CSTRMarshaler
	{
		internal unsafe static IntPtr ConvertToNative(int flags, string strManaged, IntPtr pNativeBuffer)
		{
			if (strManaged == null)
			{
				return IntPtr.Zero;
			}
			byte* ptr = (byte*)(void*)pNativeBuffer;
			int num;
			if (ptr != null || Marshal.SystemMaxDBCSCharSize == 1)
			{
				num = checked((strManaged.Length + 1) * Marshal.SystemMaxDBCSCharSize + 1);
				bool flag = false;
				if (ptr == null)
				{
					ptr = (byte*)(void*)Marshal.AllocCoTaskMem(num);
					flag = true;
				}
				try
				{
					num = Marshal.StringToAnsiString(strManaged, ptr, num, (flags & 0xFF) != 0, flags >> 8 != 0);
				}
				catch (Exception) when (flag)
				{
					Marshal.FreeCoTaskMem((IntPtr)ptr);
					throw;
				}
			}
			else if (strManaged.Length == 0)
			{
				num = 0;
				ptr = (byte*)(void*)Marshal.AllocCoTaskMem(2);
			}
			else
			{
				byte[] array = AnsiCharMarshaler.DoAnsiConversion(strManaged, (flags & 0xFF) != 0, flags >> 8 != 0, out num);
				ptr = (byte*)(void*)Marshal.AllocCoTaskMem(num + 2);
				Buffer.Memmove(ref *ptr, ref MemoryMarshal.GetArrayDataReference(array), (nuint)num);
			}
			ptr[num] = 0;
			ptr[num + 1] = 0;
			return (IntPtr)ptr;
		}

		internal unsafe static string ConvertToManaged(IntPtr cstr)
		{
			if (IntPtr.Zero == cstr)
			{
				return null;
			}
			return new string((sbyte*)(void*)cstr);
		}

		internal static void ClearNative(IntPtr pNative)
		{
			Marshal.FreeCoTaskMem(pNative);
		}

		internal unsafe static void ConvertFixedToNative(int flags, string strManaged, IntPtr pNativeBuffer, int length)
		{
			if (strManaged == null)
			{
				if (length > 0)
				{
					*(sbyte*)(void*)pNativeBuffer = 0;
				}
				return;
			}
			int num = strManaged.Length;
			if (num >= length)
			{
				num = length - 1;
			}
			byte* ptr = (byte*)(void*)pNativeBuffer;
			bool flag = flags >> 8 != 0;
			bool flag2 = (flags & 0xFF) != 0;
			uint num2 = 0u;
			int num3;
			fixed (char* lpWideCharStr = strManaged)
			{
				num3 = Interop.Kernel32.WideCharToMultiByte(0u, (!flag2) ? 1024u : 0u, lpWideCharStr, num, ptr, length, IntPtr.Zero, flag ? new IntPtr(&num2) : IntPtr.Zero);
			}
			if (num2 != 0)
			{
				throw new ArgumentException(SR.Interop_Marshal_Unmappable_Char);
			}
			if (num3 == length)
			{
				num3--;
			}
			ptr[num3] = 0;
		}

		internal unsafe static string ConvertFixedToManaged(IntPtr cstr, int length)
		{
			int num = SpanHelpers.IndexOf(ref *(byte*)(void*)cstr, 0, length);
			if (num != -1)
			{
				length = num;
			}
			return new string((sbyte*)(void*)cstr, 0, length);
		}
	}
	internal static class UTF8Marshaler
	{
		internal unsafe static IntPtr ConvertToNative(int flags, string strManaged, IntPtr pNativeBuffer)
		{
			if (strManaged == null)
			{
				return IntPtr.Zero;
			}
			byte* ptr = (byte*)(void*)pNativeBuffer;
			int cbNativeBuffer;
			if (ptr != null)
			{
				cbNativeBuffer = (strManaged.Length + 1) * 3;
				cbNativeBuffer = strManaged.GetBytesFromEncoding(ptr, cbNativeBuffer, Encoding.UTF8);
			}
			else
			{
				cbNativeBuffer = Encoding.UTF8.GetByteCount(strManaged);
				ptr = (byte*)(void*)Marshal.AllocCoTaskMem(cbNativeBuffer + 1);
				strManaged.GetBytesFromEncoding(ptr, cbNativeBuffer, Encoding.UTF8);
			}
			ptr[cbNativeBuffer] = 0;
			return (IntPtr)ptr;
		}

		internal unsafe static string ConvertToManaged(IntPtr cstr)
		{
			if (IntPtr.Zero == cstr)
			{
				return null;
			}
			byte* ptr = (byte*)(void*)cstr;
			int byteLength = string.strlen(ptr);
			return string.CreateStringFromEncoding(ptr, byteLength, Encoding.UTF8);
		}

		internal static void ClearNative(IntPtr pNative)
		{
			Marshal.FreeCoTaskMem(pNative);
		}
	}
	internal static class UTF8BufferMarshaler
	{
		internal unsafe static IntPtr ConvertToNative(StringBuilder sb, IntPtr pNativeBuffer, int flags)
		{
			if (sb == null)
			{
				return IntPtr.Zero;
			}
			string text = sb.ToString();
			int byteCount = Encoding.UTF8.GetByteCount(text);
			byte* ptr = (byte*)(void*)pNativeBuffer;
			byteCount = text.GetBytesFromEncoding(ptr, byteCount, Encoding.UTF8);
			ptr[byteCount] = 0;
			return (IntPtr)ptr;
		}

		internal unsafe static void ConvertToManaged(StringBuilder sb, IntPtr pNative)
		{
			if (!(pNative == IntPtr.Zero))
			{
				byte* ptr = (byte*)(void*)pNative;
				int length = string.strlen(ptr);
				sb.ReplaceBufferUtf8Internal(new ReadOnlySpan<byte>(ptr, length));
			}
		}
	}
	internal static class BSTRMarshaler
	{
		internal unsafe static IntPtr ConvertToNative(string strManaged, IntPtr pNativeBuffer)
		{
			if (strManaged == null)
			{
				return IntPtr.Zero;
			}
			byte data;
			bool flag = strManaged.TryGetTrailByte(out data);
			uint num = (uint)(strManaged.Length * 2);
			if (flag)
			{
				num++;
			}
			byte* ptr;
			if (pNativeBuffer != IntPtr.Zero)
			{
				*(uint*)(void*)pNativeBuffer = num;
				ptr = (byte*)(void*)pNativeBuffer + 4;
			}
			else
			{
				ptr = (byte*)(void*)Marshal.AllocBSTRByteLen(num);
			}
			Buffer.Memmove(ref *(char*)ptr, ref strManaged.GetRawStringData(), (nuint)strManaged.Length + (nuint)1u);
			if (flag)
			{
				ptr[num - 1] = data;
			}
			return (IntPtr)ptr;
		}

		internal unsafe static string ConvertToManaged(IntPtr bstr)
		{
			if (IntPtr.Zero == bstr)
			{
				return null;
			}
			uint num = Marshal.SysStringByteLen(bstr);
			StubHelpers.CheckStringLength(num);
			string text = ((num != 1) ? new string((char*)(void*)bstr, 0, (int)(num / 2)) : string.FastAllocateString(0));
			if ((num & 1) == 1)
			{
				text.SetTrailByte(((byte*)(void*)bstr)[num - 1]);
			}
			return text;
		}

		internal static void ClearNative(IntPtr pNative)
		{
			Marshal.FreeBSTR(pNative);
		}
	}
	internal static class VBByValStrMarshaler
	{
		internal unsafe static IntPtr ConvertToNative(string strManaged, bool fBestFit, bool fThrowOnUnmappableChar, ref int cch)
		{
			if (strManaged == null)
			{
				return IntPtr.Zero;
			}
			cch = strManaged.Length;
			int cb = checked(4 + (cch + 1) * Marshal.SystemMaxDBCSCharSize);
			byte* ptr = (byte*)(void*)Marshal.AllocCoTaskMem(cb);
			int* ptr2 = (int*)ptr;
			ptr += 4;
			if (cch == 0)
			{
				*ptr = 0;
				*ptr2 = 0;
			}
			else
			{
				int cbLength;
				byte[] array = AnsiCharMarshaler.DoAnsiConversion(strManaged, fBestFit, fThrowOnUnmappableChar, out cbLength);
				Buffer.Memmove(ref *ptr, ref MemoryMarshal.GetArrayDataReference(array), (nuint)cbLength);
				ptr[cbLength] = 0;
				*ptr2 = cbLength;
			}
			return new IntPtr(ptr);
		}

		internal unsafe static string ConvertToManaged(IntPtr pNative, int cch)
		{
			if (IntPtr.Zero == pNative)
			{
				return null;
			}
			return new string((sbyte*)(void*)pNative, 0, cch);
		}

		internal static void ClearNative(IntPtr pNative)
		{
			if (IntPtr.Zero != pNative)
			{
				Marshal.FreeCoTaskMem((IntPtr)((long)pNative - 4));
			}
		}
	}
	internal static class AnsiBSTRMarshaler
	{
		internal unsafe static IntPtr ConvertToNative(int flags, string strManaged)
		{
			if (strManaged == null)
			{
				return IntPtr.Zero;
			}
			byte[] array = null;
			int cbLength = 0;
			if (strManaged.Length > 0)
			{
				array = AnsiCharMarshaler.DoAnsiConversion(strManaged, (flags & 0xFF) != 0, flags >> 8 != 0, out cbLength);
			}
			uint num = (uint)cbLength;
			IntPtr intPtr = Marshal.AllocBSTRByteLen(num);
			if (array != null)
			{
				Buffer.Memmove(ref *(byte*)(void*)intPtr, ref MemoryMarshal.GetArrayDataReference(array), num);
			}
			return intPtr;
		}

		internal unsafe static string ConvertToManaged(IntPtr bstr)
		{
			if (IntPtr.Zero == bstr)
			{
				return null;
			}
			return new string((sbyte*)(void*)bstr);
		}

		internal static void ClearNative(IntPtr pNative)
		{
			Marshal.FreeBSTR(pNative);
		}
	}
	internal static class FixedWSTRMarshaler
	{
		internal unsafe static void ConvertToNative(string strManaged, IntPtr nativeHome, int length)
		{
			ReadOnlySpan<char> readOnlySpan = strManaged;
			Span<char> destination = new Span<char>((void*)nativeHome, length);
			int num = Math.Min(readOnlySpan.Length, length - 1);
			readOnlySpan.Slice(0, num).CopyTo(destination);
			destination[num] = '\0';
		}

		internal unsafe static string ConvertToManaged(IntPtr nativeHome, int length)
		{
			int num = SpanHelpers.IndexOf(ref *(char*)(void*)nativeHome, '\0', length);
			if (num != -1)
			{
				length = num;
			}
			return new string((char*)(void*)nativeHome, 0, length);
		}
	}
	internal static class ObjectMarshaler
	{
		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertToNative(object objSrc, IntPtr pDstVariant);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern object ConvertToManaged(IntPtr pSrcVariant);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ClearNative(IntPtr pVariant);
	}
	internal sealed class HandleMarshaler
	{
		internal static IntPtr ConvertSafeHandleToNative(SafeHandle handle, ref CleanupWorkListElement cleanupWorkList)
		{
			if (Unsafe.IsNullRef(ref cleanupWorkList))
			{
				throw new InvalidOperationException(SR.Interop_Marshal_SafeHandle_InvalidOperation);
			}
			if (handle == null)
			{
				throw new ArgumentNullException("handle");
			}
			return StubHelpers.AddToCleanupList(ref cleanupWorkList, handle);
		}

		internal static void ThrowSafeHandleFieldChanged()
		{
			throw new NotSupportedException(SR.Interop_Marshal_CannotCreateSafeHandleField);
		}

		internal static void ThrowCriticalHandleFieldChanged()
		{
			throw new NotSupportedException(SR.Interop_Marshal_CannotCreateCriticalHandleField);
		}
	}
	internal static class DateMarshaler
	{
		internal static double ConvertToNative(DateTime managedDate)
		{
			return managedDate.ToOADate();
		}

		internal static long ConvertToManaged(double nativeDate)
		{
			return DateTime.DoubleDateToTicks(nativeDate);
		}
	}
	internal static class InterfaceMarshaler
	{
		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IntPtr ConvertToNative(object objSrc, IntPtr itfMT, IntPtr classMT, int flags);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern object ConvertToManaged(ref IntPtr ppUnk, IntPtr itfMT, IntPtr classMT, int flags);

		[DllImport("QCall")]
		internal static extern void ClearNative(IntPtr pUnk);
	}
	internal static class MngdNativeArrayMarshaler
	{
		internal struct MarshalerState
		{
			private IntPtr m_pElementMT;

			private IntPtr m_Array;

			private IntPtr m_pManagedNativeArrayMarshaler;

			private int m_NativeDataValid;

			private int m_BestFitMap;

			private int m_ThrowOnUnmappableChar;

			private short m_vt;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void CreateMarshaler(IntPtr pMarshalState, IntPtr pMT, int dwFlags, IntPtr pManagedMarshaler);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertSpaceToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertContentsToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertSpaceToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome, int cElements);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertContentsToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ClearNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome, int cElements);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ClearNativeContents(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome, int cElements);
	}
	internal static class MngdFixedArrayMarshaler
	{
		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void CreateMarshaler(IntPtr pMarshalState, IntPtr pMT, int dwFlags, int cElements, IntPtr pManagedMarshaler);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertSpaceToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertContentsToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertSpaceToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertContentsToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ClearNativeContents(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);
	}
	internal static class MngdSafeArrayMarshaler
	{
		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void CreateMarshaler(IntPtr pMarshalState, IntPtr pMT, int iRank, int dwFlags, IntPtr pManagedMarshaler);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertSpaceToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertContentsToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome, object pOriginalManaged);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertSpaceToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertContentsToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ClearNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);
	}
	internal static class MngdRefCustomMarshaler
	{
		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void CreateMarshaler(IntPtr pMarshalState, IntPtr pCMHelper);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertContentsToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ConvertContentsToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ClearNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ClearManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);
	}
	internal struct AsAnyMarshaler
	{
		private enum BackPropAction
		{
			None,
			Array,
			Layout,
			StringBuilderAnsi,
			StringBuilderUnicode
		}

		private IntPtr pvArrayMarshaler;

		private BackPropAction backPropAction;

		private Type layoutType;

		private CleanupWorkListElement cleanupWorkList;

		private static bool IsIn(int dwFlags)
		{
			return (dwFlags & 0x10000000) != 0;
		}

		private static bool IsOut(int dwFlags)
		{
			return (dwFlags & 0x20000000) != 0;
		}

		private static bool IsAnsi(int dwFlags)
		{
			return (dwFlags & 0xFF0000) != 0;
		}

		private static bool IsThrowOn(int dwFlags)
		{
			return (dwFlags & 0xFF00) != 0;
		}

		private static bool IsBestFit(int dwFlags)
		{
			return (dwFlags & 0xFF) != 0;
		}

		internal AsAnyMarshaler(IntPtr pvArrayMarshaler)
		{
			this.pvArrayMarshaler = pvArrayMarshaler;
			backPropAction = BackPropAction.None;
			layoutType = null;
			cleanupWorkList = null;
		}

		private unsafe IntPtr ConvertArrayToNative(object pManagedHome, int dwFlags)
		{
			Type elementType = pManagedHome.GetType().GetElementType();
			VarEnum varEnum = VarEnum.VT_EMPTY;
			switch (Type.GetTypeCode(elementType))
			{
			case TypeCode.SByte:
				varEnum = VarEnum.VT_I1;
				break;
			case TypeCode.Byte:
				varEnum = VarEnum.VT_UI1;
				break;
			case TypeCode.Int16:
				varEnum = VarEnum.VT_I2;
				break;
			case TypeCode.UInt16:
				varEnum = VarEnum.VT_UI2;
				break;
			case TypeCode.Int32:
				varEnum = VarEnum.VT_I4;
				break;
			case TypeCode.UInt32:
				varEnum = VarEnum.VT_UI4;
				break;
			case TypeCode.Int64:
				varEnum = VarEnum.VT_I8;
				break;
			case TypeCode.UInt64:
				varEnum = VarEnum.VT_UI8;
				break;
			case TypeCode.Single:
				varEnum = VarEnum.VT_R4;
				break;
			case TypeCode.Double:
				varEnum = VarEnum.VT_R8;
				break;
			case TypeCode.Char:
				varEnum = (IsAnsi(dwFlags) ? ((VarEnum)253) : VarEnum.VT_UI2);
				break;
			case TypeCode.Boolean:
				varEnum = (VarEnum)254;
				break;
			case TypeCode.Object:
				if (elementType == typeof(IntPtr))
				{
					if (IntPtr.Size != 4)
					{
					}
					varEnum = VarEnum.VT_I4;
					break;
				}
				if (elementType == typeof(UIntPtr))
				{
					if (IntPtr.Size != 4)
					{
					}
					varEnum = VarEnum.VT_UI4;
					break;
				}
				goto default;
			default:
				throw new ArgumentException(SR.Arg_NDirectBadObject);
			}
			int num = (int)varEnum;
			if (IsBestFit(dwFlags))
			{
				num |= 0x10000;
			}
			if (IsThrowOn(dwFlags))
			{
				num |= 0x1000000;
			}
			MngdNativeArrayMarshaler.CreateMarshaler(pvArrayMarshaler, IntPtr.Zero, num, IntPtr.Zero);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out IntPtr result);
			IntPtr pNativeHome = new IntPtr(&result);
			MngdNativeArrayMarshaler.ConvertSpaceToNative(pvArrayMarshaler, ref pManagedHome, pNativeHome);
			if (IsIn(dwFlags))
			{
				MngdNativeArrayMarshaler.ConvertContentsToNative(pvArrayMarshaler, ref pManagedHome, pNativeHome);
			}
			if (IsOut(dwFlags))
			{
				backPropAction = BackPropAction.Array;
			}
			return result;
		}

		private unsafe static IntPtr ConvertStringToNative(string pManagedHome, int dwFlags)
		{
			IntPtr intPtr;
			if (IsAnsi(dwFlags))
			{
				intPtr = CSTRMarshaler.ConvertToNative(dwFlags & 0xFFFF, pManagedHome, IntPtr.Zero);
			}
			else
			{
				int cb = (pManagedHome.Length + 1) * 2;
				intPtr = Marshal.AllocCoTaskMem(cb);
				Buffer.Memmove(ref *(char*)(void*)intPtr, ref pManagedHome.GetRawStringData(), (nuint)pManagedHome.Length + (nuint)1u);
			}
			return intPtr;
		}

		private unsafe IntPtr ConvertStringBuilderToNative(StringBuilder pManagedHome, int dwFlags)
		{
			int capacity = pManagedHome.Capacity;
			int length = pManagedHome.Length;
			if (length > capacity)
			{
				ThrowHelper.ThrowInvalidOperationException();
			}
			IntPtr intPtr;
			if (IsAnsi(dwFlags))
			{
				StubHelpers.CheckStringLength(capacity);
				int num = checked(capacity * Marshal.SystemMaxDBCSCharSize + 4);
				intPtr = Marshal.AllocCoTaskMem(num);
				byte* ptr = (byte*)(void*)intPtr;
				*(ptr + num - 3) = 0;
				*(ptr + num - 2) = 0;
				*(ptr + num - 1) = 0;
				if (IsIn(dwFlags))
				{
					int num2 = Marshal.StringToAnsiString(pManagedHome.ToString(), ptr, num, IsBestFit(dwFlags), IsThrowOn(dwFlags));
				}
				if (IsOut(dwFlags))
				{
					backPropAction = BackPropAction.StringBuilderAnsi;
				}
			}
			else
			{
				int num3 = checked(capacity * 2 + 4);
				intPtr = Marshal.AllocCoTaskMem(num3);
				byte* ptr2 = (byte*)(void*)intPtr;
				*(ptr2 + num3 - 1) = 0;
				*(ptr2 + num3 - 2) = 0;
				if (IsIn(dwFlags))
				{
					pManagedHome.InternalCopy(intPtr, length);
					int num4 = length * 2;
					ptr2[num4] = 0;
					(ptr2 + num4)[1] = 0;
				}
				if (IsOut(dwFlags))
				{
					backPropAction = BackPropAction.StringBuilderUnicode;
				}
			}
			return intPtr;
		}

		private unsafe IntPtr ConvertLayoutToNative(object pManagedHome, int dwFlags)
		{
			int cb = Marshal.SizeOfHelper(pManagedHome.GetType(), throwIfNotMarshalable: false);
			IntPtr intPtr = Marshal.AllocCoTaskMem(cb);
			if (IsIn(dwFlags))
			{
				StubHelpers.FmtClassUpdateNativeInternal(pManagedHome, (byte*)(void*)intPtr, ref cleanupWorkList);
			}
			if (IsOut(dwFlags))
			{
				backPropAction = BackPropAction.Layout;
			}
			layoutType = pManagedHome.GetType();
			return intPtr;
		}

		internal IntPtr ConvertToNative(object pManagedHome, int dwFlags)
		{
			if (pManagedHome == null)
			{
				return IntPtr.Zero;
			}
			if (pManagedHome is ArrayWithOffset)
			{
				throw new ArgumentException(SR.Arg_MarshalAsAnyRestriction);
			}
			if (pManagedHome.GetType().IsArray)
			{
				return ConvertArrayToNative(pManagedHome, dwFlags);
			}
			if (pManagedHome is string pManagedHome2)
			{
				return ConvertStringToNative(pManagedHome2, dwFlags);
			}
			if (pManagedHome is StringBuilder pManagedHome3)
			{
				return ConvertStringBuilderToNative(pManagedHome3, dwFlags);
			}
			if (pManagedHome.GetType().IsLayoutSequential || pManagedHome.GetType().IsExplicitLayout)
			{
				return ConvertLayoutToNative(pManagedHome, dwFlags);
			}
			throw new ArgumentException(SR.Arg_NDirectBadObject);
		}

		internal unsafe void ConvertToManaged(object pManagedHome, IntPtr pNativeHome)
		{
			switch (backPropAction)
			{
			case BackPropAction.Array:
				MngdNativeArrayMarshaler.ConvertContentsToManaged(pvArrayMarshaler, ref pManagedHome, new IntPtr(&pNativeHome));
				break;
			case BackPropAction.Layout:
				StubHelpers.FmtClassUpdateCLRInternal(pManagedHome, (byte*)(void*)pNativeHome);
				break;
			case BackPropAction.StringBuilderAnsi:
			{
				int newLength2 = ((!(pNativeHome == IntPtr.Zero)) ? string.strlen((byte*)(void*)pNativeHome) : 0);
				((StringBuilder)pManagedHome).ReplaceBufferAnsiInternal((sbyte*)(void*)pNativeHome, newLength2);
				break;
			}
			case BackPropAction.StringBuilderUnicode:
			{
				int newLength = ((!(pNativeHome == IntPtr.Zero)) ? string.wcslen((char*)(void*)pNativeHome) : 0);
				((StringBuilder)pManagedHome).ReplaceBufferInternal((char*)(void*)pNativeHome, newLength);
				break;
			}
			}
		}

		internal void ClearNative(IntPtr pNativeHome)
		{
			if (pNativeHome != IntPtr.Zero)
			{
				if (layoutType != null)
				{
					Marshal.DestroyStructure(pNativeHome, layoutType);
				}
				Marshal.FreeCoTaskMem(pNativeHome);
			}
			StubHelpers.DestroyCleanupList(ref cleanupWorkList);
		}
	}
	internal struct NativeVariant
	{
		private ushort vt;

		private ushort wReserved1;

		private ushort wReserved2;

		private ushort wReserved3;

		private long data1;
	}
	internal struct NativeDecimal
	{
		private ushort reserved;

		private ushort signScale;

		private uint hi32;

		private ulong lo64;
	}
	internal abstract class CleanupWorkListElement
	{
		private CleanupWorkListElement m_Next;

		protected abstract void DestroyCore();

		public void Destroy()
		{
			DestroyCore();
			for (CleanupWorkListElement next = m_Next; next != null; next = next.m_Next)
			{
				next.DestroyCore();
			}
		}

		public static void AddToCleanupList(ref CleanupWorkListElement list, CleanupWorkListElement newElement)
		{
			if (list == null)
			{
				list = newElement;
				return;
			}
			newElement.m_Next = list;
			list = newElement;
		}
	}
	internal sealed class KeepAliveCleanupWorkListElement : CleanupWorkListElement
	{
		private object m_obj;

		public KeepAliveCleanupWorkListElement(object obj)
		{
			m_obj = obj;
		}

		protected override void DestroyCore()
		{
			GC.KeepAlive(m_obj);
		}
	}
	internal sealed class SafeHandleCleanupWorkListElement : CleanupWorkListElement
	{
		private SafeHandle m_handle;

		private bool m_owned;

		public SafeHandleCleanupWorkListElement(SafeHandle handle)
		{
			m_handle = handle;
		}

		protected override void DestroyCore()
		{
			if (m_owned)
			{
				StubHelpers.SafeHandleRelease(m_handle);
			}
		}

		public IntPtr AddRef()
		{
			return StubHelpers.SafeHandleAddRef(m_handle, ref m_owned);
		}
	}
	internal static class StubHelpers
	{
		[ThreadStatic]
		private static Exception s_pendingExceptionObject;

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void InitDeclaringType(IntPtr pMD);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IntPtr GetNDirectTarget(IntPtr pMD);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IntPtr GetDelegateTarget(Delegate pThis, ref IntPtr pStubArg);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ClearLastError();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void SetLastError();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ThrowInteropParamException(int resID, int paramIdx);

		internal static IntPtr AddToCleanupList(ref CleanupWorkListElement pCleanupWorkList, SafeHandle handle)
		{
			SafeHandleCleanupWorkListElement safeHandleCleanupWorkListElement = new SafeHandleCleanupWorkListElement(handle);
			CleanupWorkListElement.AddToCleanupList(ref pCleanupWorkList, safeHandleCleanupWorkListElement);
			return safeHandleCleanupWorkListElement.AddRef();
		}

		internal static void KeepAliveViaCleanupList(ref CleanupWorkListElement pCleanupWorkList, object obj)
		{
			KeepAliveCleanupWorkListElement newElement = new KeepAliveCleanupWorkListElement(obj);
			CleanupWorkListElement.AddToCleanupList(ref pCleanupWorkList, newElement);
		}

		internal static void DestroyCleanupList(ref CleanupWorkListElement pCleanupWorkList)
		{
			if (pCleanupWorkList != null)
			{
				pCleanupWorkList.Destroy();
				pCleanupWorkList = null;
			}
		}

		internal static Exception GetHRExceptionObject(int hr)
		{
			Exception ex = InternalGetHRExceptionObject(hr);
			ex.InternalPreserveStackTrace();
			return ex;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern Exception InternalGetHRExceptionObject(int hr);

		internal static Exception GetCOMHRExceptionObject(int hr, IntPtr pCPCMD, object pThis)
		{
			Exception ex = InternalGetCOMHRExceptionObject(hr, pCPCMD, pThis);
			ex.InternalPreserveStackTrace();
			return ex;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern Exception InternalGetCOMHRExceptionObject(int hr, IntPtr pCPCMD, object pThis);

		internal static Exception GetPendingExceptionObject()
		{
			Exception ex = s_pendingExceptionObject;
			ex?.InternalPreserveStackTrace();
			s_pendingExceptionObject = null;
			return ex;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IntPtr CreateCustomMarshalerHelper(IntPtr pMD, int paramToken, IntPtr hndManagedType);

		internal static IntPtr SafeHandleAddRef(SafeHandle pHandle, ref bool success)
		{
			if (pHandle == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.pHandle, ExceptionResource.ArgumentNull_SafeHandle);
			}
			pHandle.DangerousAddRef(ref success);
			return pHandle.DangerousGetHandle();
		}

		internal static void SafeHandleRelease(SafeHandle pHandle)
		{
			if (pHandle == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.pHandle, ExceptionResource.ArgumentNull_SafeHandle);
			}
			pHandle.DangerousRelease();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IntPtr ProfilerBeginTransitionCallback(IntPtr pSecretParam, IntPtr pThread, object pThis);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ProfilerEndTransitionCallback(IntPtr pMD, IntPtr pThread);

		internal static void CheckStringLength(int length)
		{
			CheckStringLength((uint)length);
		}

		internal static void CheckStringLength(uint length)
		{
			if (length > 2147483632)
			{
				throw new MarshalDirectiveException(SR.Marshaler_StringTooLong);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern void FmtClassUpdateNativeInternal(object obj, byte* pNative, ref CleanupWorkListElement pCleanupWorkList);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern void FmtClassUpdateCLRInternal(object obj, byte* pNative);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal unsafe static extern void LayoutDestroyNativeInternal(object obj, byte* pNative);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern object AllocateInternal(IntPtr typeHandle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void MarshalToUnmanagedVaListInternal(IntPtr va_list, uint vaListSize, IntPtr pArgIterator);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void MarshalToManagedVaListInternal(IntPtr va_list, IntPtr pArgIterator);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern uint CalcVaListSize(IntPtr va_list);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ValidateObject(object obj, IntPtr pMD, object pThis);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void LogPinnedArgument(IntPtr localDesc, IntPtr nativeArg);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void ValidateByref(IntPtr byref, IntPtr pMD, object pThis);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		internal static extern IntPtr GetStubContext();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IntPtr NextCallReturnAddress();
	}
}
namespace System.Security
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	public sealed class AllowPartiallyTrustedCallersAttribute : Attribute
	{
		public PartialTrustVisibilityLevel PartialTrustVisibilityLevel { get; set; }
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public interface IPermission : ISecurityEncodable
	{
		IPermission Copy();

		void Demand();

		IPermission? Intersect(IPermission? target);

		bool IsSubsetOf(IPermission? target);

		IPermission? Union(IPermission? target);
	}
	public interface ISecurityEncodable
	{
		void FromXml(SecurityElement e);

		SecurityElement? ToXml();
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public interface IStackWalk
	{
		void Assert();

		void Demand();

		void Deny();

		void PermitOnly();
	}
	public enum PartialTrustVisibilityLevel
	{
		VisibleToAllHosts,
		NotVisibleByDefault
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public class PermissionSet : ICollection, System.Collections.IEnumerable, IDeserializationCallback, ISecurityEncodable, IStackWalk
	{
		public virtual int Count => 0;

		public virtual bool IsReadOnly => false;

		public virtual bool IsSynchronized => false;

		public virtual object SyncRoot => this;

		public PermissionSet(PermissionState state)
		{
		}

		public PermissionSet(PermissionSet? permSet)
		{
		}

		public IPermission? AddPermission(IPermission? perm)
		{
			return AddPermissionImpl(perm);
		}

		protected virtual IPermission? AddPermissionImpl(IPermission? perm)
		{
			return null;
		}

		public void Assert()
		{
		}

		public bool ContainsNonCodeAccessPermissions()
		{
			return false;
		}

		[Obsolete]
		public static byte[] ConvertPermissionSet(string inFormat, byte[] inData, string outFormat)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_CAS);
		}

		public virtual PermissionSet Copy()
		{
			return new PermissionSet(this);
		}

		public virtual void CopyTo(Array array, int index)
		{
		}

		public void Demand()
		{
		}

		[Obsolete]
		public void Deny()
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_CAS);
		}

		public override bool Equals(object? o)
		{
			return base.Equals(o);
		}

		public virtual void FromXml(SecurityElement et)
		{
		}

		public System.Collections.IEnumerator GetEnumerator()
		{
			return GetEnumeratorImpl();
		}

		protected virtual System.Collections.IEnumerator GetEnumeratorImpl()
		{
			return Array.Empty<object>().GetEnumerator();
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		public IPermission? GetPermission(Type? permClass)
		{
			return GetPermissionImpl(permClass);
		}

		protected virtual IPermission? GetPermissionImpl(Type? permClass)
		{
			return null;
		}

		public PermissionSet? Intersect(PermissionSet? other)
		{
			return null;
		}

		public bool IsEmpty()
		{
			return false;
		}

		public bool IsSubsetOf(PermissionSet? target)
		{
			return false;
		}

		public bool IsUnrestricted()
		{
			return false;
		}

		public void PermitOnly()
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_CAS);
		}

		public IPermission? RemovePermission(Type? permClass)
		{
			return RemovePermissionImpl(permClass);
		}

		protected virtual IPermission? RemovePermissionImpl(Type? permClass)
		{
			return null;
		}

		public static void RevertAssert()
		{
		}

		public IPermission? SetPermission(IPermission? perm)
		{
			return SetPermissionImpl(perm);
		}

		protected virtual IPermission? SetPermissionImpl(IPermission? perm)
		{
			return null;
		}

		void IDeserializationCallback.OnDeserialization(object sender)
		{
		}

		public override string ToString()
		{
			return base.ToString();
		}

		public virtual SecurityElement? ToXml()
		{
			return null;
		}

		public PermissionSet? Union(PermissionSet? other)
		{
			return null;
		}
	}
	public sealed class SecureString : IDisposable
	{
		private sealed class UnmanagedBuffer : SafeBuffer
		{
			private int _byteLength;

			private UnmanagedBuffer()
				: base(ownsHandle: true)
			{
			}

			public static UnmanagedBuffer Allocate(int byteLength)
			{
				UnmanagedBuffer unmanagedBuffer = new UnmanagedBuffer();
				unmanagedBuffer.SetHandle(Marshal.AllocHGlobal(byteLength));
				unmanagedBuffer.Initialize((ulong)byteLength);
				unmanagedBuffer._byteLength = byteLength;
				return unmanagedBuffer;
			}

			internal unsafe static void Copy(UnmanagedBuffer source, UnmanagedBuffer destination, ulong bytesLength)
			{
				if (bytesLength == 0L)
				{
					return;
				}
				byte* pointer = null;
				byte* pointer2 = null;
				try
				{
					source.AcquirePointer(ref pointer);
					destination.AcquirePointer(ref pointer2);
					Buffer.MemoryCopy(pointer, pointer2, destination.ByteLength, bytesLength);
				}
				finally
				{
					if (pointer2 != null)
					{
						destination.ReleasePointer();
					}
					if (pointer != null)
					{
						source.ReleasePointer();
					}
				}
			}

			protected unsafe override bool ReleaseHandle()
			{
				new Span<byte>((void*)handle, _byteLength).Clear();
				Marshal.FreeHGlobal(handle);
				return true;
			}
		}

		private readonly object _methodLock = new object();

		private UnmanagedBuffer _buffer;

		private int _decryptedLength;

		private bool _encrypted;

		private bool _readOnly;

		public int Length
		{
			get
			{
				EnsureNotDisposed();
				return Volatile.Read(ref _decryptedLength);
			}
		}

		public SecureString()
		{
			Initialize(ReadOnlySpan<char>.Empty);
		}

		[CLSCompliant(false)]
		public unsafe SecureString(char* value, int length)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (length > 65536)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_Length);
			}
			Initialize(new ReadOnlySpan<char>(value, length));
		}

		private void Initialize(ReadOnlySpan<char> value)
		{
			_buffer = UnmanagedBuffer.Allocate(GetAlignedByteSize(value.Length));
			_decryptedLength = value.Length;
			SafeBuffer bufferToRelease = null;
			try
			{
				Span<char> destination = AcquireSpan(ref bufferToRelease);
				value.CopyTo(destination);
			}
			finally
			{
				ProtectMemory();
				bufferToRelease?.DangerousRelease();
			}
		}

		private SecureString(SecureString str)
		{
			_buffer = UnmanagedBuffer.Allocate((int)str._buffer.ByteLength);
			UnmanagedBuffer.Copy(str._buffer, _buffer, str._buffer.ByteLength);
			_decryptedLength = str._decryptedLength;
			_encrypted = str._encrypted;
		}

		private void EnsureCapacity(int capacity)
		{
			if (capacity > 65536)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_Capacity);
			}
			if ((uint)(capacity * 2) > _buffer.ByteLength)
			{
				UnmanagedBuffer buffer = _buffer;
				UnmanagedBuffer unmanagedBuffer = UnmanagedBuffer.Allocate(GetAlignedByteSize(capacity));
				UnmanagedBuffer.Copy(buffer, unmanagedBuffer, (uint)(_decryptedLength * 2));
				_buffer = unmanagedBuffer;
				buffer.Dispose();
			}
		}

		public void AppendChar(char c)
		{
			lock (_methodLock)
			{
				EnsureNotDisposed();
				EnsureNotReadOnly();
				SafeBuffer bufferToRelease = null;
				try
				{
					UnprotectMemory();
					EnsureCapacity(_decryptedLength + 1);
					AcquireSpan(ref bufferToRelease)[_decryptedLength] = c;
					_decryptedLength++;
				}
				finally
				{
					ProtectMemory();
					bufferToRelease?.DangerousRelease();
				}
			}
		}

		public void Clear()
		{
			lock (_methodLock)
			{
				EnsureNotDisposed();
				EnsureNotReadOnly();
				_decryptedLength = 0;
				SafeBuffer bufferToRelease = null;
				try
				{
					AcquireSpan(ref bufferToRelease).Clear();
				}
				finally
				{
					bufferToRelease?.DangerousRelease();
				}
			}
		}

		public SecureString Copy()
		{
			lock (_methodLock)
			{
				EnsureNotDisposed();
				return new SecureString(this);
			}
		}

		public void Dispose()
		{
			lock (_methodLock)
			{
				if (_buffer != null)
				{
					_buffer.Dispose();
					_buffer = null;
				}
			}
		}

		public void InsertAt(int index, char c)
		{
			lock (_methodLock)
			{
				if (index < 0 || index > _decryptedLength)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_IndexString);
				}
				EnsureNotDisposed();
				EnsureNotReadOnly();
				SafeBuffer bufferToRelease = null;
				try
				{
					UnprotectMemory();
					EnsureCapacity(_decryptedLength + 1);
					Span<char> span = AcquireSpan(ref bufferToRelease);
					span.Slice(index, _decryptedLength - index).CopyTo(span.Slice(index + 1));
					span[index] = c;
					_decryptedLength++;
				}
				finally
				{
					ProtectMemory();
					bufferToRelease?.DangerousRelease();
				}
			}
		}

		public bool IsReadOnly()
		{
			EnsureNotDisposed();
			return Volatile.Read(ref _readOnly);
		}

		public void MakeReadOnly()
		{
			EnsureNotDisposed();
			Volatile.Write(ref _readOnly, value: true);
		}

		public void RemoveAt(int index)
		{
			lock (_methodLock)
			{
				if (index < 0 || index >= _decryptedLength)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_IndexString);
				}
				EnsureNotDisposed();
				EnsureNotReadOnly();
				SafeBuffer bufferToRelease = null;
				try
				{
					UnprotectMemory();
					Span<char> span = AcquireSpan(ref bufferToRelease);
					span.Slice(index + 1, _decryptedLength - (index + 1)).CopyTo(span.Slice(index));
					_decryptedLength--;
				}
				finally
				{
					ProtectMemory();
					bufferToRelease?.DangerousRelease();
				}
			}
		}

		public void SetAt(int index, char c)
		{
			lock (_methodLock)
			{
				if (index < 0 || index >= _decryptedLength)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_IndexString);
				}
				EnsureNotDisposed();
				EnsureNotReadOnly();
				SafeBuffer bufferToRelease = null;
				try
				{
					UnprotectMemory();
					AcquireSpan(ref bufferToRelease)[index] = c;
				}
				finally
				{
					ProtectMemory();
					bufferToRelease?.DangerousRelease();
				}
			}
		}

		private unsafe Span<char> AcquireSpan(ref SafeBuffer bufferToRelease)
		{
			SafeBuffer buffer = _buffer;
			bool success = false;
			buffer.DangerousAddRef(ref success);
			bufferToRelease = buffer;
			return new Span<char>((void*)buffer.DangerousGetHandle(), (int)(buffer.ByteLength / 2));
		}

		private void EnsureNotReadOnly()
		{
			if (_readOnly)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
			}
		}

		private void EnsureNotDisposed()
		{
			if (_buffer == null)
			{
				throw new ObjectDisposedException(GetType().Name);
			}
		}

		internal unsafe IntPtr MarshalToBSTR()
		{
			lock (_methodLock)
			{
				EnsureNotDisposed();
				UnprotectMemory();
				SafeBuffer bufferToRelease = null;
				IntPtr intPtr = IntPtr.Zero;
				int length = 0;
				try
				{
					Span<char> span = AcquireSpan(ref bufferToRelease);
					length = _decryptedLength;
					intPtr = Marshal.AllocBSTR(length);
					span.Slice(0, length).CopyTo(new Span<char>((void*)intPtr, length));
					IntPtr result = intPtr;
					intPtr = IntPtr.Zero;
					return result;
				}
				finally
				{
					if (intPtr != IntPtr.Zero)
					{
						new Span<char>((void*)intPtr, length).Clear();
						Marshal.FreeBSTR(intPtr);
					}
					ProtectMemory();
					bufferToRelease?.DangerousRelease();
				}
			}
		}

		internal unsafe IntPtr MarshalToString(bool globalAlloc, bool unicode)
		{
			lock (_methodLock)
			{
				EnsureNotDisposed();
				UnprotectMemory();
				SafeBuffer bufferToRelease = null;
				IntPtr intPtr = IntPtr.Zero;
				int num = 0;
				try
				{
					Span<char> span = AcquireSpan(ref bufferToRelease).Slice(0, _decryptedLength);
					num = ((!unicode) ? Marshal.GetAnsiStringByteCount(span) : ((span.Length + 1) * 2));
					intPtr = ((!globalAlloc) ? Marshal.AllocCoTaskMem(num) : Marshal.AllocHGlobal(num));
					if (unicode)
					{
						Span<char> destination = new Span<char>((void*)intPtr, num / 2);
						span.CopyTo(destination);
						destination[destination.Length - 1] = '\0';
					}
					else
					{
						Marshal.GetAnsiStringBytes(span, new Span<byte>((void*)intPtr, num));
					}
					IntPtr result = intPtr;
					intPtr = IntPtr.Zero;
					return result;
				}
				finally
				{
					if (intPtr != IntPtr.Zero)
					{
						new Span<byte>((void*)intPtr, num).Clear();
						if (globalAlloc)
						{
							Marshal.FreeHGlobal(intPtr);
						}
						else
						{
							Marshal.FreeCoTaskMem(intPtr);
						}
					}
					ProtectMemory();
					bufferToRelease?.DangerousRelease();
				}
			}
		}

		private static int GetAlignedByteSize(int length)
		{
			int num = Math.Max(length, 1) * 2;
			return (num + 15) / 16 * 16;
		}

		private void ProtectMemory()
		{
			if (_decryptedLength != 0 && !_encrypted && !Interop.Crypt32.CryptProtectMemory(_buffer, (uint)_buffer.ByteLength, 0u))
			{
				throw new CryptographicException(Marshal.GetLastPInvokeError());
			}
			_encrypted = true;
		}

		private void UnprotectMemory()
		{
			if (_decryptedLength != 0 && _encrypted && !Interop.Crypt32.CryptUnprotectMemory(_buffer, (uint)_buffer.ByteLength, 0u))
			{
				throw new CryptographicException(Marshal.GetLastPInvokeError());
			}
			_encrypted = false;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	public sealed class SecurityCriticalAttribute : Attribute
	{
		[Obsolete("SecurityCriticalScope is only used for .NET 2.0 transparency compatibility.")]
		public SecurityCriticalScope Scope { get; }

		public SecurityCriticalAttribute()
		{
		}

		public SecurityCriticalAttribute(SecurityCriticalScope scope)
		{
			Scope = scope;
		}
	}
	[Obsolete("SecurityCriticalScope is only used for .NET 2.0 transparency compatibility.")]
	public enum SecurityCriticalScope
	{
		Explicit,
		Everything
	}
	public sealed class SecurityElement
	{
		internal string _tag;

		internal string _text;

		private ArrayList _children;

		internal ArrayList _attributes;

		private static readonly char[] s_tagIllegalCharacters = new char[3] { ' ', '<', '>' };

		private static readonly char[] s_textIllegalCharacters = new char[2] { '<', '>' };

		private static readonly char[] s_valueIllegalCharacters = new char[3] { '<', '>', '"' };

		private static readonly char[] s_escapeChars = new char[5] { '<', '>', '"', '\'', '&' };

		private static readonly string[] s_escapeStringPairs = new string[10] { "<", "&lt;", ">", "&gt;", "\"", "&quot;", "'", "&apos;", "&", "&amp;" };

		public string Tag
		{
			get
			{
				return _tag;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("Tag");
				}
				if (!IsValidTag(value))
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidElementTag, value));
				}
				_tag = value;
			}
		}

		public Hashtable? Attributes
		{
			get
			{
				if (_attributes == null || _attributes.Count == 0)
				{
					return null;
				}
				Hashtable hashtable = new Hashtable(_attributes.Count / 2);
				int count = _attributes.Count;
				for (int i = 0; i < count; i += 2)
				{
					hashtable.Add(_attributes[i], _attributes[i + 1]);
				}
				return hashtable;
			}
			set
			{
				if (value == null || value.Count == 0)
				{
					_attributes = null;
					return;
				}
				ArrayList arrayList = new ArrayList(value.Count);
				IDictionaryEnumerator enumerator = value.GetEnumerator();
				while (enumerator.MoveNext())
				{
					string text = (string)enumerator.Key;
					string text2 = (string)enumerator.Value;
					if (!IsValidAttributeName(text))
					{
						throw new ArgumentException(SR.Format(SR.Argument_InvalidElementName, text));
					}
					if (!IsValidAttributeValue(text2))
					{
						throw new ArgumentException(SR.Format(SR.Argument_InvalidElementValue, text2));
					}
					arrayList.Add(text);
					arrayList.Add(text2);
				}
				_attributes = arrayList;
			}
		}

		public string? Text
		{
			get
			{
				return Unescape(_text);
			}
			set
			{
				if (value == null)
				{
					_text = null;
					return;
				}
				if (!IsValidText(value))
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidElementTag, value));
				}
				_text = value;
			}
		}

		public ArrayList? Children
		{
			get
			{
				return _children;
			}
			set
			{
				if (value != null && value.Contains(null))
				{
					throw new ArgumentException(SR.ArgumentNull_Child);
				}
				_children = value;
			}
		}

		public SecurityElement(string tag)
		{
			if (tag == null)
			{
				throw new ArgumentNullException("tag");
			}
			if (!IsValidTag(tag))
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidElementTag, tag));
			}
			_tag = tag;
		}

		public SecurityElement(string tag, string? text)
		{
			if (tag == null)
			{
				throw new ArgumentNullException("tag");
			}
			if (!IsValidTag(tag))
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidElementTag, tag));
			}
			if (text != null && !IsValidText(text))
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidElementText, text));
			}
			_tag = tag;
			_text = text;
		}

		internal void AddAttributeSafe(string name, string value)
		{
			if (_attributes == null)
			{
				_attributes = new ArrayList(8);
			}
			else
			{
				int count = _attributes.Count;
				for (int i = 0; i < count; i += 2)
				{
					string a = (string)_attributes[i];
					if (string.Equals(a, name))
					{
						throw new ArgumentException(SR.Argument_AttributeNamesMustBeUnique);
					}
				}
			}
			_attributes.Add(name);
			_attributes.Add(value);
		}

		public void AddAttribute(string name, string value)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (!IsValidAttributeName(name))
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidElementName, name));
			}
			if (!IsValidAttributeValue(value))
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidElementValue, value));
			}
			AddAttributeSafe(name, value);
		}

		public void AddChild(SecurityElement child)
		{
			if (child == null)
			{
				throw new ArgumentNullException("child");
			}
			if (_children == null)
			{
				_children = new ArrayList(1);
			}
			_children.Add(child);
		}

		public bool Equal([NotNullWhen(true)] SecurityElement? other)
		{
			if (other == null)
			{
				return false;
			}
			if (!string.Equals(_tag, other._tag))
			{
				return false;
			}
			if (!string.Equals(_text, other._text))
			{
				return false;
			}
			if (_attributes == null || other._attributes == null)
			{
				if (_attributes != other._attributes)
				{
					return false;
				}
			}
			else
			{
				int count = _attributes.Count;
				if (count != other._attributes.Count)
				{
					return false;
				}
				for (int i = 0; i < count; i++)
				{
					string a = (string)_attributes[i];
					string b = (string)other._attributes[i];
					if (!string.Equals(a, b))
					{
						return false;
					}
				}
			}
			if (_children == null || other._children == null)
			{
				if (_children != other._children)
				{
					return false;
				}
			}
			else
			{
				if (_children.Count != other._children.Count)
				{
					return false;
				}
				System.Collections.IEnumerator enumerator = _children.GetEnumerator();
				System.Collections.IEnumerator enumerator2 = other._children.GetEnumerator();
				while (enumerator.MoveNext())
				{
					enumerator2.MoveNext();
					SecurityElement securityElement = (SecurityElement)enumerator.Current;
					SecurityElement other2 = (SecurityElement)enumerator2.Current;
					if (securityElement == null || !securityElement.Equal(other2))
					{
						return false;
					}
				}
			}
			return true;
		}

		public SecurityElement Copy()
		{
			SecurityElement securityElement = new SecurityElement(_tag, _text);
			securityElement._children = ((_children == null) ? null : new ArrayList(_children));
			securityElement._attributes = ((_attributes == null) ? null : new ArrayList(_attributes));
			return securityElement;
		}

		public static bool IsValidTag([NotNullWhen(true)] string? tag)
		{
			if (tag == null)
			{
				return false;
			}
			return tag.IndexOfAny(s_tagIllegalCharacters) == -1;
		}

		public static bool IsValidText([NotNullWhen(true)] string? text)
		{
			if (text == null)
			{
				return false;
			}
			return text.IndexOfAny(s_textIllegalCharacters) == -1;
		}

		public static bool IsValidAttributeName([NotNullWhen(true)] string? name)
		{
			return IsValidTag(name);
		}

		public static bool IsValidAttributeValue([NotNullWhen(true)] string? value)
		{
			if (value == null)
			{
				return false;
			}
			return value.IndexOfAny(s_valueIllegalCharacters) == -1;
		}

		private static string GetEscapeSequence(char c)
		{
			int num = s_escapeStringPairs.Length;
			for (int i = 0; i < num; i += 2)
			{
				string text = s_escapeStringPairs[i];
				string result = s_escapeStringPairs[i + 1];
				if (text[0] == c)
				{
					return result;
				}
			}
			return c.ToString();
		}

		[return: NotNullIfNotNull("str")]
		public static string? Escape(string? str)
		{
			if (str == null)
			{
				return null;
			}
			StringBuilder stringBuilder = null;
			int length = str.Length;
			int num = 0;
			while (true)
			{
				int num2 = str.IndexOfAny(s_escapeChars, num);
				if (num2 == -1)
				{
					break;
				}
				if (stringBuilder == null)
				{
					stringBuilder = new StringBuilder();
				}
				stringBuilder.Append(str, num, num2 - num);
				stringBuilder.Append(GetEscapeSequence(str[num2]));
				num = num2 + 1;
			}
			if (stringBuilder == null)
			{
				return str;
			}
			stringBuilder.Append(str, num, length - num);
			return stringBuilder.ToString();
		}

		private static string GetUnescapeSequence(string str, int index, out int newIndex)
		{
			int num = str.Length - index;
			int num2 = s_escapeStringPairs.Length;
			for (int i = 0; i < num2; i += 2)
			{
				string result = s_escapeStringPairs[i];
				string text = s_escapeStringPairs[i + 1];
				int length = text.Length;
				if (length <= num && string.Compare(text, 0, str, index, length, StringComparison.Ordinal) == 0)
				{
					newIndex = index + text.Length;
					return result;
				}
			}
			newIndex = index + 1;
			return str[index].ToString();
		}

		private static string Unescape(string str)
		{
			if (str == null)
			{
				return null;
			}
			StringBuilder stringBuilder = null;
			int length = str.Length;
			int newIndex = 0;
			while (true)
			{
				int num = str.IndexOf('&', newIndex);
				if (num == -1)
				{
					break;
				}
				if (stringBuilder == null)
				{
					stringBuilder = new StringBuilder();
				}
				stringBuilder.Append(str, newIndex, num - newIndex);
				stringBuilder.Append(GetUnescapeSequence(str, num, out newIndex));
			}
			if (stringBuilder == null)
			{
				return str;
			}
			stringBuilder.Append(str, newIndex, length - newIndex);
			return stringBuilder.ToString();
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			ToString(stringBuilder, delegate(object obj, string str)
			{
				((StringBuilder)obj).Append(str);
			});
			return stringBuilder.ToString();
		}

		private void ToString(object obj, Action<object, string> write)
		{
			write(obj, "<");
			write(obj, _tag);
			if (_attributes != null && _attributes.Count > 0)
			{
				write(obj, " ");
				int count = _attributes.Count;
				for (int i = 0; i < count; i += 2)
				{
					string arg = (string)_attributes[i];
					string arg2 = (string)_attributes[i + 1];
					write(obj, arg);
					write(obj, "=\"");
					write(obj, arg2);
					write(obj, "\"");
					if (i != _attributes.Count - 2)
					{
						write(obj, "\r\n");
					}
				}
			}
			if (_text == null && (_children == null || _children.Count == 0))
			{
				write(obj, "/>");
				write(obj, "\r\n");
				return;
			}
			write(obj, ">");
			write(obj, _text);
			if (_children != null)
			{
				write(obj, "\r\n");
				for (int j = 0; j < _children.Count; j++)
				{
					((SecurityElement)_children[j]).ToString(obj, write);
				}
			}
			write(obj, "</");
			write(obj, _tag);
			write(obj, ">");
			write(obj, "\r\n");
		}

		public string? Attribute(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (_attributes == null)
			{
				return null;
			}
			int count = _attributes.Count;
			for (int i = 0; i < count; i += 2)
			{
				string a = (string)_attributes[i];
				if (string.Equals(a, name))
				{
					string str = (string)_attributes[i + 1];
					return Unescape(str);
				}
			}
			return null;
		}

		public SecurityElement? SearchForChildByTag(string tag)
		{
			if (tag == null)
			{
				throw new ArgumentNullException("tag");
			}
			if (_children == null)
			{
				return null;
			}
			foreach (SecurityElement child in _children)
			{
				if (child != null && string.Equals(child.Tag, tag))
				{
					return child;
				}
			}
			return null;
		}

		public string? SearchForTextOfTag(string tag)
		{
			if (tag == null)
			{
				throw new ArgumentNullException("tag");
			}
			if (string.Equals(_tag, tag))
			{
				return Unescape(_text);
			}
			if (_children == null)
			{
				return null;
			}
			foreach (SecurityElement child in Children)
			{
				string text = child?.SearchForTextOfTag(tag);
				if (text != null)
				{
					return text;
				}
			}
			return null;
		}

		public static SecurityElement? FromString(string xml)
		{
			if (xml == null)
			{
				throw new ArgumentNullException("xml");
			}
			return null;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class SecurityException : SystemException
	{
		public object? Demanded { get; set; }

		public object? DenySetInstance { get; set; }

		public AssemblyName? FailedAssemblyInfo { get; set; }

		public string? GrantedSet { get; set; }

		public MethodInfo? Method { get; set; }

		public string? PermissionState { get; set; }

		public Type? PermissionType { get; set; }

		public object? PermitOnlySetInstance { get; set; }

		public string? RefusedSet { get; set; }

		public string? Url { get; set; }

		public SecurityException()
			: base(SR.Arg_SecurityException)
		{
			base.HResult = -2146233078;
		}

		public SecurityException(string? message)
			: base(message)
		{
			base.HResult = -2146233078;
		}

		public SecurityException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233078;
		}

		public SecurityException(string? message, Type? type)
			: base(message)
		{
			base.HResult = -2146233078;
			PermissionType = type;
		}

		public SecurityException(string? message, Type? type, string? state)
			: base(message)
		{
			base.HResult = -2146233078;
			PermissionType = type;
			PermissionState = state;
		}

		protected SecurityException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			Demanded = (string)info.GetValueNoThrow("Demanded", typeof(string));
			GrantedSet = (string)info.GetValueNoThrow("GrantedSet", typeof(string));
			RefusedSet = (string)info.GetValueNoThrow("RefusedSet", typeof(string));
			DenySetInstance = (string)info.GetValueNoThrow("Denied", typeof(string));
			PermitOnlySetInstance = (string)info.GetValueNoThrow("PermitOnly", typeof(string));
			Url = (string)info.GetValueNoThrow("Url", typeof(string));
		}

		public override string ToString()
		{
			return base.ToString();
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("Demanded", Demanded, typeof(string));
			info.AddValue("GrantedSet", GrantedSet, typeof(string));
			info.AddValue("RefusedSet", RefusedSet, typeof(string));
			info.AddValue("Denied", DenySetInstance, typeof(string));
			info.AddValue("PermitOnly", PermitOnlySetInstance, typeof(string));
			info.AddValue("Url", Url, typeof(string));
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false)]
	public sealed class SecurityRulesAttribute : Attribute
	{
		public bool SkipVerificationInFullTrust { get; set; }

		public SecurityRuleSet RuleSet { get; }

		public SecurityRulesAttribute(SecurityRuleSet ruleSet)
		{
			RuleSet = ruleSet;
		}
	}
	public enum SecurityRuleSet : byte
	{
		None,
		Level1,
		Level2
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	public sealed class SecuritySafeCriticalAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	public sealed class SecurityTransparentAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[Obsolete("SecurityTreatAsSafe is only used for .NET 2.0 transparency compatibility. Use the SecuritySafeCriticalAttribute instead.")]
	public sealed class SecurityTreatAsSafeAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = true, Inherited = false)]
	public sealed class SuppressUnmanagedCodeSecurityAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = true, Inherited = false)]
	public sealed class UnverifiableCodeAttribute : Attribute
	{
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class VerificationException : SystemException
	{
		public VerificationException()
			: base(SR.Verification_Exception)
		{
			base.HResult = -2146233075;
		}

		public VerificationException(string? message)
			: base(message)
		{
			base.HResult = -2146233075;
		}

		public VerificationException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233075;
		}

		protected VerificationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
}
namespace System.Security.Principal
{
	public interface IIdentity
	{
		string? Name { get; }

		string? AuthenticationType { get; }

		bool IsAuthenticated { get; }
	}
	public interface IPrincipal
	{
		IIdentity? Identity { get; }

		bool IsInRole(string role);
	}
	public enum PrincipalPolicy
	{
		UnauthenticatedPrincipal,
		NoPrincipal,
		WindowsPrincipal
	}
	public enum TokenImpersonationLevel
	{
		None,
		Anonymous,
		Identification,
		Impersonation,
		Delegation
	}
}
namespace System.Security.Permissions
{
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
	public abstract class CodeAccessSecurityAttribute : SecurityAttribute
	{
		protected CodeAccessSecurityAttribute(SecurityAction action)
			: base((SecurityAction)0)
		{
		}
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public enum PermissionState
	{
		None,
		Unrestricted
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public enum SecurityAction
	{
		Assert = 3,
		Demand = 2,
		Deny = 4,
		InheritanceDemand = 7,
		LinkDemand = 6,
		PermitOnly = 5,
		RequestMinimum = 8,
		RequestOptional = 9,
		RequestRefuse = 10
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
	public abstract class SecurityAttribute : Attribute
	{
		public SecurityAction Action { get; set; }

		public bool Unrestricted { get; set; }

		protected SecurityAttribute(SecurityAction action)
		{
		}

		public abstract IPermission? CreatePermission();
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
	public sealed class SecurityPermissionAttribute : CodeAccessSecurityAttribute
	{
		public bool Assertion { get; set; }

		public bool BindingRedirects { get; set; }

		public bool ControlAppDomain { get; set; }

		public bool ControlDomainPolicy { get; set; }

		public bool ControlEvidence { get; set; }

		public bool ControlPolicy { get; set; }

		public bool ControlPrincipal { get; set; }

		public bool ControlThread { get; set; }

		public bool Execution { get; set; }

		public SecurityPermissionFlag Flags { get; set; }

		public bool Infrastructure { get; set; }

		public bool RemotingConfiguration { get; set; }

		public bool SerializationFormatter { get; set; }

		public bool SkipVerification { get; set; }

		public bool UnmanagedCode { get; set; }

		public SecurityPermissionAttribute(SecurityAction action)
			: base((SecurityAction)0)
		{
		}

		public override IPermission? CreatePermission()
		{
			return null;
		}
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[Flags]
	public enum SecurityPermissionFlag
	{
		AllFlags = 0x3FFF,
		Assertion = 1,
		BindingRedirects = 0x2000,
		ControlAppDomain = 0x400,
		ControlDomainPolicy = 0x100,
		ControlEvidence = 0x20,
		ControlPolicy = 0x40,
		ControlPrincipal = 0x200,
		ControlThread = 0x10,
		Execution = 8,
		Infrastructure = 0x1000,
		NoFlags = 0,
		RemotingConfiguration = 0x800,
		SerializationFormatter = 0x80,
		SkipVerification = 4,
		UnmanagedCode = 2
	}
}
namespace System.Security.Cryptography
{
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class CryptographicException : SystemException
	{
		public CryptographicException()
			: base(SR.Arg_CryptographyException)
		{
		}

		public CryptographicException(int hr)
			: base(SR.Arg_CryptographyException)
		{
			base.HResult = hr;
		}

		public CryptographicException(string? message)
			: base(message)
		{
		}

		public CryptographicException(string? message, Exception? inner)
			: base(message, inner)
		{
		}

		public CryptographicException(string format, string? insert)
			: base(string.Format(format, insert))
		{
		}

		protected CryptographicException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
}
namespace System.Runtime
{
	public struct DependentHandle : IDisposable
	{
		private IntPtr _handle;

		public bool IsAllocated => _handle != (IntPtr)0;

		public object? Target
		{
			get
			{
				IntPtr handle = _handle;
				if (handle == (IntPtr)0)
				{
					ThrowHelper.ThrowInvalidOperationException();
				}
				return InternalGetTarget(handle);
			}
			set
			{
				IntPtr handle = _handle;
				if (handle == (IntPtr)0 || value != null)
				{
					ThrowHelper.ThrowInvalidOperationException();
				}
				InternalSetTargetToNull(handle);
			}
		}

		public object? Dependent
		{
			get
			{
				IntPtr handle = _handle;
				if (handle == (IntPtr)0)
				{
					ThrowHelper.ThrowInvalidOperationException();
				}
				return InternalGetDependent(handle);
			}
			set
			{
				IntPtr handle = _handle;
				if (handle == (IntPtr)0)
				{
					ThrowHelper.ThrowInvalidOperationException();
				}
				InternalSetDependent(handle, value);
			}
		}

		public (object? Target, object? Dependent) TargetAndDependent
		{
			get
			{
				IntPtr handle = _handle;
				if (handle == (IntPtr)0)
				{
					ThrowHelper.ThrowInvalidOperationException();
				}
				object dependent;
				object item = InternalGetTargetAndDependent(handle, out dependent);
				return (item, dependent);
			}
		}

		public DependentHandle(object? target, object? dependent)
		{
			_handle = InternalInitialize(target, dependent);
		}

		internal object UnsafeGetTarget()
		{
			return InternalGetTarget(_handle);
		}

		internal object UnsafeGetTargetAndDependent(out object dependent)
		{
			return InternalGetTargetAndDependent(_handle, out dependent);
		}

		internal void UnsafeSetTargetToNull()
		{
			InternalSetTargetToNull(_handle);
		}

		internal void UnsafeSetDependent(object dependent)
		{
			InternalSetDependent(_handle, dependent);
		}

		public void Dispose()
		{
			IntPtr handle = _handle;
			if (handle != (IntPtr)0)
			{
				_handle = IntPtr.Zero;
				InternalFree(handle);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr InternalInitialize(object target, object dependent);

		private unsafe static object InternalGetTarget(IntPtr dependentHandle)
		{
			return Unsafe.As<IntPtr, object>(ref *(IntPtr*)dependentHandle);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object InternalGetDependent(IntPtr dependentHandle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object InternalGetTargetAndDependent(IntPtr dependentHandle, out object dependent);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void InternalSetDependent(IntPtr dependentHandle, object dependent);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void InternalSetTargetToNull(IntPtr dependentHandle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void InternalFree(IntPtr dependentHandle);
	}
	public static class GCSettings
	{
		private enum SetLatencyModeStatus
		{
			Succeeded,
			NoGCInProgress
		}

		public static extern bool IsServerGC
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		public static GCLatencyMode LatencyMode
		{
			get
			{
				return GetGCLatencyMode();
			}
			set
			{
				if (value < GCLatencyMode.Batch || value > GCLatencyMode.SustainedLowLatency)
				{
					ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
				}
				SetLatencyModeStatus setLatencyModeStatus = SetGCLatencyMode(value);
				if (setLatencyModeStatus == SetLatencyModeStatus.NoGCInProgress)
				{
					throw new InvalidOperationException(SR.InvalidOperation_SetLatencyModeNoGC);
				}
			}
		}

		public static GCLargeObjectHeapCompactionMode LargeObjectHeapCompactionMode
		{
			get
			{
				return GetLOHCompactionMode();
			}
			set
			{
				if (value < GCLargeObjectHeapCompactionMode.Default || value > GCLargeObjectHeapCompactionMode.CompactOnce)
				{
					ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
				}
				SetLOHCompactionMode(value);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern GCLatencyMode GetGCLatencyMode();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern SetLatencyModeStatus SetGCLatencyMode(GCLatencyMode newLatencyMode);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern GCLargeObjectHeapCompactionMode GetLOHCompactionMode();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void SetLOHCompactionMode(GCLargeObjectHeapCompactionMode newLOHCompactionMode);
	}
	public static class JitInfo
	{
		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern long GetCompiledILBytes(bool currentThread = false);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern long GetCompiledMethodCount(bool currentThread = false);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern long GetCompilationTimeInTicks(bool currentThread = false);

		public static TimeSpan GetCompilationTime(bool currentThread = false)
		{
			return TimeSpan.FromTicks(GetCompilationTimeInTicks(currentThread));
		}
	}
	[Serializable]
	[TypeForwardedFrom("System.Runtime, Version=4.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
	public sealed class AmbiguousImplementationException : Exception
	{
		public AmbiguousImplementationException()
			: base(SR.AmbiguousImplementationException_NullMessage)
		{
			base.HResult = -2146234262;
		}

		public AmbiguousImplementationException(string? message)
			: base(message)
		{
			base.HResult = -2146234262;
		}

		public AmbiguousImplementationException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146234262;
		}

		private AmbiguousImplementationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public enum GCLargeObjectHeapCompactionMode
	{
		Default = 1,
		CompactOnce
	}
	public enum GCLatencyMode
	{
		Batch,
		Interactive,
		LowLatency,
		SustainedLowLatency,
		NoGCRegion
	}
	public sealed class MemoryFailPoint : CriticalFinalizerObject, IDisposable
	{
		private static readonly ulong s_topOfMemory = GetTopOfMemory();

		private static long s_hiddenLastKnownFreeAddressSpace;

		private static long s_hiddenLastTimeCheckingAddressSpace;

		private static readonly ulong s_GCSegmentSize = GC.GetSegmentSize();

		private static long s_failPointReservedMemory;

		private readonly ulong _reservedMemory;

		private bool _mustSubtractReservation;

		private static long LastKnownFreeAddressSpace
		{
			get
			{
				return Volatile.Read(ref s_hiddenLastKnownFreeAddressSpace);
			}
			set
			{
				Volatile.Write(ref s_hiddenLastKnownFreeAddressSpace, value);
			}
		}

		private static long LastTimeCheckingAddressSpace
		{
			get
			{
				return Volatile.Read(ref s_hiddenLastTimeCheckingAddressSpace);
			}
			set
			{
				Volatile.Write(ref s_hiddenLastTimeCheckingAddressSpace, value);
			}
		}

		internal static ulong MemoryFailPointReservedMemory => (ulong)Volatile.Read(ref s_failPointReservedMemory);

		private static void AddToLastKnownFreeAddressSpace(long addend)
		{
			Interlocked.Add(ref s_hiddenLastKnownFreeAddressSpace, addend);
		}

		public MemoryFailPoint(int sizeInMegabytes)
		{
			if (sizeInMegabytes <= 0)
			{
				throw new ArgumentOutOfRangeException("sizeInMegabytes", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			ulong num = (_reservedMemory = (ulong)((long)sizeInMegabytes << 20));
			ulong num2 = (ulong)(Math.Ceiling((double)num / (double)s_GCSegmentSize) * (double)s_GCSegmentSize);
			if (num2 >= s_topOfMemory)
			{
				throw new InsufficientMemoryException(SR.InsufficientMemory_MemFailPoint_TooBig);
			}
			ulong num3 = (ulong)(Math.Ceiling((double)sizeInMegabytes / 16.0) * 16.0);
			num3 <<= 20;
			for (int i = 0; i < 3; i++)
			{
				if (!CheckForAvailableMemory(out var availPageFile, out var totalAddressSpaceFree))
				{
					return;
				}
				ulong memoryFailPointReservedMemory = MemoryFailPointReservedMemory;
				ulong num4 = num2 + memoryFailPointReservedMemory;
				bool flag = num4 < num2 || num4 < memoryFailPointReservedMemory;
				bool flag2 = availPageFile < num3 + memoryFailPointReservedMemory + 16777216 || flag;
				bool flag3 = totalAddressSpaceFree < num4 || flag;
				long num5 = Environment.TickCount;
				if (num5 > LastTimeCheckingAddressSpace + 10000 || num5 < LastTimeCheckingAddressSpace || LastKnownFreeAddressSpace < (long)num2)
				{
					CheckForFreeAddressSpace(num2, shouldThrow: false);
				}
				bool flag4 = (ulong)LastKnownFreeAddressSpace < num2;
				if (!flag2 && !flag3 && !flag4)
				{
					break;
				}
				switch (i)
				{
				case 0:
					GC.Collect();
					break;
				case 1:
					if (flag2)
					{
						UIntPtr numBytes = new UIntPtr(num2);
						GrowPageFileIfNecessaryAndPossible(numBytes);
					}
					break;
				case 2:
					if (flag2 || flag3)
					{
						InsufficientMemoryException ex = new InsufficientMemoryException(SR.InsufficientMemory_MemFailPoint);
						throw ex;
					}
					if (flag4)
					{
						InsufficientMemoryException ex2 = new InsufficientMemoryException(SR.InsufficientMemory_MemFailPoint_VAFrag);
						throw ex2;
					}
					break;
				}
			}
			AddToLastKnownFreeAddressSpace((long)(0L - num));
			if (LastKnownFreeAddressSpace < 0)
			{
				CheckForFreeAddressSpace(num2, shouldThrow: true);
			}
			AddMemoryFailPointReservation((long)num);
			_mustSubtractReservation = true;
		}

		~MemoryFailPoint()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		private void Dispose(bool disposing)
		{
			if (_mustSubtractReservation)
			{
				AddMemoryFailPointReservation((long)(0L - _reservedMemory));
				_mustSubtractReservation = false;
			}
		}

		internal static long AddMemoryFailPointReservation(long size)
		{
			return Interlocked.Add(ref s_failPointReservedMemory, size);
		}

		private static ulong GetTopOfMemory()
		{
			Interop.Kernel32.GetSystemInfo(out var lpSystemInfo);
			return (ulong)(long)lpSystemInfo.lpMaximumApplicationAddress;
		}

		private unsafe static bool CheckForAvailableMemory(out ulong availPageFile, out ulong totalAddressSpaceFree)
		{
			Interop.Kernel32.MEMORYSTATUSEX mEMORYSTATUSEX = default(Interop.Kernel32.MEMORYSTATUSEX);
			mEMORYSTATUSEX.dwLength = (uint)sizeof(Interop.Kernel32.MEMORYSTATUSEX);
			if (Interop.Kernel32.GlobalMemoryStatusEx(&mEMORYSTATUSEX) == Interop.BOOL.FALSE)
			{
				availPageFile = 0uL;
				totalAddressSpaceFree = 0uL;
				return false;
			}
			availPageFile = mEMORYSTATUSEX.ullAvailPageFile;
			totalAddressSpaceFree = mEMORYSTATUSEX.ullAvailVirtual;
			return true;
		}

		private unsafe static void CheckForFreeAddressSpace(ulong size, bool shouldThrow)
		{
			ulong num2 = (ulong)(LastKnownFreeAddressSpace = (long)MemFreeAfterAddress(null, size));
			LastTimeCheckingAddressSpace = Environment.TickCount;
			if (num2 < size && shouldThrow)
			{
				throw new InsufficientMemoryException(SR.InsufficientMemory_MemFailPoint_VAFrag);
			}
		}

		private unsafe static ulong MemFreeAfterAddress(void* address, ulong size)
		{
			if (size >= s_topOfMemory)
			{
				return 0uL;
			}
			ulong num = 0uL;
			Interop.Kernel32.MEMORY_BASIC_INFORMATION lpBuffer = default(Interop.Kernel32.MEMORY_BASIC_INFORMATION);
			UIntPtr dwLength = (UIntPtr)(ulong)sizeof(Interop.Kernel32.MEMORY_BASIC_INFORMATION);
			while ((ulong)((long)address + (long)size) < s_topOfMemory)
			{
				UIntPtr uIntPtr = Interop.Kernel32.VirtualQuery(address, ref lpBuffer, dwLength);
				if (uIntPtr == UIntPtr.Zero)
				{
					throw Win32Marshal.GetExceptionForLastWin32Error();
				}
				ulong num2 = lpBuffer.RegionSize.ToUInt64();
				if (lpBuffer.State == 65536)
				{
					if (num2 >= size)
					{
						return num2;
					}
					num = Math.Max(num, num2);
				}
				address = (void*)((ulong)address + num2);
			}
			return num;
		}

		private unsafe static void GrowPageFileIfNecessaryAndPossible(UIntPtr numBytes)
		{
			void* ptr = Interop.Kernel32.VirtualAlloc(null, numBytes, 4096, 4);
			if (ptr != null && !Interop.Kernel32.VirtualFree(ptr, UIntPtr.Zero, 32768))
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyTargetedPatchBandAttribute : Attribute
	{
		public string TargetedPatchBand { get; }

		public AssemblyTargetedPatchBandAttribute(string targetedPatchBand)
		{
			TargetedPatchBand = targetedPatchBand;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public sealed class TargetedPatchingOptOutAttribute : Attribute
	{
		public string Reason { get; }

		public TargetedPatchingOptOutAttribute(string reason)
		{
			Reason = reason;
		}
	}
	public static class ProfileOptimization
	{
		public static void SetProfileRoot(string directoryPath)
		{
			AssemblyLoadContext.Default.SetProfileOptimizationRoot(directoryPath);
		}

		public static void StartProfile(string? profile)
		{
			AssemblyLoadContext.Default.StartProfileOptimization(profile);
		}
	}
}
namespace System.Runtime.Serialization
{
	public readonly struct DeserializationToken : IDisposable
	{
		private readonly DeserializationTracker _tracker;

		internal DeserializationToken(DeserializationTracker tracker)
		{
			_tracker = tracker;
		}

		public void Dispose()
		{
			if (_tracker == null || !_tracker.DeserializationInProgress)
			{
				return;
			}
			lock (_tracker)
			{
				if (_tracker.DeserializationInProgress)
				{
					_tracker.DeserializationInProgress = false;
					SerializationInfo.AsyncDeserializationInProgress.Value = false;
				}
			}
		}
	}
	internal sealed class DeserializationTracker
	{
		internal bool DeserializationInProgress { get; set; }
	}
	public interface IDeserializationCallback
	{
		void OnDeserialization(object? sender);
	}
	[CLSCompliant(false)]
	public interface IFormatterConverter
	{
		object Convert(object value, Type type);

		object Convert(object value, TypeCode typeCode);

		bool ToBoolean(object value);

		char ToChar(object value);

		sbyte ToSByte(object value);

		byte ToByte(object value);

		short ToInt16(object value);

		ushort ToUInt16(object value);

		int ToInt32(object value);

		uint ToUInt32(object value);

		long ToInt64(object value);

		ulong ToUInt64(object value);

		float ToSingle(object value);

		double ToDouble(object value);

		decimal ToDecimal(object value);

		DateTime ToDateTime(object value);

		string? ToString(object value);
	}
	public interface IObjectReference
	{
		object GetRealObject(StreamingContext context);
	}
	public interface ISafeSerializationData
	{
		void CompleteDeserialization(object deserialized);
	}
	public interface ISerializable
	{
		void GetObjectData(SerializationInfo info, StreamingContext context);
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class OnDeserializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class OnDeserializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class OnSerializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class OnSerializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field, Inherited = false)]
	public sealed class OptionalFieldAttribute : Attribute
	{
		private int _versionAdded = 1;

		public int VersionAdded
		{
			get
			{
				return _versionAdded;
			}
			set
			{
				if (value < 1)
				{
					throw new ArgumentException(SR.Serialization_OptionalFieldVersionValue);
				}
				_versionAdded = value;
			}
		}
	}
	public sealed class SafeSerializationEventArgs : EventArgs
	{
		public StreamingContext StreamingContext { get; }

		public void AddSerializedState(ISafeSerializationData serializedState)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class SerializationException : SystemException
	{
		public SerializationException()
			: base(SR.SerializationException)
		{
			base.HResult = -2146233076;
		}

		public SerializationException(string? message)
			: base(message)
		{
			base.HResult = -2146233076;
		}

		public SerializationException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146233076;
		}

		protected SerializationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public sealed class SerializationInfo
	{
		private string[] _names;

		private object[] _values;

		private Type[] _types;

		private int _count;

		private readonly Dictionary<string, int> _nameToIndex;

		private readonly IFormatterConverter _converter;

		private string _rootTypeName;

		private string _rootTypeAssemblyName;

		private Type _rootType;

		[ThreadStatic]
		private static DeserializationTracker t_deserializationTracker;

		public string FullTypeName
		{
			get
			{
				return _rootTypeName;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				_rootTypeName = value;
				IsFullTypeNameSetExplicit = true;
			}
		}

		public string AssemblyName
		{
			get
			{
				return _rootTypeAssemblyName;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				_rootTypeAssemblyName = value;
				IsAssemblyNameSetExplicit = true;
			}
		}

		public bool IsFullTypeNameSetExplicit { get; private set; }

		public bool IsAssemblyNameSetExplicit { get; private set; }

		public int MemberCount => _count;

		public Type ObjectType => _rootType;

		internal static AsyncLocal<bool> AsyncDeserializationInProgress { get; } = new AsyncLocal<bool>();


		public static bool DeserializationInProgress
		{
			get
			{
				if (AsyncDeserializationInProgress.Value)
				{
					return true;
				}
				DeserializationTracker threadDeserializationTracker = GetThreadDeserializationTracker();
				return threadDeserializationTracker.DeserializationInProgress;
			}
		}

		[CLSCompliant(false)]
		public SerializationInfo(Type type, IFormatterConverter converter)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (converter == null)
			{
				throw new ArgumentNullException("converter");
			}
			_rootType = type;
			_rootTypeName = type.FullName;
			_rootTypeAssemblyName = type.Module.Assembly.FullName;
			_names = new string[4];
			_values = new object[4];
			_types = new Type[4];
			_nameToIndex = new Dictionary<string, int>();
			_converter = converter;
		}

		[CLSCompliant(false)]
		public SerializationInfo(Type type, IFormatterConverter converter, bool requireSameTokenInPartialTrust)
			: this(type, converter)
		{
		}

		public void SetType(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if ((object)_rootType != type)
			{
				_rootType = type;
				_rootTypeName = type.FullName;
				_rootTypeAssemblyName = type.Module.Assembly.FullName;
				IsFullTypeNameSetExplicit = false;
				IsAssemblyNameSetExplicit = false;
			}
		}

		public SerializationInfoEnumerator GetEnumerator()
		{
			return new SerializationInfoEnumerator(_names, _values, _types, _count);
		}

		private void ExpandArrays()
		{
			int num = _count * 2;
			if (num < _count && int.MaxValue > _count)
			{
				num = int.MaxValue;
			}
			string[] array = new string[num];
			object[] array2 = new object[num];
			Type[] array3 = new Type[num];
			Array.Copy(_names, array, _count);
			Array.Copy(_values, array2, _count);
			Array.Copy(_types, array3, _count);
			_names = array;
			_values = array2;
			_types = array3;
		}

		public void AddValue(string name, object? value, Type type)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			AddValueInternal(name, value, type);
		}

		public void AddValue(string name, object? value)
		{
			if (value == null)
			{
				AddValue(name, value, typeof(object));
			}
			else
			{
				AddValue(name, value, value.GetType());
			}
		}

		public void AddValue(string name, bool value)
		{
			AddValue(name, value, typeof(bool));
		}

		public void AddValue(string name, char value)
		{
			AddValue(name, value, typeof(char));
		}

		[CLSCompliant(false)]
		public void AddValue(string name, sbyte value)
		{
			AddValue(name, value, typeof(sbyte));
		}

		public void AddValue(string name, byte value)
		{
			AddValue(name, value, typeof(byte));
		}

		public void AddValue(string name, short value)
		{
			AddValue(name, value, typeof(short));
		}

		[CLSCompliant(false)]
		public void AddValue(string name, ushort value)
		{
			AddValue(name, value, typeof(ushort));
		}

		public void AddValue(string name, int value)
		{
			AddValue(name, value, typeof(int));
		}

		[CLSCompliant(false)]
		public void AddValue(string name, uint value)
		{
			AddValue(name, value, typeof(uint));
		}

		public void AddValue(string name, long value)
		{
			AddValue(name, value, typeof(long));
		}

		[CLSCompliant(false)]
		public void AddValue(string name, ulong value)
		{
			AddValue(name, value, typeof(ulong));
		}

		public void AddValue(string name, float value)
		{
			AddValue(name, value, typeof(float));
		}

		public void AddValue(string name, double value)
		{
			AddValue(name, value, typeof(double));
		}

		public void AddValue(string name, decimal value)
		{
			AddValue(name, value, typeof(decimal));
		}

		public void AddValue(string name, DateTime value)
		{
			AddValue(name, value, typeof(DateTime));
		}

		internal void AddValueInternal(string name, object value, Type type)
		{
			if (!_nameToIndex.TryAdd(name, _count))
			{
				throw new SerializationException(SR.Serialization_SameNameTwice);
			}
			if (_count >= _names.Length)
			{
				ExpandArrays();
			}
			_names[_count] = name;
			_values[_count] = value;
			_types[_count] = type;
			_count++;
		}

		public void UpdateValue(string name, object value, Type type)
		{
			int num = FindElement(name);
			if (num < 0)
			{
				AddValueInternal(name, value, type);
				return;
			}
			_values[num] = value;
			_types[num] = type;
		}

		private int FindElement(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (_nameToIndex.TryGetValue(name, out var value))
			{
				return value;
			}
			return -1;
		}

		private object GetElement(string name, out Type foundType)
		{
			int num = FindElement(name);
			if (num == -1)
			{
				throw new SerializationException(SR.Format(SR.Serialization_NotFound, name));
			}
			foundType = _types[num];
			return _values[num];
		}

		private object GetElementNoThrow(string name, out Type foundType)
		{
			int num = FindElement(name);
			if (num == -1)
			{
				foundType = null;
				return null;
			}
			foundType = _types[num];
			return _values[num];
		}

		public object? GetValue(string name, Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!type.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType);
			}
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType == type || type.IsAssignableFrom(foundType) || element == null)
			{
				return element;
			}
			return _converter.Convert(element, type);
		}

		internal object GetValueNoThrow(string name, Type type)
		{
			Type foundType;
			object elementNoThrow = GetElementNoThrow(name, out foundType);
			if (elementNoThrow == null)
			{
				return null;
			}
			if ((object)foundType == type || type.IsAssignableFrom(foundType))
			{
				return elementNoThrow;
			}
			return _converter.Convert(elementNoThrow, type);
		}

		public bool GetBoolean(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(bool))
			{
				return _converter.ToBoolean(element);
			}
			return (bool)element;
		}

		public char GetChar(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(char))
			{
				return _converter.ToChar(element);
			}
			return (char)element;
		}

		[CLSCompliant(false)]
		public sbyte GetSByte(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(sbyte))
			{
				return _converter.ToSByte(element);
			}
			return (sbyte)element;
		}

		public byte GetByte(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(byte))
			{
				return _converter.ToByte(element);
			}
			return (byte)element;
		}

		public short GetInt16(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(short))
			{
				return _converter.ToInt16(element);
			}
			return (short)element;
		}

		[CLSCompliant(false)]
		public ushort GetUInt16(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(ushort))
			{
				return _converter.ToUInt16(element);
			}
			return (ushort)element;
		}

		public int GetInt32(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(int))
			{
				return _converter.ToInt32(element);
			}
			return (int)element;
		}

		[CLSCompliant(false)]
		public uint GetUInt32(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(uint))
			{
				return _converter.ToUInt32(element);
			}
			return (uint)element;
		}

		public long GetInt64(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(long))
			{
				return _converter.ToInt64(element);
			}
			return (long)element;
		}

		[CLSCompliant(false)]
		public ulong GetUInt64(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(ulong))
			{
				return _converter.ToUInt64(element);
			}
			return (ulong)element;
		}

		public float GetSingle(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(float))
			{
				return _converter.ToSingle(element);
			}
			return (float)element;
		}

		public double GetDouble(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(double))
			{
				return _converter.ToDouble(element);
			}
			return (double)element;
		}

		public decimal GetDecimal(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(decimal))
			{
				return _converter.ToDecimal(element);
			}
			return (decimal)element;
		}

		public DateTime GetDateTime(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(DateTime))
			{
				return _converter.ToDateTime(element);
			}
			return (DateTime)element;
		}

		public string? GetString(string name)
		{
			Type foundType;
			object element = GetElement(name, out foundType);
			if ((object)foundType != typeof(string) && element != null)
			{
				return _converter.ToString(element);
			}
			return (string)element;
		}

		private static DeserializationTracker GetThreadDeserializationTracker()
		{
			return t_deserializationTracker ?? (t_deserializationTracker = new DeserializationTracker());
		}

		public static void ThrowIfDeserializationInProgress()
		{
			if (DeserializationInProgress)
			{
				throw new SerializationException(SR.Serialization_DangerousDeserialization);
			}
		}

		public static void ThrowIfDeserializationInProgress(string switchSuffix, ref int cachedValue)
		{
			if (cachedValue == 0)
			{
				if (AppContext.TryGetSwitch("Switch.System.Runtime.Serialization.SerializationGuard." + switchSuffix, out var isEnabled) && isEnabled)
				{
					cachedValue = 1;
				}
				else
				{
					cachedValue = -1;
				}
			}
			if (cachedValue != 1)
			{
				if (cachedValue != -1)
				{
					throw new ArgumentOutOfRangeException("cachedValue");
				}
				if (DeserializationInProgress)
				{
					throw new SerializationException(SR.Format(SR.Serialization_DangerousDeserialization_Switch, "Switch.System.Runtime.Serialization.SerializationGuard." + switchSuffix));
				}
			}
		}

		public static DeserializationToken StartDeserialization()
		{
			if (LocalAppContextSwitches.SerializationGuard)
			{
				DeserializationTracker threadDeserializationTracker = GetThreadDeserializationTracker();
				if (!threadDeserializationTracker.DeserializationInProgress)
				{
					lock (threadDeserializationTracker)
					{
						if (!threadDeserializationTracker.DeserializationInProgress)
						{
							AsyncDeserializationInProgress.Value = true;
							threadDeserializationTracker.DeserializationInProgress = true;
							return new DeserializationToken(threadDeserializationTracker);
						}
					}
				}
			}
			return new DeserializationToken(null);
		}
	}
	public readonly struct SerializationEntry
	{
		private readonly string _name;

		private readonly object _value;

		private readonly Type _type;

		public object? Value => _value;

		public string Name => _name;

		public Type ObjectType => _type;

		internal SerializationEntry(string entryName, object entryValue, Type entryType)
		{
			_name = entryName;
			_value = entryValue;
			_type = entryType;
		}
	}
	public sealed class SerializationInfoEnumerator : System.Collections.IEnumerator
	{
		private readonly string[] _members;

		private readonly object[] _data;

		private readonly Type[] _types;

		private readonly int _numItems;

		private int _currItem;

		private bool _current;

		object? System.Collections.IEnumerator.Current => Current;

		public SerializationEntry Current
		{
			get
			{
				if (!_current)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
				return new SerializationEntry(_members[_currItem], _data[_currItem], _types[_currItem]);
			}
		}

		public string Name
		{
			get
			{
				if (!_current)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
				return _members[_currItem];
			}
		}

		public object? Value
		{
			get
			{
				if (!_current)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
				return _data[_currItem];
			}
		}

		public Type ObjectType
		{
			get
			{
				if (!_current)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
				return _types[_currItem];
			}
		}

		internal SerializationInfoEnumerator(string[] members, object[] info, Type[] types, int numItems)
		{
			_members = members;
			_data = info;
			_types = types;
			_numItems = numItems - 1;
			_currItem = -1;
		}

		public bool MoveNext()
		{
			if (_currItem < _numItems)
			{
				_currItem++;
				_current = true;
			}
			else
			{
				_current = false;
			}
			return _current;
		}

		public void Reset()
		{
			_currItem = -1;
			_current = false;
		}
	}
	public readonly struct StreamingContext
	{
		private readonly object _additionalContext;

		private readonly StreamingContextStates _state;

		public StreamingContextStates State => _state;

		public object? Context => _additionalContext;

		public StreamingContext(StreamingContextStates state)
			: this(state, null)
		{
		}

		public StreamingContext(StreamingContextStates state, object? additional)
		{
			_state = state;
			_additionalContext = additional;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (!(obj is StreamingContext streamingContext))
			{
				return false;
			}
			if (streamingContext._additionalContext == _additionalContext)
			{
				return streamingContext._state == _state;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (int)_state;
		}
	}
	[Flags]
	public enum StreamingContextStates
	{
		CrossProcess = 1,
		CrossMachine = 2,
		File = 4,
		Persistence = 8,
		Remoting = 0x10,
		Other = 0x20,
		Clone = 0x40,
		CrossAppDomain = 0x80,
		All = 0xFF
	}
}
namespace System.Runtime.Remoting
{
	public class ObjectHandle : MarshalByRefObject
	{
		private readonly object _wrappedObject;

		public ObjectHandle(object? o)
		{
			_wrappedObject = o;
		}

		public object? Unwrap()
		{
			return _wrappedObject;
		}
	}
}
namespace System.Runtime.ExceptionServices
{
	public sealed class ExceptionDispatchInfo
	{
		private readonly Exception _exception;

		private readonly Exception.DispatchState _dispatchState;

		public Exception SourceException => _exception;

		private ExceptionDispatchInfo(Exception exception)
		{
			_exception = exception;
			_dispatchState = exception.CaptureDispatchState();
		}

		public static ExceptionDispatchInfo Capture(Exception source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new ExceptionDispatchInfo(source);
		}

		[DoesNotReturn]
		[StackTraceHidden]
		public void Throw()
		{
			_exception.RestoreDispatchState(in _dispatchState);
			throw _exception;
		}

		[DoesNotReturn]
		[StackTraceHidden]
		public static void Throw(Exception source)
		{
			Capture(source).Throw();
		}

		[StackTraceHidden]
		public static Exception SetCurrentStackTrace(Exception source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			source.SetCurrentStackTrace();
			return source;
		}

		public static Exception SetRemoteStackTrace(Exception source, string stackTrace)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (stackTrace == null)
			{
				throw new ArgumentNullException("stackTrace");
			}
			source.SetRemoteStackTrace(stackTrace);
			return source;
		}
	}
	public class FirstChanceExceptionEventArgs : EventArgs
	{
		public Exception Exception { get; }

		public FirstChanceExceptionEventArgs(Exception exception)
		{
			Exception = exception;
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	[Obsolete("Recovery from corrupted process state exceptions is not supported; HandleProcessCorruptedStateExceptionsAttribute is ignored.", DiagnosticId = "SYSLIB0032", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public sealed class HandleProcessCorruptedStateExceptionsAttribute : Attribute
	{
	}
}
namespace System.Runtime.ConstrainedExecution
{
	[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public enum Cer
	{
		None,
		MayFail,
		Success
	}
	[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public enum Consistency
	{
		MayCorruptProcess,
		MayCorruptAppDomain,
		MayCorruptInstance,
		WillNotCorruptState
	}
	public abstract class CriticalFinalizerObject
	{
		~CriticalFinalizerObject()
		{
		}
	}
	[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	public sealed class PrePrepareMethodAttribute : Attribute
	{
	}
	[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Interface, Inherited = false)]
	public sealed class ReliabilityContractAttribute : Attribute
	{
		public Consistency ConsistencyGuarantee { get; }

		public Cer Cer { get; }

		public ReliabilityContractAttribute(Consistency consistencyGuarantee, Cer cer)
		{
			ConsistencyGuarantee = consistencyGuarantee;
			Cer = cer;
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	public sealed class ComponentGuaranteesAttribute : Attribute
	{
		public ComponentGuaranteesOptions Guarantees { get; }

		public ComponentGuaranteesAttribute(ComponentGuaranteesOptions guarantees)
		{
			Guarantees = guarantees;
		}
	}
	[Flags]
	public enum ComponentGuaranteesOptions
	{
		None = 0,
		Exchange = 1,
		Stable = 2,
		SideBySide = 4
	}
	public sealed class FrameworkName : IEquatable<FrameworkName?>
	{
		private readonly string _identifier;

		private readonly Version _version;

		private readonly string _profile;

		private string _fullName;

		public string Identifier => _identifier;

		public Version Version => _version;

		public string Profile => _profile;

		public string FullName
		{
			get
			{
				if (_fullName == null)
				{
					_fullName = (string.IsNullOrEmpty(Profile) ? $"{Identifier}{",Version=v"}{Version}" : $"{Identifier}{",Version=v"}{Version}{",Profile="}{Profile}");
				}
				return _fullName;
			}
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return Equals(obj as FrameworkName);
		}

		public bool Equals([NotNullWhen(true)] FrameworkName? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if (Identifier == other.Identifier && Version == other.Version)
			{
				return Profile == other.Profile;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Identifier.GetHashCode() ^ Version.GetHashCode() ^ Profile.GetHashCode();
		}

		public override string ToString()
		{
			return FullName;
		}

		public FrameworkName(string identifier, Version version)
			: this(identifier, version, null)
		{
		}

		public FrameworkName(string identifier, Version version, string? profile)
		{
			if (identifier == null)
			{
				throw new ArgumentNullException("identifier");
			}
			identifier = identifier.Trim();
			if (identifier.Length == 0)
			{
				throw new ArgumentException(SR.Format(SR.net_emptystringcall, "identifier"), "identifier");
			}
			if (version == null)
			{
				throw new ArgumentNullException("version");
			}
			_identifier = identifier;
			_version = version;
			_profile = ((profile == null) ? string.Empty : profile.Trim());
		}

		public FrameworkName(string frameworkName)
		{
			if (frameworkName == null)
			{
				throw new ArgumentNullException("frameworkName");
			}
			if (frameworkName.Length == 0)
			{
				throw new ArgumentException(SR.Format(SR.net_emptystringcall, "frameworkName"), "frameworkName");
			}
			string[] array = frameworkName.Split(',');
			if (array.Length < 2 || array.Length > 3)
			{
				throw new ArgumentException(SR.Argument_FrameworkNameTooShort, "frameworkName");
			}
			_identifier = array[0].Trim();
			if (_identifier.Length == 0)
			{
				throw new ArgumentException(SR.Argument_FrameworkNameInvalid, "frameworkName");
			}
			bool flag = false;
			_profile = string.Empty;
			for (int i = 1; i < array.Length; i++)
			{
				string text = array[i];
				int num = text.IndexOf('=');
				if (num == -1 || num != text.LastIndexOf('='))
				{
					throw new ArgumentException(SR.Argument_FrameworkNameInvalid, "frameworkName");
				}
				ReadOnlySpan<char> span = text.AsSpan(0, num).Trim();
				ReadOnlySpan<char> input = text.AsSpan(num + 1).Trim();
				if (MemoryExtensions.Equals(span, "Version", StringComparison.OrdinalIgnoreCase))
				{
					flag = true;
					if (input.Length > 0 && (input[0] == 'v' || input[0] == 'V'))
					{
						input = input.Slice(1);
					}
					try
					{
						_version = System.Version.Parse(input);
					}
					catch (Exception innerException)
					{
						throw new ArgumentException(SR.Argument_FrameworkNameInvalidVersion, "frameworkName", innerException);
					}
				}
				else
				{
					if (!MemoryExtensions.Equals(span, "Profile", StringComparison.OrdinalIgnoreCase))
					{
						throw new ArgumentException(SR.Argument_FrameworkNameInvalid, "frameworkName");
					}
					if (input.Length > 0)
					{
						_profile = input.ToString();
					}
				}
			}
			if (!flag)
			{
				throw new ArgumentException(SR.Argument_FrameworkNameMissingVersion, "frameworkName");
			}
		}

		public static bool operator ==(FrameworkName? left, FrameworkName? right)
		{
			return left?.Equals(right) ?? ((object)right == null);
		}

		public static bool operator !=(FrameworkName? left, FrameworkName? right)
		{
			return !(left == right);
		}
	}
	public abstract class OSPlatformAttribute : Attribute
	{
		public string PlatformName { get; }

		private protected OSPlatformAttribute(string platformName)
		{
			PlatformName = platformName;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	public sealed class TargetPlatformAttribute : OSPlatformAttribute
	{
		public TargetPlatformAttribute(string platformName)
			: base(platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	public sealed class SupportedOSPlatformAttribute : OSPlatformAttribute
	{
		public SupportedOSPlatformAttribute(string platformName)
			: base(platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	public sealed class UnsupportedOSPlatformAttribute : OSPlatformAttribute
	{
		public UnsupportedOSPlatformAttribute(string platformName)
			: base(platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	public sealed class SupportedOSPlatformGuardAttribute : OSPlatformAttribute
	{
		public SupportedOSPlatformGuardAttribute(string platformName)
			: base(platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	public sealed class UnsupportedOSPlatformGuardAttribute : OSPlatformAttribute
	{
		public UnsupportedOSPlatformGuardAttribute(string platformName)
			: base(platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	public sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, Inherited = false)]
	[Conditional("RESOURCE_ANNOTATION_WORK")]
	public sealed class ResourceConsumptionAttribute : Attribute
	{
		public ResourceScope ResourceScope { get; }

		public ResourceScope ConsumptionScope { get; }

		public ResourceConsumptionAttribute(ResourceScope resourceScope)
		{
			ResourceScope = resourceScope;
			ConsumptionScope = resourceScope;
		}

		public ResourceConsumptionAttribute(ResourceScope resourceScope, ResourceScope consumptionScope)
		{
			ResourceScope = resourceScope;
			ConsumptionScope = consumptionScope;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, Inherited = false)]
	[Conditional("RESOURCE_ANNOTATION_WORK")]
	public sealed class ResourceExposureAttribute : Attribute
	{
		public ResourceScope ResourceExposureLevel { get; }

		public ResourceExposureAttribute(ResourceScope exposureLevel)
		{
			ResourceExposureLevel = exposureLevel;
		}
	}
	[Flags]
	public enum ResourceScope
	{
		None = 0,
		Machine = 1,
		Process = 2,
		AppDomain = 4,
		Library = 8,
		Private = 0x10,
		Assembly = 0x20
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	public sealed class TargetFrameworkAttribute : Attribute
	{
		private readonly string _frameworkName;

		private string _frameworkDisplayName;

		public string FrameworkName => _frameworkName;

		public string? FrameworkDisplayName
		{
			get
			{
				return _frameworkDisplayName;
			}
			set
			{
				_frameworkDisplayName = value;
			}
		}

		public TargetFrameworkAttribute(string frameworkName)
		{
			if (frameworkName == null)
			{
				throw new ArgumentNullException("frameworkName");
			}
			_frameworkName = frameworkName;
		}
	}
	[Flags]
	internal enum SxSRequirements
	{
		None = 0,
		AppDomainID = 1,
		ProcessID = 2,
		CLRInstanceID = 4,
		AssemblyName = 8,
		TypeName = 0x10
	}
	public static class VersioningHelper
	{
		public static string MakeVersionSafeName(string? name, ResourceScope from, ResourceScope to)
		{
			return MakeVersionSafeName(name, from, to, null);
		}

		public static string MakeVersionSafeName(string? name, ResourceScope from, ResourceScope to, Type? type)
		{
			ResourceScope resourceScope = from & (ResourceScope.Machine | ResourceScope.Process | ResourceScope.AppDomain | ResourceScope.Library);
			ResourceScope resourceScope2 = to & (ResourceScope.Machine | ResourceScope.Process | ResourceScope.AppDomain | ResourceScope.Library);
			if (resourceScope > resourceScope2)
			{
				throw new ArgumentException(SR.Format(SR.Argument_ResourceScopeWrongDirection, resourceScope, resourceScope2), "from");
			}
			SxSRequirements requirements = GetRequirements(to, from);
			if ((requirements & (SxSRequirements.AssemblyName | SxSRequirements.TypeName)) != 0 && type == null)
			{
				throw new ArgumentNullException("type", SR.ArgumentNull_TypeRequiredByResourceScope);
			}
			StringBuilder stringBuilder = new StringBuilder(name);
			char value = '_';
			if ((requirements & SxSRequirements.ProcessID) != 0)
			{
				stringBuilder.Append(value);
				stringBuilder.Append('p');
				stringBuilder.Append(Environment.ProcessId);
			}
			if ((requirements & SxSRequirements.CLRInstanceID) != 0)
			{
				string cLRInstanceString = GetCLRInstanceString();
				stringBuilder.Append(value);
				stringBuilder.Append('r');
				stringBuilder.Append(cLRInstanceString);
			}
			if ((requirements & SxSRequirements.AppDomainID) != 0)
			{
				stringBuilder.Append(value);
				stringBuilder.Append("ad");
				stringBuilder.Append(AppDomain.CurrentDomain.Id);
			}
			if ((requirements & SxSRequirements.TypeName) != 0)
			{
				stringBuilder.Append(value);
				stringBuilder.Append(type.Name);
			}
			if ((requirements & SxSRequirements.AssemblyName) != 0)
			{
				stringBuilder.Append(value);
				stringBuilder.Append(type.Assembly.FullName);
			}
			return stringBuilder.ToString();
		}

		private static string GetCLRInstanceString()
		{
			return "3";
		}

		private static SxSRequirements GetRequirements(ResourceScope consumeAsScope, ResourceScope calleeScope)
		{
			SxSRequirements sxSRequirements = SxSRequirements.None;
			switch (calleeScope & (ResourceScope.Machine | ResourceScope.Process | ResourceScope.AppDomain | ResourceScope.Library))
			{
			case ResourceScope.Machine:
				switch (consumeAsScope & (ResourceScope.Machine | ResourceScope.Process | ResourceScope.AppDomain | ResourceScope.Library))
				{
				case ResourceScope.Process:
					sxSRequirements |= SxSRequirements.ProcessID;
					break;
				case ResourceScope.AppDomain:
					sxSRequirements |= SxSRequirements.AppDomainID | SxSRequirements.ProcessID | SxSRequirements.CLRInstanceID;
					break;
				default:
					throw new ArgumentException(SR.Format(SR.Argument_BadResourceScopeTypeBits, consumeAsScope), "consumeAsScope");
				case ResourceScope.Machine:
					break;
				}
				break;
			case ResourceScope.Process:
				if ((consumeAsScope & ResourceScope.AppDomain) != 0)
				{
					sxSRequirements |= SxSRequirements.AppDomainID | SxSRequirements.CLRInstanceID;
				}
				break;
			default:
				throw new ArgumentException(SR.Format(SR.Argument_BadResourceScopeTypeBits, calleeScope), "calleeScope");
			case ResourceScope.AppDomain:
				break;
			}
			switch (calleeScope & (ResourceScope.Private | ResourceScope.Assembly))
			{
			case ResourceScope.None:
				switch (consumeAsScope & (ResourceScope.Private | ResourceScope.Assembly))
				{
				case ResourceScope.Assembly:
					sxSRequirements |= SxSRequirements.AssemblyName;
					break;
				case ResourceScope.Private:
					sxSRequirements |= SxSRequirements.AssemblyName | SxSRequirements.TypeName;
					break;
				default:
					throw new ArgumentException(SR.Format(SR.Argument_BadResourceScopeVisibilityBits, consumeAsScope), "consumeAsScope");
				case ResourceScope.None:
					break;
				}
				break;
			case ResourceScope.Assembly:
				if ((consumeAsScope & ResourceScope.Private) != 0)
				{
					sxSRequirements |= SxSRequirements.TypeName;
				}
				break;
			default:
				throw new ArgumentException(SR.Format(SR.Argument_BadResourceScopeVisibilityBits, calleeScope), "calleeScope");
			case ResourceScope.Private:
				break;
			}
			return sxSRequirements;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class NonVersionableAttribute : Attribute
	{
	}
}
namespace System.Runtime.Loader
{
	public class AssemblyLoadContext
	{
		private enum InternalState
		{
			Alive,
			Unloading
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public struct ContextualReflectionScope : IDisposable
		{
			private readonly AssemblyLoadContext _activated;

			private readonly AssemblyLoadContext _predecessor;

			private readonly bool _initialized;

			internal ContextualReflectionScope(AssemblyLoadContext activating)
			{
				_predecessor = CurrentContextualReflectionContext;
				SetCurrentContextualReflectionContext(activating);
				_activated = activating;
				_initialized = true;
			}

			public void Dispose()
			{
				if (_initialized)
				{
					SetCurrentContextualReflectionContext(_predecessor);
				}
			}
		}

		private const string AssemblyLoadName = "AssemblyLoad";

		private static volatile Dictionary<long, WeakReference<AssemblyLoadContext>> s_allContexts;

		private static long s_nextId;

		private readonly IntPtr _nativeAssemblyLoadContext;

		private readonly object _unloadLock;

		private readonly string _name;

		private readonly long _id;

		private InternalState _state;

		private readonly bool _isCollectible;

		private static AsyncLocal<AssemblyLoadContext> s_asyncLocalCurrent;

		[MemberNotNull("s_allContexts")]
		private static Dictionary<long, WeakReference<AssemblyLoadContext>> AllContexts
		{
			[MemberNotNull("s_allContexts")]
			get
			{
				return s_allContexts ?? Interlocked.CompareExchange(ref s_allContexts, new Dictionary<long, WeakReference<AssemblyLoadContext>>(), null) ?? s_allContexts;
			}
		}

		public IEnumerable<Assembly> Assemblies
		{
			get
			{
				Assembly[] loadedAssemblies = GetLoadedAssemblies();
				foreach (Assembly assembly in loadedAssemblies)
				{
					AssemblyLoadContext loadContext = GetLoadContext(assembly);
					if (loadContext == this)
					{
						yield return assembly;
					}
				}
			}
		}

		public static AssemblyLoadContext Default => DefaultAssemblyLoadContext.s_loadContext;

		public bool IsCollectible => _isCollectible;

		public string? Name => _name;

		public static IEnumerable<AssemblyLoadContext> All
		{
			get
			{
				_ = Default;
				Dictionary<long, WeakReference<AssemblyLoadContext>> dictionary = s_allContexts;
				WeakReference<AssemblyLoadContext>[] array;
				lock (dictionary)
				{
					array = new WeakReference<AssemblyLoadContext>[dictionary.Count];
					int num = 0;
					foreach (KeyValuePair<long, WeakReference<AssemblyLoadContext>> item in dictionary)
					{
						array[num++] = item.Value;
					}
				}
				WeakReference<AssemblyLoadContext>[] array2 = array;
				foreach (WeakReference<AssemblyLoadContext> weakReference in array2)
				{
					if (weakReference.TryGetTarget(out var target))
					{
						yield return target;
					}
				}
			}
		}

		public static AssemblyLoadContext? CurrentContextualReflectionContext => s_asyncLocalCurrent?.Value;

		private event Func<Assembly, string, IntPtr>? _resolvingUnmanagedDll;

		private event Func<AssemblyLoadContext, AssemblyName, Assembly>? _resolving;

		private event Action<AssemblyLoadContext>? _unloading;

		public event Func<Assembly, string, IntPtr>? ResolvingUnmanagedDll
		{
			add
			{
				_resolvingUnmanagedDll += value;
			}
			remove
			{
				_resolvingUnmanagedDll -= value;
			}
		}

		public event Func<AssemblyLoadContext, AssemblyName, Assembly?>? Resolving
		{
			add
			{
				_resolving += value;
			}
			remove
			{
				_resolving -= value;
			}
		}

		public event Action<AssemblyLoadContext>? Unloading
		{
			add
			{
				_unloading += value;
			}
			remove
			{
				_unloading -= value;
			}
		}

		internal static event AssemblyLoadEventHandler? AssemblyLoad;

		internal static event ResolveEventHandler? TypeResolve;

		internal static event ResolveEventHandler? ResourceResolve;

		internal static event ResolveEventHandler? AssemblyResolve;

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern IntPtr InitializeAssemblyLoadContext(IntPtr ptrAssemblyLoadContext, bool fRepresentsTPALoadContext, bool isCollectible);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void PrepareForAssemblyLoadContextRelease(IntPtr ptrNativeAssemblyLoadContext, IntPtr ptrAssemblyLoadContextStrong);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		private static extern void LoadFromStream(IntPtr ptrNativeAssemblyLoadContext, IntPtr ptrAssemblyArray, int iAssemblyArrayLen, IntPtr ptrSymbols, int iSymbolArrayLen, ObjectHandleOnStack retAssembly);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void InternalSetProfileRoot(string directoryPath);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void InternalStartProfile(string profile, IntPtr ptrNativeAssemblyLoadContext);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		private static extern void LoadFromPath(IntPtr ptrNativeAssemblyLoadContext, string ilPath, string niPath, ObjectHandleOnStack retAssembly);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern Assembly[] GetLoadedAssemblies();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsTracingEnabled();

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern bool TraceResolvingHandlerInvoked(string assemblyName, string handlerName, string alcName, string resultAssemblyName, string resultAssemblyPath);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern bool TraceAssemblyResolveHandlerInvoked(string assemblyName, string handlerName, string resultAssemblyName, string resultAssemblyPath);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern bool TraceAssemblyLoadFromResolveHandlerInvoked(string assemblyName, bool isTrackedAssembly, string requestingAssemblyPath, string requestedAssemblyPath);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern bool TraceSatelliteSubdirectoryPathProbed(string filePath, int hResult);

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		private Assembly InternalLoadFromPath(string assemblyPath, string nativeImagePath)
		{
			RuntimeAssembly o = null;
			LoadFromPath(_nativeAssemblyLoadContext, assemblyPath, nativeImagePath, ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		internal unsafe Assembly InternalLoad(ReadOnlySpan<byte> arrAssembly, ReadOnlySpan<byte> arrSymbols)
		{
			RuntimeAssembly o = null;
			fixed (byte* value = arrAssembly)
			{
				fixed (byte* value2 = arrSymbols)
				{
					LoadFromStream(_nativeAssemblyLoadContext, new IntPtr(value), arrAssembly.Length, new IntPtr(value2), arrSymbols.Length, ObjectHandleOnStack.Create(ref o));
				}
			}
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern IntPtr LoadFromInMemoryModuleInternal(IntPtr ptrNativeAssemblyLoadContext, IntPtr hModule, ObjectHandleOnStack retAssembly);

		internal Assembly LoadFromInMemoryModule(IntPtr moduleHandle)
		{
			if (moduleHandle == IntPtr.Zero)
			{
				throw new ArgumentNullException("moduleHandle");
			}
			lock (_unloadLock)
			{
				VerifyIsAlive();
				RuntimeAssembly o = null;
				LoadFromInMemoryModuleInternal(_nativeAssemblyLoadContext, moduleHandle, ObjectHandleOnStack.Create(ref o));
				return o;
			}
		}

		private static Assembly ResolveSatelliteAssembly(IntPtr gchManagedAssemblyLoadContext, AssemblyName assemblyName)
		{
			AssemblyLoadContext assemblyLoadContext = (AssemblyLoadContext)GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target;
			return assemblyLoadContext.ResolveSatelliteAssembly(assemblyName);
		}

		private static IntPtr ResolveUnmanagedDll(string unmanagedDllName, IntPtr gchManagedAssemblyLoadContext)
		{
			AssemblyLoadContext assemblyLoadContext = (AssemblyLoadContext)GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target;
			return assemblyLoadContext.LoadUnmanagedDll(unmanagedDllName);
		}

		private static IntPtr ResolveUnmanagedDllUsingEvent(string unmanagedDllName, Assembly assembly, IntPtr gchManagedAssemblyLoadContext)
		{
			AssemblyLoadContext assemblyLoadContext = (AssemblyLoadContext)GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target;
			return assemblyLoadContext.GetResolvedUnmanagedDll(assembly, unmanagedDllName);
		}

		private static Assembly ResolveUsingResolvingEvent(IntPtr gchManagedAssemblyLoadContext, AssemblyName assemblyName)
		{
			AssemblyLoadContext assemblyLoadContext = (AssemblyLoadContext)GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target;
			return assemblyLoadContext.ResolveUsingEvent(assemblyName);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern IntPtr GetLoadContextForAssembly(QCallAssembly assembly);

		public static AssemblyLoadContext? GetLoadContext(Assembly assembly)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			AssemblyLoadContext result = null;
			RuntimeAssembly runtimeAssembly = GetRuntimeAssembly(assembly);
			if (runtimeAssembly != null)
			{
				RuntimeAssembly assembly2 = runtimeAssembly;
				IntPtr loadContextForAssembly = GetLoadContextForAssembly(new QCallAssembly(ref assembly2));
				result = ((!(loadContextForAssembly == IntPtr.Zero)) ? ((AssemblyLoadContext)GCHandle.FromIntPtr(loadContextForAssembly).Target) : Default);
			}
			return result;
		}

		public void SetProfileOptimizationRoot(string directoryPath)
		{
			InternalSetProfileRoot(directoryPath);
		}

		public void StartProfileOptimization(string? profile)
		{
			InternalStartProfile(profile, _nativeAssemblyLoadContext);
		}

		private static RuntimeAssembly GetRuntimeAssembly(Assembly asm)
		{
			if (!(asm == null))
			{
				if (!(asm is RuntimeAssembly result))
				{
					if (!(asm is AssemblyBuilder assemblyBuilder))
					{
						return null;
					}
					return assemblyBuilder.InternalAssembly;
				}
				return result;
			}
			return null;
		}

		private static void StartAssemblyLoad(ref Guid activityId, ref Guid relatedActivityId)
		{
			ActivityTracker.Instance.Enable();
			ActivityTracker.Instance.OnStart(NativeRuntimeEventSource.Log.Name, "AssemblyLoad", 0, ref activityId, ref relatedActivityId, EventActivityOptions.Recursive, useTplSource: false);
		}

		private static void StopAssemblyLoad(ref Guid activityId)
		{
			ActivityTracker.Instance.OnStop(NativeRuntimeEventSource.Log.Name, "AssemblyLoad", 0, ref activityId, useTplSource: false);
		}

		private static void InitializeDefaultContext()
		{
			_ = Default;
		}

		protected AssemblyLoadContext()
			: this(representsTPALoadContext: false, isCollectible: false, null)
		{
		}

		protected AssemblyLoadContext(bool isCollectible)
			: this(representsTPALoadContext: false, isCollectible, null)
		{
		}

		public AssemblyLoadContext(string? name, bool isCollectible = false)
			: this(representsTPALoadContext: false, isCollectible, name)
		{
		}

		private protected AssemblyLoadContext(bool representsTPALoadContext, bool isCollectible, string name)
		{
			_isCollectible = isCollectible;
			_name = name;
			_unloadLock = new object();
			if (!isCollectible)
			{
				GC.SuppressFinalize(this);
			}
			_nativeAssemblyLoadContext = InitializeAssemblyLoadContext(GCHandle.ToIntPtr(GCHandle.Alloc(this, IsCollectible ? GCHandleType.WeakTrackResurrection : GCHandleType.Normal)), representsTPALoadContext, isCollectible);
			Dictionary<long, WeakReference<AssemblyLoadContext>> allContexts = AllContexts;
			lock (allContexts)
			{
				_id = s_nextId++;
				allContexts.Add(_id, new WeakReference<AssemblyLoadContext>(this, trackResurrection: true));
			}
		}

		~AssemblyLoadContext()
		{
			if (_unloadLock != null)
			{
				InitiateUnload();
			}
		}

		private void RaiseUnloadEvent()
		{
			Interlocked.Exchange(ref this._unloading, null)?.Invoke(this);
		}

		private void InitiateUnload()
		{
			RaiseUnloadEvent();
			lock (_unloadLock)
			{
				GCHandle value = GCHandle.Alloc(this, GCHandleType.Normal);
				IntPtr ptrAssemblyLoadContextStrong = GCHandle.ToIntPtr(value);
				PrepareForAssemblyLoadContextRelease(_nativeAssemblyLoadContext, ptrAssemblyLoadContextStrong);
				_state = InternalState.Unloading;
			}
			Dictionary<long, WeakReference<AssemblyLoadContext>> allContexts = AllContexts;
			lock (allContexts)
			{
				allContexts.Remove(_id);
			}
		}

		public override string ToString()
		{
			return $"\"{Name}\" {GetType()} #{_id}";
		}

		public static AssemblyName GetAssemblyName(string assemblyPath)
		{
			if (assemblyPath == null)
			{
				throw new ArgumentNullException("assemblyPath");
			}
			return AssemblyName.GetAssemblyName(assemblyPath);
		}

		protected virtual Assembly? Load(AssemblyName assemblyName)
		{
			return null;
		}

		public Assembly LoadFromAssemblyName(AssemblyName assemblyName)
		{
			if (assemblyName == null)
			{
				throw new ArgumentNullException("assemblyName");
			}
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return RuntimeAssembly.InternalLoad(assemblyName, ref stackMark, this);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public Assembly LoadFromAssemblyPath(string assemblyPath)
		{
			if (assemblyPath == null)
			{
				throw new ArgumentNullException("assemblyPath");
			}
			if (PathInternal.IsPartiallyQualified(assemblyPath))
			{
				throw new ArgumentException(SR.Format(SR.Argument_AbsolutePathRequired, assemblyPath), "assemblyPath");
			}
			lock (_unloadLock)
			{
				VerifyIsAlive();
				return InternalLoadFromPath(assemblyPath, null);
			}
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public Assembly LoadFromNativeImagePath(string nativeImagePath, string? assemblyPath)
		{
			if (nativeImagePath == null)
			{
				throw new ArgumentNullException("nativeImagePath");
			}
			if (PathInternal.IsPartiallyQualified(nativeImagePath))
			{
				throw new ArgumentException(SR.Format(SR.Argument_AbsolutePathRequired, nativeImagePath), "nativeImagePath");
			}
			if (assemblyPath != null && PathInternal.IsPartiallyQualified(assemblyPath))
			{
				throw new ArgumentException(SR.Format(SR.Argument_AbsolutePathRequired, assemblyPath), "assemblyPath");
			}
			lock (_unloadLock)
			{
				VerifyIsAlive();
				return InternalLoadFromPath(assemblyPath, nativeImagePath);
			}
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public Assembly LoadFromStream(Stream assembly)
		{
			return LoadFromStream(assembly, null);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public Assembly LoadFromStream(Stream assembly, Stream? assemblySymbols)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			int num = (int)assembly.Length;
			if (num <= 0)
			{
				throw new BadImageFormatException(SR.BadImageFormat_BadILFormat);
			}
			byte[] array = new byte[num];
			assembly.Read(array, 0, num);
			byte[] array2 = null;
			if (assemblySymbols != null)
			{
				int num2 = (int)assemblySymbols.Length;
				array2 = new byte[num2];
				assemblySymbols.Read(array2, 0, num2);
			}
			lock (_unloadLock)
			{
				VerifyIsAlive();
				return InternalLoad(array, array2);
			}
		}

		protected IntPtr LoadUnmanagedDllFromPath(string unmanagedDllPath)
		{
			if (unmanagedDllPath == null)
			{
				throw new ArgumentNullException("unmanagedDllPath");
			}
			if (unmanagedDllPath.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "unmanagedDllPath");
			}
			if (PathInternal.IsPartiallyQualified(unmanagedDllPath))
			{
				throw new ArgumentException(SR.Format(SR.Argument_AbsolutePathRequired, unmanagedDllPath), "unmanagedDllPath");
			}
			return NativeLibrary.Load(unmanagedDllPath);
		}

		protected virtual IntPtr LoadUnmanagedDll(string unmanagedDllName)
		{
			return IntPtr.Zero;
		}

		public void Unload()
		{
			if (!IsCollectible)
			{
				throw new InvalidOperationException(SR.AssemblyLoadContext_Unload_CannotUnloadIfNotCollectible);
			}
			GC.SuppressFinalize(this);
			InitiateUnload();
		}

		internal static void OnProcessExit()
		{
			Dictionary<long, WeakReference<AssemblyLoadContext>> dictionary = s_allContexts;
			if (dictionary == null)
			{
				return;
			}
			lock (dictionary)
			{
				foreach (KeyValuePair<long, WeakReference<AssemblyLoadContext>> item in dictionary)
				{
					if (item.Value.TryGetTarget(out var target))
					{
						target.RaiseUnloadEvent();
					}
				}
			}
		}

		private void VerifyIsAlive()
		{
			if (_state != 0)
			{
				throw new InvalidOperationException(SR.AssemblyLoadContext_Verify_NotUnloading);
			}
		}

		private static void SetCurrentContextualReflectionContext(AssemblyLoadContext value)
		{
			if (s_asyncLocalCurrent == null)
			{
				Interlocked.CompareExchange(ref s_asyncLocalCurrent, new AsyncLocal<AssemblyLoadContext>(), null);
			}
			s_asyncLocalCurrent.Value = value;
		}

		public ContextualReflectionScope EnterContextualReflection()
		{
			return new ContextualReflectionScope(this);
		}

		public static ContextualReflectionScope EnterContextualReflection(Assembly? activating)
		{
			if (activating == null)
			{
				return new ContextualReflectionScope(null);
			}
			AssemblyLoadContext loadContext = GetLoadContext(activating);
			if (loadContext == null)
			{
				throw new ArgumentException(SR.Arg_MustBeRuntimeAssembly, "activating");
			}
			return loadContext.EnterContextualReflection();
		}

		private static Assembly Resolve(IntPtr gchManagedAssemblyLoadContext, AssemblyName assemblyName)
		{
			AssemblyLoadContext assemblyLoadContext = (AssemblyLoadContext)GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target;
			return assemblyLoadContext.ResolveUsingLoad(assemblyName);
		}

		[UnconditionalSuppressMessage("SingleFile", "IL3000: Avoid accessing Assembly file path when publishing as a single file", Justification = "The code handles the Assembly.Location equals null")]
		private Assembly GetFirstResolvedAssemblyFromResolvingEvent(AssemblyName assemblyName)
		{
			Assembly assembly = null;
			Func<AssemblyLoadContext, AssemblyName, Assembly> resolving = this._resolving;
			if (resolving != null)
			{
				Delegate[] invocationList = resolving.GetInvocationList();
				for (int i = 0; i < invocationList.Length; i++)
				{
					Func<AssemblyLoadContext, AssemblyName, Assembly> func = (Func<AssemblyLoadContext, AssemblyName, Assembly>)invocationList[i];
					assembly = func(this, assemblyName);
					if (IsTracingEnabled())
					{
						TraceResolvingHandlerInvoked(assemblyName.FullName, func.Method.Name, (this != Default) ? ToString() : Name, assembly?.FullName, (assembly != null && !assembly.IsDynamic) ? assembly.Location : null);
					}
					if (assembly != null)
					{
						return assembly;
					}
				}
			}
			return null;
		}

		private static Assembly ValidateAssemblyNameWithSimpleName(Assembly assembly, string requestedSimpleName)
		{
			if (string.IsNullOrEmpty(requestedSimpleName))
			{
				throw new ArgumentException(SR.ArgumentNull_AssemblyNameName);
			}
			string value = null;
			RuntimeAssembly runtimeAssembly = GetRuntimeAssembly(assembly);
			if (runtimeAssembly != null)
			{
				value = runtimeAssembly.GetSimpleName();
			}
			if (string.IsNullOrEmpty(value) || !requestedSimpleName.Equals(value, StringComparison.InvariantCultureIgnoreCase))
			{
				throw new InvalidOperationException(SR.Argument_CustomAssemblyLoadContextRequestedNameMismatch);
			}
			return assembly;
		}

		private Assembly ResolveUsingLoad(AssemblyName assemblyName)
		{
			string name = assemblyName.Name;
			Assembly assembly = Load(assemblyName);
			if (assembly != null)
			{
				assembly = ValidateAssemblyNameWithSimpleName(assembly, name);
			}
			return assembly;
		}

		private Assembly ResolveUsingEvent(AssemblyName assemblyName)
		{
			string name = assemblyName.Name;
			Assembly assembly = GetFirstResolvedAssemblyFromResolvingEvent(assemblyName);
			if (assembly != null)
			{
				assembly = ValidateAssemblyNameWithSimpleName(assembly, name);
			}
			return assembly;
		}

		private static void OnAssemblyLoad(RuntimeAssembly assembly)
		{
			AssemblyLoadContext.AssemblyLoad?.Invoke(AppDomain.CurrentDomain, new AssemblyLoadEventArgs(assembly));
		}

		private static RuntimeAssembly OnResourceResolve(RuntimeAssembly assembly, string resourceName)
		{
			return InvokeResolveEvent(AssemblyLoadContext.ResourceResolve, assembly, resourceName);
		}

		private static RuntimeAssembly OnTypeResolve(RuntimeAssembly assembly, string typeName)
		{
			return InvokeResolveEvent(AssemblyLoadContext.TypeResolve, assembly, typeName);
		}

		private static RuntimeAssembly OnAssemblyResolve(RuntimeAssembly assembly, string assemblyFullName)
		{
			return InvokeResolveEvent(AssemblyLoadContext.AssemblyResolve, assembly, assemblyFullName);
		}

		[UnconditionalSuppressMessage("SingleFile", "IL3000: Avoid accessing Assembly file path when publishing as a single file", Justification = "The code handles the Assembly.Location equals null")]
		private static RuntimeAssembly InvokeResolveEvent(ResolveEventHandler eventHandler, RuntimeAssembly assembly, string name)
		{
			if (eventHandler == null)
			{
				return null;
			}
			ResolveEventArgs args = new ResolveEventArgs(name, assembly);
			Delegate[] invocationList = eventHandler.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				ResolveEventHandler resolveEventHandler = (ResolveEventHandler)invocationList[i];
				Assembly assembly2 = resolveEventHandler(AppDomain.CurrentDomain, args);
				if (eventHandler == AssemblyLoadContext.AssemblyResolve && IsTracingEnabled())
				{
					TraceAssemblyResolveHandlerInvoked(name, resolveEventHandler.Method.Name, assembly2?.FullName, (assembly2 != null && !assembly2.IsDynamic) ? assembly2.Location : null);
				}
				RuntimeAssembly runtimeAssembly = GetRuntimeAssembly(assembly2);
				if (runtimeAssembly != null)
				{
					return runtimeAssembly;
				}
			}
			return null;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Satellite assemblies have no code in them and loading is not a problem")]
		[UnconditionalSuppressMessage("SingleFile", "IL3000: Avoid accessing Assembly file path when publishing as a single file", Justification = "This call is fine because native call runs before this and checks BindSatelliteResourceFromBundle")]
		private Assembly ResolveSatelliteAssembly(AssemblyName assemblyName)
		{
			if (assemblyName.Name == null || !assemblyName.Name.EndsWith(".resources", StringComparison.Ordinal))
			{
				return null;
			}
			string assemblyName2 = assemblyName.Name.Substring(0, assemblyName.Name.Length - ".resources".Length);
			Assembly assembly = LoadFromAssemblyName(new AssemblyName(assemblyName2));
			AssemblyLoadContext loadContext = GetLoadContext(assembly);
			string directoryName = Path.GetDirectoryName(assembly.Location);
			if (directoryName == null)
			{
				return null;
			}
			string text = Path.Combine(directoryName, assemblyName.CultureName, assemblyName.Name + ".dll");
			bool flag = FileSystem.FileExists(text);
			if (flag || PathInternal.IsCaseSensitive)
			{
			}
			Assembly result = (flag ? loadContext.LoadFromAssemblyPath(text) : null);
			if (IsTracingEnabled())
			{
				TraceSatelliteSubdirectoryPathProbed(text, (!flag) ? (-2147024894) : 0);
			}
			return result;
		}

		internal IntPtr GetResolvedUnmanagedDll(Assembly assembly, string unmanagedDllName)
		{
			IntPtr zero = IntPtr.Zero;
			Func<Assembly, string, IntPtr> resolvingUnmanagedDll = this._resolvingUnmanagedDll;
			if (resolvingUnmanagedDll != null)
			{
				Delegate[] invocationList = resolvingUnmanagedDll.GetInvocationList();
				for (int i = 0; i < invocationList.Length; i++)
				{
					Func<Assembly, string, IntPtr> func = (Func<Assembly, string, IntPtr>)invocationList[i];
					zero = func(assembly, unmanagedDllName);
					if (zero != IntPtr.Zero)
					{
						return zero;
					}
				}
			}
			return IntPtr.Zero;
		}
	}
	internal sealed class DefaultAssemblyLoadContext : AssemblyLoadContext
	{
		internal static readonly AssemblyLoadContext s_loadContext = new DefaultAssemblyLoadContext();

		internal DefaultAssemblyLoadContext()
			: base(representsTPALoadContext: true, isCollectible: false, "Default")
		{
		}
	}
	internal sealed class IndividualAssemblyLoadContext : AssemblyLoadContext
	{
		internal IndividualAssemblyLoadContext(string name)
			: base(representsTPALoadContext: false, isCollectible: false, name)
		{
		}
	}
	internal struct LibraryNameVariation
	{
		public string Prefix;

		public string Suffix;

		public LibraryNameVariation(string prefix, string suffix)
		{
			Prefix = prefix;
			Suffix = suffix;
		}

		internal static IEnumerable<LibraryNameVariation> DetermineLibraryNameVariations(string libName, bool isRelativePath, bool forOSLoader = false)
		{
			yield return new LibraryNameVariation(string.Empty, string.Empty);
			if (isRelativePath && (!forOSLoader || (libName.Contains('.') && !libName.EndsWith('.'))) && !libName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) && !libName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
			{
				yield return new LibraryNameVariation(string.Empty, ".dll");
			}
		}
	}
	[UnsupportedOSPlatform("android")]
	[UnsupportedOSPlatform("browser")]
	[UnsupportedOSPlatform("ios")]
	[UnsupportedOSPlatform("tvos")]
	public sealed class AssemblyDependencyResolver
	{
		private readonly Dictionary<string, string> _assemblyPaths;

		private readonly string[] _nativeSearchPaths;

		private readonly string[] _resourceSearchPaths;

		private readonly string[] _assemblyDirectorySearchPaths;

		public AssemblyDependencyResolver(string componentAssemblyPath)
		{
			if (componentAssemblyPath == null)
			{
				throw new ArgumentNullException("componentAssemblyPath");
			}
			string assemblyPathsList = null;
			string nativeSearchPathsList = null;
			string resourceSearchPathsList = null;
			int num = 0;
			StringBuilder errorMessage = new StringBuilder();
			try
			{
				Interop.HostPolicy.corehost_error_writer_fn corehost_error_writer_fn = delegate(string message)
				{
					errorMessage.AppendLine(message);
				};
				IntPtr functionPointerForDelegate = Marshal.GetFunctionPointerForDelegate(corehost_error_writer_fn);
				IntPtr errorWriter = Interop.HostPolicy.corehost_set_error_writer(functionPointerForDelegate);
				try
				{
					num = Interop.HostPolicy.corehost_resolve_component_dependencies(componentAssemblyPath, delegate(string assemblyPaths, string nativeSearchPaths, string resourceSearchPaths)
					{
						assemblyPathsList = assemblyPaths;
						nativeSearchPathsList = nativeSearchPaths;
						resourceSearchPathsList = resourceSearchPaths;
					});
				}
				finally
				{
					Interop.HostPolicy.corehost_set_error_writer(errorWriter);
					GC.KeepAlive(corehost_error_writer_fn);
				}
			}
			catch (EntryPointNotFoundException innerException)
			{
				throw new InvalidOperationException(SR.AssemblyDependencyResolver_FailedToLoadHostpolicy, innerException);
			}
			catch (DllNotFoundException innerException2)
			{
				throw new InvalidOperationException(SR.AssemblyDependencyResolver_FailedToLoadHostpolicy, innerException2);
			}
			if (num != 0)
			{
				throw new InvalidOperationException(SR.Format(SR.AssemblyDependencyResolver_FailedToResolveDependencies, componentAssemblyPath, num, errorMessage));
			}
			string[] array = SplitPathsList(assemblyPathsList);
			_assemblyPaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			string[] array2 = array;
			foreach (string text in array2)
			{
				_assemblyPaths.TryAdd(Path.GetFileNameWithoutExtension(text), text);
			}
			_nativeSearchPaths = SplitPathsList(nativeSearchPathsList);
			_resourceSearchPaths = SplitPathsList(resourceSearchPathsList);
			_assemblyDirectorySearchPaths = new string[1] { Path.GetDirectoryName(componentAssemblyPath) };
		}

		public string? ResolveAssemblyToPath(AssemblyName assemblyName)
		{
			if (assemblyName == null)
			{
				throw new ArgumentNullException("assemblyName");
			}
			string value;
			if (!string.IsNullOrEmpty(assemblyName.CultureName) && !string.Equals(assemblyName.CultureName, "neutral", StringComparison.OrdinalIgnoreCase))
			{
				string[] resourceSearchPaths = _resourceSearchPaths;
				foreach (string path in resourceSearchPaths)
				{
					string text = Path.Combine(path, assemblyName.CultureName, assemblyName.Name + ".dll");
					if (File.Exists(text))
					{
						return text;
					}
				}
			}
			else if (assemblyName.Name != null && _assemblyPaths.TryGetValue(assemblyName.Name, out value) && File.Exists(value))
			{
				return value;
			}
			return null;
		}

		public string? ResolveUnmanagedDllToPath(string unmanagedDllName)
		{
			if (unmanagedDllName == null)
			{
				throw new ArgumentNullException("unmanagedDllName");
			}
			string[] array = ((!unmanagedDllName.Contains(Path.DirectorySeparatorChar)) ? _nativeSearchPaths : _assemblyDirectorySearchPaths);
			bool isRelativePath = !Path.IsPathFullyQualified(unmanagedDllName);
			foreach (LibraryNameVariation item in LibraryNameVariation.DetermineLibraryNameVariations(unmanagedDllName, isRelativePath))
			{
				string path = item.Prefix + unmanagedDllName + item.Suffix;
				string[] array2 = array;
				foreach (string path2 in array2)
				{
					string text = Path.Combine(path2, path);
					if (File.Exists(text))
					{
						return text;
					}
				}
			}
			return null;
		}

		private static string[] SplitPathsList(string pathsList)
		{
			if (pathsList == null)
			{
				return Array.Empty<string>();
			}
			return pathsList.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);
		}
	}
}
namespace System.Runtime.Intrinsics
{
	public static class Vector128
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector128<U> As<T, U>(this Vector128<T> vector) where T : struct where U : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<U>();
			return Unsafe.As<Vector128<T>, Vector128<U>>(ref vector);
		}

		[Intrinsic]
		public static Vector128<byte> AsByte<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, byte>();
		}

		[Intrinsic]
		public static Vector128<double> AsDouble<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, double>();
		}

		[Intrinsic]
		public static Vector128<short> AsInt16<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, short>();
		}

		[Intrinsic]
		public static Vector128<int> AsInt32<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, int>();
		}

		[Intrinsic]
		public static Vector128<long> AsInt64<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, long>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<sbyte> AsSByte<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, sbyte>();
		}

		[Intrinsic]
		public static Vector128<float> AsSingle<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, float>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<ushort> AsUInt16<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, ushort>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<uint> AsUInt32<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, uint>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<ulong> AsUInt64<T>(this Vector128<T> vector) where T : struct
		{
			return vector.As<T, ulong>();
		}

		public static Vector128<float> AsVector128(this Vector2 value)
		{
			return new Vector4(value, 0f, 0f).AsVector128();
		}

		public static Vector128<float> AsVector128(this Vector3 value)
		{
			return new Vector4(value, 0f).AsVector128();
		}

		[Intrinsic]
		public static Vector128<float> AsVector128(this Vector4 value)
		{
			return Unsafe.As<Vector4, Vector128<float>>(ref value);
		}

		[Intrinsic]
		public static Vector128<T> AsVector128<T>(this Vector<T> value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			return Unsafe.As<Vector<T>, Vector128<T>>(ref value);
		}

		public static Vector2 AsVector2(this Vector128<float> value)
		{
			return Unsafe.As<Vector128<float>, Vector2>(ref value);
		}

		public static Vector3 AsVector3(this Vector128<float> value)
		{
			return Unsafe.As<Vector128<float>, Vector3>(ref value);
		}

		[Intrinsic]
		public static Vector4 AsVector4(this Vector128<float> value)
		{
			return Unsafe.As<Vector128<float>, Vector4>(ref value);
		}

		[Intrinsic]
		public static Vector<T> AsVector<T>(this Vector128<T> value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			Vector<T> source = default(Vector<T>);
			Unsafe.WriteUnaligned(ref Unsafe.As<Vector<T>, byte>(ref source), value);
			return source;
		}

		[Intrinsic]
		public static Vector128<byte> Create(byte value)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<byte> SoftwareFallback(byte value)
			{
				byte* source = stackalloc byte[16]
				{
					value, value, value, value, value, value, value, value, value, value,
					value, value, value, value, value, value
				};
				return Unsafe.AsRef<Vector128<byte>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<double> Create(double value)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<double> SoftwareFallback(double value)
			{
				double* source = stackalloc double[2] { value, value };
				return Unsafe.AsRef<Vector128<double>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<short> Create(short value)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<short> SoftwareFallback(short value)
			{
				short* source = stackalloc short[8] { value, value, value, value, value, value, value, value };
				return Unsafe.AsRef<Vector128<short>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<int> Create(int value)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<int> SoftwareFallback(int value)
			{
				int* source = stackalloc int[4] { value, value, value, value };
				return Unsafe.AsRef<Vector128<int>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<long> Create(long value)
		{
			if (Sse2.X64.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<long> SoftwareFallback(long value)
			{
				long* source = stackalloc long[2] { value, value };
				return Unsafe.AsRef<Vector128<long>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<sbyte> Create(sbyte value)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<sbyte> SoftwareFallback(sbyte value)
			{
				sbyte* source = stackalloc sbyte[16]
				{
					value, value, value, value, value, value, value, value, value, value,
					value, value, value, value, value, value
				};
				return Unsafe.AsRef<Vector128<sbyte>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<float> Create(float value)
		{
			if (Sse.IsSupported || AdvSimd.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<float> SoftwareFallback(float value)
			{
				float* source = stackalloc float[4] { value, value, value, value };
				return Unsafe.AsRef<Vector128<float>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<ushort> Create(ushort value)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<ushort> SoftwareFallback(ushort value)
			{
				ushort* source = stackalloc ushort[8] { value, value, value, value, value, value, value, value };
				return Unsafe.AsRef<Vector128<ushort>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<uint> Create(uint value)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<uint> SoftwareFallback(uint value)
			{
				uint* source = stackalloc uint[4] { value, value, value, value };
				return Unsafe.AsRef<Vector128<uint>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<ulong> Create(ulong value)
		{
			if (Sse2.X64.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector128<ulong> SoftwareFallback(ulong value)
			{
				ulong* source = stackalloc ulong[2] { value, value };
				return Unsafe.AsRef<Vector128<ulong>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15);
			unsafe static Vector128<byte> SoftwareFallback(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15)
			{
				byte* source = stackalloc byte[16]
				{
					e0, e1, e2, e3, e4, e5, e6, e7, e8, e9,
					e10, e11, e12, e13, e14, e15
				};
				return Unsafe.AsRef<Vector128<byte>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<double> Create(double e0, double e1)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(e0, e1);
			}
			return SoftwareFallback(e0, e1);
			unsafe static Vector128<double> SoftwareFallback(double e0, double e1)
			{
				double* source = stackalloc double[2] { e0, e1 };
				return Unsafe.AsRef<Vector128<double>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<short> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7);
			unsafe static Vector128<short> SoftwareFallback(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7)
			{
				short* source = stackalloc short[8] { e0, e1, e2, e3, e4, e5, e6, e7 };
				return Unsafe.AsRef<Vector128<short>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<int> Create(int e0, int e1, int e2, int e3)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(e0, e1, e2, e3);
			}
			return SoftwareFallback(e0, e1, e2, e3);
			unsafe static Vector128<int> SoftwareFallback(int e0, int e1, int e2, int e3)
			{
				int* source = stackalloc int[4] { e0, e1, e2, e3 };
				return Unsafe.AsRef<Vector128<int>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<long> Create(long e0, long e1)
		{
			if (Sse2.X64.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				return Create(e0, e1);
			}
			return SoftwareFallback(e0, e1);
			unsafe static Vector128<long> SoftwareFallback(long e0, long e1)
			{
				long* source = stackalloc long[2] { e0, e1 };
				return Unsafe.AsRef<Vector128<long>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<sbyte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15);
			unsafe static Vector128<sbyte> SoftwareFallback(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15)
			{
				sbyte* source = stackalloc sbyte[16]
				{
					e0, e1, e2, e3, e4, e5, e6, e7, e8, e9,
					e10, e11, e12, e13, e14, e15
				};
				return Unsafe.AsRef<Vector128<sbyte>>(source);
			}
		}

		[Intrinsic]
		public static Vector128<float> Create(float e0, float e1, float e2, float e3)
		{
			if (Sse.IsSupported || AdvSimd.IsSupported)
			{
				return Create(e0, e1, e2, e3);
			}
			return SoftwareFallback(e0, e1, e2, e3);
			unsafe static Vector128<float> SoftwareFallback(float e0, float e1, float e2, float e3)
			{
				float* source = stackalloc float[4] { e0, e1, e2, e3 };
				return Unsafe.AsRef<Vector128<float>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<ushort> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7);
			unsafe static Vector128<ushort> SoftwareFallback(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7)
			{
				ushort* source = stackalloc ushort[8] { e0, e1, e2, e3, e4, e5, e6, e7 };
				return Unsafe.AsRef<Vector128<ushort>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<uint> Create(uint e0, uint e1, uint e2, uint e3)
		{
			if (Sse2.IsSupported || AdvSimd.IsSupported)
			{
				return Create(e0, e1, e2, e3);
			}
			return SoftwareFallback(e0, e1, e2, e3);
			unsafe static Vector128<uint> SoftwareFallback(uint e0, uint e1, uint e2, uint e3)
			{
				uint* source = stackalloc uint[4] { e0, e1, e2, e3 };
				return Unsafe.AsRef<Vector128<uint>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector128<ulong> Create(ulong e0, ulong e1)
		{
			if (Sse2.X64.IsSupported || AdvSimd.Arm64.IsSupported)
			{
				return Create(e0, e1);
			}
			return SoftwareFallback(e0, e1);
			unsafe static Vector128<ulong> SoftwareFallback(ulong e0, ulong e1)
			{
				ulong* source = stackalloc ulong[2] { e0, e1 };
				return Unsafe.AsRef<Vector128<ulong>>(source);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<byte> Create(Vector64<byte> lower, Vector64<byte> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<byte> SoftwareFallback(Vector64<byte> lower, Vector64<byte> upper)
			{
				Vector128<byte> source = Vector128<byte>.Zero;
				ref Vector64<byte> reference = ref Unsafe.As<Vector128<byte>, Vector64<byte>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<double> Create(Vector64<double> lower, Vector64<double> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<double> SoftwareFallback(Vector64<double> lower, Vector64<double> upper)
			{
				Vector128<double> source = Vector128<double>.Zero;
				ref Vector64<double> reference = ref Unsafe.As<Vector128<double>, Vector64<double>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<short> Create(Vector64<short> lower, Vector64<short> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<short> SoftwareFallback(Vector64<short> lower, Vector64<short> upper)
			{
				Vector128<short> source = Vector128<short>.Zero;
				ref Vector64<short> reference = ref Unsafe.As<Vector128<short>, Vector64<short>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<int> Create(Vector64<int> lower, Vector64<int> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<int> SoftwareFallback(Vector64<int> lower, Vector64<int> upper)
			{
				Vector128<int> source = Vector128<int>.Zero;
				ref Vector64<int> reference = ref Unsafe.As<Vector128<int>, Vector64<int>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<long> Create(Vector64<long> lower, Vector64<long> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<long> SoftwareFallback(Vector64<long> lower, Vector64<long> upper)
			{
				Vector128<long> source = Vector128<long>.Zero;
				ref Vector64<long> reference = ref Unsafe.As<Vector128<long>, Vector64<long>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector128<sbyte> Create(Vector64<sbyte> lower, Vector64<sbyte> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<sbyte> SoftwareFallback(Vector64<sbyte> lower, Vector64<sbyte> upper)
			{
				Vector128<sbyte> source = Vector128<sbyte>.Zero;
				ref Vector64<sbyte> reference = ref Unsafe.As<Vector128<sbyte>, Vector64<sbyte>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<float> Create(Vector64<float> lower, Vector64<float> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<float> SoftwareFallback(Vector64<float> lower, Vector64<float> upper)
			{
				Vector128<float> source = Vector128<float>.Zero;
				ref Vector64<float> reference = ref Unsafe.As<Vector128<float>, Vector64<float>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector128<ushort> Create(Vector64<ushort> lower, Vector64<ushort> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<ushort> SoftwareFallback(Vector64<ushort> lower, Vector64<ushort> upper)
			{
				Vector128<ushort> source = Vector128<ushort>.Zero;
				ref Vector64<ushort> reference = ref Unsafe.As<Vector128<ushort>, Vector64<ushort>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector128<uint> Create(Vector64<uint> lower, Vector64<uint> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<uint> SoftwareFallback(Vector64<uint> lower, Vector64<uint> upper)
			{
				Vector128<uint> source = Vector128<uint>.Zero;
				ref Vector64<uint> reference = ref Unsafe.As<Vector128<uint>, Vector64<uint>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector128<ulong> Create(Vector64<ulong> lower, Vector64<ulong> upper)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(lower, upper);
			static Vector128<ulong> SoftwareFallback(Vector64<ulong> lower, Vector64<ulong> upper)
			{
				Vector128<ulong> source = Vector128<ulong>.Zero;
				ref Vector64<ulong> reference = ref Unsafe.As<Vector128<ulong>, Vector64<ulong>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<byte> CreateScalar(byte value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.IsSupported)
			{
				return Sse2.ConvertScalarToVector128UInt32(value).AsByte();
			}
			return SoftwareFallback(value);
			static Vector128<byte> SoftwareFallback(byte value)
			{
				Vector128<byte> source = Vector128<byte>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<byte>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<double> CreateScalar(double value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.IsSupported)
			{
				return Sse2.MoveScalar(Vector128<double>.Zero, CreateScalarUnsafe(value));
			}
			return SoftwareFallback(value);
			static Vector128<double> SoftwareFallback(double value)
			{
				Vector128<double> source = Vector128<double>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<double>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<short> CreateScalar(short value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.IsSupported)
			{
				return Sse2.ConvertScalarToVector128UInt32((ushort)value).AsInt16();
			}
			return SoftwareFallback(value);
			static Vector128<short> SoftwareFallback(short value)
			{
				Vector128<short> source = Vector128<short>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<short>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<int> CreateScalar(int value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.IsSupported)
			{
				return Sse2.ConvertScalarToVector128Int32(value);
			}
			return SoftwareFallback(value);
			static Vector128<int> SoftwareFallback(int value)
			{
				Vector128<int> source = Vector128<int>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<int>, byte>(ref source), value);
				return source;
			}
		}

		public static Vector128<long> CreateScalar(long value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.X64.IsSupported)
			{
				return Sse2.X64.ConvertScalarToVector128Int64(value);
			}
			return SoftwareFallback(value);
			static Vector128<long> SoftwareFallback(long value)
			{
				Vector128<long> source = Vector128<long>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<long>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector128<sbyte> CreateScalar(sbyte value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.IsSupported)
			{
				return Sse2.ConvertScalarToVector128UInt32((byte)value).AsSByte();
			}
			return SoftwareFallback(value);
			static Vector128<sbyte> SoftwareFallback(sbyte value)
			{
				Vector128<sbyte> source = Vector128<sbyte>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<sbyte>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<float> CreateScalar(float value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse.IsSupported)
			{
				return Sse.MoveScalar(Vector128<float>.Zero, CreateScalarUnsafe(value));
			}
			return SoftwareFallback(value);
			static Vector128<float> SoftwareFallback(float value)
			{
				Vector128<float> source = Vector128<float>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<float>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector128<ushort> CreateScalar(ushort value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.IsSupported)
			{
				return Sse2.ConvertScalarToVector128UInt32(value).AsUInt16();
			}
			return SoftwareFallback(value);
			static Vector128<ushort> SoftwareFallback(ushort value)
			{
				Vector128<ushort> source = Vector128<ushort>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<ushort>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector128<uint> CreateScalar(uint value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.IsSupported)
			{
				return Sse2.ConvertScalarToVector128UInt32(value);
			}
			return SoftwareFallback(value);
			static Vector128<uint> SoftwareFallback(uint value)
			{
				Vector128<uint> source = Vector128<uint>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<uint>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector128<ulong> CreateScalar(ulong value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			if (Sse2.X64.IsSupported)
			{
				return Sse2.X64.ConvertScalarToVector128UInt64(value);
			}
			return SoftwareFallback(value);
			static Vector128<ulong> SoftwareFallback(ulong value)
			{
				Vector128<ulong> source = Vector128<ulong>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<ulong>, byte>(ref source), value);
				return source;
			}
		}

		[Intrinsic]
		public unsafe static Vector128<byte> CreateScalarUnsafe(byte value)
		{
			byte* ptr = stackalloc byte[16];
			*ptr = value;
			return Unsafe.AsRef<Vector128<byte>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector128<double> CreateScalarUnsafe(double value)
		{
			double* ptr = stackalloc double[2];
			*ptr = value;
			return Unsafe.AsRef<Vector128<double>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector128<short> CreateScalarUnsafe(short value)
		{
			short* ptr = stackalloc short[8];
			*ptr = value;
			return Unsafe.AsRef<Vector128<short>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector128<int> CreateScalarUnsafe(int value)
		{
			int* ptr = stackalloc int[4];
			*ptr = value;
			return Unsafe.AsRef<Vector128<int>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector128<long> CreateScalarUnsafe(long value)
		{
			long* ptr = stackalloc long[2];
			*ptr = value;
			return Unsafe.AsRef<Vector128<long>>(ptr);
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public unsafe static Vector128<sbyte> CreateScalarUnsafe(sbyte value)
		{
			sbyte* ptr = stackalloc sbyte[16];
			*ptr = value;
			return Unsafe.AsRef<Vector128<sbyte>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector128<float> CreateScalarUnsafe(float value)
		{
			float* ptr = stackalloc float[4];
			*ptr = value;
			return Unsafe.AsRef<Vector128<float>>(ptr);
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public unsafe static Vector128<ushort> CreateScalarUnsafe(ushort value)
		{
			ushort* ptr = stackalloc ushort[8];
			*ptr = value;
			return Unsafe.AsRef<Vector128<ushort>>(ptr);
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public unsafe static Vector128<uint> CreateScalarUnsafe(uint value)
		{
			uint* ptr = stackalloc uint[4];
			*ptr = value;
			return Unsafe.AsRef<Vector128<uint>>(ptr);
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public unsafe static Vector128<ulong> CreateScalarUnsafe(ulong value)
		{
			ulong* ptr = stackalloc ulong[2];
			*ptr = value;
			return Unsafe.AsRef<Vector128<ulong>>(ptr);
		}

		[Intrinsic]
		public static T GetElement<T>(this Vector128<T> vector, int index) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if ((uint)index >= (uint)Vector128<T>.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return Unsafe.Add(ref Unsafe.As<Vector128<T>, T>(ref vector), index);
		}

		[Intrinsic]
		public static Vector128<T> WithElement<T>(this Vector128<T> vector, int index, T value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if ((uint)index >= (uint)Vector128<T>.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			Vector128<T> source = vector;
			Unsafe.Add(ref Unsafe.As<Vector128<T>, T>(ref source), index) = value;
			return source;
		}

		[Intrinsic]
		public static Vector64<T> GetLower<T>(this Vector128<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			return Unsafe.As<Vector128<T>, Vector64<T>>(ref vector);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<T> WithLower<T>(this Vector128<T> vector, Vector64<T> value) where T : struct
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(vector, value);
			static Vector128<T> SoftwareFallback(Vector128<T> vector, Vector64<T> value)
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				Vector128<T> source = vector;
				Unsafe.As<Vector128<T>, Vector64<T>>(ref source) = value;
				return source;
			}
		}

		[Intrinsic]
		public static Vector64<T> GetUpper<T>(this Vector128<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			return Unsafe.Add(ref Unsafe.As<Vector128<T>, Vector64<T>>(ref vector), 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<T> WithUpper<T>(this Vector128<T> vector, Vector64<T> value) where T : struct
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(vector, value);
			static Vector128<T> SoftwareFallback(Vector128<T> vector, Vector64<T> value)
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				Vector128<T> source = vector;
				Unsafe.Add(ref Unsafe.As<Vector128<T>, Vector64<T>>(ref source), 1) = value;
				return source;
			}
		}

		[Intrinsic]
		public static T ToScalar<T>(this Vector128<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			return Unsafe.As<Vector128<T>, T>(ref vector);
		}

		[Intrinsic]
		public static Vector256<T> ToVector256<T>(this Vector128<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			Vector256<T> source = Vector256<T>.Zero;
			Unsafe.As<Vector256<T>, Vector128<T>>(ref source) = vector;
			return source;
		}

		[Intrinsic]
		public unsafe static Vector256<T> ToVector256Unsafe<T>(this Vector128<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			byte* source = stackalloc byte[32];
			Unsafe.AsRef<Vector128<T>>(source) = vector;
			return Unsafe.AsRef<Vector256<T>>(source);
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 16)]
	[Intrinsic]
	[DebuggerDisplay("{DisplayString,nq}")]
	[DebuggerTypeProxy(typeof(Vector128DebugView<>))]
	public readonly struct Vector128<T> : IEquatable<Vector128<T>> where T : struct
	{
		private readonly ulong _00;

		private readonly ulong _01;

		public static int Count
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return 16 / Unsafe.SizeOf<T>();
			}
		}

		public static Vector128<T> Zero
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return default(Vector128<T>);
			}
		}

		public static Vector128<T> AllBitsSet
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return Vector128.Create(uint.MaxValue).As<uint, T>();
			}
		}

		internal string DisplayString
		{
			get
			{
				if (IsSupported)
				{
					return ToString();
				}
				return SR.NotSupported_Type;
			}
		}

		internal static bool IsSupported
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!(typeof(T) == typeof(byte)) && !(typeof(T) == typeof(sbyte)) && !(typeof(T) == typeof(short)) && !(typeof(T) == typeof(ushort)) && !(typeof(T) == typeof(int)) && !(typeof(T) == typeof(uint)) && !(typeof(T) == typeof(long)) && !(typeof(T) == typeof(ulong)) && !(typeof(T) == typeof(float)))
				{
					return typeof(T) == typeof(double);
				}
				return true;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Equals(Vector128<T> other)
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if (Sse.IsSupported && typeof(T) == typeof(float))
			{
				Vector128<float> value = Sse.CompareEqual(this.AsSingle(), other.AsSingle());
				return Sse.MoveMask(value) == 15;
			}
			if (Sse2.IsSupported)
			{
				if (typeof(T) == typeof(double))
				{
					Vector128<double> value2 = Sse2.CompareEqual(this.AsDouble(), other.AsDouble());
					return Sse2.MoveMask(value2) == 3;
				}
				Vector128<byte> value3 = Sse2.CompareEqual(this.AsByte(), other.AsByte());
				return Sse2.MoveMask(value3) == 65535;
			}
			return SoftwareFallback(in this, other);
			static bool SoftwareFallback(in Vector128<T> vector, Vector128<T> other)
			{
				for (int i = 0; i < Count; i++)
				{
					if (!((IEquatable<T>)(object)vector.GetElement(i)).Equals(other.GetElement(i)))
					{
						return false;
					}
				}
				return true;
			}
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Vector128<T>)
			{
				return Equals((Vector128<T>)obj);
			}
			return false;
		}

		public override int GetHashCode()
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			HashCode hashCode = default(HashCode);
			for (int i = 0; i < Count; i++)
			{
				hashCode.Add(this.GetElement(i).GetHashCode());
			}
			return hashCode.ToHashCode();
		}

		public override string ToString()
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			int num = Count - 1;
			Span<char> initialBuffer = stackalloc char[64];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			valueStringBuilder.Append('<');
			for (int i = 0; i < num; i++)
			{
				valueStringBuilder.Append(((IFormattable)(object)this.GetElement(i)).ToString("G", invariantCulture));
				valueStringBuilder.Append(',');
				valueStringBuilder.Append(' ');
			}
			valueStringBuilder.Append(((IFormattable)(object)this.GetElement(num)).ToString("G", invariantCulture));
			valueStringBuilder.Append('>');
			return valueStringBuilder.ToString();
		}
	}
	internal readonly struct Vector128DebugView<T> where T : struct
	{
		private readonly Vector128<T> _value;

		public byte[] ByteView
		{
			get
			{
				byte[] array = new byte[16];
				Unsafe.WriteUnaligned(ref array[0], _value);
				return array;
			}
		}

		public double[] DoubleView
		{
			get
			{
				double[] array = new double[2];
				Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref array[0]), _value);
				return array;
			}
		}

		public short[] Int16View
		{
			get
			{
				short[] array = new short[8];
				Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref array[0]), _value);
				return array;
			}
		}

		public int[] Int32View
		{
			get
			{
				int[] array = new int[4];
				Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref array[0]), _value);
				return array;
			}
		}

		public long[] Int64View
		{
			get
			{
				long[] array = new long[2];
				Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref array[0]), _value);
				return array;
			}
		}

		public sbyte[] SByteView
		{
			get
			{
				sbyte[] array = new sbyte[16];
				Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref array[0]), _value);
				return array;
			}
		}

		public float[] SingleView
		{
			get
			{
				float[] array = new float[4];
				Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), _value);
				return array;
			}
		}

		public ushort[] UInt16View
		{
			get
			{
				ushort[] array = new ushort[8];
				Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref array[0]), _value);
				return array;
			}
		}

		public uint[] UInt32View
		{
			get
			{
				uint[] array = new uint[4];
				Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref array[0]), _value);
				return array;
			}
		}

		public ulong[] UInt64View
		{
			get
			{
				ulong[] array = new ulong[2];
				Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref array[0]), _value);
				return array;
			}
		}

		public Vector128DebugView(Vector128<T> value)
		{
			_value = value;
		}
	}
	public static class Vector256
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector256<U> As<T, U>(this Vector256<T> vector) where T : struct where U : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<U>();
			return Unsafe.As<Vector256<T>, Vector256<U>>(ref vector);
		}

		[Intrinsic]
		public static Vector256<byte> AsByte<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, byte>();
		}

		[Intrinsic]
		public static Vector256<double> AsDouble<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, double>();
		}

		[Intrinsic]
		public static Vector256<short> AsInt16<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, short>();
		}

		[Intrinsic]
		public static Vector256<int> AsInt32<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, int>();
		}

		[Intrinsic]
		public static Vector256<long> AsInt64<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, long>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<sbyte> AsSByte<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, sbyte>();
		}

		[Intrinsic]
		public static Vector256<float> AsSingle<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, float>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<ushort> AsUInt16<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, ushort>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<uint> AsUInt32<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, uint>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<ulong> AsUInt64<T>(this Vector256<T> vector) where T : struct
		{
			return vector.As<T, ulong>();
		}

		[Intrinsic]
		public static Vector256<T> AsVector256<T>(this Vector<T> value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			Vector256<T> source = default(Vector256<T>);
			Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<T>, byte>(ref source), value);
			return source;
		}

		[Intrinsic]
		public static Vector<T> AsVector<T>(this Vector256<T> value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			return Unsafe.As<Vector256<T>, Vector<T>>(ref value);
		}

		[Intrinsic]
		public static Vector256<byte> Create(byte value)
		{
			if (Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<byte> SoftwareFallback(byte value)
			{
				byte* source = stackalloc byte[32]
				{
					value, value, value, value, value, value, value, value, value, value,
					value, value, value, value, value, value, value, value, value, value,
					value, value, value, value, value, value, value, value, value, value,
					value, value
				};
				return Unsafe.AsRef<Vector256<byte>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<double> Create(double value)
		{
			if (Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<double> SoftwareFallback(double value)
			{
				double* source = stackalloc double[4] { value, value, value, value };
				return Unsafe.AsRef<Vector256<double>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<short> Create(short value)
		{
			if (Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<short> SoftwareFallback(short value)
			{
				short* source = stackalloc short[16]
				{
					value, value, value, value, value, value, value, value, value, value,
					value, value, value, value, value, value
				};
				return Unsafe.AsRef<Vector256<short>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<int> Create(int value)
		{
			if (Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<int> SoftwareFallback(int value)
			{
				int* source = stackalloc int[8] { value, value, value, value, value, value, value, value };
				return Unsafe.AsRef<Vector256<int>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<long> Create(long value)
		{
			if (Sse2.X64.IsSupported && Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<long> SoftwareFallback(long value)
			{
				long* source = stackalloc long[4] { value, value, value, value };
				return Unsafe.AsRef<Vector256<long>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<sbyte> Create(sbyte value)
		{
			if (Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<sbyte> SoftwareFallback(sbyte value)
			{
				sbyte* source = stackalloc sbyte[32]
				{
					value, value, value, value, value, value, value, value, value, value,
					value, value, value, value, value, value, value, value, value, value,
					value, value, value, value, value, value, value, value, value, value,
					value, value
				};
				return Unsafe.AsRef<Vector256<sbyte>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<float> Create(float value)
		{
			if (Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<float> SoftwareFallback(float value)
			{
				float* source = stackalloc float[8] { value, value, value, value, value, value, value, value };
				return Unsafe.AsRef<Vector256<float>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<ushort> Create(ushort value)
		{
			if (Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<ushort> SoftwareFallback(ushort value)
			{
				ushort* source = stackalloc ushort[16]
				{
					value, value, value, value, value, value, value, value, value, value,
					value, value, value, value, value, value
				};
				return Unsafe.AsRef<Vector256<ushort>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<uint> Create(uint value)
		{
			if (Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<uint> SoftwareFallback(uint value)
			{
				uint* source = stackalloc uint[8] { value, value, value, value, value, value, value, value };
				return Unsafe.AsRef<Vector256<uint>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<ulong> Create(ulong value)
		{
			if (Sse2.X64.IsSupported && Avx.IsSupported)
			{
				return Create(value);
			}
			return SoftwareFallback(value);
			unsafe static Vector256<ulong> SoftwareFallback(ulong value)
			{
				ulong* source = stackalloc ulong[4] { value, value, value, value };
				return Unsafe.AsRef<Vector256<ulong>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31)
		{
			if (Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31);
			unsafe static Vector256<byte> SoftwareFallback(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7, byte e8, byte e9, byte e10, byte e11, byte e12, byte e13, byte e14, byte e15, byte e16, byte e17, byte e18, byte e19, byte e20, byte e21, byte e22, byte e23, byte e24, byte e25, byte e26, byte e27, byte e28, byte e29, byte e30, byte e31)
			{
				byte* source = stackalloc byte[32]
				{
					e0, e1, e2, e3, e4, e5, e6, e7, e8, e9,
					e10, e11, e12, e13, e14, e15, e16, e17, e18, e19,
					e20, e21, e22, e23, e24, e25, e26, e27, e28, e29,
					e30, e31
				};
				return Unsafe.AsRef<Vector256<byte>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<double> Create(double e0, double e1, double e2, double e3)
		{
			if (Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3);
			}
			return SoftwareFallback(e0, e1, e2, e3);
			unsafe static Vector256<double> SoftwareFallback(double e0, double e1, double e2, double e3)
			{
				double* source = stackalloc double[4] { e0, e1, e2, e3 };
				return Unsafe.AsRef<Vector256<double>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<short> Create(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15)
		{
			if (Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15);
			unsafe static Vector256<short> SoftwareFallback(short e0, short e1, short e2, short e3, short e4, short e5, short e6, short e7, short e8, short e9, short e10, short e11, short e12, short e13, short e14, short e15)
			{
				short* source = stackalloc short[16]
				{
					e0, e1, e2, e3, e4, e5, e6, e7, e8, e9,
					e10, e11, e12, e13, e14, e15
				};
				return Unsafe.AsRef<Vector256<short>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<int> Create(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7)
		{
			if (Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7);
			unsafe static Vector256<int> SoftwareFallback(int e0, int e1, int e2, int e3, int e4, int e5, int e6, int e7)
			{
				int* source = stackalloc int[8] { e0, e1, e2, e3, e4, e5, e6, e7 };
				return Unsafe.AsRef<Vector256<int>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<long> Create(long e0, long e1, long e2, long e3)
		{
			if (Sse2.X64.IsSupported && Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3);
			}
			return SoftwareFallback(e0, e1, e2, e3);
			unsafe static Vector256<long> SoftwareFallback(long e0, long e1, long e2, long e3)
			{
				long* source = stackalloc long[4] { e0, e1, e2, e3 };
				return Unsafe.AsRef<Vector256<long>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<sbyte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31)
		{
			if (Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31);
			unsafe static Vector256<sbyte> SoftwareFallback(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7, sbyte e8, sbyte e9, sbyte e10, sbyte e11, sbyte e12, sbyte e13, sbyte e14, sbyte e15, sbyte e16, sbyte e17, sbyte e18, sbyte e19, sbyte e20, sbyte e21, sbyte e22, sbyte e23, sbyte e24, sbyte e25, sbyte e26, sbyte e27, sbyte e28, sbyte e29, sbyte e30, sbyte e31)
			{
				sbyte* source = stackalloc sbyte[32]
				{
					e0, e1, e2, e3, e4, e5, e6, e7, e8, e9,
					e10, e11, e12, e13, e14, e15, e16, e17, e18, e19,
					e20, e21, e22, e23, e24, e25, e26, e27, e28, e29,
					e30, e31
				};
				return Unsafe.AsRef<Vector256<sbyte>>(source);
			}
		}

		[Intrinsic]
		public static Vector256<float> Create(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7)
		{
			if (Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7);
			unsafe static Vector256<float> SoftwareFallback(float e0, float e1, float e2, float e3, float e4, float e5, float e6, float e7)
			{
				float* source = stackalloc float[8] { e0, e1, e2, e3, e4, e5, e6, e7 };
				return Unsafe.AsRef<Vector256<float>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<ushort> Create(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15)
		{
			if (Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15);
			unsafe static Vector256<ushort> SoftwareFallback(ushort e0, ushort e1, ushort e2, ushort e3, ushort e4, ushort e5, ushort e6, ushort e7, ushort e8, ushort e9, ushort e10, ushort e11, ushort e12, ushort e13, ushort e14, ushort e15)
			{
				ushort* source = stackalloc ushort[16]
				{
					e0, e1, e2, e3, e4, e5, e6, e7, e8, e9,
					e10, e11, e12, e13, e14, e15
				};
				return Unsafe.AsRef<Vector256<ushort>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<uint> Create(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7)
		{
			if (Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3, e4, e5, e6, e7);
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7);
			unsafe static Vector256<uint> SoftwareFallback(uint e0, uint e1, uint e2, uint e3, uint e4, uint e5, uint e6, uint e7)
			{
				uint* source = stackalloc uint[8] { e0, e1, e2, e3, e4, e5, e6, e7 };
				return Unsafe.AsRef<Vector256<uint>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector256<ulong> Create(ulong e0, ulong e1, ulong e2, ulong e3)
		{
			if (Sse2.X64.IsSupported && Avx.IsSupported)
			{
				return Create(e0, e1, e2, e3);
			}
			return SoftwareFallback(e0, e1, e2, e3);
			unsafe static Vector256<ulong> SoftwareFallback(ulong e0, ulong e1, ulong e2, ulong e3)
			{
				ulong* source = stackalloc ulong[4] { e0, e1, e2, e3 };
				return Unsafe.AsRef<Vector256<ulong>>(source);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<byte> Create(Vector128<byte> lower, Vector128<byte> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<byte> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<byte> SoftwareFallback(Vector128<byte> lower, Vector128<byte> upper)
			{
				Vector256<byte> source = Vector256<byte>.Zero;
				ref Vector128<byte> reference = ref Unsafe.As<Vector256<byte>, Vector128<byte>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<double> Create(Vector128<double> lower, Vector128<double> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<double> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<double> SoftwareFallback(Vector128<double> lower, Vector128<double> upper)
			{
				Vector256<double> source = Vector256<double>.Zero;
				ref Vector128<double> reference = ref Unsafe.As<Vector256<double>, Vector128<double>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<short> Create(Vector128<short> lower, Vector128<short> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<short> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<short> SoftwareFallback(Vector128<short> lower, Vector128<short> upper)
			{
				Vector256<short> source = Vector256<short>.Zero;
				ref Vector128<short> reference = ref Unsafe.As<Vector256<short>, Vector128<short>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<int> Create(Vector128<int> lower, Vector128<int> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<int> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<int> SoftwareFallback(Vector128<int> lower, Vector128<int> upper)
			{
				Vector256<int> source = Vector256<int>.Zero;
				ref Vector128<int> reference = ref Unsafe.As<Vector256<int>, Vector128<int>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<long> Create(Vector128<long> lower, Vector128<long> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<long> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<long> SoftwareFallback(Vector128<long> lower, Vector128<long> upper)
			{
				Vector256<long> source = Vector256<long>.Zero;
				ref Vector128<long> reference = ref Unsafe.As<Vector256<long>, Vector128<long>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector256<sbyte> Create(Vector128<sbyte> lower, Vector128<sbyte> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<sbyte> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<sbyte> SoftwareFallback(Vector128<sbyte> lower, Vector128<sbyte> upper)
			{
				Vector256<sbyte> source = Vector256<sbyte>.Zero;
				ref Vector128<sbyte> reference = ref Unsafe.As<Vector256<sbyte>, Vector128<sbyte>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<float> Create(Vector128<float> lower, Vector128<float> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<float> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<float> SoftwareFallback(Vector128<float> lower, Vector128<float> upper)
			{
				Vector256<float> source = Vector256<float>.Zero;
				ref Vector128<float> reference = ref Unsafe.As<Vector256<float>, Vector128<float>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector256<ushort> Create(Vector128<ushort> lower, Vector128<ushort> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<ushort> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<ushort> SoftwareFallback(Vector128<ushort> lower, Vector128<ushort> upper)
			{
				Vector256<ushort> source = Vector256<ushort>.Zero;
				ref Vector128<ushort> reference = ref Unsafe.As<Vector256<ushort>, Vector128<ushort>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector256<uint> Create(Vector128<uint> lower, Vector128<uint> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<uint> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<uint> SoftwareFallback(Vector128<uint> lower, Vector128<uint> upper)
			{
				Vector256<uint> source = Vector256<uint>.Zero;
				ref Vector128<uint> reference = ref Unsafe.As<Vector256<uint>, Vector128<uint>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector256<ulong> Create(Vector128<ulong> lower, Vector128<ulong> upper)
		{
			if (Avx.IsSupported)
			{
				Vector256<ulong> vector = lower.ToVector256Unsafe();
				return vector.WithUpper(upper);
			}
			return SoftwareFallback(lower, upper);
			static Vector256<ulong> SoftwareFallback(Vector128<ulong> lower, Vector128<ulong> upper)
			{
				Vector256<ulong> source = Vector256<ulong>.Zero;
				ref Vector128<ulong> reference = ref Unsafe.As<Vector256<ulong>, Vector128<ulong>>(ref source);
				reference = lower;
				Unsafe.Add(ref reference, 1) = upper;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<byte> CreateScalar(byte value)
		{
			if (Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<byte> SoftwareFallback(byte value)
			{
				Vector256<byte> source = Vector256<byte>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<byte>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<double> CreateScalar(double value)
		{
			if (Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<double> SoftwareFallback(double value)
			{
				Vector256<double> source = Vector256<double>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<double>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<short> CreateScalar(short value)
		{
			if (Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<short> SoftwareFallback(short value)
			{
				Vector256<short> source = Vector256<short>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<short>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<int> CreateScalar(int value)
		{
			if (Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<int> SoftwareFallback(int value)
			{
				Vector256<int> source = Vector256<int>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<int>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<long> CreateScalar(long value)
		{
			if (Sse2.X64.IsSupported && Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<long> SoftwareFallback(long value)
			{
				Vector256<long> source = Vector256<long>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<long>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector256<sbyte> CreateScalar(sbyte value)
		{
			if (Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<sbyte> SoftwareFallback(sbyte value)
			{
				Vector256<sbyte> source = Vector256<sbyte>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<sbyte>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<float> CreateScalar(float value)
		{
			if (Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<float> SoftwareFallback(float value)
			{
				Vector256<float> source = Vector256<float>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<float>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector256<ushort> CreateScalar(ushort value)
		{
			if (Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<ushort> SoftwareFallback(ushort value)
			{
				Vector256<ushort> source = Vector256<ushort>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<ushort>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector256<uint> CreateScalar(uint value)
		{
			if (Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<uint> SoftwareFallback(uint value)
			{
				Vector256<uint> source = Vector256<uint>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<uint>, byte>(ref source), value);
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static Vector256<ulong> CreateScalar(ulong value)
		{
			if (Sse2.X64.IsSupported && Avx.IsSupported)
			{
				return Vector128.CreateScalar(value).ToVector256();
			}
			return SoftwareFallback(value);
			static Vector256<ulong> SoftwareFallback(ulong value)
			{
				Vector256<ulong> source = Vector256<ulong>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<ulong>, byte>(ref source), value);
				return source;
			}
		}

		[Intrinsic]
		public unsafe static Vector256<byte> CreateScalarUnsafe(byte value)
		{
			byte* ptr = stackalloc byte[32];
			*ptr = value;
			return Unsafe.AsRef<Vector256<byte>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector256<double> CreateScalarUnsafe(double value)
		{
			double* ptr = stackalloc double[4];
			*ptr = value;
			return Unsafe.AsRef<Vector256<double>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector256<short> CreateScalarUnsafe(short value)
		{
			short* ptr = stackalloc short[16];
			*ptr = value;
			return Unsafe.AsRef<Vector256<short>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector256<int> CreateScalarUnsafe(int value)
		{
			int* ptr = stackalloc int[8];
			*ptr = value;
			return Unsafe.AsRef<Vector256<int>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector256<long> CreateScalarUnsafe(long value)
		{
			long* ptr = stackalloc long[4];
			*ptr = value;
			return Unsafe.AsRef<Vector256<long>>(ptr);
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public unsafe static Vector256<sbyte> CreateScalarUnsafe(sbyte value)
		{
			sbyte* ptr = stackalloc sbyte[32];
			*ptr = value;
			return Unsafe.AsRef<Vector256<sbyte>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector256<float> CreateScalarUnsafe(float value)
		{
			float* ptr = stackalloc float[8];
			*ptr = value;
			return Unsafe.AsRef<Vector256<float>>(ptr);
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public unsafe static Vector256<ushort> CreateScalarUnsafe(ushort value)
		{
			ushort* ptr = stackalloc ushort[16];
			*ptr = value;
			return Unsafe.AsRef<Vector256<ushort>>(ptr);
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public unsafe static Vector256<uint> CreateScalarUnsafe(uint value)
		{
			uint* ptr = stackalloc uint[8];
			*ptr = value;
			return Unsafe.AsRef<Vector256<uint>>(ptr);
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public unsafe static Vector256<ulong> CreateScalarUnsafe(ulong value)
		{
			ulong* ptr = stackalloc ulong[4];
			*ptr = value;
			return Unsafe.AsRef<Vector256<ulong>>(ptr);
		}

		[Intrinsic]
		public static T GetElement<T>(this Vector256<T> vector, int index) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if ((uint)index >= (uint)Vector256<T>.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return Unsafe.Add(ref Unsafe.As<Vector256<T>, T>(ref vector), index);
		}

		[Intrinsic]
		public static Vector256<T> WithElement<T>(this Vector256<T> vector, int index, T value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if ((uint)index >= (uint)Vector256<T>.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			Vector256<T> source = vector;
			Unsafe.Add(ref Unsafe.As<Vector256<T>, T>(ref source), index) = value;
			return source;
		}

		[Intrinsic]
		public static Vector128<T> GetLower<T>(this Vector256<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			return Unsafe.As<Vector256<T>, Vector128<T>>(ref vector);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<T> WithLower<T>(this Vector256<T> vector, Vector128<T> value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if (Avx2.IsSupported && typeof(T) != typeof(float) && typeof(T) != typeof(double))
			{
				return Avx2.InsertVector128(vector.AsByte(), value.AsByte(), 0).As<byte, T>();
			}
			if (Avx.IsSupported)
			{
				return Avx.InsertVector128(vector.AsSingle(), value.AsSingle(), 0).As<float, T>();
			}
			return SoftwareFallback(vector, value);
			static Vector256<T> SoftwareFallback(Vector256<T> vector, Vector128<T> value)
			{
				Vector256<T> source = vector;
				Unsafe.As<Vector256<T>, Vector128<T>>(ref source) = value;
				return source;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector128<T> GetUpper<T>(this Vector256<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if (Avx2.IsSupported && typeof(T) != typeof(float) && typeof(T) != typeof(double))
			{
				return Avx2.ExtractVector128(vector.AsByte(), 1).As<byte, T>();
			}
			if (Avx.IsSupported)
			{
				return Avx.ExtractVector128(vector.AsSingle(), 1).As<float, T>();
			}
			return SoftwareFallback(vector);
			static Vector128<T> SoftwareFallback(Vector256<T> vector)
			{
				return Unsafe.Add(ref Unsafe.As<Vector256<T>, Vector128<T>>(ref vector), 1);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Vector256<T> WithUpper<T>(this Vector256<T> vector, Vector128<T> value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if (Avx2.IsSupported && typeof(T) != typeof(float) && typeof(T) != typeof(double))
			{
				return Avx2.InsertVector128(vector.AsByte(), value.AsByte(), 1).As<byte, T>();
			}
			if (Avx.IsSupported)
			{
				return Avx.InsertVector128(vector.AsSingle(), value.AsSingle(), 1).As<float, T>();
			}
			return SoftwareFallback(vector, value);
			static Vector256<T> SoftwareFallback(Vector256<T> vector, Vector128<T> value)
			{
				Vector256<T> source = vector;
				Unsafe.Add(ref Unsafe.As<Vector256<T>, Vector128<T>>(ref source), 1) = value;
				return source;
			}
		}

		[Intrinsic]
		public static T ToScalar<T>(this Vector256<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			return Unsafe.As<Vector256<T>, T>(ref vector);
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 32)]
	[Intrinsic]
	[DebuggerDisplay("{DisplayString,nq}")]
	[DebuggerTypeProxy(typeof(Vector256DebugView<>))]
	public readonly struct Vector256<T> : IEquatable<Vector256<T>> where T : struct
	{
		private readonly ulong _00;

		private readonly ulong _01;

		private readonly ulong _02;

		private readonly ulong _03;

		public static int Count
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return 32 / Unsafe.SizeOf<T>();
			}
		}

		public static Vector256<T> Zero
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return default(Vector256<T>);
			}
		}

		public static Vector256<T> AllBitsSet
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return Vector256.Create(uint.MaxValue).As<uint, T>();
			}
		}

		internal string DisplayString
		{
			get
			{
				if (IsSupported)
				{
					return ToString();
				}
				return SR.NotSupported_Type;
			}
		}

		internal static bool IsSupported
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!(typeof(T) == typeof(byte)) && !(typeof(T) == typeof(sbyte)) && !(typeof(T) == typeof(short)) && !(typeof(T) == typeof(ushort)) && !(typeof(T) == typeof(int)) && !(typeof(T) == typeof(uint)) && !(typeof(T) == typeof(long)) && !(typeof(T) == typeof(ulong)) && !(typeof(T) == typeof(float)))
				{
					return typeof(T) == typeof(double);
				}
				return true;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Equals(Vector256<T> other)
		{
			if (Avx.IsSupported)
			{
				if (typeof(T) == typeof(float))
				{
					Vector256<float> value = Avx.Compare(this.AsSingle(), other.AsSingle(), FloatComparisonMode.OrderedEqualNonSignaling);
					return Avx.MoveMask(value) == 255;
				}
				if (typeof(T) == typeof(double))
				{
					Vector256<double> value2 = Avx.Compare(this.AsDouble(), other.AsDouble(), FloatComparisonMode.OrderedEqualNonSignaling);
					return Avx.MoveMask(value2) == 15;
				}
			}
			if (Avx2.IsSupported)
			{
				Vector256<byte> value3 = Avx2.CompareEqual(this.AsByte(), other.AsByte());
				return Avx2.MoveMask(value3) == -1;
			}
			return SoftwareFallback(in this, other);
			static bool SoftwareFallback(in Vector256<T> vector, Vector256<T> other)
			{
				for (int i = 0; i < Count; i++)
				{
					if (!((IEquatable<T>)(object)vector.GetElement(i)).Equals(other.GetElement(i)))
					{
						return false;
					}
				}
				return true;
			}
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Vector256<T>)
			{
				return Equals((Vector256<T>)obj);
			}
			return false;
		}

		public override int GetHashCode()
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			HashCode hashCode = default(HashCode);
			for (int i = 0; i < Count; i++)
			{
				hashCode.Add(this.GetElement(i).GetHashCode());
			}
			return hashCode.ToHashCode();
		}

		public override string ToString()
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			int num = Count - 1;
			Span<char> initialBuffer = stackalloc char[64];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			valueStringBuilder.Append('<');
			for (int i = 0; i < num; i++)
			{
				valueStringBuilder.Append(((IFormattable)(object)this.GetElement(i)).ToString("G", invariantCulture));
				valueStringBuilder.Append(',');
				valueStringBuilder.Append(' ');
			}
			valueStringBuilder.Append(((IFormattable)(object)this.GetElement(num)).ToString("G", invariantCulture));
			valueStringBuilder.Append('>');
			return valueStringBuilder.ToString();
		}
	}
	internal readonly struct Vector256DebugView<T> where T : struct
	{
		private readonly Vector256<T> _value;

		public byte[] ByteView
		{
			get
			{
				byte[] array = new byte[32];
				Unsafe.WriteUnaligned(ref array[0], _value);
				return array;
			}
		}

		public double[] DoubleView
		{
			get
			{
				double[] array = new double[4];
				Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref array[0]), _value);
				return array;
			}
		}

		public short[] Int16View
		{
			get
			{
				short[] array = new short[16];
				Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref array[0]), _value);
				return array;
			}
		}

		public int[] Int32View
		{
			get
			{
				int[] array = new int[8];
				Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref array[0]), _value);
				return array;
			}
		}

		public long[] Int64View
		{
			get
			{
				long[] array = new long[4];
				Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref array[0]), _value);
				return array;
			}
		}

		public sbyte[] SByteView
		{
			get
			{
				sbyte[] array = new sbyte[32];
				Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref array[0]), _value);
				return array;
			}
		}

		public float[] SingleView
		{
			get
			{
				float[] array = new float[8];
				Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), _value);
				return array;
			}
		}

		public ushort[] UInt16View
		{
			get
			{
				ushort[] array = new ushort[16];
				Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref array[0]), _value);
				return array;
			}
		}

		public uint[] UInt32View
		{
			get
			{
				uint[] array = new uint[8];
				Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref array[0]), _value);
				return array;
			}
		}

		public ulong[] UInt64View
		{
			get
			{
				ulong[] array = new ulong[4];
				Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref array[0]), _value);
				return array;
			}
		}

		public Vector256DebugView(Vector256<T> value)
		{
			_value = value;
		}
	}
	public static class Vector64
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		public static Vector64<U> As<T, U>(this Vector64<T> vector) where T : struct where U : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<U>();
			return Unsafe.As<Vector64<T>, Vector64<U>>(ref vector);
		}

		[Intrinsic]
		public static Vector64<byte> AsByte<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, byte>();
		}

		[Intrinsic]
		public static Vector64<double> AsDouble<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, double>();
		}

		[Intrinsic]
		public static Vector64<short> AsInt16<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, short>();
		}

		[Intrinsic]
		public static Vector64<int> AsInt32<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, int>();
		}

		[Intrinsic]
		public static Vector64<long> AsInt64<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, long>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<sbyte> AsSByte<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, sbyte>();
		}

		[Intrinsic]
		public static Vector64<float> AsSingle<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, float>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<ushort> AsUInt16<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, ushort>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<uint> AsUInt32<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, uint>();
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<ulong> AsUInt64<T>(this Vector64<T> vector) where T : struct
		{
			return vector.As<T, ulong>();
		}

		[Intrinsic]
		public static Vector64<byte> Create(byte value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			unsafe static Vector64<byte> SoftwareFallback(byte value)
			{
				byte* source = stackalloc byte[8] { value, value, value, value, value, value, value, value };
				return Unsafe.AsRef<Vector64<byte>>(source);
			}
		}

		[Intrinsic]
		public static Vector64<double> Create(double value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<double> SoftwareFallback(double value)
			{
				return Unsafe.As<double, Vector64<double>>(ref value);
			}
		}

		[Intrinsic]
		public static Vector64<short> Create(short value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			unsafe static Vector64<short> SoftwareFallback(short value)
			{
				short* source = stackalloc short[4] { value, value, value, value };
				return Unsafe.AsRef<Vector64<short>>(source);
			}
		}

		[Intrinsic]
		public static Vector64<int> Create(int value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			unsafe static Vector64<int> SoftwareFallback(int value)
			{
				int* source = stackalloc int[2] { value, value };
				return Unsafe.AsRef<Vector64<int>>(source);
			}
		}

		[Intrinsic]
		public static Vector64<long> Create(long value)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<long> SoftwareFallback(long value)
			{
				return Unsafe.As<long, Vector64<long>>(ref value);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<sbyte> Create(sbyte value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			unsafe static Vector64<sbyte> SoftwareFallback(sbyte value)
			{
				sbyte* source = stackalloc sbyte[8] { value, value, value, value, value, value, value, value };
				return Unsafe.AsRef<Vector64<sbyte>>(source);
			}
		}

		[Intrinsic]
		public static Vector64<float> Create(float value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			unsafe static Vector64<float> SoftwareFallback(float value)
			{
				float* source = stackalloc float[2] { value, value };
				return Unsafe.AsRef<Vector64<float>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<ushort> Create(ushort value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			unsafe static Vector64<ushort> SoftwareFallback(ushort value)
			{
				ushort* source = stackalloc ushort[4] { value, value, value, value };
				return Unsafe.AsRef<Vector64<ushort>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<uint> Create(uint value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			unsafe static Vector64<uint> SoftwareFallback(uint value)
			{
				uint* source = stackalloc uint[2] { value, value };
				return Unsafe.AsRef<Vector64<uint>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<ulong> Create(ulong value)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<ulong> SoftwareFallback(ulong value)
			{
				return Unsafe.As<ulong, Vector64<ulong>>(ref value);
			}
		}

		[Intrinsic]
		public static Vector64<byte> Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7);
			unsafe static Vector64<byte> SoftwareFallback(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7)
			{
				byte* source = stackalloc byte[8] { e0, e1, e2, e3, e4, e5, e6, e7 };
				return Unsafe.AsRef<Vector64<byte>>(source);
			}
		}

		[Intrinsic]
		public static Vector64<short> Create(short e0, short e1, short e2, short e3)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(e0, e1, e2, e3);
			unsafe static Vector64<short> SoftwareFallback(short e0, short e1, short e2, short e3)
			{
				short* source = stackalloc short[4] { e0, e1, e2, e3 };
				return Unsafe.AsRef<Vector64<short>>(source);
			}
		}

		[Intrinsic]
		public static Vector64<int> Create(int e0, int e1)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(e0, e1);
			unsafe static Vector64<int> SoftwareFallback(int e0, int e1)
			{
				int* source = stackalloc int[2] { e0, e1 };
				return Unsafe.AsRef<Vector64<int>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<sbyte> Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(e0, e1, e2, e3, e4, e5, e6, e7);
			unsafe static Vector64<sbyte> SoftwareFallback(sbyte e0, sbyte e1, sbyte e2, sbyte e3, sbyte e4, sbyte e5, sbyte e6, sbyte e7)
			{
				sbyte* source = stackalloc sbyte[8] { e0, e1, e2, e3, e4, e5, e6, e7 };
				return Unsafe.AsRef<Vector64<sbyte>>(source);
			}
		}

		[Intrinsic]
		public static Vector64<float> Create(float e0, float e1)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(e0, e1);
			unsafe static Vector64<float> SoftwareFallback(float e0, float e1)
			{
				float* source = stackalloc float[2] { e0, e1 };
				return Unsafe.AsRef<Vector64<float>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<ushort> Create(ushort e0, ushort e1, ushort e2, ushort e3)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(e0, e1, e2, e3);
			unsafe static Vector64<ushort> SoftwareFallback(ushort e0, ushort e1, ushort e2, ushort e3)
			{
				ushort* source = stackalloc ushort[4] { e0, e1, e2, e3 };
				return Unsafe.AsRef<Vector64<ushort>>(source);
			}
		}

		[Intrinsic]
		[CLSCompliant(false)]
		public static Vector64<uint> Create(uint e0, uint e1)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(e0, e1);
			unsafe static Vector64<uint> SoftwareFallback(uint e0, uint e1)
			{
				uint* source = stackalloc uint[2] { e0, e1 };
				return Unsafe.AsRef<Vector64<uint>>(source);
			}
		}

		public static Vector64<byte> CreateScalar(byte value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<byte> SoftwareFallback(byte value)
			{
				Vector64<byte> source = Vector64<byte>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector64<byte>, byte>(ref source), value);
				return source;
			}
		}

		public static Vector64<double> CreateScalar(double value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<double> SoftwareFallback(double value)
			{
				return Unsafe.As<double, Vector64<double>>(ref value);
			}
		}

		public static Vector64<short> CreateScalar(short value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<short> SoftwareFallback(short value)
			{
				Vector64<short> source = Vector64<short>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector64<short>, byte>(ref source), value);
				return source;
			}
		}

		public static Vector64<int> CreateScalar(int value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<int> SoftwareFallback(int value)
			{
				Vector64<int> source = Vector64<int>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector64<int>, byte>(ref source), value);
				return source;
			}
		}

		public static Vector64<long> CreateScalar(long value)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<long> SoftwareFallback(long value)
			{
				return Unsafe.As<long, Vector64<long>>(ref value);
			}
		}

		[CLSCompliant(false)]
		public static Vector64<sbyte> CreateScalar(sbyte value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<sbyte> SoftwareFallback(sbyte value)
			{
				Vector64<sbyte> source = Vector64<sbyte>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector64<sbyte>, byte>(ref source), value);
				return source;
			}
		}

		public static Vector64<float> CreateScalar(float value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<float> SoftwareFallback(float value)
			{
				Vector64<float> source = Vector64<float>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector64<float>, byte>(ref source), value);
				return source;
			}
		}

		[CLSCompliant(false)]
		public static Vector64<ushort> CreateScalar(ushort value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<ushort> SoftwareFallback(ushort value)
			{
				Vector64<ushort> source = Vector64<ushort>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector64<ushort>, byte>(ref source), value);
				return source;
			}
		}

		[CLSCompliant(false)]
		public static Vector64<uint> CreateScalar(uint value)
		{
			if (AdvSimd.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<uint> SoftwareFallback(uint value)
			{
				Vector64<uint> source = Vector64<uint>.Zero;
				Unsafe.WriteUnaligned(ref Unsafe.As<Vector64<uint>, byte>(ref source), value);
				return source;
			}
		}

		[CLSCompliant(false)]
		public static Vector64<ulong> CreateScalar(ulong value)
		{
			if (AdvSimd.Arm64.IsSupported)
			{
			}
			return SoftwareFallback(value);
			static Vector64<ulong> SoftwareFallback(ulong value)
			{
				return Unsafe.As<ulong, Vector64<ulong>>(ref value);
			}
		}

		[Intrinsic]
		public unsafe static Vector64<byte> CreateScalarUnsafe(byte value)
		{
			byte* ptr = stackalloc byte[8];
			*ptr = value;
			return Unsafe.AsRef<Vector64<byte>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector64<short> CreateScalarUnsafe(short value)
		{
			short* ptr = stackalloc short[4];
			*ptr = value;
			return Unsafe.AsRef<Vector64<short>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector64<int> CreateScalarUnsafe(int value)
		{
			int* ptr = stackalloc int[2];
			*ptr = value;
			return Unsafe.AsRef<Vector64<int>>(ptr);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector64<sbyte> CreateScalarUnsafe(sbyte value)
		{
			sbyte* ptr = stackalloc sbyte[8];
			*ptr = value;
			return Unsafe.AsRef<Vector64<sbyte>>(ptr);
		}

		[Intrinsic]
		public unsafe static Vector64<float> CreateScalarUnsafe(float value)
		{
			float* ptr = stackalloc float[2];
			*ptr = value;
			return Unsafe.AsRef<Vector64<float>>(ptr);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector64<ushort> CreateScalarUnsafe(ushort value)
		{
			ushort* ptr = stackalloc ushort[4];
			*ptr = value;
			return Unsafe.AsRef<Vector64<ushort>>(ptr);
		}

		[CLSCompliant(false)]
		[Intrinsic]
		public unsafe static Vector64<uint> CreateScalarUnsafe(uint value)
		{
			uint* ptr = stackalloc uint[2];
			*ptr = value;
			return Unsafe.AsRef<Vector64<uint>>(ptr);
		}

		[Intrinsic]
		public static T GetElement<T>(this Vector64<T> vector, int index) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if ((uint)index >= (uint)Vector64<T>.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			return Unsafe.Add(ref Unsafe.As<Vector64<T>, T>(ref vector), index);
		}

		[Intrinsic]
		public static Vector64<T> WithElement<T>(this Vector64<T> vector, int index, T value) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			if ((uint)index >= (uint)Vector64<T>.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			Vector64<T> source = vector;
			Unsafe.Add(ref Unsafe.As<Vector64<T>, T>(ref source), index) = value;
			return source;
		}

		[Intrinsic]
		public static T ToScalar<T>(this Vector64<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			return Unsafe.As<Vector64<T>, T>(ref vector);
		}

		[Intrinsic]
		public static Vector128<T> ToVector128<T>(this Vector64<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			Vector128<T> source = Vector128<T>.Zero;
			Unsafe.As<Vector128<T>, Vector64<T>>(ref source) = vector;
			return source;
		}

		[Intrinsic]
		public unsafe static Vector128<T> ToVector128Unsafe<T>(this Vector64<T> vector) where T : struct
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			byte* source = stackalloc byte[16];
			Unsafe.AsRef<Vector64<T>>(source) = vector;
			return Unsafe.AsRef<Vector128<T>>(source);
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 8)]
	[Intrinsic]
	[DebuggerDisplay("{DisplayString,nq}")]
	[DebuggerTypeProxy(typeof(Vector64DebugView<>))]
	public readonly struct Vector64<T> : IEquatable<Vector64<T>> where T : struct
	{
		private readonly ulong _00;

		public static int Count
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return 8 / Unsafe.SizeOf<T>();
			}
		}

		public static Vector64<T> Zero
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return default(Vector64<T>);
			}
		}

		public static Vector64<T> AllBitsSet
		{
			[Intrinsic]
			get
			{
				ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
				return Vector64.Create(uint.MaxValue).As<uint, T>();
			}
		}

		internal string DisplayString
		{
			get
			{
				if (IsSupported)
				{
					return ToString();
				}
				return SR.NotSupported_Type;
			}
		}

		internal static bool IsSupported
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!(typeof(T) == typeof(byte)) && !(typeof(T) == typeof(sbyte)) && !(typeof(T) == typeof(short)) && !(typeof(T) == typeof(ushort)) && !(typeof(T) == typeof(int)) && !(typeof(T) == typeof(uint)) && !(typeof(T) == typeof(long)) && !(typeof(T) == typeof(ulong)) && !(typeof(T) == typeof(float)))
				{
					return typeof(T) == typeof(double);
				}
				return true;
			}
		}

		public bool Equals(Vector64<T> other)
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			for (int i = 0; i < Count; i++)
			{
				if (!((IEquatable<T>)(object)this.GetElement(i)).Equals(other.GetElement(i)))
				{
					return false;
				}
			}
			return true;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Vector64<T>)
			{
				return Equals((Vector64<T>)obj);
			}
			return false;
		}

		public override int GetHashCode()
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			HashCode hashCode = default(HashCode);
			for (int i = 0; i < Count; i++)
			{
				hashCode.Add(this.GetElement(i).GetHashCode());
			}
			return hashCode.ToHashCode();
		}

		public override string ToString()
		{
			ThrowHelper.ThrowForUnsupportedIntrinsicsVectorBaseType<T>();
			int num = Count - 1;
			Span<char> initialBuffer = stackalloc char[64];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			valueStringBuilder.Append('<');
			for (int i = 0; i < num; i++)
			{
				valueStringBuilder.Append(((IFormattable)(object)this.GetElement(i)).ToString("G", invariantCulture));
				valueStringBuilder.Append(',');
				valueStringBuilder.Append(' ');
			}
			valueStringBuilder.Append(((IFormattable)(object)this.GetElement(num)).ToString("G", invariantCulture));
			valueStringBuilder.Append('>');
			return valueStringBuilder.ToString();
		}
	}
	internal readonly struct Vector64DebugView<T> where T : struct
	{
		private readonly Vector64<T> _value;

		public byte[] ByteView
		{
			get
			{
				byte[] array = new byte[8];
				Unsafe.WriteUnaligned(ref array[0], _value);
				return array;
			}
		}

		public double[] DoubleView
		{
			get
			{
				double[] array = new double[1];
				Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref array[0]), _value);
				return array;
			}
		}

		public short[] Int16View
		{
			get
			{
				short[] array = new short[4];
				Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref array[0]), _value);
				return array;
			}
		}

		public int[] Int32View
		{
			get
			{
				int[] array = new int[2];
				Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref array[0]), _value);
				return array;
			}
		}

		public long[] Int64View
		{
			get
			{
				long[] array = new long[1];
				Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref array[0]), _value);
				return array;
			}
		}

		public sbyte[] SByteView
		{
			get
			{
				sbyte[] array = new sbyte[8];
				Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref array[0]), _value);
				return array;
			}
		}

		public float[] SingleView
		{
			get
			{
				float[] array = new float[2];
				Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), _value);
				return array;
			}
		}

		public ushort[] UInt16View
		{
			get
			{
				ushort[] array = new ushort[4];
				Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref array[0]), _value);
				return array;
			}
		}

		public uint[] UInt32View
		{
			get
			{
				uint[] array = new uint[2];
				Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref array[0]), _value);
				return array;
			}
		}

		public ulong[] UInt64View
		{
			get
			{
				ulong[] array = new ulong[1];
				Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref array[0]), _value);
				return array;
			}
		}

		public Vector64DebugView(Vector64<T> value)
		{
			_value = value;
		}
	}
}
namespace System.Runtime.Intrinsics.Arm
{
	[CLSCompliant(false)]
	public abstract class AdvSimd : ArmBase
	{
		public new abstract class Arm64 : ArmBase.Arm64
		{
			public new static bool IsSupported
			{
				[Intrinsic]
				get
				{
					return false;
				}
			}

			public static Vector128<double> Abs(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> Abs(Vector128<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> AbsSaturate(Vector128<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> AbsSaturateScalar(Vector64<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> AbsSaturateScalar(Vector64<int> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> AbsSaturateScalar(Vector64<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> AbsSaturateScalar(Vector64<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> AbsScalar(Vector64<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> AbsoluteCompareGreaterThan(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> AbsoluteCompareGreaterThanScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> AbsoluteCompareGreaterThanScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> AbsoluteCompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> AbsoluteCompareGreaterThanOrEqualScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> AbsoluteCompareGreaterThanOrEqualScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> AbsoluteCompareLessThan(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> AbsoluteCompareLessThanScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> AbsoluteCompareLessThanScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> AbsoluteCompareLessThanOrEqual(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> AbsoluteCompareLessThanOrEqualScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> AbsoluteCompareLessThanOrEqualScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> AbsoluteDifference(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> AbsoluteDifferenceScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> AbsoluteDifferenceScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Add(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> AddAcross(Vector64<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> AddAcross(Vector64<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> AddAcross(Vector64<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> AddAcross(Vector64<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> AddAcross(Vector128<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> AddAcross(Vector128<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> AddAcross(Vector128<int> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> AddAcross(Vector128<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> AddAcross(Vector128<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> AddAcross(Vector128<uint> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> AddAcrossWidening(Vector64<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> AddAcrossWidening(Vector64<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> AddAcrossWidening(Vector64<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> AddAcrossWidening(Vector64<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> AddAcrossWidening(Vector128<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> AddAcrossWidening(Vector128<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> AddAcrossWidening(Vector128<int> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> AddAcrossWidening(Vector128<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> AddAcrossWidening(Vector128<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> AddAcrossWidening(Vector128<uint> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> AddPairwise(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> AddPairwise(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> AddPairwise(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> AddPairwise(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> AddPairwise(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> AddPairwise(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> AddPairwise(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> AddPairwise(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> AddPairwise(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> AddPairwise(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> AddPairwiseScalar(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> AddPairwiseScalar(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> AddPairwiseScalar(Vector128<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> AddPairwiseScalar(Vector128<ulong> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> AddSaturate(Vector64<byte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> AddSaturate(Vector64<short> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> AddSaturate(Vector64<int> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> AddSaturate(Vector64<sbyte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> AddSaturate(Vector64<ushort> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> AddSaturate(Vector64<uint> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> AddSaturateScalar(Vector64<byte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> AddSaturateScalar(Vector64<byte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> AddSaturateScalar(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> AddSaturateScalar(Vector64<short> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> AddSaturateScalar(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> AddSaturateScalar(Vector64<int> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> AddSaturateScalar(Vector64<long> left, Vector64<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> AddSaturateScalar(Vector64<sbyte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> AddSaturateScalar(Vector64<sbyte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> AddSaturateScalar(Vector64<ushort> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> AddSaturateScalar(Vector64<ushort> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> AddSaturateScalar(Vector64<uint> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> AddSaturateScalar(Vector64<uint> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> AddSaturateScalar(Vector64<ulong> left, Vector64<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Ceiling(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> CompareEqualScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> CompareEqualScalar(Vector64<long> left, Vector64<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> CompareEqualScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> CompareEqualScalar(Vector64<ulong> left, Vector64<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> CompareGreaterThan(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> CompareGreaterThanScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> CompareGreaterThanScalar(Vector64<long> left, Vector64<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> CompareGreaterThanScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> CompareGreaterThanScalar(Vector64<ulong> left, Vector64<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> CompareGreaterThanOrEqual(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> CompareGreaterThanOrEqual(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> CompareGreaterThanOrEqualScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> CompareGreaterThanOrEqualScalar(Vector64<long> left, Vector64<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> CompareGreaterThanOrEqualScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> CompareGreaterThanOrEqualScalar(Vector64<ulong> left, Vector64<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> CompareLessThan(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> CompareLessThan(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> CompareLessThanScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> CompareLessThanScalar(Vector64<long> left, Vector64<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> CompareLessThanScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> CompareLessThanScalar(Vector64<ulong> left, Vector64<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> CompareLessThanOrEqual(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> CompareLessThanOrEqual(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> CompareLessThanOrEqualScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> CompareLessThanOrEqualScalar(Vector64<long> left, Vector64<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> CompareLessThanOrEqualScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> CompareLessThanOrEqualScalar(Vector64<ulong> left, Vector64<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> CompareTest(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> CompareTest(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> CompareTest(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> CompareTestScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> CompareTestScalar(Vector64<long> left, Vector64<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> CompareTestScalar(Vector64<ulong> left, Vector64<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ConvertToDouble(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ConvertToDouble(Vector128<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ConvertToDouble(Vector128<ulong> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> ConvertToDoubleScalar(Vector64<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> ConvertToDoubleScalar(Vector64<ulong> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ConvertToDoubleUpper(Vector128<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> ConvertToInt64RoundAwayFromZero(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> ConvertToInt64RoundAwayFromZeroScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> ConvertToInt64RoundToEven(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> ConvertToInt64RoundToEvenScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> ConvertToInt64RoundToNegativeInfinity(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> ConvertToInt64RoundToNegativeInfinityScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> ConvertToInt64RoundToPositiveInfinity(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> ConvertToInt64RoundToPositiveInfinityScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> ConvertToInt64RoundToZero(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> ConvertToInt64RoundToZeroScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ConvertToSingleLower(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ConvertToSingleRoundToOddLower(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> ConvertToSingleRoundToOddUpper(Vector64<float> lower, Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> ConvertToSingleUpper(Vector64<float> lower, Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> ConvertToUInt64RoundAwayFromZero(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> ConvertToUInt64RoundAwayFromZeroScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> ConvertToUInt64RoundToEven(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> ConvertToUInt64RoundToEvenScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> ConvertToUInt64RoundToNegativeInfinity(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> ConvertToUInt64RoundToNegativeInfinityScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> ConvertToUInt64RoundToPositiveInfinity(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> ConvertToUInt64RoundToPositiveInfinityScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> ConvertToUInt64RoundToZero(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ulong> ConvertToUInt64RoundToZeroScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> Divide(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> DuplicateSelectedScalarToVector128(Vector128<double> value, byte index)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> DuplicateSelectedScalarToVector128(Vector128<long> value, byte index)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> DuplicateSelectedScalarToVector128(Vector128<ulong> value, byte index)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> DuplicateToVector128(double value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> DuplicateToVector128(long value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> DuplicateToVector128(ulong value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ExtractNarrowingSaturateScalar(Vector64<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ExtractNarrowingSaturateScalar(Vector64<int> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ExtractNarrowingSaturateScalar(Vector64<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ExtractNarrowingSaturateScalar(Vector64<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ExtractNarrowingSaturateScalar(Vector64<uint> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ExtractNarrowingSaturateScalar(Vector64<ulong> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ExtractNarrowingSaturateUnsignedScalar(Vector64<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ExtractNarrowingSaturateUnsignedScalar(Vector64<int> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ExtractNarrowingSaturateUnsignedScalar(Vector64<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Floor(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> FusedMultiplyAdd(Vector128<double> addend, Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplyAddByScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> FusedMultiplyAddByScalar(Vector128<double> addend, Vector128<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> FusedMultiplyAddByScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplyAddBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> FusedMultiplyAddBySelectedScalar(Vector128<double> addend, Vector128<double> left, Vector128<double> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> FusedMultiplyAddBySelectedScalar(Vector128<float> addend, Vector128<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> FusedMultiplyAddScalarBySelectedScalar(Vector64<double> addend, Vector64<double> left, Vector128<double> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplyAddScalarBySelectedScalar(Vector64<float> addend, Vector64<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> FusedMultiplySubtract(Vector128<double> minuend, Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplySubtractByScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> FusedMultiplySubtractByScalar(Vector128<double> minuend, Vector128<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> FusedMultiplySubtractByScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplySubtractBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> FusedMultiplySubtractBySelectedScalar(Vector128<double> minuend, Vector128<double> left, Vector128<double> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> FusedMultiplySubtractBySelectedScalar(Vector128<float> minuend, Vector128<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> FusedMultiplySubtractScalarBySelectedScalar(Vector64<double> minuend, Vector64<double> left, Vector128<double> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> FusedMultiplySubtractScalarBySelectedScalar(Vector64<float> minuend, Vector64<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, byte resultIndex, Vector64<byte> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> InsertSelectedScalar(Vector64<byte> result, byte resultIndex, Vector128<byte> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> InsertSelectedScalar(Vector64<short> result, byte resultIndex, Vector64<short> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> InsertSelectedScalar(Vector64<short> result, byte resultIndex, Vector128<short> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> InsertSelectedScalar(Vector64<int> result, byte resultIndex, Vector64<int> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> InsertSelectedScalar(Vector64<int> result, byte resultIndex, Vector128<int> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, byte resultIndex, Vector64<sbyte> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> InsertSelectedScalar(Vector64<sbyte> result, byte resultIndex, Vector128<sbyte> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> InsertSelectedScalar(Vector64<float> result, byte resultIndex, Vector64<float> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> InsertSelectedScalar(Vector64<float> result, byte resultIndex, Vector128<float> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, byte resultIndex, Vector64<ushort> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> InsertSelectedScalar(Vector64<ushort> result, byte resultIndex, Vector128<ushort> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, byte resultIndex, Vector64<uint> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> InsertSelectedScalar(Vector64<uint> result, byte resultIndex, Vector128<uint> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, byte resultIndex, Vector64<byte> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> InsertSelectedScalar(Vector128<byte> result, byte resultIndex, Vector128<byte> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> InsertSelectedScalar(Vector128<double> result, byte resultIndex, Vector128<double> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> InsertSelectedScalar(Vector128<short> result, byte resultIndex, Vector64<short> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> InsertSelectedScalar(Vector128<short> result, byte resultIndex, Vector128<short> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> InsertSelectedScalar(Vector128<int> result, byte resultIndex, Vector64<int> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> InsertSelectedScalar(Vector128<int> result, byte resultIndex, Vector128<int> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> InsertSelectedScalar(Vector128<long> result, byte resultIndex, Vector128<long> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, byte resultIndex, Vector64<sbyte> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> InsertSelectedScalar(Vector128<sbyte> result, byte resultIndex, Vector128<sbyte> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> InsertSelectedScalar(Vector128<float> result, byte resultIndex, Vector64<float> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> InsertSelectedScalar(Vector128<float> result, byte resultIndex, Vector128<float> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, byte resultIndex, Vector64<ushort> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> InsertSelectedScalar(Vector128<ushort> result, byte resultIndex, Vector128<ushort> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, byte resultIndex, Vector64<uint> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> InsertSelectedScalar(Vector128<uint> result, byte resultIndex, Vector128<uint> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> InsertSelectedScalar(Vector128<ulong> result, byte resultIndex, Vector128<ulong> value, byte valueIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static Vector128<double> LoadAndReplicateToVector128(double* address)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static Vector128<long> LoadAndReplicateToVector128(long* address)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static Vector128<ulong> LoadAndReplicateToVector128(ulong* address)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Max(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> MaxAcross(Vector64<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MaxAcross(Vector64<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> MaxAcross(Vector64<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> MaxAcross(Vector64<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> MaxAcross(Vector128<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MaxAcross(Vector128<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MaxAcross(Vector128<int> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> MaxAcross(Vector128<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MaxAcross(Vector128<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> MaxAcross(Vector128<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> MaxAcross(Vector128<uint> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MaxNumber(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MaxNumberAcross(Vector128<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MaxNumberPairwise(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MaxNumberPairwise(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> MaxNumberPairwise(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MaxNumberPairwiseScalar(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MaxNumberPairwiseScalar(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> MaxPairwise(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MaxPairwise(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> MaxPairwise(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> MaxPairwise(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> MaxPairwise(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> MaxPairwise(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> MaxPairwise(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> MaxPairwise(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MaxPairwiseScalar(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MaxPairwiseScalar(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MaxScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MaxScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Min(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> MinAcross(Vector64<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MinAcross(Vector64<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> MinAcross(Vector64<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> MinAcross(Vector64<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> MinAcross(Vector128<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MinAcross(Vector128<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MinAcross(Vector128<int> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> MinAcross(Vector128<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MinAcross(Vector128<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> MinAcross(Vector128<ushort> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> MinAcross(Vector128<uint> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MinNumber(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MinNumberAcross(Vector128<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MinNumberPairwise(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MinNumberPairwise(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> MinNumberPairwise(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MinNumberPairwiseScalar(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MinNumberPairwiseScalar(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> MinPairwise(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MinPairwise(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> MinPairwise(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> MinPairwise(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> MinPairwise(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> MinPairwise(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> MinPairwise(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> MinPairwise(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MinPairwiseScalar(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MinPairwiseScalar(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MinScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MinScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MultiplyByScalar(Vector128<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MultiplyBySelectedScalar(Vector128<double> left, Vector128<double> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyDoublingSaturateHighScalar(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingSaturateHighScalar(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningAndAddSaturateScalar(Vector64<int> addend, Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningAndAddSaturateScalar(Vector64<long> addend, Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningAndSubtractSaturateScalar(Vector64<int> minuend, Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningAndSubtractSaturateScalar(Vector64<long> minuend, Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningSaturateScalar(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningSaturateScalar(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MultiplyExtended(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MultiplyExtended(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> MultiplyExtended(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MultiplyExtendedByScalar(Vector128<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MultiplyExtendedBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> MultiplyExtendedBySelectedScalar(Vector128<double> left, Vector128<double> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> MultiplyExtendedBySelectedScalar(Vector128<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MultiplyExtendedScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MultiplyExtendedScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MultiplyExtendedScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> MultiplyExtendedScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyRoundedDoublingSaturateHighScalar(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingSaturateHighScalar(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> MultiplyScalarBySelectedScalar(Vector64<double> left, Vector128<double> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Negate(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> Negate(Vector128<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> NegateSaturate(Vector128<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> NegateSaturateScalar(Vector64<short> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> NegateSaturateScalar(Vector64<int> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> NegateSaturateScalar(Vector64<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> NegateSaturateScalar(Vector64<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<long> NegateScalar(Vector64<long> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ReciprocalEstimate(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> ReciprocalEstimateScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ReciprocalEstimateScalar(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> ReciprocalExponentScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ReciprocalExponentScalar(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ReciprocalSquareRootEstimate(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> ReciprocalSquareRootEstimateScalar(Vector64<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ReciprocalSquareRootEstimateScalar(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ReciprocalSquareRootStep(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> ReciprocalSquareRootStepScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ReciprocalSquareRootStepScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ReciprocalStep(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<double> ReciprocalStepScalar(Vector64<double> left, Vector64<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ReciprocalStepScalar(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> RoundAwayFromZero(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> RoundToNearest(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> RoundToZero(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftArithmeticRoundedSaturateScalar(Vector64<short> value, Vector64<short> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftArithmeticRoundedSaturateScalar(Vector64<int> value, Vector64<int> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftArithmeticRoundedSaturateScalar(Vector64<sbyte> value, Vector64<sbyte> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftArithmeticSaturateScalar(Vector64<short> value, Vector64<short> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftArithmeticSaturateScalar(Vector64<int> value, Vector64<int> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftArithmeticSaturateScalar(Vector64<sbyte> value, Vector64<sbyte> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ShiftLeftLogicalSaturateScalar(Vector64<byte> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftLeftLogicalSaturateScalar(Vector64<short> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftLeftLogicalSaturateScalar(Vector64<int> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftLeftLogicalSaturateScalar(Vector64<sbyte> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ShiftLeftLogicalSaturateScalar(Vector64<ushort> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ShiftLeftLogicalSaturateScalar(Vector64<uint> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<short> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<int> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<sbyte> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ShiftLogicalRoundedSaturateScalar(Vector64<byte> value, Vector64<sbyte> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftLogicalRoundedSaturateScalar(Vector64<short> value, Vector64<short> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftLogicalRoundedSaturateScalar(Vector64<int> value, Vector64<int> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftLogicalRoundedSaturateScalar(Vector64<sbyte> value, Vector64<sbyte> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ShiftLogicalRoundedSaturateScalar(Vector64<ushort> value, Vector64<short> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ShiftLogicalRoundedSaturateScalar(Vector64<uint> value, Vector64<int> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ShiftLogicalSaturateScalar(Vector64<byte> value, Vector64<sbyte> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftLogicalSaturateScalar(Vector64<short> value, Vector64<short> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftLogicalSaturateScalar(Vector64<int> value, Vector64<int> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftLogicalSaturateScalar(Vector64<sbyte> value, Vector64<sbyte> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ShiftLogicalSaturateScalar(Vector64<ushort> value, Vector64<short> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ShiftLogicalSaturateScalar(Vector64<uint> value, Vector64<int> count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<int> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<long> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateScalar(Vector64<short> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<short> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<int> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64<long> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<int> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<long> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64<short> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<short> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<int> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64<long> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ushort> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftRightLogicalNarrowingSaturateScalar(Vector64<int> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftRightLogicalNarrowingSaturateScalar(Vector64<long> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateScalar(Vector64<short> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateScalar(Vector64<uint> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ShiftRightLogicalNarrowingSaturateScalar(Vector64<ulong> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ushort> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<int> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<long> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<short> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<uint> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64<ulong> value, byte count)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> Sqrt(Vector64<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Sqrt(Vector128<double> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> Sqrt(Vector128<float> value)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(byte* address, Vector64<byte> value1, Vector64<byte> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(double* address, Vector64<double> value1, Vector64<double> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(short* address, Vector64<short> value1, Vector64<short> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(int* address, Vector64<int> value1, Vector64<int> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(long* address, Vector64<long> value1, Vector64<long> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(sbyte* address, Vector64<sbyte> value1, Vector64<sbyte> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(float* address, Vector64<float> value1, Vector64<float> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(ushort* address, Vector64<ushort> value1, Vector64<ushort> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(uint* address, Vector64<uint> value1, Vector64<uint> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(ulong* address, Vector64<ulong> value1, Vector64<ulong> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(byte* address, Vector128<byte> value1, Vector128<byte> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(double* address, Vector128<double> value1, Vector128<double> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(short* address, Vector128<short> value1, Vector128<short> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(int* address, Vector128<int> value1, Vector128<int> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(long* address, Vector128<long> value1, Vector128<long> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(sbyte* address, Vector128<sbyte> value1, Vector128<sbyte> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(float* address, Vector128<float> value1, Vector128<float> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(ushort* address, Vector128<ushort> value1, Vector128<ushort> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(uint* address, Vector128<uint> value1, Vector128<uint> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePair(ulong* address, Vector128<ulong> value1, Vector128<ulong> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(byte* address, Vector64<byte> value1, Vector64<byte> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(double* address, Vector64<double> value1, Vector64<double> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(short* address, Vector64<short> value1, Vector64<short> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(int* address, Vector64<int> value1, Vector64<int> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(long* address, Vector64<long> value1, Vector64<long> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(sbyte* address, Vector64<sbyte> value1, Vector64<sbyte> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(float* address, Vector64<float> value1, Vector64<float> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(ushort* address, Vector64<ushort> value1, Vector64<ushort> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(uint* address, Vector64<uint> value1, Vector64<uint> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(ulong* address, Vector64<ulong> value1, Vector64<ulong> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(byte* address, Vector128<byte> value1, Vector128<byte> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(double* address, Vector128<double> value1, Vector128<double> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(short* address, Vector128<short> value1, Vector128<short> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(int* address, Vector128<int> value1, Vector128<int> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(long* address, Vector128<long> value1, Vector128<long> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(sbyte* address, Vector128<sbyte> value1, Vector128<sbyte> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(float* address, Vector128<float> value1, Vector128<float> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(ushort* address, Vector128<ushort> value1, Vector128<ushort> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(uint* address, Vector128<uint> value1, Vector128<uint> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairNonTemporal(ulong* address, Vector128<ulong> value1, Vector128<ulong> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairScalar(int* address, Vector64<int> value1, Vector64<int> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairScalar(float* address, Vector64<float> value1, Vector64<float> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairScalar(uint* address, Vector64<uint> value1, Vector64<uint> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairScalarNonTemporal(int* address, Vector64<int> value1, Vector64<int> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairScalarNonTemporal(float* address, Vector64<float> value1, Vector64<float> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public unsafe static void StorePairScalarNonTemporal(uint* address, Vector64<uint> value1, Vector64<uint> value2)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> SubtractSaturateScalar(Vector64<byte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> SubtractSaturateScalar(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> SubtractSaturateScalar(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> SubtractSaturateScalar(Vector64<sbyte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> SubtractSaturateScalar(Vector64<ushort> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> SubtractSaturateScalar(Vector64<uint> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ReverseElementBits(Vector64<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ReverseElementBits(Vector64<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> ReverseElementBits(Vector128<byte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> ReverseElementBits(Vector128<sbyte> value)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> TransposeEven(Vector64<byte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> TransposeEven(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> TransposeEven(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> TransposeEven(Vector64<sbyte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> TransposeEven(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> TransposeEven(Vector64<ushort> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> TransposeEven(Vector64<uint> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> TransposeEven(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> TransposeEven(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> TransposeEven(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> TransposeEven(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> TransposeEven(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> TransposeEven(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> TransposeEven(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> TransposeEven(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> TransposeEven(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> TransposeEven(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> TransposeOdd(Vector64<byte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> TransposeOdd(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> TransposeOdd(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> TransposeOdd(Vector64<sbyte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> TransposeOdd(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> TransposeOdd(Vector64<ushort> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> TransposeOdd(Vector64<uint> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> TransposeOdd(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> TransposeOdd(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> TransposeOdd(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> TransposeOdd(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> TransposeOdd(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> TransposeOdd(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> TransposeOdd(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> TransposeOdd(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> TransposeOdd(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> TransposeOdd(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> UnzipEven(Vector64<byte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> UnzipEven(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> UnzipEven(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> UnzipEven(Vector64<sbyte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> UnzipEven(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> UnzipEven(Vector64<ushort> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> UnzipEven(Vector64<uint> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> UnzipEven(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> UnzipEven(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> UnzipEven(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> UnzipEven(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> UnzipEven(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> UnzipEven(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> UnzipEven(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> UnzipEven(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> UnzipEven(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> UnzipEven(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> UnzipOdd(Vector64<byte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> UnzipOdd(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> UnzipOdd(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> UnzipOdd(Vector64<sbyte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> UnzipOdd(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> UnzipOdd(Vector64<ushort> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> UnzipOdd(Vector64<uint> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> UnzipOdd(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> UnzipOdd(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> UnzipOdd(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> UnzipOdd(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> UnzipOdd(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> UnzipOdd(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> UnzipOdd(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> UnzipOdd(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> UnzipOdd(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> UnzipOdd(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> VectorTableLookup(Vector128<byte> table, Vector128<byte> byteIndexes)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> VectorTableLookup(Vector128<sbyte> table, Vector128<sbyte> byteIndexes)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> VectorTableLookupExtension(Vector128<byte> defaultValues, Vector128<byte> table, Vector128<byte> byteIndexes)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> VectorTableLookupExtension(Vector128<sbyte> defaultValues, Vector128<sbyte> table, Vector128<sbyte> byteIndexes)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ZipHigh(Vector64<byte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ZipHigh(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ZipHigh(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ZipHigh(Vector64<sbyte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ZipHigh(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ZipHigh(Vector64<ushort> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ZipHigh(Vector64<uint> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> ZipHigh(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ZipHigh(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> ZipHigh(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> ZipHigh(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> ZipHigh(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> ZipHigh(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> ZipHigh(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> ZipHigh(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> ZipHigh(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> ZipHigh(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<byte> ZipLow(Vector64<byte> left, Vector64<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> ZipLow(Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> ZipLow(Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<sbyte> ZipLow(Vector64<sbyte> left, Vector64<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<float> ZipLow(Vector64<float> left, Vector64<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<ushort> ZipLow(Vector64<ushort> left, Vector64<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<uint> ZipLow(Vector64<uint> left, Vector64<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<byte> ZipLow(Vector128<byte> left, Vector128<byte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<double> ZipLow(Vector128<double> left, Vector128<double> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<short> ZipLow(Vector128<short> left, Vector128<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<int> ZipLow(Vector128<int> left, Vector128<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<long> ZipLow(Vector128<long> left, Vector128<long> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<sbyte> ZipLow(Vector128<sbyte> left, Vector128<sbyte> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<float> ZipLow(Vector128<float> left, Vector128<float> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ushort> ZipLow(Vector128<ushort> left, Vector128<ushort> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<uint> ZipLow(Vector128<uint> left, Vector128<uint> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector128<ulong> ZipLow(Vector128<ulong> left, Vector128<ulong> right)
			{
				throw new PlatformNotSupportedException();
			}
		}

		public new static bool IsSupported
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		public static Vector64<ushort> Abs(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Abs(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Abs(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Abs(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Abs(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Abs(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Abs(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Abs(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> AbsSaturate(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> AbsSaturate(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> AbsSaturate(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AbsSaturate(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AbsSaturate(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> AbsSaturate(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> AbsScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> AbsScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> AbsoluteCompareGreaterThan(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> AbsoluteCompareGreaterThan(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> AbsoluteCompareGreaterThanOrEqual(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> AbsoluteCompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> AbsoluteCompareLessThan(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> AbsoluteCompareLessThan(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> AbsoluteCompareLessThanOrEqual(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> AbsoluteCompareLessThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> AbsoluteDifference(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AbsoluteDifference(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AbsoluteDifference(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> AbsoluteDifference(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> AbsoluteDifference(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AbsoluteDifference(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AbsoluteDifference(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> AbsoluteDifference(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifference(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifference(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> AbsoluteDifference(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> AbsoluteDifference(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifference(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifference(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> AbsoluteDifferenceAdd(Vector64<byte> addend, Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> AbsoluteDifferenceAdd(Vector64<short> addend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> AbsoluteDifferenceAdd(Vector64<int> addend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> AbsoluteDifferenceAdd(Vector64<sbyte> addend, Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AbsoluteDifferenceAdd(Vector64<ushort> addend, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AbsoluteDifferenceAdd(Vector64<uint> addend, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> AbsoluteDifferenceAdd(Vector128<byte> addend, Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AbsoluteDifferenceAdd(Vector128<short> addend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AbsoluteDifferenceAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> AbsoluteDifferenceAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifferenceAdd(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifferenceAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifferenceWideningLower(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifferenceWideningLower(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AbsoluteDifferenceWideningLower(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifferenceWideningLower(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifferenceWideningLower(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AbsoluteDifferenceWideningLower(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifferenceWideningLowerAndAdd(Vector128<ushort> addend, Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AbsoluteDifferenceWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AbsoluteDifferenceWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AbsoluteDifferenceWideningLowerAndAdd(Vector128<short> addend, Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifferenceWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AbsoluteDifferenceWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifferenceWideningUpper(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifferenceWideningUpper(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AbsoluteDifferenceWideningUpper(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifferenceWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifferenceWideningUpper(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AbsoluteDifferenceWideningUpper(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AbsoluteDifferenceWideningUpperAndAdd(Vector128<ushort> addend, Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AbsoluteDifferenceWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AbsoluteDifferenceWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AbsoluteDifferenceWideningUpperAndAdd(Vector128<short> addend, Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AbsoluteDifferenceWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AbsoluteDifferenceWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Add(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Add(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Add(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Add(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Add(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Add(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Add(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Add(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Add(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> Add(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Add(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> AddHighNarrowingLower(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> AddHighNarrowingLower(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> AddHighNarrowingLower(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> AddHighNarrowingLower(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AddHighNarrowingLower(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AddHighNarrowingLower(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> AddHighNarrowingUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddHighNarrowingUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddHighNarrowingUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> AddHighNarrowingUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddHighNarrowingUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddHighNarrowingUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> AddPairwise(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> AddPairwise(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> AddPairwise(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> AddPairwise(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> AddPairwise(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AddPairwise(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AddPairwise(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AddPairwiseWidening(Vector64<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> AddPairwiseWidening(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> AddPairwiseWidening(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AddPairwiseWidening(Vector64<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddPairwiseWidening(Vector128<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddPairwiseWidening(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AddPairwiseWidening(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddPairwiseWidening(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddPairwiseWidening(Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AddPairwiseWidening(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AddPairwiseWideningAndAdd(Vector64<ushort> addend, Vector64<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> AddPairwiseWideningAndAdd(Vector64<int> addend, Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> AddPairwiseWideningAndAdd(Vector64<short> addend, Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AddPairwiseWideningAndAdd(Vector64<uint> addend, Vector64<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddPairwiseWideningAndAdd(Vector128<ushort> addend, Vector128<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddPairwiseWideningAndAdd(Vector128<int> addend, Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AddPairwiseWideningAndAdd(Vector128<long> addend, Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddPairwiseWideningAndAdd(Vector128<short> addend, Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddPairwiseWideningAndAdd(Vector128<uint> addend, Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AddPairwiseWideningAndAdd(Vector128<ulong> addend, Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> AddPairwiseWideningAndAddScalar(Vector64<long> addend, Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> AddPairwiseWideningAndAddScalar(Vector64<ulong> addend, Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> AddPairwiseWideningScalar(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> AddPairwiseWideningScalar(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> AddRoundedHighNarrowingLower(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> AddRoundedHighNarrowingLower(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> AddRoundedHighNarrowingLower(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> AddRoundedHighNarrowingLower(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AddRoundedHighNarrowingLower(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AddRoundedHighNarrowingLower(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> AddRoundedHighNarrowingUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddRoundedHighNarrowingUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddRoundedHighNarrowingUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> AddRoundedHighNarrowingUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddRoundedHighNarrowingUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddRoundedHighNarrowingUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> AddSaturate(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> AddSaturate(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> AddSaturate(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> AddSaturate(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> AddSaturate(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> AddSaturate(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddSaturate(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AddSaturate(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddSaturate(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AddSaturate(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> AddSaturateScalar(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> AddSaturateScalar(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> AddScalar(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> AddScalar(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> AddScalar(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> AddScalar(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddWideningLower(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddWideningLower(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AddWideningLower(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddWideningLower(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddWideningLower(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AddWideningLower(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddWideningLower(Vector128<short> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddWideningLower(Vector128<int> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AddWideningLower(Vector128<long> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddWideningLower(Vector128<ushort> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddWideningLower(Vector128<uint> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AddWideningLower(Vector128<ulong> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddWideningUpper(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddWideningUpper(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddWideningUpper(Vector128<short> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> AddWideningUpper(Vector128<int> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AddWideningUpper(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> AddWideningUpper(Vector128<long> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> AddWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> AddWideningUpper(Vector128<ushort> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddWideningUpper(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> AddWideningUpper(Vector128<uint> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AddWideningUpper(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> AddWideningUpper(Vector128<ulong> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> And(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> And(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> And(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> And(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> And(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> And(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> And(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> And(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> And(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> And(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> And(Vector128<double> left, Vector128<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> And(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> And(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> And(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> And(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> BitwiseClear(Vector64<byte> value, Vector64<byte> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> BitwiseClear(Vector64<double> value, Vector64<double> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> BitwiseClear(Vector64<short> value, Vector64<short> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> BitwiseClear(Vector64<int> value, Vector64<int> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> BitwiseClear(Vector64<long> value, Vector64<long> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> BitwiseClear(Vector64<sbyte> value, Vector64<sbyte> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> BitwiseClear(Vector64<float> value, Vector64<float> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> BitwiseClear(Vector64<ushort> value, Vector64<ushort> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> BitwiseClear(Vector64<uint> value, Vector64<uint> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> BitwiseClear(Vector64<ulong> value, Vector64<ulong> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> BitwiseClear(Vector128<byte> value, Vector128<byte> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> BitwiseClear(Vector128<double> value, Vector128<double> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> BitwiseClear(Vector128<short> value, Vector128<short> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> BitwiseClear(Vector128<int> value, Vector128<int> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> BitwiseClear(Vector128<long> value, Vector128<long> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> BitwiseClear(Vector128<sbyte> value, Vector128<sbyte> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> BitwiseClear(Vector128<float> value, Vector128<float> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> BitwiseClear(Vector128<ushort> value, Vector128<ushort> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> BitwiseClear(Vector128<uint> value, Vector128<uint> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> BitwiseClear(Vector128<ulong> value, Vector128<ulong> mask)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> BitwiseSelect(Vector64<byte> select, Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> BitwiseSelect(Vector64<double> select, Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> BitwiseSelect(Vector64<short> select, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> BitwiseSelect(Vector64<int> select, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> BitwiseSelect(Vector64<long> select, Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> BitwiseSelect(Vector64<sbyte> select, Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> BitwiseSelect(Vector64<float> select, Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> BitwiseSelect(Vector64<ushort> select, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> BitwiseSelect(Vector64<uint> select, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> BitwiseSelect(Vector64<ulong> select, Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> BitwiseSelect(Vector128<byte> select, Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> BitwiseSelect(Vector128<double> select, Vector128<double> left, Vector128<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> BitwiseSelect(Vector128<short> select, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> BitwiseSelect(Vector128<int> select, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> BitwiseSelect(Vector128<long> select, Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> BitwiseSelect(Vector128<sbyte> select, Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> BitwiseSelect(Vector128<float> select, Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> BitwiseSelect(Vector128<ushort> select, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> BitwiseSelect(Vector128<uint> select, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> BitwiseSelect(Vector128<ulong> select, Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Ceiling(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Ceiling(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> CeilingScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> CeilingScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> CompareEqual(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> CompareEqual(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> CompareEqual(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> CompareEqual(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> CompareEqual(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> CompareEqual(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> CompareEqual(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> CompareGreaterThan(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> CompareGreaterThan(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> CompareGreaterThan(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> CompareGreaterThan(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> CompareGreaterThan(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> CompareGreaterThan(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> CompareGreaterThan(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> CompareGreaterThan(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> CompareGreaterThanOrEqual(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> CompareGreaterThanOrEqual(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> CompareGreaterThanOrEqual(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> CompareGreaterThanOrEqual(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> CompareGreaterThanOrEqual(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> CompareGreaterThanOrEqual(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> CompareGreaterThanOrEqual(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> CompareGreaterThanOrEqual(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> CompareGreaterThanOrEqual(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> CompareGreaterThanOrEqual(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> CompareGreaterThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> CompareGreaterThanOrEqual(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> CompareGreaterThanOrEqual(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> CompareLessThan(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> CompareLessThan(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> CompareLessThan(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> CompareLessThan(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> CompareLessThan(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> CompareLessThan(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> CompareLessThan(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> CompareLessThan(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> CompareLessThan(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> CompareLessThan(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> CompareLessThanOrEqual(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> CompareLessThanOrEqual(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> CompareLessThanOrEqual(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> CompareLessThanOrEqual(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> CompareLessThanOrEqual(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> CompareLessThanOrEqual(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> CompareLessThanOrEqual(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> CompareLessThanOrEqual(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> CompareLessThanOrEqual(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> CompareTest(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> CompareTest(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> CompareTest(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> CompareTest(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> CompareTest(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> CompareTest(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> CompareTest(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> CompareTest(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> CompareTest(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> CompareTest(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> CompareTest(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> CompareTest(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> CompareTest(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> CompareTest(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundAwayFromZero(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ConvertToInt32RoundAwayFromZero(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundAwayFromZeroScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundToEven(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ConvertToInt32RoundToEven(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundToEvenScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundToNegativeInfinity(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ConvertToInt32RoundToNegativeInfinity(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundToNegativeInfinityScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundToPositiveInfinity(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ConvertToInt32RoundToPositiveInfinity(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundToPositiveInfinityScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundToZero(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ConvertToInt32RoundToZero(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ConvertToInt32RoundToZeroScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ConvertToSingle(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ConvertToSingle(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> ConvertToSingle(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> ConvertToSingle(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ConvertToSingleScalar(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ConvertToSingleScalar(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundAwayFromZero(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ConvertToUInt32RoundAwayFromZero(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundAwayFromZeroScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundToEven(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ConvertToUInt32RoundToEven(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundToEvenScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundToNegativeInfinity(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ConvertToUInt32RoundToNegativeInfinity(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundToNegativeInfinityScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundToPositiveInfinity(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ConvertToUInt32RoundToPositiveInfinity(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundToPositiveInfinityScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundToZero(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ConvertToUInt32RoundToZero(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ConvertToUInt32RoundToZeroScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> DivideScalar(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> DivideScalar(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector64<byte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> DuplicateSelectedScalarToVector64(Vector64<short> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> DuplicateSelectedScalarToVector64(Vector64<int> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> DuplicateSelectedScalarToVector64(Vector64<float> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector64<sbyte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector64<ushort> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector64<uint> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> DuplicateSelectedScalarToVector64(Vector128<byte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> DuplicateSelectedScalarToVector64(Vector128<short> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> DuplicateSelectedScalarToVector64(Vector128<int> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> DuplicateSelectedScalarToVector64(Vector128<float> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> DuplicateSelectedScalarToVector64(Vector128<sbyte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> DuplicateSelectedScalarToVector64(Vector128<ushort> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> DuplicateSelectedScalarToVector64(Vector128<uint> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector64<byte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> DuplicateSelectedScalarToVector128(Vector64<short> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> DuplicateSelectedScalarToVector128(Vector64<int> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> DuplicateSelectedScalarToVector128(Vector64<float> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector64<sbyte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector64<ushort> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector64<uint> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> DuplicateSelectedScalarToVector128(Vector128<byte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> DuplicateSelectedScalarToVector128(Vector128<short> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> DuplicateSelectedScalarToVector128(Vector128<int> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> DuplicateSelectedScalarToVector128(Vector128<float> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> DuplicateSelectedScalarToVector128(Vector128<sbyte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> DuplicateSelectedScalarToVector128(Vector128<ushort> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> DuplicateSelectedScalarToVector128(Vector128<uint> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> DuplicateToVector64(byte value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> DuplicateToVector64(short value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> DuplicateToVector64(int value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> DuplicateToVector64(sbyte value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> DuplicateToVector64(float value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> DuplicateToVector64(ushort value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> DuplicateToVector64(uint value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> DuplicateToVector128(byte value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> DuplicateToVector128(short value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> DuplicateToVector128(int value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> DuplicateToVector128(sbyte value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> DuplicateToVector128(float value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> DuplicateToVector128(ushort value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> DuplicateToVector128(uint value)
		{
			throw new PlatformNotSupportedException();
		}

		public static byte Extract(Vector64<byte> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static short Extract(Vector64<short> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static int Extract(Vector64<int> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static sbyte Extract(Vector64<sbyte> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static float Extract(Vector64<float> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static ushort Extract(Vector64<ushort> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static uint Extract(Vector64<uint> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static byte Extract(Vector128<byte> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static double Extract(Vector128<double> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static short Extract(Vector128<short> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static int Extract(Vector128<int> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static long Extract(Vector128<long> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static sbyte Extract(Vector128<sbyte> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static float Extract(Vector128<float> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static ushort Extract(Vector128<ushort> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static uint Extract(Vector128<uint> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static ulong Extract(Vector128<ulong> vector, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ExtractNarrowingLower(Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ExtractNarrowingLower(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ExtractNarrowingLower(Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ExtractNarrowingLower(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ExtractNarrowingLower(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ExtractNarrowingLower(Vector128<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ExtractNarrowingSaturateLower(Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ExtractNarrowingSaturateLower(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ExtractNarrowingSaturateLower(Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ExtractNarrowingSaturateLower(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ExtractNarrowingSaturateLower(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ExtractNarrowingSaturateLower(Vector128<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ExtractNarrowingSaturateUnsignedLower(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ExtractNarrowingSaturateUnsignedLower(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ExtractNarrowingSaturateUnsignedLower(Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ExtractNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ExtractNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ExtractNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ExtractNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ExtractNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ExtractNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ExtractNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ExtractNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ExtractNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ExtractNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ExtractNarrowingUpper(Vector64<short> lower, Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ExtractNarrowingUpper(Vector64<int> lower, Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ExtractNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ExtractNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ExtractNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ExtractVector64(Vector64<byte> upper, Vector64<byte> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ExtractVector64(Vector64<short> upper, Vector64<short> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ExtractVector64(Vector64<int> upper, Vector64<int> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ExtractVector64(Vector64<sbyte> upper, Vector64<sbyte> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ExtractVector64(Vector64<float> upper, Vector64<float> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ExtractVector64(Vector64<ushort> upper, Vector64<ushort> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ExtractVector64(Vector64<uint> upper, Vector64<uint> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ExtractVector128(Vector128<byte> upper, Vector128<byte> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> ExtractVector128(Vector128<double> upper, Vector128<double> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ExtractVector128(Vector128<short> upper, Vector128<short> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ExtractVector128(Vector128<int> upper, Vector128<int> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ExtractVector128(Vector128<long> upper, Vector128<long> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ExtractVector128(Vector128<sbyte> upper, Vector128<sbyte> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> ExtractVector128(Vector128<float> upper, Vector128<float> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ExtractVector128(Vector128<ushort> upper, Vector128<ushort> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ExtractVector128(Vector128<uint> upper, Vector128<uint> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ExtractVector128(Vector128<ulong> upper, Vector128<ulong> lower, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Floor(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Floor(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> FloorScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> FloorScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> FusedAddHalving(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> FusedAddHalving(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> FusedAddHalving(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> FusedAddHalving(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> FusedAddHalving(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> FusedAddHalving(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> FusedAddHalving(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> FusedAddHalving(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> FusedAddHalving(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> FusedAddHalving(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> FusedAddHalving(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> FusedAddHalving(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> FusedAddRoundedHalving(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> FusedAddRoundedHalving(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> FusedAddRoundedHalving(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> FusedAddRoundedHalving(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> FusedAddRoundedHalving(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> FusedAddRoundedHalving(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> FusedAddRoundedHalving(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> FusedAddRoundedHalving(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> FusedAddRoundedHalving(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> FusedAddRoundedHalving(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> FusedAddRoundedHalving(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> FusedAddRoundedHalving(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> FusedMultiplyAdd(Vector64<float> addend, Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> FusedMultiplyAdd(Vector128<float> addend, Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> FusedMultiplyAddNegatedScalar(Vector64<double> addend, Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> FusedMultiplyAddNegatedScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> FusedMultiplyAddScalar(Vector64<double> addend, Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> FusedMultiplyAddScalar(Vector64<float> addend, Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> FusedMultiplySubtract(Vector64<float> minuend, Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> FusedMultiplySubtract(Vector128<float> minuend, Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> FusedMultiplySubtractNegatedScalar(Vector64<double> minuend, Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> FusedMultiplySubtractNegatedScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> FusedMultiplySubtractScalar(Vector64<double> minuend, Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> FusedMultiplySubtractScalar(Vector64<float> minuend, Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> FusedSubtractHalving(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> FusedSubtractHalving(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> FusedSubtractHalving(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> FusedSubtractHalving(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> FusedSubtractHalving(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> FusedSubtractHalving(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> FusedSubtractHalving(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> FusedSubtractHalving(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> FusedSubtractHalving(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> FusedSubtractHalving(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> FusedSubtractHalving(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> FusedSubtractHalving(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Insert(Vector64<byte> vector, byte index, byte data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Insert(Vector64<short> vector, byte index, short data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Insert(Vector64<int> vector, byte index, int data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Insert(Vector64<sbyte> vector, byte index, sbyte data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Insert(Vector64<float> vector, byte index, float data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Insert(Vector64<ushort> vector, byte index, ushort data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Insert(Vector64<uint> vector, byte index, uint data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Insert(Vector128<byte> vector, byte index, byte data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> Insert(Vector128<double> vector, byte index, double data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Insert(Vector128<short> vector, byte index, short data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Insert(Vector128<int> vector, byte index, int data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> Insert(Vector128<long> vector, byte index, long data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Insert(Vector128<sbyte> vector, byte index, sbyte data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Insert(Vector128<float> vector, byte index, float data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Insert(Vector128<ushort> vector, byte index, ushort data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Insert(Vector128<uint> vector, byte index, uint data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> Insert(Vector128<ulong> vector, byte index, ulong data)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> InsertScalar(Vector128<double> result, byte resultIndex, Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> InsertScalar(Vector128<long> result, byte resultIndex, Vector64<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> InsertScalar(Vector128<ulong> result, byte resultIndex, Vector64<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> LeadingSignCount(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> LeadingSignCount(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> LeadingSignCount(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> LeadingSignCount(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> LeadingSignCount(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> LeadingSignCount(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> LeadingZeroCount(Vector64<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> LeadingZeroCount(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> LeadingZeroCount(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> LeadingZeroCount(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> LeadingZeroCount(Vector64<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> LeadingZeroCount(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> LeadingZeroCount(Vector128<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> LeadingZeroCount(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> LeadingZeroCount(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> LeadingZeroCount(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> LeadingZeroCount(Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> LeadingZeroCount(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<byte> LoadAndInsertScalar(Vector64<byte> value, byte index, byte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<short> LoadAndInsertScalar(Vector64<short> value, byte index, short* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<int> LoadAndInsertScalar(Vector64<int> value, byte index, int* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<sbyte> LoadAndInsertScalar(Vector64<sbyte> value, byte index, sbyte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<float> LoadAndInsertScalar(Vector64<float> value, byte index, float* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<ushort> LoadAndInsertScalar(Vector64<ushort> value, byte index, ushort* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<uint> LoadAndInsertScalar(Vector64<uint> value, byte index, uint* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<byte> LoadAndInsertScalar(Vector128<byte> value, byte index, byte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<double> LoadAndInsertScalar(Vector128<double> value, byte index, double* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<short> LoadAndInsertScalar(Vector128<short> value, byte index, short* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<int> LoadAndInsertScalar(Vector128<int> value, byte index, int* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<long> LoadAndInsertScalar(Vector128<long> value, byte index, long* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<sbyte> LoadAndInsertScalar(Vector128<sbyte> value, byte index, sbyte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<float> LoadAndInsertScalar(Vector128<float> value, byte index, float* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<ushort> LoadAndInsertScalar(Vector128<ushort> value, byte index, ushort* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<uint> LoadAndInsertScalar(Vector128<uint> value, byte index, uint* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<ulong> LoadAndInsertScalar(Vector128<ulong> value, byte index, ulong* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<byte> LoadAndReplicateToVector64(byte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<short> LoadAndReplicateToVector64(short* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<int> LoadAndReplicateToVector64(int* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<sbyte> LoadAndReplicateToVector64(sbyte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<float> LoadAndReplicateToVector64(float* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<ushort> LoadAndReplicateToVector64(ushort* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<uint> LoadAndReplicateToVector64(uint* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<byte> LoadAndReplicateToVector128(byte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<short> LoadAndReplicateToVector128(short* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<int> LoadAndReplicateToVector128(int* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<sbyte> LoadAndReplicateToVector128(sbyte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<float> LoadAndReplicateToVector128(float* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<ushort> LoadAndReplicateToVector128(ushort* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<uint> LoadAndReplicateToVector128(uint* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<byte> LoadVector64(byte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<double> LoadVector64(double* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<short> LoadVector64(short* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<int> LoadVector64(int* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<long> LoadVector64(long* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<sbyte> LoadVector64(sbyte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<float> LoadVector64(float* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<ushort> LoadVector64(ushort* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<uint> LoadVector64(uint* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector64<ulong> LoadVector64(ulong* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<byte> LoadVector128(byte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<double> LoadVector128(double* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<short> LoadVector128(short* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<int> LoadVector128(int* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<long> LoadVector128(long* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<sbyte> LoadVector128(sbyte* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<float> LoadVector128(float* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<ushort> LoadVector128(ushort* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<uint> LoadVector128(uint* address)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static Vector128<ulong> LoadVector128(ulong* address)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Max(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Max(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Max(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Max(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Max(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Max(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Max(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Max(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Max(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Max(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MaxNumber(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> MaxNumber(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> MaxNumberScalar(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MaxNumberScalar(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> MaxPairwise(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MaxPairwise(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MaxPairwise(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> MaxPairwise(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MaxPairwise(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MaxPairwise(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MaxPairwise(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Min(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Min(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Min(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Min(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Min(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Min(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Min(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Min(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Min(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Min(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MinNumber(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> MinNumber(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> MinNumberScalar(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MinNumberScalar(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> MinPairwise(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MinPairwise(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MinPairwise(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> MinPairwise(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MinPairwise(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MinPairwise(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MinPairwise(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Multiply(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Multiply(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Multiply(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Multiply(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Multiply(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Multiply(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Multiply(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Multiply(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Multiply(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Multiply(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Multiply(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Multiply(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Multiply(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> MultiplyAdd(Vector64<byte> addend, Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyAdd(Vector64<short> addend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyAdd(Vector64<int> addend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> MultiplyAdd(Vector64<sbyte> addend, Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplyAdd(Vector64<ushort> addend, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplyAdd(Vector64<uint> addend, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> MultiplyAdd(Vector128<byte> addend, Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyAdd(Vector128<short> addend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyAdd(Vector128<int> addend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> MultiplyAdd(Vector128<sbyte> addend, Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyAdd(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyAdd(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyAddByScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyAddByScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplyAddByScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplyAddByScalar(Vector64<uint> addend, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyAddByScalar(Vector128<short> addend, Vector128<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyAddByScalar(Vector128<int> addend, Vector128<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyAddByScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyAddByScalar(Vector128<uint> addend, Vector128<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyAddBySelectedScalar(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyAddBySelectedScalar(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplyAddBySelectedScalar(Vector64<ushort> addend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplyAddBySelectedScalar(Vector64<uint> addend, Vector64<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyAddBySelectedScalar(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyAddBySelectedScalar(Vector128<int> addend, Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyAddBySelectedScalar(Vector128<ushort> addend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyAddBySelectedScalar(Vector128<uint> addend, Vector128<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyByScalar(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyByScalar(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MultiplyByScalar(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplyByScalar(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplyByScalar(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyByScalar(Vector128<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyByScalar(Vector128<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> MultiplyByScalar(Vector128<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyByScalar(Vector128<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyByScalar(Vector128<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MultiplyBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplyBySelectedScalar(Vector64<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplyBySelectedScalar(Vector64<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyBySelectedScalar(Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalar(Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector64<float> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> MultiplyBySelectedScalar(Vector128<float> left, Vector128<float> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyBySelectedScalar(Vector128<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalar(Vector128<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningLower(Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningLower(Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningLower(Vector64<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningLower(Vector64<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningUpper(Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningUpper(Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningUpper(Vector128<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningUpper(Vector128<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyDoublingByScalarSaturateHigh(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyDoublingByScalarSaturateHigh(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyDoublingByScalarSaturateHigh(Vector128<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingByScalarSaturateHigh(Vector128<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyDoublingSaturateHigh(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyDoublingSaturateHigh(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyDoublingSaturateHigh(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingSaturateHigh(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningLowerAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningLowerAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningLowerAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningLowerAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningLowerByScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningLowerByScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningSaturateLower(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningSaturateLower(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningSaturateLowerByScalar(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningSaturateLowerByScalar(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningSaturateUpper(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningSaturateUpper(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningSaturateUpperByScalar(Vector128<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningSaturateUpperByScalar(Vector128<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningUpperAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningUpperAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningUpperAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningUpperAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningUpperByScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningUpperByScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128<long> addend, Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<int> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128<long> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingByScalarSaturateHigh(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingByScalarSaturateHigh(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingByScalarSaturateHigh(Vector128<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingByScalarSaturateHigh(Vector128<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingSaturateHigh(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingSaturateHigh(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingSaturateHigh(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingSaturateHigh(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> MultiplyScalar(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MultiplyScalar(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector64<float> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> MultiplyScalarBySelectedScalar(Vector64<float> left, Vector128<float> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> MultiplySubtract(Vector64<byte> minuend, Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplySubtract(Vector64<short> minuend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplySubtract(Vector64<int> minuend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> MultiplySubtract(Vector64<sbyte> minuend, Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplySubtract(Vector64<ushort> minuend, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplySubtract(Vector64<uint> minuend, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> MultiplySubtract(Vector128<byte> minuend, Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplySubtract(Vector128<short> minuend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplySubtract(Vector128<int> minuend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> MultiplySubtract(Vector128<sbyte> minuend, Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplySubtract(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplySubtract(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplySubtractByScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplySubtractByScalar(Vector64<int> minuend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplySubtractByScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplySubtractByScalar(Vector64<uint> minuend, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplySubtractByScalar(Vector128<short> minuend, Vector128<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplySubtractByScalar(Vector128<int> minuend, Vector128<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplySubtractByScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplySubtractByScalar(Vector128<uint> minuend, Vector128<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplySubtractBySelectedScalar(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplySubtractBySelectedScalar(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> MultiplySubtractBySelectedScalar(Vector64<ushort> minuend, Vector64<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> MultiplySubtractBySelectedScalar(Vector64<uint> minuend, Vector64<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplySubtractBySelectedScalar(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplySubtractBySelectedScalar(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector64<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplySubtractBySelectedScalar(Vector128<ushort> minuend, Vector128<ushort> left, Vector128<ushort> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector64<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplySubtractBySelectedScalar(Vector128<uint> minuend, Vector128<uint> left, Vector128<uint> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyWideningLower(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyWideningLower(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyWideningLower(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyWideningLower(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyWideningLower(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyWideningLower(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyWideningLowerAndAdd(Vector128<ushort> addend, Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyWideningLowerAndAdd(Vector128<int> addend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyWideningLowerAndAdd(Vector128<long> addend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyWideningLowerAndAdd(Vector128<short> addend, Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyWideningLowerAndAdd(Vector128<uint> addend, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyWideningLowerAndAdd(Vector128<ulong> addend, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyWideningLowerAndSubtract(Vector128<ushort> minuend, Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyWideningLowerAndSubtract(Vector128<int> minuend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyWideningLowerAndSubtract(Vector128<long> minuend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyWideningLowerAndSubtract(Vector128<short> minuend, Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyWideningLowerAndSubtract(Vector128<uint> minuend, Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyWideningLowerAndSubtract(Vector128<ulong> minuend, Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyWideningUpper(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyWideningUpper(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyWideningUpper(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyWideningUpper(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyWideningUpper(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyWideningUpperAndAdd(Vector128<ushort> addend, Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyWideningUpperAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyWideningUpperAndAdd(Vector128<long> addend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyWideningUpperAndAdd(Vector128<short> addend, Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyWideningUpperAndAdd(Vector128<uint> addend, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyWideningUpperAndAdd(Vector128<ulong> addend, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> MultiplyWideningUpperAndSubtract(Vector128<ushort> minuend, Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyWideningUpperAndSubtract(Vector128<int> minuend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> MultiplyWideningUpperAndSubtract(Vector128<long> minuend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyWideningUpperAndSubtract(Vector128<short> minuend, Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> MultiplyWideningUpperAndSubtract(Vector128<uint> minuend, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> MultiplyWideningUpperAndSubtract(Vector128<ulong> minuend, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Negate(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Negate(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Negate(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Negate(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Negate(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Negate(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Negate(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Negate(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> NegateSaturate(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> NegateSaturate(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> NegateSaturate(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> NegateSaturate(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> NegateSaturate(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> NegateSaturate(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> NegateScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> NegateScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Not(Vector64<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> Not(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Not(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Not(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> Not(Vector64<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Not(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Not(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Not(Vector64<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Not(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> Not(Vector64<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Not(Vector128<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> Not(Vector128<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Not(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Not(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> Not(Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Not(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Not(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Not(Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Not(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> Not(Vector128<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Or(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> Or(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Or(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Or(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> Or(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Or(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Or(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Or(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Or(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> Or(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> Or(Vector128<double> left, Vector128<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Or(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Or(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> Or(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Or(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> OrNot(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> OrNot(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> OrNot(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> OrNot(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> OrNot(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> OrNot(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> OrNot(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> OrNot(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> OrNot(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> OrNot(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> OrNot(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> OrNot(Vector128<double> left, Vector128<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> OrNot(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> OrNot(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> OrNot(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> OrNot(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> OrNot(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> OrNot(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> OrNot(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> OrNot(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> PolynomialMultiply(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> PolynomialMultiply(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> PolynomialMultiply(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> PolynomialMultiply(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> PolynomialMultiplyWideningLower(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> PolynomialMultiplyWideningLower(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> PolynomialMultiplyWideningUpper(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> PolynomialMultiplyWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> PopCount(Vector64<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> PopCount(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> PopCount(Vector128<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> PopCount(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ReciprocalEstimate(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ReciprocalEstimate(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> ReciprocalEstimate(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ReciprocalEstimate(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ReciprocalSquareRootEstimate(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ReciprocalSquareRootEstimate(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> ReciprocalSquareRootEstimate(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ReciprocalSquareRootEstimate(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ReciprocalSquareRootStep(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> ReciprocalSquareRootStep(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> ReciprocalStep(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> ReciprocalStep(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ReverseElement16(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ReverseElement16(Vector64<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ReverseElement16(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ReverseElement16(Vector64<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ReverseElement16(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ReverseElement16(Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ReverseElement16(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ReverseElement16(Vector128<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ReverseElement32(Vector64<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ReverseElement32(Vector64<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ReverseElement32(Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ReverseElement32(Vector128<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ReverseElement8(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ReverseElement8(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ReverseElement8(Vector64<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ReverseElement8(Vector64<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ReverseElement8(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ReverseElement8(Vector64<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ReverseElement8(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ReverseElement8(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ReverseElement8(Vector128<long> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ReverseElement8(Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ReverseElement8(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ReverseElement8(Vector128<ulong> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundAwayFromZero(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> RoundAwayFromZero(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> RoundAwayFromZeroScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundAwayFromZeroScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundToNearest(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> RoundToNearest(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> RoundToNearestScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundToNearestScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundToNegativeInfinity(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> RoundToNegativeInfinityScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundToNegativeInfinityScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundToPositiveInfinity(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> RoundToPositiveInfinityScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundToPositiveInfinityScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundToZero(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> RoundToZero(Vector128<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> RoundToZeroScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> RoundToZeroScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftArithmetic(Vector64<short> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftArithmetic(Vector64<int> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftArithmetic(Vector64<sbyte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftArithmetic(Vector128<short> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftArithmetic(Vector128<int> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftArithmetic(Vector128<long> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftArithmetic(Vector128<sbyte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftArithmeticRounded(Vector64<short> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftArithmeticRounded(Vector64<int> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftArithmeticRounded(Vector64<sbyte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftArithmeticRounded(Vector128<short> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftArithmeticRounded(Vector128<int> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftArithmeticRounded(Vector128<long> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftArithmeticRounded(Vector128<sbyte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftArithmeticRoundedSaturate(Vector64<short> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftArithmeticRoundedSaturate(Vector64<int> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftArithmeticRoundedSaturate(Vector64<sbyte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftArithmeticRoundedSaturate(Vector128<short> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftArithmeticRoundedSaturate(Vector128<int> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftArithmeticRoundedSaturate(Vector128<long> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftArithmeticRoundedSaturate(Vector128<sbyte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftArithmeticRoundedSaturateScalar(Vector64<long> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftArithmeticRoundedScalar(Vector64<long> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftArithmeticSaturate(Vector64<short> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftArithmeticSaturate(Vector64<int> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftArithmeticSaturate(Vector64<sbyte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftArithmeticSaturate(Vector128<short> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftArithmeticSaturate(Vector128<int> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftArithmeticSaturate(Vector128<long> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftArithmeticSaturate(Vector128<sbyte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftArithmeticSaturateScalar(Vector64<long> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftArithmeticScalar(Vector64<long> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftLeftAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftLeftAndInsert(Vector64<short> left, Vector64<short> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftLeftAndInsert(Vector64<int> left, Vector64<int> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftLeftAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftLeftAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftLeftAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftLeftAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLeftAndInsert(Vector128<short> left, Vector128<short> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftLeftAndInsert(Vector128<int> left, Vector128<int> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLeftAndInsert(Vector128<long> left, Vector128<long> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftLeftAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLeftAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLeftAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLeftAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftLeftAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftLeftAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftLeftLogical(Vector64<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftLeftLogical(Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftLeftLogical(Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftLeftLogical(Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftLeftLogical(Vector64<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftLeftLogical(Vector64<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftLeftLogical(Vector128<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftLeftLogical(Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftLeftLogicalSaturate(Vector64<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftLeftLogicalSaturate(Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftLeftLogicalSaturate(Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftLeftLogicalSaturate(Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftLeftLogicalSaturate(Vector64<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftLeftLogicalSaturate(Vector64<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftLeftLogicalSaturate(Vector128<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLeftLogicalSaturate(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftLeftLogicalSaturate(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLeftLogicalSaturate(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftLeftLogicalSaturate(Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLeftLogicalSaturate(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLeftLogicalSaturate(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLeftLogicalSaturate(Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftLeftLogicalSaturateScalar(Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftLeftLogicalSaturateScalar(Vector64<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftLeftLogicalSaturateUnsigned(Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftLeftLogicalSaturateUnsigned(Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftLeftLogicalSaturateUnsigned(Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLeftLogicalSaturateUnsigned(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLeftLogicalSaturateUnsigned(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLeftLogicalSaturateUnsigned(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftLeftLogicalSaturateUnsigned(Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftLeftLogicalSaturateUnsignedScalar(Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftLeftLogicalScalar(Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftLeftLogicalScalar(Vector64<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLeftLogicalWideningLower(Vector64<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftLeftLogicalWideningLower(Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLeftLogicalWideningLower(Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLeftLogicalWideningLower(Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLeftLogicalWideningLower(Vector64<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLeftLogicalWideningLower(Vector64<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLeftLogicalWideningUpper(Vector128<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftLeftLogicalWideningUpper(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLeftLogicalWideningUpper(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLeftLogicalWideningUpper(Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLeftLogicalWideningUpper(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLeftLogicalWideningUpper(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftLogical(Vector64<byte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftLogical(Vector64<short> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftLogical(Vector64<int> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftLogical(Vector64<sbyte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftLogical(Vector64<ushort> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftLogical(Vector64<uint> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftLogical(Vector128<byte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLogical(Vector128<short> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftLogical(Vector128<int> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLogical(Vector128<long> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftLogical(Vector128<sbyte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLogical(Vector128<ushort> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLogical(Vector128<uint> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLogical(Vector128<ulong> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftLogicalRounded(Vector64<byte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftLogicalRounded(Vector64<short> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftLogicalRounded(Vector64<int> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftLogicalRounded(Vector64<sbyte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftLogicalRounded(Vector64<ushort> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftLogicalRounded(Vector64<uint> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftLogicalRounded(Vector128<byte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLogicalRounded(Vector128<short> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftLogicalRounded(Vector128<int> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLogicalRounded(Vector128<long> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftLogicalRounded(Vector128<sbyte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLogicalRounded(Vector128<ushort> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLogicalRounded(Vector128<uint> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLogicalRounded(Vector128<ulong> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftLogicalRoundedSaturate(Vector64<byte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftLogicalRoundedSaturate(Vector64<short> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftLogicalRoundedSaturate(Vector64<int> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftLogicalRoundedSaturate(Vector64<sbyte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftLogicalRoundedSaturate(Vector64<ushort> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftLogicalRoundedSaturate(Vector64<uint> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftLogicalRoundedSaturate(Vector128<byte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLogicalRoundedSaturate(Vector128<short> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftLogicalRoundedSaturate(Vector128<int> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLogicalRoundedSaturate(Vector128<long> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftLogicalRoundedSaturate(Vector128<sbyte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLogicalRoundedSaturate(Vector128<ushort> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLogicalRoundedSaturate(Vector128<uint> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLogicalRoundedSaturate(Vector128<ulong> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftLogicalRoundedSaturateScalar(Vector64<long> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftLogicalRoundedSaturateScalar(Vector64<ulong> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftLogicalRoundedScalar(Vector64<long> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftLogicalRoundedScalar(Vector64<ulong> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftLogicalSaturate(Vector64<byte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftLogicalSaturate(Vector64<short> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftLogicalSaturate(Vector64<int> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftLogicalSaturate(Vector64<sbyte> value, Vector64<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftLogicalSaturate(Vector64<ushort> value, Vector64<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftLogicalSaturate(Vector64<uint> value, Vector64<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftLogicalSaturate(Vector128<byte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftLogicalSaturate(Vector128<short> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftLogicalSaturate(Vector128<int> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftLogicalSaturate(Vector128<long> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftLogicalSaturate(Vector128<sbyte> value, Vector128<sbyte> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftLogicalSaturate(Vector128<ushort> value, Vector128<short> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftLogicalSaturate(Vector128<uint> value, Vector128<int> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftLogicalSaturate(Vector128<ulong> value, Vector128<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftLogicalSaturateScalar(Vector64<long> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftLogicalSaturateScalar(Vector64<ulong> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftLogicalScalar(Vector64<long> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftLogicalScalar(Vector64<ulong> value, Vector64<long> count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightAndInsert(Vector64<byte> left, Vector64<byte> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightAndInsert(Vector64<short> left, Vector64<short> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightAndInsert(Vector64<int> left, Vector64<int> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightAndInsert(Vector64<sbyte> left, Vector64<sbyte> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightAndInsert(Vector64<ushort> left, Vector64<ushort> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightAndInsert(Vector64<uint> left, Vector64<uint> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightAndInsert(Vector128<byte> left, Vector128<byte> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightAndInsert(Vector128<short> left, Vector128<short> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightAndInsert(Vector128<int> left, Vector128<int> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightAndInsert(Vector128<long> left, Vector128<long> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightAndInsert(Vector128<sbyte> left, Vector128<sbyte> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightAndInsert(Vector128<ushort> left, Vector128<ushort> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightAndInsert(Vector128<uint> left, Vector128<uint> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftRightAndInsert(Vector128<ulong> left, Vector128<ulong> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightAndInsertScalar(Vector64<long> left, Vector64<long> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftRightAndInsertScalar(Vector64<ulong> left, Vector64<ulong> right, byte shift)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightArithmetic(Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightArithmetic(Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightArithmetic(Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightArithmetic(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightArithmetic(Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightArithmeticAdd(Vector64<short> addend, Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightArithmeticAdd(Vector64<int> addend, Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightArithmeticAdd(Vector64<sbyte> addend, Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightArithmeticAdd(Vector128<short> addend, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightArithmeticAdd(Vector128<int> addend, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightArithmeticAdd(Vector128<long> addend, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightArithmeticAdd(Vector128<sbyte> addend, Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightArithmeticAddScalar(Vector64<long> addend, Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightArithmeticNarrowingSaturateLower(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightArithmeticNarrowingSaturateLower(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightArithmeticNarrowingSaturateLower(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightArithmeticNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightArithmeticRounded(Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightArithmeticRounded(Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightArithmeticRounded(Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightArithmeticRounded(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightArithmeticRounded(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightArithmeticRounded(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightArithmeticRounded(Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightArithmeticRoundedAdd(Vector64<short> addend, Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightArithmeticRoundedAdd(Vector64<int> addend, Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightArithmeticRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightArithmeticRoundedAdd(Vector128<short> addend, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightArithmeticRoundedAdd(Vector128<int> addend, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightArithmeticRoundedAdd(Vector128<long> addend, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightArithmeticRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightArithmeticRoundedAddScalar(Vector64<long> addend, Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<byte> lower, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<ushort> lower, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64<uint> lower, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightArithmeticRoundedScalar(Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightArithmeticScalar(Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightLogical(Vector64<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightLogical(Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightLogical(Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightLogical(Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightLogical(Vector64<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightLogical(Vector64<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightLogical(Vector128<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightLogical(Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightLogicalAdd(Vector64<byte> addend, Vector64<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightLogicalAdd(Vector64<short> addend, Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightLogicalAdd(Vector64<int> addend, Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightLogicalAdd(Vector64<sbyte> addend, Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightLogicalAdd(Vector64<ushort> addend, Vector64<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightLogicalAdd(Vector64<uint> addend, Vector64<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightLogicalAdd(Vector128<byte> addend, Vector128<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightLogicalAdd(Vector128<short> addend, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightLogicalAdd(Vector128<int> addend, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightLogicalAdd(Vector128<long> addend, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightLogicalAdd(Vector128<sbyte> addend, Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightLogicalAdd(Vector128<ushort> addend, Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightLogicalAdd(Vector128<uint> addend, Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftRightLogicalAdd(Vector128<ulong> addend, Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightLogicalAddScalar(Vector64<long> addend, Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftRightLogicalAddScalar(Vector64<ulong> addend, Vector64<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightLogicalNarrowingLower(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightLogicalNarrowingLower(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightLogicalNarrowingLower(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightLogicalNarrowingLower(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightLogicalNarrowingLower(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightLogicalNarrowingLower(Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightLogicalNarrowingSaturateLower(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightLogicalNarrowingSaturateLower(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightLogicalNarrowingSaturateLower(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightLogicalNarrowingSaturateLower(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightLogicalNarrowingSaturateLower(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightLogicalNarrowingSaturateLower(Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightLogicalNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightLogicalNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightLogicalNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightLogicalNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightLogicalNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightLogicalNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightLogicalNarrowingUpper(Vector64<short> lower, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightLogicalNarrowingUpper(Vector64<int> lower, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightLogicalNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightLogicalNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightLogicalNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightLogicalRounded(Vector64<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightLogicalRounded(Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightLogicalRounded(Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightLogicalRounded(Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightLogicalRounded(Vector64<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightLogicalRounded(Vector64<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightLogicalRounded(Vector128<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightLogicalRounded(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightLogicalRounded(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightLogicalRounded(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightLogicalRounded(Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightLogicalRounded(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightLogicalRounded(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftRightLogicalRounded(Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightLogicalRoundedAdd(Vector64<byte> addend, Vector64<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightLogicalRoundedAdd(Vector64<short> addend, Vector64<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightLogicalRoundedAdd(Vector64<int> addend, Vector64<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightLogicalRoundedAdd(Vector64<sbyte> addend, Vector64<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightLogicalRoundedAdd(Vector64<ushort> addend, Vector64<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightLogicalRoundedAdd(Vector64<uint> addend, Vector64<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightLogicalRoundedAdd(Vector128<byte> addend, Vector128<byte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightLogicalRoundedAdd(Vector128<short> addend, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightLogicalRoundedAdd(Vector128<int> addend, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ShiftRightLogicalRoundedAdd(Vector128<long> addend, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightLogicalRoundedAdd(Vector128<sbyte> addend, Vector128<sbyte> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightLogicalRoundedAdd(Vector128<ushort> addend, Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightLogicalRoundedAdd(Vector128<uint> addend, Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ShiftRightLogicalRoundedAdd(Vector128<ulong> addend, Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightLogicalRoundedAddScalar(Vector64<long> addend, Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftRightLogicalRoundedAddScalar(Vector64<ulong> addend, Vector64<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightLogicalRoundedNarrowingLower(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightLogicalRoundedNarrowingLower(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightLogicalRoundedNarrowingLower(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingLower(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingLower(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightLogicalRoundedNarrowingLower(Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<byte> lower, Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<short> lower, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<int> lower, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<sbyte> lower, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<ushort> lower, Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64<uint> lower, Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<byte> lower, Vector128<ushort> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ShiftRightLogicalRoundedNarrowingUpper(Vector64<short> lower, Vector128<int> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ShiftRightLogicalRoundedNarrowingUpper(Vector64<int> lower, Vector128<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> ShiftRightLogicalRoundedNarrowingUpper(Vector64<sbyte> lower, Vector128<short> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ShiftRightLogicalRoundedNarrowingUpper(Vector64<ushort> lower, Vector128<uint> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ShiftRightLogicalRoundedNarrowingUpper(Vector64<uint> lower, Vector128<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightLogicalRoundedScalar(Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftRightLogicalRoundedScalar(Vector64<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> ShiftRightLogicalScalar(Vector64<long> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> ShiftRightLogicalScalar(Vector64<ulong> value, byte count)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SignExtendWideningLower(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> SignExtendWideningLower(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SignExtendWideningLower(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SignExtendWideningUpper(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> SignExtendWideningUpper(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SignExtendWideningUpper(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> SqrtScalar(Vector64<double> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> SqrtScalar(Vector64<float> value)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(byte* address, Vector64<byte> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(double* address, Vector64<double> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(short* address, Vector64<short> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(int* address, Vector64<int> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(long* address, Vector64<long> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(sbyte* address, Vector64<sbyte> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(float* address, Vector64<float> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(ushort* address, Vector64<ushort> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(uint* address, Vector64<uint> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(ulong* address, Vector64<ulong> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(byte* address, Vector128<byte> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(double* address, Vector128<double> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(short* address, Vector128<short> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(int* address, Vector128<int> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(long* address, Vector128<long> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(sbyte* address, Vector128<sbyte> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(float* address, Vector128<float> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(ushort* address, Vector128<ushort> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(uint* address, Vector128<uint> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void Store(ulong* address, Vector128<ulong> source)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(byte* address, Vector64<byte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(short* address, Vector64<short> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(int* address, Vector64<int> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(sbyte* address, Vector64<sbyte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(float* address, Vector64<float> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(ushort* address, Vector64<ushort> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(uint* address, Vector64<uint> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(byte* address, Vector128<byte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(double* address, Vector128<double> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(short* address, Vector128<short> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(int* address, Vector128<int> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(long* address, Vector128<long> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(sbyte* address, Vector128<sbyte> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(float* address, Vector128<float> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(ushort* address, Vector128<ushort> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(uint* address, Vector128<uint> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public unsafe static void StoreSelectedScalar(ulong* address, Vector128<ulong> value, byte index)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Subtract(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Subtract(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Subtract(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Subtract(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Subtract(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Subtract(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Subtract(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> SubtractHighNarrowingLower(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> SubtractHighNarrowingLower(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> SubtractHighNarrowingLower(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> SubtractHighNarrowingLower(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> SubtractHighNarrowingLower(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> SubtractHighNarrowingLower(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> SubtractHighNarrowingUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SubtractHighNarrowingUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SubtractHighNarrowingUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> SubtractHighNarrowingUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> SubtractHighNarrowingUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> SubtractHighNarrowingUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> SubtractRoundedHighNarrowingLower(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> SubtractRoundedHighNarrowingLower(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> SubtractRoundedHighNarrowingLower(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> SubtractRoundedHighNarrowingLower(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> SubtractRoundedHighNarrowingLower(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> SubtractRoundedHighNarrowingLower(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> SubtractRoundedHighNarrowingUpper(Vector64<byte> lower, Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SubtractRoundedHighNarrowingUpper(Vector64<short> lower, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SubtractRoundedHighNarrowingUpper(Vector64<int> lower, Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> SubtractRoundedHighNarrowingUpper(Vector64<sbyte> lower, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> SubtractRoundedHighNarrowingUpper(Vector64<ushort> lower, Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> SubtractRoundedHighNarrowingUpper(Vector64<uint> lower, Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> SubtractSaturate(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> SubtractSaturate(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> SubtractSaturate(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> SubtractSaturate(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> SubtractSaturate(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> SubtractSaturate(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SubtractSaturate(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> SubtractSaturate(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> SubtractSaturate(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> SubtractSaturate(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> SubtractSaturateScalar(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> SubtractSaturateScalar(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> SubtractScalar(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> SubtractScalar(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> SubtractScalar(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> SubtractScalar(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> SubtractWideningLower(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SubtractWideningLower(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> SubtractWideningLower(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SubtractWideningLower(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> SubtractWideningLower(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> SubtractWideningLower(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SubtractWideningLower(Vector128<short> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SubtractWideningLower(Vector128<int> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> SubtractWideningLower(Vector128<long> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> SubtractWideningLower(Vector128<ushort> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> SubtractWideningLower(Vector128<uint> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> SubtractWideningLower(Vector128<ulong> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> SubtractWideningUpper(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SubtractWideningUpper(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SubtractWideningUpper(Vector128<short> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> SubtractWideningUpper(Vector128<int> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> SubtractWideningUpper(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> SubtractWideningUpper(Vector128<long> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> SubtractWideningUpper(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> SubtractWideningUpper(Vector128<ushort> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> SubtractWideningUpper(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> SubtractWideningUpper(Vector128<uint> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> SubtractWideningUpper(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> SubtractWideningUpper(Vector128<ulong> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> VectorTableLookup(Vector128<byte> table, Vector64<byte> byteIndexes)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> VectorTableLookup(Vector128<sbyte> table, Vector64<sbyte> byteIndexes)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> VectorTableLookupExtension(Vector64<byte> defaultValues, Vector128<byte> table, Vector64<byte> byteIndexes)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> VectorTableLookupExtension(Vector64<sbyte> defaultValues, Vector128<sbyte> table, Vector64<sbyte> byteIndexes)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<byte> Xor(Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<double> Xor(Vector64<double> left, Vector64<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> Xor(Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> Xor(Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<long> Xor(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<sbyte> Xor(Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<float> Xor(Vector64<float> left, Vector64<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ushort> Xor(Vector64<ushort> left, Vector64<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> Xor(Vector64<uint> left, Vector64<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<ulong> Xor(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ZeroExtendWideningLower(Vector64<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ZeroExtendWideningLower(Vector64<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ZeroExtendWideningLower(Vector64<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ZeroExtendWideningLower(Vector64<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ZeroExtendWideningLower(Vector64<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ZeroExtendWideningLower(Vector64<uint> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ushort> ZeroExtendWideningUpper(Vector128<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> ZeroExtendWideningUpper(Vector128<short> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> ZeroExtendWideningUpper(Vector128<int> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> ZeroExtendWideningUpper(Vector128<sbyte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ZeroExtendWideningUpper(Vector128<ushort> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> ZeroExtendWideningUpper(Vector128<uint> value)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[CLSCompliant(false)]
	public abstract class Aes : ArmBase
	{
		public new abstract class Arm64 : ArmBase.Arm64
		{
			public new static bool IsSupported
			{
				[Intrinsic]
				get
				{
					return false;
				}
			}
		}

		public new static bool IsSupported
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> InverseMixColumns(Vector128<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<byte> MixColumns(Vector128<byte> value)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> PolynomialMultiplyWideningLower(Vector64<long> left, Vector64<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> PolynomialMultiplyWideningLower(Vector64<ulong> left, Vector64<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<long> PolynomialMultiplyWideningUpper(Vector128<long> left, Vector128<long> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<ulong> PolynomialMultiplyWideningUpper(Vector128<ulong> left, Vector128<ulong> right)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[CLSCompliant(false)]
	public abstract class ArmBase
	{
		public abstract class Arm64
		{
			public static bool IsSupported
			{
				[Intrinsic]
				get
				{
					return false;
				}
			}

			public static int LeadingSignCount(int value)
			{
				throw new PlatformNotSupportedException();
			}

			public static int LeadingSignCount(long value)
			{
				throw new PlatformNotSupportedException();
			}

			public static int LeadingZeroCount(long value)
			{
				throw new PlatformNotSupportedException();
			}

			public static int LeadingZeroCount(ulong value)
			{
				throw new PlatformNotSupportedException();
			}

			public static long MultiplyHigh(long left, long right)
			{
				throw new PlatformNotSupportedException();
			}

			public static ulong MultiplyHigh(ulong left, ulong right)
			{
				throw new PlatformNotSupportedException();
			}

			public static long ReverseElementBits(long value)
			{
				throw new PlatformNotSupportedException();
			}

			public static ulong ReverseElementBits(ulong value)
			{
				throw new PlatformNotSupportedException();
			}
		}

		public static bool IsSupported
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		public static int LeadingZeroCount(int value)
		{
			throw new PlatformNotSupportedException();
		}

		public static int LeadingZeroCount(uint value)
		{
			throw new PlatformNotSupportedException();
		}

		public static int ReverseElementBits(int value)
		{
			throw new PlatformNotSupportedException();
		}

		public static uint ReverseElementBits(uint value)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Crc32 : ArmBase
	{
		[Intrinsic]
		public new abstract class Arm64 : ArmBase.Arm64
		{
			public new static bool IsSupported
			{
				[Intrinsic]
				get
				{
					return false;
				}
			}

			public static uint ComputeCrc32(uint crc, ulong data)
			{
				throw new PlatformNotSupportedException();
			}

			public static uint ComputeCrc32C(uint crc, ulong data)
			{
				throw new PlatformNotSupportedException();
			}
		}

		public new static bool IsSupported
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		public static uint ComputeCrc32(uint crc, byte data)
		{
			throw new PlatformNotSupportedException();
		}

		public static uint ComputeCrc32(uint crc, ushort data)
		{
			throw new PlatformNotSupportedException();
		}

		public static uint ComputeCrc32(uint crc, uint data)
		{
			throw new PlatformNotSupportedException();
		}

		public static uint ComputeCrc32C(uint crc, byte data)
		{
			throw new PlatformNotSupportedException();
		}

		public static uint ComputeCrc32C(uint crc, ushort data)
		{
			throw new PlatformNotSupportedException();
		}

		public static uint ComputeCrc32C(uint crc, uint data)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[CLSCompliant(false)]
	public abstract class Dp : AdvSimd
	{
		public new abstract class Arm64 : AdvSimd.Arm64
		{
			public new static bool IsSupported
			{
				[Intrinsic]
				get
				{
					return false;
				}
			}
		}

		public new static bool IsSupported
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		public static Vector64<int> DotProduct(Vector64<int> addend, Vector64<sbyte> left, Vector64<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> DotProduct(Vector64<uint> addend, Vector64<byte> left, Vector64<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> DotProduct(Vector128<int> addend, Vector128<sbyte> left, Vector128<sbyte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> DotProduct(Vector128<uint> addend, Vector128<byte> left, Vector128<byte> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector64<sbyte> right, byte rightScaledIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> DotProductBySelectedQuadruplet(Vector64<int> addend, Vector64<sbyte> left, Vector128<sbyte> right, byte rightScaledIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector64<byte> right, byte rightScaledIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<uint> DotProductBySelectedQuadruplet(Vector64<uint> addend, Vector64<byte> left, Vector128<byte> right, byte rightScaledIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector128<sbyte> right, byte rightScaledIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> DotProductBySelectedQuadruplet(Vector128<int> addend, Vector128<sbyte> left, Vector64<sbyte> right, byte rightScaledIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector128<byte> right, byte rightScaledIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> DotProductBySelectedQuadruplet(Vector128<uint> addend, Vector128<byte> left, Vector64<byte> right, byte rightScaledIndex)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[CLSCompliant(false)]
	public abstract class Rdm : AdvSimd
	{
		public new abstract class Arm64 : AdvSimd.Arm64
		{
			public new static bool IsSupported
			{
				[Intrinsic]
				get
				{
					return false;
				}
			}

			public static Vector64<short> MultiplyRoundedDoublingAndAddSaturateHighScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingAndAddSaturateHighScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyRoundedDoublingAndSubtractSaturateHighScalar(Vector64<short> addend, Vector64<short> left, Vector64<short> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingAndSubtractSaturateHighScalar(Vector64<int> addend, Vector64<int> left, Vector64<int> right)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<short> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}

			public static Vector64<int> MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex)
			{
				throw new PlatformNotSupportedException();
			}
		}

		public new static bool IsSupported
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		public static Vector64<short> MultiplyRoundedDoublingAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector128<int> right)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<short> addend, Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64<int> addend, Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<short> addend, Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128<int> addend, Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<short> minuend, Vector64<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector64<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64<int> minuend, Vector64<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector64<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<short> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<short> minuend, Vector128<short> left, Vector128<short> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector64<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<int> MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128<int> minuend, Vector128<int> left, Vector128<int> right, byte rightIndex)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[CLSCompliant(false)]
	public abstract class Sha1 : ArmBase
	{
		public new abstract class Arm64 : ArmBase.Arm64
		{
			public new static bool IsSupported
			{
				[Intrinsic]
				get
				{
					return false;
				}
			}
		}

		public new static bool IsSupported
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		public static Vector64<uint> FixedRotate(Vector64<uint> hash_e)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> HashUpdateChoose(Vector128<uint> hash_abcd, Vector64<uint> hash_e, Vector128<uint> wk)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> HashUpdateMajority(Vector128<uint> hash_abcd, Vector64<uint> hash_e, Vector128<uint> wk)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> HashUpdateParity(Vector128<uint> hash_abcd, Vector64<uint> hash_e, Vector128<uint> wk)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ScheduleUpdate0(Vector128<uint> w0_3, Vector128<uint> w4_7, Vector128<uint> w8_11)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ScheduleUpdate1(Vector128<uint> tw0_3, Vector128<uint> w12_15)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[CLSCompliant(false)]
	public abstract class Sha256 : ArmBase
	{
		public new abstract class Arm64 : ArmBase.Arm64
		{
			public new static bool IsSupported
			{
				[Intrinsic]
				get
				{
					return false;
				}
			}
		}

		public new static bool IsSupported
		{
			[Intrinsic]
			get
			{
				return false;
			}
		}

		public static Vector128<uint> HashUpdate1(Vector128<uint> hash_abcd, Vector128<uint> hash_efgh, Vector128<uint> wk)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> HashUpdate2(Vector128<uint> hash_efgh, Vector128<uint> hash_abcd, Vector128<uint> wk)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ScheduleUpdate0(Vector128<uint> w0_3, Vector128<uint> w4_7)
		{
			throw new PlatformNotSupportedException();
		}

		public static Vector128<uint> ScheduleUpdate1(Vector128<uint> w0_3, Vector128<uint> w8_11, Vector128<uint> w12_15)
		{
			throw new PlatformNotSupportedException();
		}
	}
}
namespace System.Runtime.Intrinsics.X86
{
	[Intrinsic]
	public abstract class X86Base
	{
		[Intrinsic]
		public abstract class X64
		{
			public static bool IsSupported => IsSupported;

			internal static ulong BitScanForward(ulong value)
			{
				return BitScanForward(value);
			}

			internal static ulong BitScanReverse(ulong value)
			{
				return BitScanReverse(value);
			}
		}

		public static bool IsSupported => IsSupported;

		[DllImport("QCall")]
		private unsafe static extern void __cpuidex(int* cpuInfo, int functionId, int subFunctionId);

		internal static uint BitScanForward(uint value)
		{
			return BitScanForward(value);
		}

		internal static uint BitScanReverse(uint value)
		{
			return BitScanReverse(value);
		}

		public unsafe static (int Eax, int Ebx, int Ecx, int Edx) CpuId(int functionId, int subFunctionId)
		{
			int* ptr = stackalloc int[4];
			__cpuidex(ptr, functionId, subFunctionId);
			return (*ptr, ptr[1], ptr[2], ptr[3]);
		}
	}
	public enum FloatComparisonMode : byte
	{
		OrderedEqualNonSignaling,
		OrderedLessThanSignaling,
		OrderedLessThanOrEqualSignaling,
		UnorderedNonSignaling,
		UnorderedNotEqualNonSignaling,
		UnorderedNotLessThanSignaling,
		UnorderedNotLessThanOrEqualSignaling,
		OrderedNonSignaling,
		UnorderedEqualNonSignaling,
		UnorderedNotGreaterThanOrEqualSignaling,
		UnorderedNotGreaterThanSignaling,
		OrderedFalseNonSignaling,
		OrderedNotEqualNonSignaling,
		OrderedGreaterThanOrEqualSignaling,
		OrderedGreaterThanSignaling,
		UnorderedTrueNonSignaling,
		OrderedEqualSignaling,
		OrderedLessThanNonSignaling,
		OrderedLessThanOrEqualNonSignaling,
		UnorderedSignaling,
		UnorderedNotEqualSignaling,
		UnorderedNotLessThanNonSignaling,
		UnorderedNotLessThanOrEqualNonSignaling,
		OrderedSignaling,
		UnorderedEqualSignaling,
		UnorderedNotGreaterThanOrEqualNonSignaling,
		UnorderedNotGreaterThanNonSignaling,
		OrderedFalseSignaling,
		OrderedNotEqualSignaling,
		OrderedGreaterThanOrEqualNonSignaling,
		OrderedGreaterThanNonSignaling,
		UnorderedTrueSignaling
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Aes : Sse2
	{
		[Intrinsic]
		public new abstract class X64 : Sse2.X64
		{
			public new static bool IsSupported => IsSupported;
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<byte> Decrypt(Vector128<byte> value, Vector128<byte> roundKey)
		{
			return Decrypt(value, roundKey);
		}

		public static Vector128<byte> DecryptLast(Vector128<byte> value, Vector128<byte> roundKey)
		{
			return DecryptLast(value, roundKey);
		}

		public static Vector128<byte> Encrypt(Vector128<byte> value, Vector128<byte> roundKey)
		{
			return Encrypt(value, roundKey);
		}

		public static Vector128<byte> EncryptLast(Vector128<byte> value, Vector128<byte> roundKey)
		{
			return EncryptLast(value, roundKey);
		}

		public static Vector128<byte> InverseMixColumns(Vector128<byte> value)
		{
			return InverseMixColumns(value);
		}

		public static Vector128<byte> KeygenAssist(Vector128<byte> value, byte control)
		{
			return KeygenAssist(value, control);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Avx : Sse42
	{
		[Intrinsic]
		public new abstract class X64 : Sse42.X64
		{
			public new static bool IsSupported => IsSupported;
		}

		public new static bool IsSupported => IsSupported;

		public static Vector256<float> Add(Vector256<float> left, Vector256<float> right)
		{
			return Add(left, right);
		}

		public static Vector256<double> Add(Vector256<double> left, Vector256<double> right)
		{
			return Add(left, right);
		}

		public static Vector256<float> AddSubtract(Vector256<float> left, Vector256<float> right)
		{
			return AddSubtract(left, right);
		}

		public static Vector256<double> AddSubtract(Vector256<double> left, Vector256<double> right)
		{
			return AddSubtract(left, right);
		}

		public static Vector256<float> And(Vector256<float> left, Vector256<float> right)
		{
			return And(left, right);
		}

		public static Vector256<double> And(Vector256<double> left, Vector256<double> right)
		{
			return And(left, right);
		}

		public static Vector256<float> AndNot(Vector256<float> left, Vector256<float> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<double> AndNot(Vector256<double> left, Vector256<double> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<float> Blend(Vector256<float> left, Vector256<float> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector256<double> Blend(Vector256<double> left, Vector256<double> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector256<float> BlendVariable(Vector256<float> left, Vector256<float> right, Vector256<float> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector256<double> BlendVariable(Vector256<double> left, Vector256<double> right, Vector256<double> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public unsafe static Vector128<float> BroadcastScalarToVector128(float* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public unsafe static Vector256<float> BroadcastScalarToVector256(float* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<double> BroadcastScalarToVector256(double* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<float> BroadcastVector128ToVector256(float* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public unsafe static Vector256<double> BroadcastVector128ToVector256(double* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public static Vector256<float> Ceiling(Vector256<float> value)
		{
			return Ceiling(value);
		}

		public static Vector256<double> Ceiling(Vector256<double> value)
		{
			return Ceiling(value);
		}

		public static Vector128<float> Compare(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode)
		{
			return Compare(left, right, mode);
		}

		public static Vector128<double> Compare(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode)
		{
			return Compare(left, right, mode);
		}

		public static Vector256<float> Compare(Vector256<float> left, Vector256<float> right, FloatComparisonMode mode)
		{
			return Compare(left, right, mode);
		}

		public static Vector256<double> Compare(Vector256<double> left, Vector256<double> right, FloatComparisonMode mode)
		{
			return Compare(left, right, mode);
		}

		public static Vector256<float> CompareEqual(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedEqualNonSignaling);
		}

		public static Vector256<double> CompareEqual(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedEqualNonSignaling);
		}

		public static Vector256<float> CompareGreaterThan(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedGreaterThanSignaling);
		}

		public static Vector256<double> CompareGreaterThan(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedGreaterThanSignaling);
		}

		public static Vector256<float> CompareGreaterThanOrEqual(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedGreaterThanOrEqualSignaling);
		}

		public static Vector256<double> CompareGreaterThanOrEqual(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedGreaterThanOrEqualSignaling);
		}

		public static Vector256<float> CompareLessThan(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedLessThanSignaling);
		}

		public static Vector256<double> CompareLessThan(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedLessThanSignaling);
		}

		public static Vector256<float> CompareLessThanOrEqual(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedLessThanOrEqualSignaling);
		}

		public static Vector256<double> CompareLessThanOrEqual(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedLessThanOrEqualSignaling);
		}

		public static Vector256<float> CompareNotEqual(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotEqualNonSignaling);
		}

		public static Vector256<double> CompareNotEqual(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotEqualNonSignaling);
		}

		public static Vector256<float> CompareNotGreaterThan(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotGreaterThanSignaling);
		}

		public static Vector256<double> CompareNotGreaterThan(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotGreaterThanSignaling);
		}

		public static Vector256<float> CompareNotGreaterThanOrEqual(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotGreaterThanOrEqualSignaling);
		}

		public static Vector256<double> CompareNotGreaterThanOrEqual(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotGreaterThanOrEqualSignaling);
		}

		public static Vector256<float> CompareNotLessThan(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotLessThanSignaling);
		}

		public static Vector256<double> CompareNotLessThan(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotLessThanSignaling);
		}

		public static Vector256<float> CompareNotLessThanOrEqual(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotLessThanOrEqualSignaling);
		}

		public static Vector256<double> CompareNotLessThanOrEqual(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNotLessThanOrEqualSignaling);
		}

		public static Vector256<float> CompareOrdered(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedNonSignaling);
		}

		public static Vector256<double> CompareOrdered(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.OrderedNonSignaling);
		}

		public static Vector128<double> CompareScalar(Vector128<double> left, Vector128<double> right, FloatComparisonMode mode)
		{
			return CompareScalar(left, right, mode);
		}

		public static Vector128<float> CompareScalar(Vector128<float> left, Vector128<float> right, FloatComparisonMode mode)
		{
			return CompareScalar(left, right, mode);
		}

		public static Vector256<float> CompareUnordered(Vector256<float> left, Vector256<float> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNonSignaling);
		}

		public static Vector256<double> CompareUnordered(Vector256<double> left, Vector256<double> right)
		{
			return Compare(left, right, FloatComparisonMode.UnorderedNonSignaling);
		}

		public static Vector128<int> ConvertToVector128Int32(Vector256<double> value)
		{
			return ConvertToVector128Int32(value);
		}

		public static Vector128<float> ConvertToVector128Single(Vector256<double> value)
		{
			return ConvertToVector128Single(value);
		}

		public static Vector256<int> ConvertToVector256Int32(Vector256<float> value)
		{
			return ConvertToVector256Int32(value);
		}

		public static Vector256<float> ConvertToVector256Single(Vector256<int> value)
		{
			return ConvertToVector256Single(value);
		}

		public static Vector256<double> ConvertToVector256Double(Vector128<float> value)
		{
			return ConvertToVector256Double(value);
		}

		public static Vector256<double> ConvertToVector256Double(Vector128<int> value)
		{
			return ConvertToVector256Double(value);
		}

		public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector256<double> value)
		{
			return ConvertToVector128Int32WithTruncation(value);
		}

		public static Vector256<int> ConvertToVector256Int32WithTruncation(Vector256<float> value)
		{
			return ConvertToVector256Int32WithTruncation(value);
		}

		public static Vector256<float> Divide(Vector256<float> left, Vector256<float> right)
		{
			return Divide(left, right);
		}

		public static Vector256<double> Divide(Vector256<double> left, Vector256<double> right)
		{
			return Divide(left, right);
		}

		public static Vector256<float> DotProduct(Vector256<float> left, Vector256<float> right, byte control)
		{
			return DotProduct(left, right, control);
		}

		public static Vector256<float> DuplicateEvenIndexed(Vector256<float> value)
		{
			return DuplicateEvenIndexed(value);
		}

		public static Vector256<double> DuplicateEvenIndexed(Vector256<double> value)
		{
			return DuplicateEvenIndexed(value);
		}

		public static Vector256<float> DuplicateOddIndexed(Vector256<float> value)
		{
			return DuplicateOddIndexed(value);
		}

		public static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<short> ExtractVector128(Vector256<short> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<int> ExtractVector128(Vector256<int> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<long> ExtractVector128(Vector256<long> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<float> ExtractVector128(Vector256<float> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector128<double> ExtractVector128(Vector256<double> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public static Vector256<float> Floor(Vector256<float> value)
		{
			return Floor(value);
		}

		public static Vector256<double> Floor(Vector256<double> value)
		{
			return Floor(value);
		}

		public static Vector256<float> HorizontalAdd(Vector256<float> left, Vector256<float> right)
		{
			return HorizontalAdd(left, right);
		}

		public static Vector256<double> HorizontalAdd(Vector256<double> left, Vector256<double> right)
		{
			return HorizontalAdd(left, right);
		}

		public static Vector256<float> HorizontalSubtract(Vector256<float> left, Vector256<float> right)
		{
			return HorizontalSubtract(left, right);
		}

		public static Vector256<double> HorizontalSubtract(Vector256<double> left, Vector256<double> right)
		{
			return HorizontalSubtract(left, right);
		}

		public static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<float> InsertVector128(Vector256<float> value, Vector128<float> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public static Vector256<double> InsertVector128(Vector256<double> value, Vector128<double> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public unsafe static Vector256<sbyte> LoadVector256(sbyte* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<byte> LoadVector256(byte* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<short> LoadVector256(short* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<ushort> LoadVector256(ushort* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<int> LoadVector256(int* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<uint> LoadVector256(uint* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<long> LoadVector256(long* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<ulong> LoadVector256(ulong* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<float> LoadVector256(float* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<double> LoadVector256(double* address)
		{
			return LoadVector256(address);
		}

		public unsafe static Vector256<sbyte> LoadAlignedVector256(sbyte* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<byte> LoadAlignedVector256(byte* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<short> LoadAlignedVector256(short* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<ushort> LoadAlignedVector256(ushort* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<int> LoadAlignedVector256(int* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<uint> LoadAlignedVector256(uint* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<long> LoadAlignedVector256(long* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<ulong> LoadAlignedVector256(ulong* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<float> LoadAlignedVector256(float* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<double> LoadAlignedVector256(double* address)
		{
			return LoadAlignedVector256(address);
		}

		public unsafe static Vector256<sbyte> LoadDquVector256(sbyte* address)
		{
			return LoadDquVector256(address);
		}

		public unsafe static Vector256<byte> LoadDquVector256(byte* address)
		{
			return LoadDquVector256(address);
		}

		public unsafe static Vector256<short> LoadDquVector256(short* address)
		{
			return LoadDquVector256(address);
		}

		public unsafe static Vector256<ushort> LoadDquVector256(ushort* address)
		{
			return LoadDquVector256(address);
		}

		public unsafe static Vector256<int> LoadDquVector256(int* address)
		{
			return LoadDquVector256(address);
		}

		public unsafe static Vector256<uint> LoadDquVector256(uint* address)
		{
			return LoadDquVector256(address);
		}

		public unsafe static Vector256<long> LoadDquVector256(long* address)
		{
			return LoadDquVector256(address);
		}

		public unsafe static Vector256<ulong> LoadDquVector256(ulong* address)
		{
			return LoadDquVector256(address);
		}

		public unsafe static Vector128<float> MaskLoad(float* address, Vector128<float> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector128<double> MaskLoad(double* address, Vector128<double> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector256<float> MaskLoad(float* address, Vector256<float> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector256<double> MaskLoad(double* address, Vector256<double> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static void MaskStore(float* address, Vector128<float> mask, Vector128<float> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(double* address, Vector128<double> mask, Vector128<double> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(float* address, Vector256<float> mask, Vector256<float> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(double* address, Vector256<double> mask, Vector256<double> source)
		{
			MaskStore(address, mask, source);
		}

		public static Vector256<float> Max(Vector256<float> left, Vector256<float> right)
		{
			return Max(left, right);
		}

		public static Vector256<double> Max(Vector256<double> left, Vector256<double> right)
		{
			return Max(left, right);
		}

		public static Vector256<float> Min(Vector256<float> left, Vector256<float> right)
		{
			return Min(left, right);
		}

		public static Vector256<double> Min(Vector256<double> left, Vector256<double> right)
		{
			return Min(left, right);
		}

		public static int MoveMask(Vector256<float> value)
		{
			return MoveMask(value);
		}

		public static int MoveMask(Vector256<double> value)
		{
			return MoveMask(value);
		}

		public static Vector256<float> Multiply(Vector256<float> left, Vector256<float> right)
		{
			return Multiply(left, right);
		}

		public static Vector256<double> Multiply(Vector256<double> left, Vector256<double> right)
		{
			return Multiply(left, right);
		}

		public static Vector256<float> Or(Vector256<float> left, Vector256<float> right)
		{
			return Or(left, right);
		}

		public static Vector256<double> Or(Vector256<double> left, Vector256<double> right)
		{
			return Or(left, right);
		}

		public static Vector128<float> Permute(Vector128<float> value, byte control)
		{
			return Permute(value, control);
		}

		public static Vector128<double> Permute(Vector128<double> value, byte control)
		{
			return Permute(value, control);
		}

		public static Vector256<float> Permute(Vector256<float> value, byte control)
		{
			return Permute(value, control);
		}

		public static Vector256<double> Permute(Vector256<double> value, byte control)
		{
			return Permute(value, control);
		}

		public static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<float> Permute2x128(Vector256<float> left, Vector256<float> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<double> Permute2x128(Vector256<double> left, Vector256<double> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector128<float> PermuteVar(Vector128<float> left, Vector128<int> control)
		{
			return PermuteVar(left, control);
		}

		public static Vector128<double> PermuteVar(Vector128<double> left, Vector128<long> control)
		{
			return PermuteVar(left, control);
		}

		public static Vector256<float> PermuteVar(Vector256<float> left, Vector256<int> control)
		{
			return PermuteVar(left, control);
		}

		public static Vector256<double> PermuteVar(Vector256<double> left, Vector256<long> control)
		{
			return PermuteVar(left, control);
		}

		public static Vector256<float> Reciprocal(Vector256<float> value)
		{
			return Reciprocal(value);
		}

		public static Vector256<float> ReciprocalSqrt(Vector256<float> value)
		{
			return ReciprocalSqrt(value);
		}

		public static Vector256<float> RoundToNearestInteger(Vector256<float> value)
		{
			return RoundToNearestInteger(value);
		}

		public static Vector256<float> RoundToNegativeInfinity(Vector256<float> value)
		{
			return RoundToNegativeInfinity(value);
		}

		public static Vector256<float> RoundToPositiveInfinity(Vector256<float> value)
		{
			return RoundToPositiveInfinity(value);
		}

		public static Vector256<float> RoundToZero(Vector256<float> value)
		{
			return RoundToZero(value);
		}

		public static Vector256<float> RoundCurrentDirection(Vector256<float> value)
		{
			return RoundCurrentDirection(value);
		}

		public static Vector256<double> RoundToNearestInteger(Vector256<double> value)
		{
			return RoundToNearestInteger(value);
		}

		public static Vector256<double> RoundToNegativeInfinity(Vector256<double> value)
		{
			return RoundToNegativeInfinity(value);
		}

		public static Vector256<double> RoundToPositiveInfinity(Vector256<double> value)
		{
			return RoundToPositiveInfinity(value);
		}

		public static Vector256<double> RoundToZero(Vector256<double> value)
		{
			return RoundToZero(value);
		}

		public static Vector256<double> RoundCurrentDirection(Vector256<double> value)
		{
			return RoundCurrentDirection(value);
		}

		public static Vector256<float> Shuffle(Vector256<float> value, Vector256<float> right, byte control)
		{
			return Shuffle(value, right, control);
		}

		public static Vector256<double> Shuffle(Vector256<double> value, Vector256<double> right, byte control)
		{
			return Shuffle(value, right, control);
		}

		public static Vector256<float> Sqrt(Vector256<float> value)
		{
			return Sqrt(value);
		}

		public static Vector256<double> Sqrt(Vector256<double> value)
		{
			return Sqrt(value);
		}

		public unsafe static void StoreAligned(sbyte* address, Vector256<sbyte> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(byte* address, Vector256<byte> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(short* address, Vector256<short> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(ushort* address, Vector256<ushort> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(int* address, Vector256<int> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(uint* address, Vector256<uint> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(long* address, Vector256<long> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(ulong* address, Vector256<ulong> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(float* address, Vector256<float> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(double* address, Vector256<double> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(sbyte* address, Vector256<sbyte> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(byte* address, Vector256<byte> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(short* address, Vector256<short> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(ushort* address, Vector256<ushort> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(int* address, Vector256<int> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(uint* address, Vector256<uint> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(long* address, Vector256<long> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(ulong* address, Vector256<ulong> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(float* address, Vector256<float> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(double* address, Vector256<double> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void Store(sbyte* address, Vector256<sbyte> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(byte* address, Vector256<byte> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(short* address, Vector256<short> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(ushort* address, Vector256<ushort> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(int* address, Vector256<int> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(uint* address, Vector256<uint> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(long* address, Vector256<long> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(ulong* address, Vector256<ulong> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(float* address, Vector256<float> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(double* address, Vector256<double> source)
		{
			Store(address, source);
		}

		public static Vector256<float> Subtract(Vector256<float> left, Vector256<float> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<double> Subtract(Vector256<double> left, Vector256<double> right)
		{
			return Subtract(left, right);
		}

		public static bool TestC(Vector128<float> left, Vector128<float> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector128<double> left, Vector128<double> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<byte> left, Vector256<byte> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<short> left, Vector256<short> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<ushort> left, Vector256<ushort> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<int> left, Vector256<int> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<uint> left, Vector256<uint> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<long> left, Vector256<long> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<ulong> left, Vector256<ulong> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<float> left, Vector256<float> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector256<double> left, Vector256<double> right)
		{
			return TestC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<float> left, Vector128<float> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<double> left, Vector128<double> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<byte> left, Vector256<byte> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<short> left, Vector256<short> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<ushort> left, Vector256<ushort> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<int> left, Vector256<int> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<uint> left, Vector256<uint> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<long> left, Vector256<long> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<ulong> left, Vector256<ulong> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<float> left, Vector256<float> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector256<double> left, Vector256<double> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestZ(Vector128<float> left, Vector128<float> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector128<double> left, Vector128<double> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<byte> left, Vector256<byte> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<short> left, Vector256<short> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<ushort> left, Vector256<ushort> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<int> left, Vector256<int> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<uint> left, Vector256<uint> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<long> left, Vector256<long> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<ulong> left, Vector256<ulong> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<float> left, Vector256<float> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector256<double> left, Vector256<double> right)
		{
			return TestZ(left, right);
		}

		public static Vector256<float> UnpackHigh(Vector256<float> left, Vector256<float> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<double> UnpackHigh(Vector256<double> left, Vector256<double> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<float> UnpackLow(Vector256<float> left, Vector256<float> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<double> UnpackLow(Vector256<double> left, Vector256<double> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<float> Xor(Vector256<float> left, Vector256<float> right)
		{
			return Xor(left, right);
		}

		public static Vector256<double> Xor(Vector256<double> left, Vector256<double> right)
		{
			return Xor(left, right);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Avx2 : Avx
	{
		[Intrinsic]
		public new abstract class X64 : Avx.X64
		{
			public new static bool IsSupported => IsSupported;
		}

		public new static bool IsSupported => IsSupported;

		public static Vector256<byte> Abs(Vector256<sbyte> value)
		{
			return Abs(value);
		}

		public static Vector256<ushort> Abs(Vector256<short> value)
		{
			return Abs(value);
		}

		public static Vector256<uint> Abs(Vector256<int> value)
		{
			return Abs(value);
		}

		public static Vector256<sbyte> Add(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return Add(left, right);
		}

		public static Vector256<byte> Add(Vector256<byte> left, Vector256<byte> right)
		{
			return Add(left, right);
		}

		public static Vector256<short> Add(Vector256<short> left, Vector256<short> right)
		{
			return Add(left, right);
		}

		public static Vector256<ushort> Add(Vector256<ushort> left, Vector256<ushort> right)
		{
			return Add(left, right);
		}

		public static Vector256<int> Add(Vector256<int> left, Vector256<int> right)
		{
			return Add(left, right);
		}

		public static Vector256<uint> Add(Vector256<uint> left, Vector256<uint> right)
		{
			return Add(left, right);
		}

		public static Vector256<long> Add(Vector256<long> left, Vector256<long> right)
		{
			return Add(left, right);
		}

		public static Vector256<ulong> Add(Vector256<ulong> left, Vector256<ulong> right)
		{
			return Add(left, right);
		}

		public static Vector256<sbyte> AddSaturate(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return AddSaturate(left, right);
		}

		public static Vector256<byte> AddSaturate(Vector256<byte> left, Vector256<byte> right)
		{
			return AddSaturate(left, right);
		}

		public static Vector256<short> AddSaturate(Vector256<short> left, Vector256<short> right)
		{
			return AddSaturate(left, right);
		}

		public static Vector256<ushort> AddSaturate(Vector256<ushort> left, Vector256<ushort> right)
		{
			return AddSaturate(left, right);
		}

		public static Vector256<sbyte> AlignRight(Vector256<sbyte> left, Vector256<sbyte> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector256<byte> AlignRight(Vector256<byte> left, Vector256<byte> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector256<short> AlignRight(Vector256<short> left, Vector256<short> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector256<ushort> AlignRight(Vector256<ushort> left, Vector256<ushort> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector256<int> AlignRight(Vector256<int> left, Vector256<int> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector256<uint> AlignRight(Vector256<uint> left, Vector256<uint> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector256<long> AlignRight(Vector256<long> left, Vector256<long> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector256<ulong> AlignRight(Vector256<ulong> left, Vector256<ulong> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector256<sbyte> And(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return And(left, right);
		}

		public static Vector256<byte> And(Vector256<byte> left, Vector256<byte> right)
		{
			return And(left, right);
		}

		public static Vector256<short> And(Vector256<short> left, Vector256<short> right)
		{
			return And(left, right);
		}

		public static Vector256<ushort> And(Vector256<ushort> left, Vector256<ushort> right)
		{
			return And(left, right);
		}

		public static Vector256<int> And(Vector256<int> left, Vector256<int> right)
		{
			return And(left, right);
		}

		public static Vector256<uint> And(Vector256<uint> left, Vector256<uint> right)
		{
			return And(left, right);
		}

		public static Vector256<long> And(Vector256<long> left, Vector256<long> right)
		{
			return And(left, right);
		}

		public static Vector256<ulong> And(Vector256<ulong> left, Vector256<ulong> right)
		{
			return And(left, right);
		}

		public static Vector256<sbyte> AndNot(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<byte> AndNot(Vector256<byte> left, Vector256<byte> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<short> AndNot(Vector256<short> left, Vector256<short> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<ushort> AndNot(Vector256<ushort> left, Vector256<ushort> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<int> AndNot(Vector256<int> left, Vector256<int> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<uint> AndNot(Vector256<uint> left, Vector256<uint> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<long> AndNot(Vector256<long> left, Vector256<long> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<ulong> AndNot(Vector256<ulong> left, Vector256<ulong> right)
		{
			return AndNot(left, right);
		}

		public static Vector256<byte> Average(Vector256<byte> left, Vector256<byte> right)
		{
			return Average(left, right);
		}

		public static Vector256<ushort> Average(Vector256<ushort> left, Vector256<ushort> right)
		{
			return Average(left, right);
		}

		public static Vector128<int> Blend(Vector128<int> left, Vector128<int> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector128<uint> Blend(Vector128<uint> left, Vector128<uint> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector256<short> Blend(Vector256<short> left, Vector256<short> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector256<ushort> Blend(Vector256<ushort> left, Vector256<ushort> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector256<int> Blend(Vector256<int> left, Vector256<int> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector256<uint> Blend(Vector256<uint> left, Vector256<uint> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector256<short> BlendVariable(Vector256<short> left, Vector256<short> right, Vector256<short> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector256<ushort> BlendVariable(Vector256<ushort> left, Vector256<ushort> right, Vector256<ushort> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector256<int> BlendVariable(Vector256<int> left, Vector256<int> right, Vector256<int> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector256<uint> BlendVariable(Vector256<uint> left, Vector256<uint> right, Vector256<uint> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector256<long> BlendVariable(Vector256<long> left, Vector256<long> right, Vector256<long> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector256<ulong> BlendVariable(Vector256<ulong> left, Vector256<ulong> right, Vector256<ulong> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<byte> BroadcastScalarToVector128(Vector128<byte> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<sbyte> BroadcastScalarToVector128(Vector128<sbyte> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<short> BroadcastScalarToVector128(Vector128<short> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<ushort> BroadcastScalarToVector128(Vector128<ushort> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<int> BroadcastScalarToVector128(Vector128<int> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<uint> BroadcastScalarToVector128(Vector128<uint> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<long> BroadcastScalarToVector128(Vector128<long> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<ulong> BroadcastScalarToVector128(Vector128<ulong> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<float> BroadcastScalarToVector128(Vector128<float> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public static Vector128<double> BroadcastScalarToVector128(Vector128<double> value)
		{
			return BroadcastScalarToVector128(value);
		}

		public unsafe static Vector128<byte> BroadcastScalarToVector128(byte* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public unsafe static Vector128<sbyte> BroadcastScalarToVector128(sbyte* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public unsafe static Vector128<short> BroadcastScalarToVector128(short* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public unsafe static Vector128<ushort> BroadcastScalarToVector128(ushort* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public unsafe static Vector128<int> BroadcastScalarToVector128(int* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public unsafe static Vector128<uint> BroadcastScalarToVector128(uint* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public unsafe static Vector128<long> BroadcastScalarToVector128(long* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public unsafe static Vector128<ulong> BroadcastScalarToVector128(ulong* source)
		{
			return BroadcastScalarToVector128(source);
		}

		public static Vector256<byte> BroadcastScalarToVector256(Vector128<byte> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<sbyte> BroadcastScalarToVector256(Vector128<sbyte> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<short> BroadcastScalarToVector256(Vector128<short> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<ushort> BroadcastScalarToVector256(Vector128<ushort> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<int> BroadcastScalarToVector256(Vector128<int> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<uint> BroadcastScalarToVector256(Vector128<uint> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<long> BroadcastScalarToVector256(Vector128<long> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<ulong> BroadcastScalarToVector256(Vector128<ulong> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<float> BroadcastScalarToVector256(Vector128<float> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public static Vector256<double> BroadcastScalarToVector256(Vector128<double> value)
		{
			return BroadcastScalarToVector256(value);
		}

		public unsafe static Vector256<byte> BroadcastScalarToVector256(byte* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<sbyte> BroadcastScalarToVector256(sbyte* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<short> BroadcastScalarToVector256(short* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<ushort> BroadcastScalarToVector256(ushort* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<int> BroadcastScalarToVector256(int* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<uint> BroadcastScalarToVector256(uint* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<long> BroadcastScalarToVector256(long* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<ulong> BroadcastScalarToVector256(ulong* source)
		{
			return BroadcastScalarToVector256(source);
		}

		public unsafe static Vector256<sbyte> BroadcastVector128ToVector256(sbyte* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public unsafe static Vector256<byte> BroadcastVector128ToVector256(byte* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public unsafe static Vector256<short> BroadcastVector128ToVector256(short* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public unsafe static Vector256<ushort> BroadcastVector128ToVector256(ushort* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public unsafe static Vector256<int> BroadcastVector128ToVector256(int* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public unsafe static Vector256<uint> BroadcastVector128ToVector256(uint* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public unsafe static Vector256<long> BroadcastVector128ToVector256(long* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public unsafe static Vector256<ulong> BroadcastVector128ToVector256(ulong* address)
		{
			return BroadcastVector128ToVector256(address);
		}

		public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector256<int> CompareEqual(Vector256<int> left, Vector256<int> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector256<uint> CompareEqual(Vector256<uint> left, Vector256<uint> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector256<long> CompareEqual(Vector256<long> left, Vector256<long> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector256<ulong> CompareEqual(Vector256<ulong> left, Vector256<ulong> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static Vector256<int> CompareGreaterThan(Vector256<int> left, Vector256<int> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static Vector256<long> CompareGreaterThan(Vector256<long> left, Vector256<long> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static int ConvertToInt32(Vector256<int> value)
		{
			return ConvertToInt32(value);
		}

		public static uint ConvertToUInt32(Vector256<uint> value)
		{
			return ConvertToUInt32(value);
		}

		public static Vector256<short> ConvertToVector256Int16(Vector128<sbyte> value)
		{
			return ConvertToVector256Int16(value);
		}

		public static Vector256<short> ConvertToVector256Int16(Vector128<byte> value)
		{
			return ConvertToVector256Int16(value);
		}

		public static Vector256<int> ConvertToVector256Int32(Vector128<sbyte> value)
		{
			return ConvertToVector256Int32(value);
		}

		public static Vector256<int> ConvertToVector256Int32(Vector128<byte> value)
		{
			return ConvertToVector256Int32(value);
		}

		public static Vector256<int> ConvertToVector256Int32(Vector128<short> value)
		{
			return ConvertToVector256Int32(value);
		}

		public static Vector256<int> ConvertToVector256Int32(Vector128<ushort> value)
		{
			return ConvertToVector256Int32(value);
		}

		public static Vector256<long> ConvertToVector256Int64(Vector128<sbyte> value)
		{
			return ConvertToVector256Int64(value);
		}

		public static Vector256<long> ConvertToVector256Int64(Vector128<byte> value)
		{
			return ConvertToVector256Int64(value);
		}

		public static Vector256<long> ConvertToVector256Int64(Vector128<short> value)
		{
			return ConvertToVector256Int64(value);
		}

		public static Vector256<long> ConvertToVector256Int64(Vector128<ushort> value)
		{
			return ConvertToVector256Int64(value);
		}

		public static Vector256<long> ConvertToVector256Int64(Vector128<int> value)
		{
			return ConvertToVector256Int64(value);
		}

		public static Vector256<long> ConvertToVector256Int64(Vector128<uint> value)
		{
			return ConvertToVector256Int64(value);
		}

		public unsafe static Vector256<short> ConvertToVector256Int16(sbyte* address)
		{
			return ConvertToVector256Int16(address);
		}

		public unsafe static Vector256<short> ConvertToVector256Int16(byte* address)
		{
			return ConvertToVector256Int16(address);
		}

		public unsafe static Vector256<int> ConvertToVector256Int32(sbyte* address)
		{
			return ConvertToVector256Int32(address);
		}

		public unsafe static Vector256<int> ConvertToVector256Int32(byte* address)
		{
			return ConvertToVector256Int32(address);
		}

		public unsafe static Vector256<int> ConvertToVector256Int32(short* address)
		{
			return ConvertToVector256Int32(address);
		}

		public unsafe static Vector256<int> ConvertToVector256Int32(ushort* address)
		{
			return ConvertToVector256Int32(address);
		}

		public unsafe static Vector256<long> ConvertToVector256Int64(sbyte* address)
		{
			return ConvertToVector256Int64(address);
		}

		public unsafe static Vector256<long> ConvertToVector256Int64(byte* address)
		{
			return ConvertToVector256Int64(address);
		}

		public unsafe static Vector256<long> ConvertToVector256Int64(short* address)
		{
			return ConvertToVector256Int64(address);
		}

		public unsafe static Vector256<long> ConvertToVector256Int64(ushort* address)
		{
			return ConvertToVector256Int64(address);
		}

		public unsafe static Vector256<long> ConvertToVector256Int64(int* address)
		{
			return ConvertToVector256Int64(address);
		}

		public unsafe static Vector256<long> ConvertToVector256Int64(uint* address)
		{
			return ConvertToVector256Int64(address);
		}

		public new static Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public new static Vector128<byte> ExtractVector128(Vector256<byte> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public new static Vector128<short> ExtractVector128(Vector256<short> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public new static Vector128<ushort> ExtractVector128(Vector256<ushort> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public new static Vector128<int> ExtractVector128(Vector256<int> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public new static Vector128<uint> ExtractVector128(Vector256<uint> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public new static Vector128<long> ExtractVector128(Vector256<long> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public new static Vector128<ulong> ExtractVector128(Vector256<ulong> value, byte index)
		{
			return ExtractVector128(value, index);
		}

		public unsafe static Vector128<int> GatherVector128(int* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<uint> GatherVector128(uint* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<long> GatherVector128(long* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<float> GatherVector128(float* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<double> GatherVector128(double* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<int> GatherVector128(int* baseAddress, Vector128<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<uint> GatherVector128(uint* baseAddress, Vector128<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<long> GatherVector128(long* baseAddress, Vector128<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<ulong> GatherVector128(ulong* baseAddress, Vector128<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<float> GatherVector128(float* baseAddress, Vector128<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<double> GatherVector128(double* baseAddress, Vector128<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<int> GatherVector256(int* baseAddress, Vector256<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<uint> GatherVector256(uint* baseAddress, Vector256<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<long> GatherVector256(long* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<ulong> GatherVector256(ulong* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<float> GatherVector256(float* baseAddress, Vector256<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<double> GatherVector256(double* baseAddress, Vector128<int> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<int> GatherVector128(int* baseAddress, Vector256<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<uint> GatherVector128(uint* baseAddress, Vector256<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<long> GatherVector256(long* baseAddress, Vector256<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<ulong> GatherVector256(ulong* baseAddress, Vector256<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<float> GatherVector128(float* baseAddress, Vector256<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector128(baseAddress, index, 1), 
				2 => GatherVector128(baseAddress, index, 2), 
				4 => GatherVector128(baseAddress, index, 4), 
				8 => GatherVector128(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<double> GatherVector256(double* baseAddress, Vector256<long> index, byte scale)
		{
			return scale switch
			{
				1 => GatherVector256(baseAddress, index, 1), 
				2 => GatherVector256(baseAddress, index, 2), 
				4 => GatherVector256(baseAddress, index, 4), 
				8 => GatherVector256(baseAddress, index, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<int> index, Vector128<int> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<int> index, Vector128<uint> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<int> index, Vector128<long> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<int> index, Vector128<ulong> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<int> index, Vector128<float> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<int> index, Vector128<double> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector128<long> index, Vector128<int> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector128<long> index, Vector128<uint> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<long> GatherMaskVector128(Vector128<long> source, long* baseAddress, Vector128<long> index, Vector128<long> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<ulong> GatherMaskVector128(Vector128<ulong> source, ulong* baseAddress, Vector128<long> index, Vector128<ulong> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector128<long> index, Vector128<float> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<double> GatherMaskVector128(Vector128<double> source, double* baseAddress, Vector128<long> index, Vector128<double> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<int> GatherMaskVector256(Vector256<int> source, int* baseAddress, Vector256<int> index, Vector256<int> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<uint> GatherMaskVector256(Vector256<uint> source, uint* baseAddress, Vector256<int> index, Vector256<uint> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector128<int> index, Vector256<long> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector128<int> index, Vector256<ulong> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<float> GatherMaskVector256(Vector256<float> source, float* baseAddress, Vector256<int> index, Vector256<float> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector128<int> index, Vector256<double> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<int> GatherMaskVector128(Vector128<int> source, int* baseAddress, Vector256<long> index, Vector128<int> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<uint> GatherMaskVector128(Vector128<uint> source, uint* baseAddress, Vector256<long> index, Vector128<uint> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<long> GatherMaskVector256(Vector256<long> source, long* baseAddress, Vector256<long> index, Vector256<long> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<ulong> GatherMaskVector256(Vector256<ulong> source, ulong* baseAddress, Vector256<long> index, Vector256<ulong> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector128<float> GatherMaskVector128(Vector128<float> source, float* baseAddress, Vector256<long> index, Vector128<float> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector128(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector128(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector128(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector128(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public unsafe static Vector256<double> GatherMaskVector256(Vector256<double> source, double* baseAddress, Vector256<long> index, Vector256<double> mask, byte scale)
		{
			return scale switch
			{
				1 => GatherMaskVector256(source, baseAddress, index, mask, 1), 
				2 => GatherMaskVector256(source, baseAddress, index, mask, 2), 
				4 => GatherMaskVector256(source, baseAddress, index, mask, 4), 
				8 => GatherMaskVector256(source, baseAddress, index, mask, 8), 
				_ => throw new ArgumentOutOfRangeException("scale"), 
			};
		}

		public static Vector256<short> HorizontalAdd(Vector256<short> left, Vector256<short> right)
		{
			return HorizontalAdd(left, right);
		}

		public static Vector256<int> HorizontalAdd(Vector256<int> left, Vector256<int> right)
		{
			return HorizontalAdd(left, right);
		}

		public static Vector256<short> HorizontalAddSaturate(Vector256<short> left, Vector256<short> right)
		{
			return HorizontalAddSaturate(left, right);
		}

		public static Vector256<short> HorizontalSubtract(Vector256<short> left, Vector256<short> right)
		{
			return HorizontalSubtract(left, right);
		}

		public static Vector256<int> HorizontalSubtract(Vector256<int> left, Vector256<int> right)
		{
			return HorizontalSubtract(left, right);
		}

		public static Vector256<short> HorizontalSubtractSaturate(Vector256<short> left, Vector256<short> right)
		{
			return HorizontalSubtractSaturate(left, right);
		}

		public new static Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public new static Vector256<byte> InsertVector128(Vector256<byte> value, Vector128<byte> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public new static Vector256<short> InsertVector128(Vector256<short> value, Vector128<short> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public new static Vector256<ushort> InsertVector128(Vector256<ushort> value, Vector128<ushort> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public new static Vector256<int> InsertVector128(Vector256<int> value, Vector128<int> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public new static Vector256<uint> InsertVector128(Vector256<uint> value, Vector128<uint> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public new static Vector256<long> InsertVector128(Vector256<long> value, Vector128<long> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public new static Vector256<ulong> InsertVector128(Vector256<ulong> value, Vector128<ulong> data, byte index)
		{
			return InsertVector128(value, data, index);
		}

		public unsafe static Vector256<sbyte> LoadAlignedVector256NonTemporal(sbyte* address)
		{
			return LoadAlignedVector256NonTemporal(address);
		}

		public unsafe static Vector256<byte> LoadAlignedVector256NonTemporal(byte* address)
		{
			return LoadAlignedVector256NonTemporal(address);
		}

		public unsafe static Vector256<short> LoadAlignedVector256NonTemporal(short* address)
		{
			return LoadAlignedVector256NonTemporal(address);
		}

		public unsafe static Vector256<ushort> LoadAlignedVector256NonTemporal(ushort* address)
		{
			return LoadAlignedVector256NonTemporal(address);
		}

		public unsafe static Vector256<int> LoadAlignedVector256NonTemporal(int* address)
		{
			return LoadAlignedVector256NonTemporal(address);
		}

		public unsafe static Vector256<uint> LoadAlignedVector256NonTemporal(uint* address)
		{
			return LoadAlignedVector256NonTemporal(address);
		}

		public unsafe static Vector256<long> LoadAlignedVector256NonTemporal(long* address)
		{
			return LoadAlignedVector256NonTemporal(address);
		}

		public unsafe static Vector256<ulong> LoadAlignedVector256NonTemporal(ulong* address)
		{
			return LoadAlignedVector256NonTemporal(address);
		}

		public unsafe static Vector128<int> MaskLoad(int* address, Vector128<int> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector128<uint> MaskLoad(uint* address, Vector128<uint> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector128<long> MaskLoad(long* address, Vector128<long> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector128<ulong> MaskLoad(ulong* address, Vector128<ulong> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector256<int> MaskLoad(int* address, Vector256<int> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector256<uint> MaskLoad(uint* address, Vector256<uint> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector256<long> MaskLoad(long* address, Vector256<long> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static Vector256<ulong> MaskLoad(ulong* address, Vector256<ulong> mask)
		{
			return MaskLoad(address, mask);
		}

		public unsafe static void MaskStore(int* address, Vector128<int> mask, Vector128<int> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(uint* address, Vector128<uint> mask, Vector128<uint> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(long* address, Vector128<long> mask, Vector128<long> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(ulong* address, Vector128<ulong> mask, Vector128<ulong> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(int* address, Vector256<int> mask, Vector256<int> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(uint* address, Vector256<uint> mask, Vector256<uint> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(long* address, Vector256<long> mask, Vector256<long> source)
		{
			MaskStore(address, mask, source);
		}

		public unsafe static void MaskStore(ulong* address, Vector256<ulong> mask, Vector256<ulong> source)
		{
			MaskStore(address, mask, source);
		}

		public static Vector256<int> MultiplyAddAdjacent(Vector256<short> left, Vector256<short> right)
		{
			return MultiplyAddAdjacent(left, right);
		}

		public static Vector256<short> MultiplyAddAdjacent(Vector256<byte> left, Vector256<sbyte> right)
		{
			return MultiplyAddAdjacent(left, right);
		}

		public static Vector256<sbyte> Max(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return Max(left, right);
		}

		public static Vector256<byte> Max(Vector256<byte> left, Vector256<byte> right)
		{
			return Max(left, right);
		}

		public static Vector256<short> Max(Vector256<short> left, Vector256<short> right)
		{
			return Max(left, right);
		}

		public static Vector256<ushort> Max(Vector256<ushort> left, Vector256<ushort> right)
		{
			return Max(left, right);
		}

		public static Vector256<int> Max(Vector256<int> left, Vector256<int> right)
		{
			return Max(left, right);
		}

		public static Vector256<uint> Max(Vector256<uint> left, Vector256<uint> right)
		{
			return Max(left, right);
		}

		public static Vector256<sbyte> Min(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return Min(left, right);
		}

		public static Vector256<byte> Min(Vector256<byte> left, Vector256<byte> right)
		{
			return Min(left, right);
		}

		public static Vector256<short> Min(Vector256<short> left, Vector256<short> right)
		{
			return Min(left, right);
		}

		public static Vector256<ushort> Min(Vector256<ushort> left, Vector256<ushort> right)
		{
			return Min(left, right);
		}

		public static Vector256<int> Min(Vector256<int> left, Vector256<int> right)
		{
			return Min(left, right);
		}

		public static Vector256<uint> Min(Vector256<uint> left, Vector256<uint> right)
		{
			return Min(left, right);
		}

		public static int MoveMask(Vector256<sbyte> value)
		{
			return MoveMask(value);
		}

		public static int MoveMask(Vector256<byte> value)
		{
			return MoveMask(value);
		}

		public static Vector256<ushort> MultipleSumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right, byte mask)
		{
			return MultipleSumAbsoluteDifferences(left, right, mask);
		}

		public static Vector256<long> Multiply(Vector256<int> left, Vector256<int> right)
		{
			return Multiply(left, right);
		}

		public static Vector256<ulong> Multiply(Vector256<uint> left, Vector256<uint> right)
		{
			return Multiply(left, right);
		}

		public static Vector256<short> MultiplyHigh(Vector256<short> left, Vector256<short> right)
		{
			return MultiplyHigh(left, right);
		}

		public static Vector256<ushort> MultiplyHigh(Vector256<ushort> left, Vector256<ushort> right)
		{
			return MultiplyHigh(left, right);
		}

		public static Vector256<short> MultiplyHighRoundScale(Vector256<short> left, Vector256<short> right)
		{
			return MultiplyHighRoundScale(left, right);
		}

		public static Vector256<short> MultiplyLow(Vector256<short> left, Vector256<short> right)
		{
			return MultiplyLow(left, right);
		}

		public static Vector256<ushort> MultiplyLow(Vector256<ushort> left, Vector256<ushort> right)
		{
			return MultiplyLow(left, right);
		}

		public static Vector256<int> MultiplyLow(Vector256<int> left, Vector256<int> right)
		{
			return MultiplyLow(left, right);
		}

		public static Vector256<uint> MultiplyLow(Vector256<uint> left, Vector256<uint> right)
		{
			return MultiplyLow(left, right);
		}

		public static Vector256<sbyte> Or(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return Or(left, right);
		}

		public static Vector256<byte> Or(Vector256<byte> left, Vector256<byte> right)
		{
			return Or(left, right);
		}

		public static Vector256<short> Or(Vector256<short> left, Vector256<short> right)
		{
			return Or(left, right);
		}

		public static Vector256<ushort> Or(Vector256<ushort> left, Vector256<ushort> right)
		{
			return Or(left, right);
		}

		public static Vector256<int> Or(Vector256<int> left, Vector256<int> right)
		{
			return Or(left, right);
		}

		public static Vector256<uint> Or(Vector256<uint> left, Vector256<uint> right)
		{
			return Or(left, right);
		}

		public static Vector256<long> Or(Vector256<long> left, Vector256<long> right)
		{
			return Or(left, right);
		}

		public static Vector256<ulong> Or(Vector256<ulong> left, Vector256<ulong> right)
		{
			return Or(left, right);
		}

		public static Vector256<sbyte> PackSignedSaturate(Vector256<short> left, Vector256<short> right)
		{
			return PackSignedSaturate(left, right);
		}

		public static Vector256<short> PackSignedSaturate(Vector256<int> left, Vector256<int> right)
		{
			return PackSignedSaturate(left, right);
		}

		public static Vector256<byte> PackUnsignedSaturate(Vector256<short> left, Vector256<short> right)
		{
			return PackUnsignedSaturate(left, right);
		}

		public static Vector256<ushort> PackUnsignedSaturate(Vector256<int> left, Vector256<int> right)
		{
			return PackUnsignedSaturate(left, right);
		}

		public new static Vector256<sbyte> Permute2x128(Vector256<sbyte> left, Vector256<sbyte> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public new static Vector256<byte> Permute2x128(Vector256<byte> left, Vector256<byte> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public new static Vector256<short> Permute2x128(Vector256<short> left, Vector256<short> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public new static Vector256<ushort> Permute2x128(Vector256<ushort> left, Vector256<ushort> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public new static Vector256<int> Permute2x128(Vector256<int> left, Vector256<int> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public new static Vector256<uint> Permute2x128(Vector256<uint> left, Vector256<uint> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public new static Vector256<long> Permute2x128(Vector256<long> left, Vector256<long> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public new static Vector256<ulong> Permute2x128(Vector256<ulong> left, Vector256<ulong> right, byte control)
		{
			return Permute2x128(left, right, control);
		}

		public static Vector256<long> Permute4x64(Vector256<long> value, byte control)
		{
			return Permute4x64(value, control);
		}

		public static Vector256<ulong> Permute4x64(Vector256<ulong> value, byte control)
		{
			return Permute4x64(value, control);
		}

		public static Vector256<double> Permute4x64(Vector256<double> value, byte control)
		{
			return Permute4x64(value, control);
		}

		public static Vector256<int> PermuteVar8x32(Vector256<int> left, Vector256<int> control)
		{
			return PermuteVar8x32(left, control);
		}

		public static Vector256<uint> PermuteVar8x32(Vector256<uint> left, Vector256<uint> control)
		{
			return PermuteVar8x32(left, control);
		}

		public static Vector256<float> PermuteVar8x32(Vector256<float> left, Vector256<int> control)
		{
			return PermuteVar8x32(left, control);
		}

		public static Vector256<short> ShiftLeftLogical(Vector256<short> value, Vector128<short> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, Vector128<ushort> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<int> ShiftLeftLogical(Vector256<int> value, Vector128<int> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, Vector128<uint> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<long> ShiftLeftLogical(Vector256<long> value, Vector128<long> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, Vector128<ulong> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<short> ShiftLeftLogical(Vector256<short> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<ushort> ShiftLeftLogical(Vector256<ushort> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<int> ShiftLeftLogical(Vector256<int> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<uint> ShiftLeftLogical(Vector256<uint> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<long> ShiftLeftLogical(Vector256<long> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<ulong> ShiftLeftLogical(Vector256<ulong> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector256<sbyte> ShiftLeftLogical128BitLane(Vector256<sbyte> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector256<byte> ShiftLeftLogical128BitLane(Vector256<byte> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector256<short> ShiftLeftLogical128BitLane(Vector256<short> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector256<ushort> ShiftLeftLogical128BitLane(Vector256<ushort> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector256<int> ShiftLeftLogical128BitLane(Vector256<int> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector256<uint> ShiftLeftLogical128BitLane(Vector256<uint> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector256<long> ShiftLeftLogical128BitLane(Vector256<long> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector256<ulong> ShiftLeftLogical128BitLane(Vector256<ulong> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector256<int> ShiftLeftLogicalVariable(Vector256<int> value, Vector256<uint> count)
		{
			return ShiftLeftLogicalVariable(value, count);
		}

		public static Vector256<uint> ShiftLeftLogicalVariable(Vector256<uint> value, Vector256<uint> count)
		{
			return ShiftLeftLogicalVariable(value, count);
		}

		public static Vector256<long> ShiftLeftLogicalVariable(Vector256<long> value, Vector256<ulong> count)
		{
			return ShiftLeftLogicalVariable(value, count);
		}

		public static Vector256<ulong> ShiftLeftLogicalVariable(Vector256<ulong> value, Vector256<ulong> count)
		{
			return ShiftLeftLogicalVariable(value, count);
		}

		public static Vector128<int> ShiftLeftLogicalVariable(Vector128<int> value, Vector128<uint> count)
		{
			return ShiftLeftLogicalVariable(value, count);
		}

		public static Vector128<uint> ShiftLeftLogicalVariable(Vector128<uint> value, Vector128<uint> count)
		{
			return ShiftLeftLogicalVariable(value, count);
		}

		public static Vector128<long> ShiftLeftLogicalVariable(Vector128<long> value, Vector128<ulong> count)
		{
			return ShiftLeftLogicalVariable(value, count);
		}

		public static Vector128<ulong> ShiftLeftLogicalVariable(Vector128<ulong> value, Vector128<ulong> count)
		{
			return ShiftLeftLogicalVariable(value, count);
		}

		public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, Vector128<short> count)
		{
			return ShiftRightArithmetic(value, count);
		}

		public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, Vector128<int> count)
		{
			return ShiftRightArithmetic(value, count);
		}

		public static Vector256<short> ShiftRightArithmetic(Vector256<short> value, byte count)
		{
			return ShiftRightArithmetic(value, count);
		}

		public static Vector256<int> ShiftRightArithmetic(Vector256<int> value, byte count)
		{
			return ShiftRightArithmetic(value, count);
		}

		public static Vector256<int> ShiftRightArithmeticVariable(Vector256<int> value, Vector256<uint> count)
		{
			return ShiftRightArithmeticVariable(value, count);
		}

		public static Vector128<int> ShiftRightArithmeticVariable(Vector128<int> value, Vector128<uint> count)
		{
			return ShiftRightArithmeticVariable(value, count);
		}

		public static Vector256<short> ShiftRightLogical(Vector256<short> value, Vector128<short> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, Vector128<ushort> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<int> ShiftRightLogical(Vector256<int> value, Vector128<int> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, Vector128<uint> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<long> ShiftRightLogical(Vector256<long> value, Vector128<long> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, Vector128<ulong> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<short> ShiftRightLogical(Vector256<short> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<ushort> ShiftRightLogical(Vector256<ushort> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<int> ShiftRightLogical(Vector256<int> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<uint> ShiftRightLogical(Vector256<uint> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<long> ShiftRightLogical(Vector256<long> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<ulong> ShiftRightLogical(Vector256<ulong> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector256<sbyte> ShiftRightLogical128BitLane(Vector256<sbyte> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector256<byte> ShiftRightLogical128BitLane(Vector256<byte> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector256<short> ShiftRightLogical128BitLane(Vector256<short> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector256<ushort> ShiftRightLogical128BitLane(Vector256<ushort> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector256<int> ShiftRightLogical128BitLane(Vector256<int> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector256<uint> ShiftRightLogical128BitLane(Vector256<uint> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector256<long> ShiftRightLogical128BitLane(Vector256<long> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector256<ulong> ShiftRightLogical128BitLane(Vector256<ulong> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector256<int> ShiftRightLogicalVariable(Vector256<int> value, Vector256<uint> count)
		{
			return ShiftRightLogicalVariable(value, count);
		}

		public static Vector256<uint> ShiftRightLogicalVariable(Vector256<uint> value, Vector256<uint> count)
		{
			return ShiftRightLogicalVariable(value, count);
		}

		public static Vector256<long> ShiftRightLogicalVariable(Vector256<long> value, Vector256<ulong> count)
		{
			return ShiftRightLogicalVariable(value, count);
		}

		public static Vector256<ulong> ShiftRightLogicalVariable(Vector256<ulong> value, Vector256<ulong> count)
		{
			return ShiftRightLogicalVariable(value, count);
		}

		public static Vector128<int> ShiftRightLogicalVariable(Vector128<int> value, Vector128<uint> count)
		{
			return ShiftRightLogicalVariable(value, count);
		}

		public static Vector128<uint> ShiftRightLogicalVariable(Vector128<uint> value, Vector128<uint> count)
		{
			return ShiftRightLogicalVariable(value, count);
		}

		public static Vector128<long> ShiftRightLogicalVariable(Vector128<long> value, Vector128<ulong> count)
		{
			return ShiftRightLogicalVariable(value, count);
		}

		public static Vector128<ulong> ShiftRightLogicalVariable(Vector128<ulong> value, Vector128<ulong> count)
		{
			return ShiftRightLogicalVariable(value, count);
		}

		public static Vector256<sbyte> Shuffle(Vector256<sbyte> value, Vector256<sbyte> mask)
		{
			return Shuffle(value, mask);
		}

		public static Vector256<byte> Shuffle(Vector256<byte> value, Vector256<byte> mask)
		{
			return Shuffle(value, mask);
		}

		public static Vector256<int> Shuffle(Vector256<int> value, byte control)
		{
			return Shuffle(value, control);
		}

		public static Vector256<uint> Shuffle(Vector256<uint> value, byte control)
		{
			return Shuffle(value, control);
		}

		public static Vector256<short> ShuffleHigh(Vector256<short> value, byte control)
		{
			return ShuffleHigh(value, control);
		}

		public static Vector256<ushort> ShuffleHigh(Vector256<ushort> value, byte control)
		{
			return ShuffleHigh(value, control);
		}

		public static Vector256<short> ShuffleLow(Vector256<short> value, byte control)
		{
			return ShuffleLow(value, control);
		}

		public static Vector256<ushort> ShuffleLow(Vector256<ushort> value, byte control)
		{
			return ShuffleLow(value, control);
		}

		public static Vector256<sbyte> Sign(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return Sign(left, right);
		}

		public static Vector256<short> Sign(Vector256<short> left, Vector256<short> right)
		{
			return Sign(left, right);
		}

		public static Vector256<int> Sign(Vector256<int> left, Vector256<int> right)
		{
			return Sign(left, right);
		}

		public static Vector256<sbyte> Subtract(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<byte> Subtract(Vector256<byte> left, Vector256<byte> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<short> Subtract(Vector256<short> left, Vector256<short> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<ushort> Subtract(Vector256<ushort> left, Vector256<ushort> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<int> Subtract(Vector256<int> left, Vector256<int> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<uint> Subtract(Vector256<uint> left, Vector256<uint> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<long> Subtract(Vector256<long> left, Vector256<long> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<ulong> Subtract(Vector256<ulong> left, Vector256<ulong> right)
		{
			return Subtract(left, right);
		}

		public static Vector256<sbyte> SubtractSaturate(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return SubtractSaturate(left, right);
		}

		public static Vector256<short> SubtractSaturate(Vector256<short> left, Vector256<short> right)
		{
			return SubtractSaturate(left, right);
		}

		public static Vector256<byte> SubtractSaturate(Vector256<byte> left, Vector256<byte> right)
		{
			return SubtractSaturate(left, right);
		}

		public static Vector256<ushort> SubtractSaturate(Vector256<ushort> left, Vector256<ushort> right)
		{
			return SubtractSaturate(left, right);
		}

		public static Vector256<ushort> SumAbsoluteDifferences(Vector256<byte> left, Vector256<byte> right)
		{
			return SumAbsoluteDifferences(left, right);
		}

		public static Vector256<sbyte> UnpackHigh(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<byte> UnpackHigh(Vector256<byte> left, Vector256<byte> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<short> UnpackHigh(Vector256<short> left, Vector256<short> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<ushort> UnpackHigh(Vector256<ushort> left, Vector256<ushort> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<int> UnpackHigh(Vector256<int> left, Vector256<int> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<uint> UnpackHigh(Vector256<uint> left, Vector256<uint> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<long> UnpackHigh(Vector256<long> left, Vector256<long> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<ulong> UnpackHigh(Vector256<ulong> left, Vector256<ulong> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector256<sbyte> UnpackLow(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<byte> UnpackLow(Vector256<byte> left, Vector256<byte> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<short> UnpackLow(Vector256<short> left, Vector256<short> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<ushort> UnpackLow(Vector256<ushort> left, Vector256<ushort> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<int> UnpackLow(Vector256<int> left, Vector256<int> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<uint> UnpackLow(Vector256<uint> left, Vector256<uint> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<long> UnpackLow(Vector256<long> left, Vector256<long> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<ulong> UnpackLow(Vector256<ulong> left, Vector256<ulong> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector256<sbyte> Xor(Vector256<sbyte> left, Vector256<sbyte> right)
		{
			return Xor(left, right);
		}

		public static Vector256<byte> Xor(Vector256<byte> left, Vector256<byte> right)
		{
			return Xor(left, right);
		}

		public static Vector256<short> Xor(Vector256<short> left, Vector256<short> right)
		{
			return Xor(left, right);
		}

		public static Vector256<ushort> Xor(Vector256<ushort> left, Vector256<ushort> right)
		{
			return Xor(left, right);
		}

		public static Vector256<int> Xor(Vector256<int> left, Vector256<int> right)
		{
			return Xor(left, right);
		}

		public static Vector256<uint> Xor(Vector256<uint> left, Vector256<uint> right)
		{
			return Xor(left, right);
		}

		public static Vector256<long> Xor(Vector256<long> left, Vector256<long> right)
		{
			return Xor(left, right);
		}

		public static Vector256<ulong> Xor(Vector256<ulong> left, Vector256<ulong> right)
		{
			return Xor(left, right);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	[RequiresPreviewFeatures("AvxVnni is in preview.")]
	public abstract class AvxVnni : Avx2
	{
		[Intrinsic]
		public new abstract class X64 : Avx2.X64
		{
			public new static bool IsSupported => IsSupported;
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<int> MultiplyWideningAndAdd(Vector128<int> addend, Vector128<byte> left, Vector128<sbyte> right)
		{
			return MultiplyWideningAndAdd(addend, left, right);
		}

		public static Vector128<int> MultiplyWideningAndAdd(Vector128<int> addend, Vector128<short> left, Vector128<short> right)
		{
			return MultiplyWideningAndAdd(addend, left, right);
		}

		public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<byte> left, Vector256<sbyte> right)
		{
			return MultiplyWideningAndAdd(addend, left, right);
		}

		public static Vector256<int> MultiplyWideningAndAdd(Vector256<int> addend, Vector256<short> left, Vector256<short> right)
		{
			return MultiplyWideningAndAdd(addend, left, right);
		}

		public static Vector128<int> MultiplyWideningAndAddSaturate(Vector128<int> addend, Vector128<byte> left, Vector128<sbyte> right)
		{
			return MultiplyWideningAndAddSaturate(addend, left, right);
		}

		public static Vector128<int> MultiplyWideningAndAddSaturate(Vector128<int> addend, Vector128<short> left, Vector128<short> right)
		{
			return MultiplyWideningAndAddSaturate(addend, left, right);
		}

		public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<byte> left, Vector256<sbyte> right)
		{
			return MultiplyWideningAndAddSaturate(addend, left, right);
		}

		public static Vector256<int> MultiplyWideningAndAddSaturate(Vector256<int> addend, Vector256<short> left, Vector256<short> right)
		{
			return MultiplyWideningAndAddSaturate(addend, left, right);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Bmi1 : X86Base
	{
		[Intrinsic]
		public new abstract class X64 : X86Base.X64
		{
			public new static bool IsSupported => IsSupported;

			public static ulong AndNot(ulong left, ulong right)
			{
				return AndNot(left, right);
			}

			public static ulong BitFieldExtract(ulong value, byte start, byte length)
			{
				return BitFieldExtract(value, (ushort)(start | (length << 8)));
			}

			public static ulong BitFieldExtract(ulong value, ushort control)
			{
				return BitFieldExtract(value, control);
			}

			public static ulong ExtractLowestSetBit(ulong value)
			{
				return ExtractLowestSetBit(value);
			}

			public static ulong GetMaskUpToLowestSetBit(ulong value)
			{
				return GetMaskUpToLowestSetBit(value);
			}

			public static ulong ResetLowestSetBit(ulong value)
			{
				return ResetLowestSetBit(value);
			}

			public static ulong TrailingZeroCount(ulong value)
			{
				return TrailingZeroCount(value);
			}
		}

		public new static bool IsSupported => IsSupported;

		public static uint AndNot(uint left, uint right)
		{
			return AndNot(left, right);
		}

		public static uint BitFieldExtract(uint value, byte start, byte length)
		{
			return BitFieldExtract(value, (ushort)(start | (length << 8)));
		}

		public static uint BitFieldExtract(uint value, ushort control)
		{
			return BitFieldExtract(value, control);
		}

		public static uint ExtractLowestSetBit(uint value)
		{
			return ExtractLowestSetBit(value);
		}

		public static uint GetMaskUpToLowestSetBit(uint value)
		{
			return GetMaskUpToLowestSetBit(value);
		}

		public static uint ResetLowestSetBit(uint value)
		{
			return ResetLowestSetBit(value);
		}

		public static uint TrailingZeroCount(uint value)
		{
			return TrailingZeroCount(value);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Bmi2 : X86Base
	{
		[Intrinsic]
		public new abstract class X64 : X86Base.X64
		{
			public new static bool IsSupported => IsSupported;

			public static ulong ZeroHighBits(ulong value, ulong index)
			{
				return ZeroHighBits(value, index);
			}

			public static ulong MultiplyNoFlags(ulong left, ulong right)
			{
				return MultiplyNoFlags(left, right);
			}

			public unsafe static ulong MultiplyNoFlags(ulong left, ulong right, ulong* low)
			{
				return MultiplyNoFlags(left, right, low);
			}

			public static ulong ParallelBitDeposit(ulong value, ulong mask)
			{
				return ParallelBitDeposit(value, mask);
			}

			public static ulong ParallelBitExtract(ulong value, ulong mask)
			{
				return ParallelBitExtract(value, mask);
			}
		}

		public new static bool IsSupported => IsSupported;

		public static uint ZeroHighBits(uint value, uint index)
		{
			return ZeroHighBits(value, index);
		}

		public static uint MultiplyNoFlags(uint left, uint right)
		{
			return MultiplyNoFlags(left, right);
		}

		public unsafe static uint MultiplyNoFlags(uint left, uint right, uint* low)
		{
			return MultiplyNoFlags(left, right, low);
		}

		public static uint ParallelBitDeposit(uint value, uint mask)
		{
			return ParallelBitDeposit(value, mask);
		}

		public static uint ParallelBitExtract(uint value, uint mask)
		{
			return ParallelBitExtract(value, mask);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Fma : Avx
	{
		[Intrinsic]
		public new abstract class X64 : Avx.X64
		{
			public new static bool IsSupported => IsSupported;
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<float> MultiplyAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplyAdd(a, b, c);
		}

		public static Vector128<double> MultiplyAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplyAdd(a, b, c);
		}

		public static Vector256<float> MultiplyAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c)
		{
			return MultiplyAdd(a, b, c);
		}

		public static Vector256<double> MultiplyAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c)
		{
			return MultiplyAdd(a, b, c);
		}

		public static Vector128<float> MultiplyAddScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplyAddScalar(a, b, c);
		}

		public static Vector128<double> MultiplyAddScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplyAddScalar(a, b, c);
		}

		public static Vector128<float> MultiplyAddSubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplyAddSubtract(a, b, c);
		}

		public static Vector128<double> MultiplyAddSubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplyAddSubtract(a, b, c);
		}

		public static Vector256<float> MultiplyAddSubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c)
		{
			return MultiplyAddSubtract(a, b, c);
		}

		public static Vector256<double> MultiplyAddSubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c)
		{
			return MultiplyAddSubtract(a, b, c);
		}

		public static Vector128<float> MultiplySubtract(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplySubtract(a, b, c);
		}

		public static Vector128<double> MultiplySubtract(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplySubtract(a, b, c);
		}

		public static Vector256<float> MultiplySubtract(Vector256<float> a, Vector256<float> b, Vector256<float> c)
		{
			return MultiplySubtract(a, b, c);
		}

		public static Vector256<double> MultiplySubtract(Vector256<double> a, Vector256<double> b, Vector256<double> c)
		{
			return MultiplySubtract(a, b, c);
		}

		public static Vector128<float> MultiplySubtractScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplySubtractScalar(a, b, c);
		}

		public static Vector128<double> MultiplySubtractScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplySubtractScalar(a, b, c);
		}

		public static Vector128<float> MultiplySubtractAdd(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplySubtractAdd(a, b, c);
		}

		public static Vector128<double> MultiplySubtractAdd(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplySubtractAdd(a, b, c);
		}

		public static Vector256<float> MultiplySubtractAdd(Vector256<float> a, Vector256<float> b, Vector256<float> c)
		{
			return MultiplySubtractAdd(a, b, c);
		}

		public static Vector256<double> MultiplySubtractAdd(Vector256<double> a, Vector256<double> b, Vector256<double> c)
		{
			return MultiplySubtractAdd(a, b, c);
		}

		public static Vector128<float> MultiplyAddNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplyAddNegated(a, b, c);
		}

		public static Vector128<double> MultiplyAddNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplyAddNegated(a, b, c);
		}

		public static Vector256<float> MultiplyAddNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c)
		{
			return MultiplyAddNegated(a, b, c);
		}

		public static Vector256<double> MultiplyAddNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c)
		{
			return MultiplyAddNegated(a, b, c);
		}

		public static Vector128<float> MultiplyAddNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplyAddNegatedScalar(a, b, c);
		}

		public static Vector128<double> MultiplyAddNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplyAddNegatedScalar(a, b, c);
		}

		public static Vector128<float> MultiplySubtractNegated(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplySubtractNegated(a, b, c);
		}

		public static Vector128<double> MultiplySubtractNegated(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplySubtractNegated(a, b, c);
		}

		public static Vector256<float> MultiplySubtractNegated(Vector256<float> a, Vector256<float> b, Vector256<float> c)
		{
			return MultiplySubtractNegated(a, b, c);
		}

		public static Vector256<double> MultiplySubtractNegated(Vector256<double> a, Vector256<double> b, Vector256<double> c)
		{
			return MultiplySubtractNegated(a, b, c);
		}

		public static Vector128<float> MultiplySubtractNegatedScalar(Vector128<float> a, Vector128<float> b, Vector128<float> c)
		{
			return MultiplySubtractNegatedScalar(a, b, c);
		}

		public static Vector128<double> MultiplySubtractNegatedScalar(Vector128<double> a, Vector128<double> b, Vector128<double> c)
		{
			return MultiplySubtractNegatedScalar(a, b, c);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Lzcnt : X86Base
	{
		[Intrinsic]
		public new abstract class X64 : X86Base.X64
		{
			public new static bool IsSupported => IsSupported;

			public static ulong LeadingZeroCount(ulong value)
			{
				return LeadingZeroCount(value);
			}
		}

		public new static bool IsSupported => IsSupported;

		public static uint LeadingZeroCount(uint value)
		{
			return LeadingZeroCount(value);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Pclmulqdq : Sse2
	{
		[Intrinsic]
		public new abstract class X64 : Sse2.X64
		{
			public new static bool IsSupported => IsSupported;
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<long> CarrylessMultiply(Vector128<long> left, Vector128<long> right, byte control)
		{
			return CarrylessMultiply(left, right, control);
		}

		public static Vector128<ulong> CarrylessMultiply(Vector128<ulong> left, Vector128<ulong> right, byte control)
		{
			return CarrylessMultiply(left, right, control);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Popcnt : Sse42
	{
		[Intrinsic]
		public new abstract class X64 : Sse42.X64
		{
			public new static bool IsSupported => IsSupported;

			public static ulong PopCount(ulong value)
			{
				return PopCount(value);
			}
		}

		public new static bool IsSupported => IsSupported;

		public static uint PopCount(uint value)
		{
			return PopCount(value);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Sse : X86Base
	{
		[Intrinsic]
		public new abstract class X64 : X86Base.X64
		{
			public new static bool IsSupported => IsSupported;

			public static long ConvertToInt64(Vector128<float> value)
			{
				return ConvertToInt64(value);
			}

			public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, long value)
			{
				return ConvertScalarToVector128Single(upper, value);
			}

			public static long ConvertToInt64WithTruncation(Vector128<float> value)
			{
				return ConvertToInt64WithTruncation(value);
			}
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<float> Add(Vector128<float> left, Vector128<float> right)
		{
			return Add(left, right);
		}

		public static Vector128<float> AddScalar(Vector128<float> left, Vector128<float> right)
		{
			return AddScalar(left, right);
		}

		public static Vector128<float> And(Vector128<float> left, Vector128<float> right)
		{
			return And(left, right);
		}

		public static Vector128<float> AndNot(Vector128<float> left, Vector128<float> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<float> CompareEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareEqual(left, right);
		}

		public static bool CompareScalarOrderedEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarOrderedEqual(left, right);
		}

		public static bool CompareScalarUnorderedEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarUnorderedEqual(left, right);
		}

		public static Vector128<float> CompareScalarEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarEqual(left, right);
		}

		public static Vector128<float> CompareGreaterThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static bool CompareScalarOrderedGreaterThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarOrderedGreaterThan(left, right);
		}

		public static bool CompareScalarUnorderedGreaterThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarUnorderedGreaterThan(left, right);
		}

		public static Vector128<float> CompareScalarGreaterThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarGreaterThan(left, right);
		}

		public static Vector128<float> CompareGreaterThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareGreaterThanOrEqual(left, right);
		}

		public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarOrderedGreaterThanOrEqual(left, right);
		}

		public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarUnorderedGreaterThanOrEqual(left, right);
		}

		public static Vector128<float> CompareScalarGreaterThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarGreaterThanOrEqual(left, right);
		}

		public static Vector128<float> CompareLessThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareLessThan(left, right);
		}

		public static bool CompareScalarOrderedLessThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarOrderedLessThan(left, right);
		}

		public static bool CompareScalarUnorderedLessThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarUnorderedLessThan(left, right);
		}

		public static Vector128<float> CompareScalarLessThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarLessThan(left, right);
		}

		public static Vector128<float> CompareLessThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareLessThanOrEqual(left, right);
		}

		public static bool CompareScalarOrderedLessThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarOrderedLessThanOrEqual(left, right);
		}

		public static bool CompareScalarUnorderedLessThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarUnorderedLessThanOrEqual(left, right);
		}

		public static Vector128<float> CompareScalarLessThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarLessThanOrEqual(left, right);
		}

		public static Vector128<float> CompareNotEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareNotEqual(left, right);
		}

		public static bool CompareScalarOrderedNotEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarOrderedNotEqual(left, right);
		}

		public static bool CompareScalarUnorderedNotEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarUnorderedNotEqual(left, right);
		}

		public static Vector128<float> CompareScalarNotEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarNotEqual(left, right);
		}

		public static Vector128<float> CompareNotGreaterThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareNotGreaterThan(left, right);
		}

		public static Vector128<float> CompareScalarNotGreaterThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarNotGreaterThan(left, right);
		}

		public static Vector128<float> CompareNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareNotGreaterThanOrEqual(left, right);
		}

		public static Vector128<float> CompareScalarNotGreaterThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarNotGreaterThanOrEqual(left, right);
		}

		public static Vector128<float> CompareNotLessThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareNotLessThan(left, right);
		}

		public static Vector128<float> CompareScalarNotLessThan(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarNotLessThan(left, right);
		}

		public static Vector128<float> CompareNotLessThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareNotLessThanOrEqual(left, right);
		}

		public static Vector128<float> CompareScalarNotLessThanOrEqual(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarNotLessThanOrEqual(left, right);
		}

		public static Vector128<float> CompareOrdered(Vector128<float> left, Vector128<float> right)
		{
			return CompareOrdered(left, right);
		}

		public static Vector128<float> CompareScalarOrdered(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarOrdered(left, right);
		}

		public static Vector128<float> CompareUnordered(Vector128<float> left, Vector128<float> right)
		{
			return CompareUnordered(left, right);
		}

		public static Vector128<float> CompareScalarUnordered(Vector128<float> left, Vector128<float> right)
		{
			return CompareScalarUnordered(left, right);
		}

		public static int ConvertToInt32(Vector128<float> value)
		{
			return ConvertToInt32(value);
		}

		public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, int value)
		{
			return ConvertScalarToVector128Single(upper, value);
		}

		public static int ConvertToInt32WithTruncation(Vector128<float> value)
		{
			return ConvertToInt32WithTruncation(value);
		}

		public static Vector128<float> Divide(Vector128<float> left, Vector128<float> right)
		{
			return Divide(left, right);
		}

		public static Vector128<float> DivideScalar(Vector128<float> left, Vector128<float> right)
		{
			return DivideScalar(left, right);
		}

		public unsafe static Vector128<float> LoadVector128(float* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<float> LoadScalarVector128(float* address)
		{
			return LoadScalarVector128(address);
		}

		public unsafe static Vector128<float> LoadAlignedVector128(float* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<float> LoadHigh(Vector128<float> lower, float* address)
		{
			return LoadHigh(lower, address);
		}

		public unsafe static Vector128<float> LoadLow(Vector128<float> upper, float* address)
		{
			return LoadLow(upper, address);
		}

		public static Vector128<float> Max(Vector128<float> left, Vector128<float> right)
		{
			return Max(left, right);
		}

		public static Vector128<float> MaxScalar(Vector128<float> left, Vector128<float> right)
		{
			return MaxScalar(left, right);
		}

		public static Vector128<float> Min(Vector128<float> left, Vector128<float> right)
		{
			return Min(left, right);
		}

		public static Vector128<float> MinScalar(Vector128<float> left, Vector128<float> right)
		{
			return MinScalar(left, right);
		}

		public static Vector128<float> MoveScalar(Vector128<float> upper, Vector128<float> value)
		{
			return MoveScalar(upper, value);
		}

		public static Vector128<float> MoveHighToLow(Vector128<float> left, Vector128<float> right)
		{
			return MoveHighToLow(left, right);
		}

		public static Vector128<float> MoveLowToHigh(Vector128<float> left, Vector128<float> right)
		{
			return MoveLowToHigh(left, right);
		}

		public static int MoveMask(Vector128<float> value)
		{
			return MoveMask(value);
		}

		public static Vector128<float> Multiply(Vector128<float> left, Vector128<float> right)
		{
			return Multiply(left, right);
		}

		public static Vector128<float> MultiplyScalar(Vector128<float> left, Vector128<float> right)
		{
			return MultiplyScalar(left, right);
		}

		public static Vector128<float> Or(Vector128<float> left, Vector128<float> right)
		{
			return Or(left, right);
		}

		public unsafe static void Prefetch0(void* address)
		{
			Prefetch0(address);
		}

		public unsafe static void Prefetch1(void* address)
		{
			Prefetch1(address);
		}

		public unsafe static void Prefetch2(void* address)
		{
			Prefetch2(address);
		}

		public unsafe static void PrefetchNonTemporal(void* address)
		{
			PrefetchNonTemporal(address);
		}

		public static Vector128<float> Reciprocal(Vector128<float> value)
		{
			return Reciprocal(value);
		}

		public static Vector128<float> ReciprocalScalar(Vector128<float> value)
		{
			return ReciprocalScalar(value);
		}

		public static Vector128<float> ReciprocalScalar(Vector128<float> upper, Vector128<float> value)
		{
			return ReciprocalScalar(upper, value);
		}

		public static Vector128<float> ReciprocalSqrt(Vector128<float> value)
		{
			return ReciprocalSqrt(value);
		}

		public static Vector128<float> ReciprocalSqrtScalar(Vector128<float> value)
		{
			return ReciprocalSqrtScalar(value);
		}

		public static Vector128<float> ReciprocalSqrtScalar(Vector128<float> upper, Vector128<float> value)
		{
			return ReciprocalSqrtScalar(upper, value);
		}

		public static Vector128<float> Shuffle(Vector128<float> left, Vector128<float> right, byte control)
		{
			return Shuffle(left, right, control);
		}

		public static Vector128<float> Sqrt(Vector128<float> value)
		{
			return Sqrt(value);
		}

		public static Vector128<float> SqrtScalar(Vector128<float> value)
		{
			return SqrtScalar(value);
		}

		public static Vector128<float> SqrtScalar(Vector128<float> upper, Vector128<float> value)
		{
			return SqrtScalar(upper, value);
		}

		public unsafe static void StoreAligned(float* address, Vector128<float> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(float* address, Vector128<float> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void Store(float* address, Vector128<float> source)
		{
			Store(address, source);
		}

		public static void StoreFence()
		{
			StoreFence();
		}

		public unsafe static void StoreScalar(float* address, Vector128<float> source)
		{
			StoreScalar(address, source);
		}

		public unsafe static void StoreHigh(float* address, Vector128<float> source)
		{
			StoreHigh(address, source);
		}

		public unsafe static void StoreLow(float* address, Vector128<float> source)
		{
			StoreLow(address, source);
		}

		public static Vector128<float> Subtract(Vector128<float> left, Vector128<float> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<float> SubtractScalar(Vector128<float> left, Vector128<float> right)
		{
			return SubtractScalar(left, right);
		}

		public static Vector128<float> UnpackHigh(Vector128<float> left, Vector128<float> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<float> UnpackLow(Vector128<float> left, Vector128<float> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<float> Xor(Vector128<float> left, Vector128<float> right)
		{
			return Xor(left, right);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Sse2 : Sse
	{
		[Intrinsic]
		public new abstract class X64 : Sse.X64
		{
			public new static bool IsSupported => IsSupported;

			public static long ConvertToInt64(Vector128<double> value)
			{
				return ConvertToInt64(value);
			}

			public static long ConvertToInt64(Vector128<long> value)
			{
				return ConvertToInt64(value);
			}

			public static ulong ConvertToUInt64(Vector128<ulong> value)
			{
				return ConvertToUInt64(value);
			}

			public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, long value)
			{
				return ConvertScalarToVector128Double(upper, value);
			}

			public static Vector128<long> ConvertScalarToVector128Int64(long value)
			{
				return ConvertScalarToVector128Int64(value);
			}

			public static Vector128<ulong> ConvertScalarToVector128UInt64(ulong value)
			{
				return ConvertScalarToVector128UInt64(value);
			}

			public static long ConvertToInt64WithTruncation(Vector128<double> value)
			{
				return ConvertToInt64WithTruncation(value);
			}

			public unsafe static void StoreNonTemporal(long* address, long value)
			{
				StoreNonTemporal(address, value);
			}

			public unsafe static void StoreNonTemporal(ulong* address, ulong value)
			{
				StoreNonTemporal(address, value);
			}
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<byte> Add(Vector128<byte> left, Vector128<byte> right)
		{
			return Add(left, right);
		}

		public static Vector128<sbyte> Add(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return Add(left, right);
		}

		public static Vector128<short> Add(Vector128<short> left, Vector128<short> right)
		{
			return Add(left, right);
		}

		public static Vector128<ushort> Add(Vector128<ushort> left, Vector128<ushort> right)
		{
			return Add(left, right);
		}

		public static Vector128<int> Add(Vector128<int> left, Vector128<int> right)
		{
			return Add(left, right);
		}

		public static Vector128<uint> Add(Vector128<uint> left, Vector128<uint> right)
		{
			return Add(left, right);
		}

		public static Vector128<long> Add(Vector128<long> left, Vector128<long> right)
		{
			return Add(left, right);
		}

		public static Vector128<ulong> Add(Vector128<ulong> left, Vector128<ulong> right)
		{
			return Add(left, right);
		}

		public static Vector128<double> Add(Vector128<double> left, Vector128<double> right)
		{
			return Add(left, right);
		}

		public static Vector128<double> AddScalar(Vector128<double> left, Vector128<double> right)
		{
			return AddScalar(left, right);
		}

		public static Vector128<sbyte> AddSaturate(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return AddSaturate(left, right);
		}

		public static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right)
		{
			return AddSaturate(left, right);
		}

		public static Vector128<short> AddSaturate(Vector128<short> left, Vector128<short> right)
		{
			return AddSaturate(left, right);
		}

		public static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right)
		{
			return AddSaturate(left, right);
		}

		public static Vector128<byte> And(Vector128<byte> left, Vector128<byte> right)
		{
			return And(left, right);
		}

		public static Vector128<sbyte> And(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return And(left, right);
		}

		public static Vector128<short> And(Vector128<short> left, Vector128<short> right)
		{
			return And(left, right);
		}

		public static Vector128<ushort> And(Vector128<ushort> left, Vector128<ushort> right)
		{
			return And(left, right);
		}

		public static Vector128<int> And(Vector128<int> left, Vector128<int> right)
		{
			return And(left, right);
		}

		public static Vector128<uint> And(Vector128<uint> left, Vector128<uint> right)
		{
			return And(left, right);
		}

		public static Vector128<long> And(Vector128<long> left, Vector128<long> right)
		{
			return And(left, right);
		}

		public static Vector128<ulong> And(Vector128<ulong> left, Vector128<ulong> right)
		{
			return And(left, right);
		}

		public static Vector128<double> And(Vector128<double> left, Vector128<double> right)
		{
			return And(left, right);
		}

		public static Vector128<byte> AndNot(Vector128<byte> left, Vector128<byte> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<sbyte> AndNot(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<short> AndNot(Vector128<short> left, Vector128<short> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<ushort> AndNot(Vector128<ushort> left, Vector128<ushort> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<int> AndNot(Vector128<int> left, Vector128<int> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<uint> AndNot(Vector128<uint> left, Vector128<uint> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<long> AndNot(Vector128<long> left, Vector128<long> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<ulong> AndNot(Vector128<ulong> left, Vector128<ulong> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<double> AndNot(Vector128<double> left, Vector128<double> right)
		{
			return AndNot(left, right);
		}

		public static Vector128<byte> Average(Vector128<byte> left, Vector128<byte> right)
		{
			return Average(left, right);
		}

		public static Vector128<ushort> Average(Vector128<ushort> left, Vector128<ushort> right)
		{
			return Average(left, right);
		}

		public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector128<int> CompareEqual(Vector128<int> left, Vector128<int> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector128<uint> CompareEqual(Vector128<uint> left, Vector128<uint> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector128<double> CompareEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareEqual(left, right);
		}

		public static bool CompareScalarOrderedEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarOrderedEqual(left, right);
		}

		public static bool CompareScalarUnorderedEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarUnorderedEqual(left, right);
		}

		public static Vector128<double> CompareScalarEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarEqual(left, right);
		}

		public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static Vector128<int> CompareGreaterThan(Vector128<int> left, Vector128<int> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static Vector128<double> CompareGreaterThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static bool CompareScalarOrderedGreaterThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarOrderedGreaterThan(left, right);
		}

		public static bool CompareScalarUnorderedGreaterThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarUnorderedGreaterThan(left, right);
		}

		public static Vector128<double> CompareScalarGreaterThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarGreaterThan(left, right);
		}

		public static Vector128<double> CompareGreaterThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareGreaterThanOrEqual(left, right);
		}

		public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarOrderedGreaterThanOrEqual(left, right);
		}

		public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarUnorderedGreaterThanOrEqual(left, right);
		}

		public static Vector128<double> CompareScalarGreaterThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarGreaterThanOrEqual(left, right);
		}

		public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return CompareLessThan(left, right);
		}

		public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right)
		{
			return CompareLessThan(left, right);
		}

		public static Vector128<int> CompareLessThan(Vector128<int> left, Vector128<int> right)
		{
			return CompareLessThan(left, right);
		}

		public static Vector128<double> CompareLessThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareLessThan(left, right);
		}

		public static bool CompareScalarOrderedLessThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarOrderedLessThan(left, right);
		}

		public static bool CompareScalarUnorderedLessThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarUnorderedLessThan(left, right);
		}

		public static Vector128<double> CompareScalarLessThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarLessThan(left, right);
		}

		public static Vector128<double> CompareLessThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareLessThanOrEqual(left, right);
		}

		public static bool CompareScalarOrderedLessThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarOrderedLessThanOrEqual(left, right);
		}

		public static bool CompareScalarUnorderedLessThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarUnorderedLessThanOrEqual(left, right);
		}

		public static Vector128<double> CompareScalarLessThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarLessThanOrEqual(left, right);
		}

		public static Vector128<double> CompareNotEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareNotEqual(left, right);
		}

		public static bool CompareScalarOrderedNotEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarOrderedNotEqual(left, right);
		}

		public static bool CompareScalarUnorderedNotEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarUnorderedNotEqual(left, right);
		}

		public static Vector128<double> CompareScalarNotEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarNotEqual(left, right);
		}

		public static Vector128<double> CompareNotGreaterThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareNotGreaterThan(left, right);
		}

		public static Vector128<double> CompareScalarNotGreaterThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarNotGreaterThan(left, right);
		}

		public static Vector128<double> CompareNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareNotGreaterThanOrEqual(left, right);
		}

		public static Vector128<double> CompareScalarNotGreaterThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarNotGreaterThanOrEqual(left, right);
		}

		public static Vector128<double> CompareNotLessThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareNotLessThan(left, right);
		}

		public static Vector128<double> CompareScalarNotLessThan(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarNotLessThan(left, right);
		}

		public static Vector128<double> CompareNotLessThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareNotLessThanOrEqual(left, right);
		}

		public static Vector128<double> CompareScalarNotLessThanOrEqual(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarNotLessThanOrEqual(left, right);
		}

		public static Vector128<double> CompareOrdered(Vector128<double> left, Vector128<double> right)
		{
			return CompareOrdered(left, right);
		}

		public static Vector128<double> CompareScalarOrdered(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarOrdered(left, right);
		}

		public static Vector128<double> CompareUnordered(Vector128<double> left, Vector128<double> right)
		{
			return CompareUnordered(left, right);
		}

		public static Vector128<double> CompareScalarUnordered(Vector128<double> left, Vector128<double> right)
		{
			return CompareScalarUnordered(left, right);
		}

		public static Vector128<int> ConvertToVector128Int32(Vector128<float> value)
		{
			return ConvertToVector128Int32(value);
		}

		public static Vector128<int> ConvertToVector128Int32(Vector128<double> value)
		{
			return ConvertToVector128Int32(value);
		}

		public static Vector128<float> ConvertToVector128Single(Vector128<int> value)
		{
			return ConvertToVector128Single(value);
		}

		public static Vector128<float> ConvertToVector128Single(Vector128<double> value)
		{
			return ConvertToVector128Single(value);
		}

		public static Vector128<double> ConvertToVector128Double(Vector128<int> value)
		{
			return ConvertToVector128Double(value);
		}

		public static Vector128<double> ConvertToVector128Double(Vector128<float> value)
		{
			return ConvertToVector128Double(value);
		}

		public static int ConvertToInt32(Vector128<double> value)
		{
			return ConvertToInt32(value);
		}

		public static int ConvertToInt32(Vector128<int> value)
		{
			return ConvertToInt32(value);
		}

		public static uint ConvertToUInt32(Vector128<uint> value)
		{
			return ConvertToUInt32(value);
		}

		public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, int value)
		{
			return ConvertScalarToVector128Double(upper, value);
		}

		public static Vector128<double> ConvertScalarToVector128Double(Vector128<double> upper, Vector128<float> value)
		{
			return ConvertScalarToVector128Double(upper, value);
		}

		public static Vector128<int> ConvertScalarToVector128Int32(int value)
		{
			return ConvertScalarToVector128Int32(value);
		}

		public static Vector128<float> ConvertScalarToVector128Single(Vector128<float> upper, Vector128<double> value)
		{
			return ConvertScalarToVector128Single(upper, value);
		}

		public static Vector128<uint> ConvertScalarToVector128UInt32(uint value)
		{
			return ConvertScalarToVector128UInt32(value);
		}

		public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<float> value)
		{
			return ConvertToVector128Int32WithTruncation(value);
		}

		public static Vector128<int> ConvertToVector128Int32WithTruncation(Vector128<double> value)
		{
			return ConvertToVector128Int32WithTruncation(value);
		}

		public static int ConvertToInt32WithTruncation(Vector128<double> value)
		{
			return ConvertToInt32WithTruncation(value);
		}

		public static Vector128<double> Divide(Vector128<double> left, Vector128<double> right)
		{
			return Divide(left, right);
		}

		public static Vector128<double> DivideScalar(Vector128<double> left, Vector128<double> right)
		{
			return DivideScalar(left, right);
		}

		public static ushort Extract(Vector128<ushort> value, byte index)
		{
			return Extract(value, index);
		}

		public static Vector128<short> Insert(Vector128<short> value, short data, byte index)
		{
			return Insert(value, data, index);
		}

		public static Vector128<ushort> Insert(Vector128<ushort> value, ushort data, byte index)
		{
			return Insert(value, data, index);
		}

		public unsafe static Vector128<sbyte> LoadVector128(sbyte* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<byte> LoadVector128(byte* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<short> LoadVector128(short* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<ushort> LoadVector128(ushort* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<int> LoadVector128(int* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<uint> LoadVector128(uint* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<long> LoadVector128(long* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<ulong> LoadVector128(ulong* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<double> LoadVector128(double* address)
		{
			return LoadVector128(address);
		}

		public unsafe static Vector128<double> LoadScalarVector128(double* address)
		{
			return LoadScalarVector128(address);
		}

		public unsafe static Vector128<sbyte> LoadAlignedVector128(sbyte* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<byte> LoadAlignedVector128(byte* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<short> LoadAlignedVector128(short* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<ushort> LoadAlignedVector128(ushort* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<int> LoadAlignedVector128(int* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<uint> LoadAlignedVector128(uint* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<long> LoadAlignedVector128(long* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<ulong> LoadAlignedVector128(ulong* address)
		{
			return LoadAlignedVector128(address);
		}

		public unsafe static Vector128<double> LoadAlignedVector128(double* address)
		{
			return LoadAlignedVector128(address);
		}

		public static void LoadFence()
		{
			LoadFence();
		}

		public unsafe static Vector128<double> LoadHigh(Vector128<double> lower, double* address)
		{
			return LoadHigh(lower, address);
		}

		public unsafe static Vector128<double> LoadLow(Vector128<double> upper, double* address)
		{
			return LoadLow(upper, address);
		}

		public unsafe static Vector128<int> LoadScalarVector128(int* address)
		{
			return LoadScalarVector128(address);
		}

		public unsafe static Vector128<uint> LoadScalarVector128(uint* address)
		{
			return LoadScalarVector128(address);
		}

		public unsafe static Vector128<long> LoadScalarVector128(long* address)
		{
			return LoadScalarVector128(address);
		}

		public unsafe static Vector128<ulong> LoadScalarVector128(ulong* address)
		{
			return LoadScalarVector128(address);
		}

		public unsafe static void MaskMove(Vector128<sbyte> source, Vector128<sbyte> mask, sbyte* address)
		{
			MaskMove(source, mask, address);
		}

		public unsafe static void MaskMove(Vector128<byte> source, Vector128<byte> mask, byte* address)
		{
			MaskMove(source, mask, address);
		}

		public static Vector128<byte> Max(Vector128<byte> left, Vector128<byte> right)
		{
			return Max(left, right);
		}

		public static Vector128<short> Max(Vector128<short> left, Vector128<short> right)
		{
			return Max(left, right);
		}

		public static Vector128<double> Max(Vector128<double> left, Vector128<double> right)
		{
			return Max(left, right);
		}

		public static Vector128<double> MaxScalar(Vector128<double> left, Vector128<double> right)
		{
			return MaxScalar(left, right);
		}

		public static void MemoryFence()
		{
			MemoryFence();
		}

		public static Vector128<byte> Min(Vector128<byte> left, Vector128<byte> right)
		{
			return Min(left, right);
		}

		public static Vector128<short> Min(Vector128<short> left, Vector128<short> right)
		{
			return Min(left, right);
		}

		public static Vector128<double> Min(Vector128<double> left, Vector128<double> right)
		{
			return Min(left, right);
		}

		public static Vector128<double> MinScalar(Vector128<double> left, Vector128<double> right)
		{
			return MinScalar(left, right);
		}

		public static Vector128<double> MoveScalar(Vector128<double> upper, Vector128<double> value)
		{
			return MoveScalar(upper, value);
		}

		public static int MoveMask(Vector128<sbyte> value)
		{
			return MoveMask(value);
		}

		public static int MoveMask(Vector128<byte> value)
		{
			return MoveMask(value);
		}

		public static int MoveMask(Vector128<double> value)
		{
			return MoveMask(value);
		}

		public static Vector128<long> MoveScalar(Vector128<long> value)
		{
			return MoveScalar(value);
		}

		public static Vector128<ulong> MoveScalar(Vector128<ulong> value)
		{
			return MoveScalar(value);
		}

		public static Vector128<ulong> Multiply(Vector128<uint> left, Vector128<uint> right)
		{
			return Multiply(left, right);
		}

		public static Vector128<double> Multiply(Vector128<double> left, Vector128<double> right)
		{
			return Multiply(left, right);
		}

		public static Vector128<double> MultiplyScalar(Vector128<double> left, Vector128<double> right)
		{
			return MultiplyScalar(left, right);
		}

		public static Vector128<short> MultiplyHigh(Vector128<short> left, Vector128<short> right)
		{
			return MultiplyHigh(left, right);
		}

		public static Vector128<ushort> MultiplyHigh(Vector128<ushort> left, Vector128<ushort> right)
		{
			return MultiplyHigh(left, right);
		}

		public static Vector128<int> MultiplyAddAdjacent(Vector128<short> left, Vector128<short> right)
		{
			return MultiplyAddAdjacent(left, right);
		}

		public static Vector128<short> MultiplyLow(Vector128<short> left, Vector128<short> right)
		{
			return MultiplyLow(left, right);
		}

		public static Vector128<ushort> MultiplyLow(Vector128<ushort> left, Vector128<ushort> right)
		{
			return MultiplyLow(left, right);
		}

		public static Vector128<byte> Or(Vector128<byte> left, Vector128<byte> right)
		{
			return Or(left, right);
		}

		public static Vector128<sbyte> Or(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return Or(left, right);
		}

		public static Vector128<short> Or(Vector128<short> left, Vector128<short> right)
		{
			return Or(left, right);
		}

		public static Vector128<ushort> Or(Vector128<ushort> left, Vector128<ushort> right)
		{
			return Or(left, right);
		}

		public static Vector128<int> Or(Vector128<int> left, Vector128<int> right)
		{
			return Or(left, right);
		}

		public static Vector128<uint> Or(Vector128<uint> left, Vector128<uint> right)
		{
			return Or(left, right);
		}

		public static Vector128<long> Or(Vector128<long> left, Vector128<long> right)
		{
			return Or(left, right);
		}

		public static Vector128<ulong> Or(Vector128<ulong> left, Vector128<ulong> right)
		{
			return Or(left, right);
		}

		public static Vector128<double> Or(Vector128<double> left, Vector128<double> right)
		{
			return Or(left, right);
		}

		public static Vector128<sbyte> PackSignedSaturate(Vector128<short> left, Vector128<short> right)
		{
			return PackSignedSaturate(left, right);
		}

		public static Vector128<short> PackSignedSaturate(Vector128<int> left, Vector128<int> right)
		{
			return PackSignedSaturate(left, right);
		}

		public static Vector128<byte> PackUnsignedSaturate(Vector128<short> left, Vector128<short> right)
		{
			return PackUnsignedSaturate(left, right);
		}

		public static Vector128<ushort> SumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right)
		{
			return SumAbsoluteDifferences(left, right);
		}

		public static Vector128<int> Shuffle(Vector128<int> value, byte control)
		{
			return Shuffle(value, control);
		}

		public static Vector128<uint> Shuffle(Vector128<uint> value, byte control)
		{
			return Shuffle(value, control);
		}

		public static Vector128<double> Shuffle(Vector128<double> left, Vector128<double> right, byte control)
		{
			return Shuffle(left, right, control);
		}

		public static Vector128<short> ShuffleHigh(Vector128<short> value, byte control)
		{
			return ShuffleHigh(value, control);
		}

		public static Vector128<ushort> ShuffleHigh(Vector128<ushort> value, byte control)
		{
			return ShuffleHigh(value, control);
		}

		public static Vector128<short> ShuffleLow(Vector128<short> value, byte control)
		{
			return ShuffleLow(value, control);
		}

		public static Vector128<ushort> ShuffleLow(Vector128<ushort> value, byte control)
		{
			return ShuffleLow(value, control);
		}

		public static Vector128<short> ShiftLeftLogical(Vector128<short> value, Vector128<short> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, Vector128<ushort> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<int> ShiftLeftLogical(Vector128<int> value, Vector128<int> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, Vector128<uint> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<long> ShiftLeftLogical(Vector128<long> value, Vector128<long> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, Vector128<ulong> count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<short> ShiftLeftLogical(Vector128<short> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<ushort> ShiftLeftLogical(Vector128<ushort> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<int> ShiftLeftLogical(Vector128<int> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<uint> ShiftLeftLogical(Vector128<uint> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<long> ShiftLeftLogical(Vector128<long> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<ulong> ShiftLeftLogical(Vector128<ulong> value, byte count)
		{
			return ShiftLeftLogical(value, count);
		}

		public static Vector128<sbyte> ShiftLeftLogical128BitLane(Vector128<sbyte> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector128<byte> ShiftLeftLogical128BitLane(Vector128<byte> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector128<short> ShiftLeftLogical128BitLane(Vector128<short> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector128<ushort> ShiftLeftLogical128BitLane(Vector128<ushort> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector128<int> ShiftLeftLogical128BitLane(Vector128<int> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector128<uint> ShiftLeftLogical128BitLane(Vector128<uint> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector128<long> ShiftLeftLogical128BitLane(Vector128<long> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector128<ulong> ShiftLeftLogical128BitLane(Vector128<ulong> value, byte numBytes)
		{
			return ShiftLeftLogical128BitLane(value, numBytes);
		}

		public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, Vector128<short> count)
		{
			return ShiftRightArithmetic(value, count);
		}

		public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, Vector128<int> count)
		{
			return ShiftRightArithmetic(value, count);
		}

		public static Vector128<short> ShiftRightArithmetic(Vector128<short> value, byte count)
		{
			return ShiftRightArithmetic(value, count);
		}

		public static Vector128<int> ShiftRightArithmetic(Vector128<int> value, byte count)
		{
			return ShiftRightArithmetic(value, count);
		}

		public static Vector128<short> ShiftRightLogical(Vector128<short> value, Vector128<short> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, Vector128<ushort> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<int> ShiftRightLogical(Vector128<int> value, Vector128<int> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, Vector128<uint> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<long> ShiftRightLogical(Vector128<long> value, Vector128<long> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, Vector128<ulong> count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<short> ShiftRightLogical(Vector128<short> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<ushort> ShiftRightLogical(Vector128<ushort> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<int> ShiftRightLogical(Vector128<int> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<uint> ShiftRightLogical(Vector128<uint> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<long> ShiftRightLogical(Vector128<long> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<ulong> ShiftRightLogical(Vector128<ulong> value, byte count)
		{
			return ShiftRightLogical(value, count);
		}

		public static Vector128<sbyte> ShiftRightLogical128BitLane(Vector128<sbyte> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector128<byte> ShiftRightLogical128BitLane(Vector128<byte> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector128<short> ShiftRightLogical128BitLane(Vector128<short> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector128<ushort> ShiftRightLogical128BitLane(Vector128<ushort> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector128<int> ShiftRightLogical128BitLane(Vector128<int> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector128<uint> ShiftRightLogical128BitLane(Vector128<uint> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector128<long> ShiftRightLogical128BitLane(Vector128<long> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector128<ulong> ShiftRightLogical128BitLane(Vector128<ulong> value, byte numBytes)
		{
			return ShiftRightLogical128BitLane(value, numBytes);
		}

		public static Vector128<double> Sqrt(Vector128<double> value)
		{
			return Sqrt(value);
		}

		public static Vector128<double> SqrtScalar(Vector128<double> value)
		{
			return SqrtScalar(value);
		}

		public static Vector128<double> SqrtScalar(Vector128<double> upper, Vector128<double> value)
		{
			return SqrtScalar(upper, value);
		}

		public unsafe static void StoreScalar(double* address, Vector128<double> source)
		{
			StoreScalar(address, source);
		}

		public unsafe static void StoreScalar(int* address, Vector128<int> source)
		{
			StoreScalar(address, source);
		}

		public unsafe static void StoreScalar(long* address, Vector128<long> source)
		{
			StoreScalar(address, source);
		}

		public unsafe static void StoreScalar(uint* address, Vector128<uint> source)
		{
			StoreScalar(address, source);
		}

		public unsafe static void StoreScalar(ulong* address, Vector128<ulong> source)
		{
			StoreScalar(address, source);
		}

		public unsafe static void StoreAligned(sbyte* address, Vector128<sbyte> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(byte* address, Vector128<byte> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(short* address, Vector128<short> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(ushort* address, Vector128<ushort> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(int* address, Vector128<int> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(uint* address, Vector128<uint> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(long* address, Vector128<long> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(ulong* address, Vector128<ulong> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAligned(double* address, Vector128<double> source)
		{
			StoreAligned(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(sbyte* address, Vector128<sbyte> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(byte* address, Vector128<byte> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(short* address, Vector128<short> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(ushort* address, Vector128<ushort> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(int* address, Vector128<int> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(uint* address, Vector128<uint> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(long* address, Vector128<long> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(ulong* address, Vector128<ulong> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void StoreAlignedNonTemporal(double* address, Vector128<double> source)
		{
			StoreAlignedNonTemporal(address, source);
		}

		public unsafe static void Store(sbyte* address, Vector128<sbyte> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(byte* address, Vector128<byte> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(short* address, Vector128<short> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(ushort* address, Vector128<ushort> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(int* address, Vector128<int> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(uint* address, Vector128<uint> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(long* address, Vector128<long> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(ulong* address, Vector128<ulong> source)
		{
			Store(address, source);
		}

		public unsafe static void Store(double* address, Vector128<double> source)
		{
			Store(address, source);
		}

		public unsafe static void StoreHigh(double* address, Vector128<double> source)
		{
			StoreHigh(address, source);
		}

		public unsafe static void StoreLow(double* address, Vector128<double> source)
		{
			StoreLow(address, source);
		}

		public unsafe static void StoreNonTemporal(int* address, int value)
		{
			StoreNonTemporal(address, value);
		}

		public unsafe static void StoreNonTemporal(uint* address, uint value)
		{
			StoreNonTemporal(address, value);
		}

		public static Vector128<byte> Subtract(Vector128<byte> left, Vector128<byte> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<sbyte> Subtract(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<short> Subtract(Vector128<short> left, Vector128<short> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<ushort> Subtract(Vector128<ushort> left, Vector128<ushort> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<int> Subtract(Vector128<int> left, Vector128<int> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<uint> Subtract(Vector128<uint> left, Vector128<uint> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<long> Subtract(Vector128<long> left, Vector128<long> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<ulong> Subtract(Vector128<ulong> left, Vector128<ulong> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<double> Subtract(Vector128<double> left, Vector128<double> right)
		{
			return Subtract(left, right);
		}

		public static Vector128<double> SubtractScalar(Vector128<double> left, Vector128<double> right)
		{
			return SubtractScalar(left, right);
		}

		public static Vector128<sbyte> SubtractSaturate(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return SubtractSaturate(left, right);
		}

		public static Vector128<short> SubtractSaturate(Vector128<short> left, Vector128<short> right)
		{
			return SubtractSaturate(left, right);
		}

		public static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right)
		{
			return SubtractSaturate(left, right);
		}

		public static Vector128<ushort> SubtractSaturate(Vector128<ushort> left, Vector128<ushort> right)
		{
			return SubtractSaturate(left, right);
		}

		public static Vector128<byte> UnpackHigh(Vector128<byte> left, Vector128<byte> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<sbyte> UnpackHigh(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<short> UnpackHigh(Vector128<short> left, Vector128<short> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<ushort> UnpackHigh(Vector128<ushort> left, Vector128<ushort> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<int> UnpackHigh(Vector128<int> left, Vector128<int> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<uint> UnpackHigh(Vector128<uint> left, Vector128<uint> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<long> UnpackHigh(Vector128<long> left, Vector128<long> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<ulong> UnpackHigh(Vector128<ulong> left, Vector128<ulong> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<double> UnpackHigh(Vector128<double> left, Vector128<double> right)
		{
			return UnpackHigh(left, right);
		}

		public static Vector128<byte> UnpackLow(Vector128<byte> left, Vector128<byte> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<sbyte> UnpackLow(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<short> UnpackLow(Vector128<short> left, Vector128<short> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<ushort> UnpackLow(Vector128<ushort> left, Vector128<ushort> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<int> UnpackLow(Vector128<int> left, Vector128<int> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<uint> UnpackLow(Vector128<uint> left, Vector128<uint> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<long> UnpackLow(Vector128<long> left, Vector128<long> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<ulong> UnpackLow(Vector128<ulong> left, Vector128<ulong> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<double> UnpackLow(Vector128<double> left, Vector128<double> right)
		{
			return UnpackLow(left, right);
		}

		public static Vector128<byte> Xor(Vector128<byte> left, Vector128<byte> right)
		{
			return Xor(left, right);
		}

		public static Vector128<sbyte> Xor(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return Xor(left, right);
		}

		public static Vector128<short> Xor(Vector128<short> left, Vector128<short> right)
		{
			return Xor(left, right);
		}

		public static Vector128<ushort> Xor(Vector128<ushort> left, Vector128<ushort> right)
		{
			return Xor(left, right);
		}

		public static Vector128<int> Xor(Vector128<int> left, Vector128<int> right)
		{
			return Xor(left, right);
		}

		public static Vector128<uint> Xor(Vector128<uint> left, Vector128<uint> right)
		{
			return Xor(left, right);
		}

		public static Vector128<long> Xor(Vector128<long> left, Vector128<long> right)
		{
			return Xor(left, right);
		}

		public static Vector128<ulong> Xor(Vector128<ulong> left, Vector128<ulong> right)
		{
			return Xor(left, right);
		}

		public static Vector128<double> Xor(Vector128<double> left, Vector128<double> right)
		{
			return Xor(left, right);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Sse3 : Sse2
	{
		[Intrinsic]
		public new abstract class X64 : Sse2.X64
		{
			public new static bool IsSupported => IsSupported;
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<float> AddSubtract(Vector128<float> left, Vector128<float> right)
		{
			return AddSubtract(left, right);
		}

		public static Vector128<double> AddSubtract(Vector128<double> left, Vector128<double> right)
		{
			return AddSubtract(left, right);
		}

		public static Vector128<float> HorizontalAdd(Vector128<float> left, Vector128<float> right)
		{
			return HorizontalAdd(left, right);
		}

		public static Vector128<double> HorizontalAdd(Vector128<double> left, Vector128<double> right)
		{
			return HorizontalAdd(left, right);
		}

		public static Vector128<float> HorizontalSubtract(Vector128<float> left, Vector128<float> right)
		{
			return HorizontalSubtract(left, right);
		}

		public static Vector128<double> HorizontalSubtract(Vector128<double> left, Vector128<double> right)
		{
			return HorizontalSubtract(left, right);
		}

		public unsafe static Vector128<double> LoadAndDuplicateToVector128(double* address)
		{
			return LoadAndDuplicateToVector128(address);
		}

		public unsafe static Vector128<sbyte> LoadDquVector128(sbyte* address)
		{
			return LoadDquVector128(address);
		}

		public unsafe static Vector128<byte> LoadDquVector128(byte* address)
		{
			return LoadDquVector128(address);
		}

		public unsafe static Vector128<short> LoadDquVector128(short* address)
		{
			return LoadDquVector128(address);
		}

		public unsafe static Vector128<ushort> LoadDquVector128(ushort* address)
		{
			return LoadDquVector128(address);
		}

		public unsafe static Vector128<int> LoadDquVector128(int* address)
		{
			return LoadDquVector128(address);
		}

		public unsafe static Vector128<uint> LoadDquVector128(uint* address)
		{
			return LoadDquVector128(address);
		}

		public unsafe static Vector128<long> LoadDquVector128(long* address)
		{
			return LoadDquVector128(address);
		}

		public unsafe static Vector128<ulong> LoadDquVector128(ulong* address)
		{
			return LoadDquVector128(address);
		}

		public static Vector128<double> MoveAndDuplicate(Vector128<double> source)
		{
			return MoveAndDuplicate(source);
		}

		public static Vector128<float> MoveHighAndDuplicate(Vector128<float> source)
		{
			return MoveHighAndDuplicate(source);
		}

		public static Vector128<float> MoveLowAndDuplicate(Vector128<float> source)
		{
			return MoveLowAndDuplicate(source);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Sse41 : Ssse3
	{
		[Intrinsic]
		public new abstract class X64 : Ssse3.X64
		{
			public new static bool IsSupported => IsSupported;

			public static long Extract(Vector128<long> value, byte index)
			{
				return Extract(value, index);
			}

			public static ulong Extract(Vector128<ulong> value, byte index)
			{
				return Extract(value, index);
			}

			public static Vector128<long> Insert(Vector128<long> value, long data, byte index)
			{
				return Insert(value, data, index);
			}

			public static Vector128<ulong> Insert(Vector128<ulong> value, ulong data, byte index)
			{
				return Insert(value, data, index);
			}
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<short> Blend(Vector128<short> left, Vector128<short> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector128<ushort> Blend(Vector128<ushort> left, Vector128<ushort> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector128<float> Blend(Vector128<float> left, Vector128<float> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector128<double> Blend(Vector128<double> left, Vector128<double> right, byte control)
		{
			return Blend(left, right, control);
		}

		public static Vector128<sbyte> BlendVariable(Vector128<sbyte> left, Vector128<sbyte> right, Vector128<sbyte> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<byte> BlendVariable(Vector128<byte> left, Vector128<byte> right, Vector128<byte> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<short> BlendVariable(Vector128<short> left, Vector128<short> right, Vector128<short> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<ushort> BlendVariable(Vector128<ushort> left, Vector128<ushort> right, Vector128<ushort> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<int> BlendVariable(Vector128<int> left, Vector128<int> right, Vector128<int> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<uint> BlendVariable(Vector128<uint> left, Vector128<uint> right, Vector128<uint> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<long> BlendVariable(Vector128<long> left, Vector128<long> right, Vector128<long> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<ulong> BlendVariable(Vector128<ulong> left, Vector128<ulong> right, Vector128<ulong> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<float> BlendVariable(Vector128<float> left, Vector128<float> right, Vector128<float> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<double> BlendVariable(Vector128<double> left, Vector128<double> right, Vector128<double> mask)
		{
			return BlendVariable(left, right, mask);
		}

		public static Vector128<float> Ceiling(Vector128<float> value)
		{
			return Ceiling(value);
		}

		public static Vector128<double> Ceiling(Vector128<double> value)
		{
			return Ceiling(value);
		}

		public static Vector128<double> CeilingScalar(Vector128<double> value)
		{
			return CeilingScalar(value);
		}

		public static Vector128<float> CeilingScalar(Vector128<float> value)
		{
			return CeilingScalar(value);
		}

		public static Vector128<double> CeilingScalar(Vector128<double> upper, Vector128<double> value)
		{
			return CeilingScalar(upper, value);
		}

		public static Vector128<float> CeilingScalar(Vector128<float> upper, Vector128<float> value)
		{
			return CeilingScalar(upper, value);
		}

		public static Vector128<long> CompareEqual(Vector128<long> left, Vector128<long> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector128<ulong> CompareEqual(Vector128<ulong> left, Vector128<ulong> right)
		{
			return CompareEqual(left, right);
		}

		public static Vector128<short> ConvertToVector128Int16(Vector128<sbyte> value)
		{
			return ConvertToVector128Int16(value);
		}

		public static Vector128<short> ConvertToVector128Int16(Vector128<byte> value)
		{
			return ConvertToVector128Int16(value);
		}

		public static Vector128<int> ConvertToVector128Int32(Vector128<sbyte> value)
		{
			return ConvertToVector128Int32(value);
		}

		public static Vector128<int> ConvertToVector128Int32(Vector128<byte> value)
		{
			return ConvertToVector128Int32(value);
		}

		public static Vector128<int> ConvertToVector128Int32(Vector128<short> value)
		{
			return ConvertToVector128Int32(value);
		}

		public static Vector128<int> ConvertToVector128Int32(Vector128<ushort> value)
		{
			return ConvertToVector128Int32(value);
		}

		public static Vector128<long> ConvertToVector128Int64(Vector128<sbyte> value)
		{
			return ConvertToVector128Int64(value);
		}

		public static Vector128<long> ConvertToVector128Int64(Vector128<byte> value)
		{
			return ConvertToVector128Int64(value);
		}

		public static Vector128<long> ConvertToVector128Int64(Vector128<short> value)
		{
			return ConvertToVector128Int64(value);
		}

		public static Vector128<long> ConvertToVector128Int64(Vector128<ushort> value)
		{
			return ConvertToVector128Int64(value);
		}

		public static Vector128<long> ConvertToVector128Int64(Vector128<int> value)
		{
			return ConvertToVector128Int64(value);
		}

		public static Vector128<long> ConvertToVector128Int64(Vector128<uint> value)
		{
			return ConvertToVector128Int64(value);
		}

		public unsafe static Vector128<short> ConvertToVector128Int16(sbyte* address)
		{
			return ConvertToVector128Int16(address);
		}

		public unsafe static Vector128<short> ConvertToVector128Int16(byte* address)
		{
			return ConvertToVector128Int16(address);
		}

		public unsafe static Vector128<int> ConvertToVector128Int32(sbyte* address)
		{
			return ConvertToVector128Int32(address);
		}

		public unsafe static Vector128<int> ConvertToVector128Int32(byte* address)
		{
			return ConvertToVector128Int32(address);
		}

		public unsafe static Vector128<int> ConvertToVector128Int32(short* address)
		{
			return ConvertToVector128Int32(address);
		}

		public unsafe static Vector128<int> ConvertToVector128Int32(ushort* address)
		{
			return ConvertToVector128Int32(address);
		}

		public unsafe static Vector128<long> ConvertToVector128Int64(sbyte* address)
		{
			return ConvertToVector128Int64(address);
		}

		public unsafe static Vector128<long> ConvertToVector128Int64(byte* address)
		{
			return ConvertToVector128Int64(address);
		}

		public unsafe static Vector128<long> ConvertToVector128Int64(short* address)
		{
			return ConvertToVector128Int64(address);
		}

		public unsafe static Vector128<long> ConvertToVector128Int64(ushort* address)
		{
			return ConvertToVector128Int64(address);
		}

		public unsafe static Vector128<long> ConvertToVector128Int64(int* address)
		{
			return ConvertToVector128Int64(address);
		}

		public unsafe static Vector128<long> ConvertToVector128Int64(uint* address)
		{
			return ConvertToVector128Int64(address);
		}

		public static Vector128<float> DotProduct(Vector128<float> left, Vector128<float> right, byte control)
		{
			return DotProduct(left, right, control);
		}

		public static Vector128<double> DotProduct(Vector128<double> left, Vector128<double> right, byte control)
		{
			return DotProduct(left, right, control);
		}

		public static byte Extract(Vector128<byte> value, byte index)
		{
			return Extract(value, index);
		}

		public static int Extract(Vector128<int> value, byte index)
		{
			return Extract(value, index);
		}

		public static uint Extract(Vector128<uint> value, byte index)
		{
			return Extract(value, index);
		}

		public static float Extract(Vector128<float> value, byte index)
		{
			return Extract(value, index);
		}

		public static Vector128<float> Floor(Vector128<float> value)
		{
			return Floor(value);
		}

		public static Vector128<double> Floor(Vector128<double> value)
		{
			return Floor(value);
		}

		public static Vector128<double> FloorScalar(Vector128<double> value)
		{
			return FloorScalar(value);
		}

		public static Vector128<float> FloorScalar(Vector128<float> value)
		{
			return FloorScalar(value);
		}

		public static Vector128<double> FloorScalar(Vector128<double> upper, Vector128<double> value)
		{
			return FloorScalar(upper, value);
		}

		public static Vector128<float> FloorScalar(Vector128<float> upper, Vector128<float> value)
		{
			return FloorScalar(upper, value);
		}

		public static Vector128<sbyte> Insert(Vector128<sbyte> value, sbyte data, byte index)
		{
			return Insert(value, data, index);
		}

		public static Vector128<byte> Insert(Vector128<byte> value, byte data, byte index)
		{
			return Insert(value, data, index);
		}

		public static Vector128<int> Insert(Vector128<int> value, int data, byte index)
		{
			return Insert(value, data, index);
		}

		public static Vector128<uint> Insert(Vector128<uint> value, uint data, byte index)
		{
			return Insert(value, data, index);
		}

		public static Vector128<float> Insert(Vector128<float> value, Vector128<float> data, byte index)
		{
			return Insert(value, data, index);
		}

		public static Vector128<sbyte> Max(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return Max(left, right);
		}

		public static Vector128<ushort> Max(Vector128<ushort> left, Vector128<ushort> right)
		{
			return Max(left, right);
		}

		public static Vector128<int> Max(Vector128<int> left, Vector128<int> right)
		{
			return Max(left, right);
		}

		public static Vector128<uint> Max(Vector128<uint> left, Vector128<uint> right)
		{
			return Max(left, right);
		}

		public static Vector128<sbyte> Min(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return Min(left, right);
		}

		public static Vector128<ushort> Min(Vector128<ushort> left, Vector128<ushort> right)
		{
			return Min(left, right);
		}

		public static Vector128<int> Min(Vector128<int> left, Vector128<int> right)
		{
			return Min(left, right);
		}

		public static Vector128<uint> Min(Vector128<uint> left, Vector128<uint> right)
		{
			return Min(left, right);
		}

		public static Vector128<ushort> MinHorizontal(Vector128<ushort> value)
		{
			return MinHorizontal(value);
		}

		public static Vector128<ushort> MultipleSumAbsoluteDifferences(Vector128<byte> left, Vector128<byte> right, byte mask)
		{
			return MultipleSumAbsoluteDifferences(left, right, mask);
		}

		public static Vector128<long> Multiply(Vector128<int> left, Vector128<int> right)
		{
			return Multiply(left, right);
		}

		public static Vector128<int> MultiplyLow(Vector128<int> left, Vector128<int> right)
		{
			return MultiplyLow(left, right);
		}

		public static Vector128<uint> MultiplyLow(Vector128<uint> left, Vector128<uint> right)
		{
			return MultiplyLow(left, right);
		}

		public static Vector128<ushort> PackUnsignedSaturate(Vector128<int> left, Vector128<int> right)
		{
			return PackUnsignedSaturate(left, right);
		}

		public static Vector128<float> RoundToNearestInteger(Vector128<float> value)
		{
			return RoundToNearestInteger(value);
		}

		public static Vector128<float> RoundToNegativeInfinity(Vector128<float> value)
		{
			return RoundToNegativeInfinity(value);
		}

		public static Vector128<float> RoundToPositiveInfinity(Vector128<float> value)
		{
			return RoundToPositiveInfinity(value);
		}

		public static Vector128<float> RoundToZero(Vector128<float> value)
		{
			return RoundToZero(value);
		}

		public static Vector128<float> RoundCurrentDirection(Vector128<float> value)
		{
			return RoundCurrentDirection(value);
		}

		public static Vector128<double> RoundToNearestInteger(Vector128<double> value)
		{
			return RoundToNearestInteger(value);
		}

		public static Vector128<double> RoundToNegativeInfinity(Vector128<double> value)
		{
			return RoundToNegativeInfinity(value);
		}

		public static Vector128<double> RoundToPositiveInfinity(Vector128<double> value)
		{
			return RoundToPositiveInfinity(value);
		}

		public static Vector128<double> RoundToZero(Vector128<double> value)
		{
			return RoundToZero(value);
		}

		public static Vector128<double> RoundCurrentDirection(Vector128<double> value)
		{
			return RoundCurrentDirection(value);
		}

		public static Vector128<double> RoundCurrentDirectionScalar(Vector128<double> value)
		{
			return RoundCurrentDirectionScalar(value);
		}

		public static Vector128<double> RoundToNearestIntegerScalar(Vector128<double> value)
		{
			return RoundToNearestIntegerScalar(value);
		}

		public static Vector128<double> RoundToNegativeInfinityScalar(Vector128<double> value)
		{
			return RoundToNegativeInfinityScalar(value);
		}

		public static Vector128<double> RoundToPositiveInfinityScalar(Vector128<double> value)
		{
			return RoundToPositiveInfinityScalar(value);
		}

		public static Vector128<double> RoundToZeroScalar(Vector128<double> value)
		{
			return RoundToZeroScalar(value);
		}

		public static Vector128<double> RoundCurrentDirectionScalar(Vector128<double> upper, Vector128<double> value)
		{
			return RoundCurrentDirectionScalar(upper, value);
		}

		public static Vector128<double> RoundToNearestIntegerScalar(Vector128<double> upper, Vector128<double> value)
		{
			return RoundToNearestIntegerScalar(upper, value);
		}

		public static Vector128<double> RoundToNegativeInfinityScalar(Vector128<double> upper, Vector128<double> value)
		{
			return RoundToNegativeInfinityScalar(upper, value);
		}

		public static Vector128<double> RoundToPositiveInfinityScalar(Vector128<double> upper, Vector128<double> value)
		{
			return RoundToPositiveInfinityScalar(upper, value);
		}

		public static Vector128<double> RoundToZeroScalar(Vector128<double> upper, Vector128<double> value)
		{
			return RoundToZeroScalar(upper, value);
		}

		public static Vector128<float> RoundCurrentDirectionScalar(Vector128<float> value)
		{
			return RoundCurrentDirectionScalar(value);
		}

		public static Vector128<float> RoundToNearestIntegerScalar(Vector128<float> value)
		{
			return RoundToNearestIntegerScalar(value);
		}

		public static Vector128<float> RoundToNegativeInfinityScalar(Vector128<float> value)
		{
			return RoundToNegativeInfinityScalar(value);
		}

		public static Vector128<float> RoundToPositiveInfinityScalar(Vector128<float> value)
		{
			return RoundToPositiveInfinityScalar(value);
		}

		public static Vector128<float> RoundToZeroScalar(Vector128<float> value)
		{
			return RoundToZeroScalar(value);
		}

		public static Vector128<float> RoundCurrentDirectionScalar(Vector128<float> upper, Vector128<float> value)
		{
			return RoundCurrentDirectionScalar(upper, value);
		}

		public static Vector128<float> RoundToNearestIntegerScalar(Vector128<float> upper, Vector128<float> value)
		{
			return RoundToNearestIntegerScalar(upper, value);
		}

		public static Vector128<float> RoundToNegativeInfinityScalar(Vector128<float> upper, Vector128<float> value)
		{
			return RoundToNegativeInfinityScalar(upper, value);
		}

		public static Vector128<float> RoundToPositiveInfinityScalar(Vector128<float> upper, Vector128<float> value)
		{
			return RoundToPositiveInfinityScalar(upper, value);
		}

		public static Vector128<float> RoundToZeroScalar(Vector128<float> upper, Vector128<float> value)
		{
			return RoundToZeroScalar(upper, value);
		}

		public unsafe static Vector128<sbyte> LoadAlignedVector128NonTemporal(sbyte* address)
		{
			return LoadAlignedVector128NonTemporal(address);
		}

		public unsafe static Vector128<byte> LoadAlignedVector128NonTemporal(byte* address)
		{
			return LoadAlignedVector128NonTemporal(address);
		}

		public unsafe static Vector128<short> LoadAlignedVector128NonTemporal(short* address)
		{
			return LoadAlignedVector128NonTemporal(address);
		}

		public unsafe static Vector128<ushort> LoadAlignedVector128NonTemporal(ushort* address)
		{
			return LoadAlignedVector128NonTemporal(address);
		}

		public unsafe static Vector128<int> LoadAlignedVector128NonTemporal(int* address)
		{
			return LoadAlignedVector128NonTemporal(address);
		}

		public unsafe static Vector128<uint> LoadAlignedVector128NonTemporal(uint* address)
		{
			return LoadAlignedVector128NonTemporal(address);
		}

		public unsafe static Vector128<long> LoadAlignedVector128NonTemporal(long* address)
		{
			return LoadAlignedVector128NonTemporal(address);
		}

		public unsafe static Vector128<ulong> LoadAlignedVector128NonTemporal(ulong* address)
		{
			return LoadAlignedVector128NonTemporal(address);
		}

		public static bool TestC(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector128<byte> left, Vector128<byte> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector128<short> left, Vector128<short> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector128<ushort> left, Vector128<ushort> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector128<int> left, Vector128<int> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector128<uint> left, Vector128<uint> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector128<long> left, Vector128<long> right)
		{
			return TestC(left, right);
		}

		public static bool TestC(Vector128<ulong> left, Vector128<ulong> right)
		{
			return TestC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<byte> left, Vector128<byte> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<short> left, Vector128<short> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<ushort> left, Vector128<ushort> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<int> left, Vector128<int> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<uint> left, Vector128<uint> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<long> left, Vector128<long> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestNotZAndNotC(Vector128<ulong> left, Vector128<ulong> right)
		{
			return TestNotZAndNotC(left, right);
		}

		public static bool TestZ(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector128<byte> left, Vector128<byte> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector128<short> left, Vector128<short> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector128<ushort> left, Vector128<ushort> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector128<int> left, Vector128<int> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector128<uint> left, Vector128<uint> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector128<long> left, Vector128<long> right)
		{
			return TestZ(left, right);
		}

		public static bool TestZ(Vector128<ulong> left, Vector128<ulong> right)
		{
			return TestZ(left, right);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Sse42 : Sse41
	{
		[Intrinsic]
		public new abstract class X64 : Sse41.X64
		{
			public new static bool IsSupported => IsSupported;

			public static ulong Crc32(ulong crc, ulong data)
			{
				return Crc32(crc, data);
			}
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<long> CompareGreaterThan(Vector128<long> left, Vector128<long> right)
		{
			return CompareGreaterThan(left, right);
		}

		public static uint Crc32(uint crc, byte data)
		{
			return Crc32(crc, data);
		}

		public static uint Crc32(uint crc, ushort data)
		{
			return Crc32(crc, data);
		}

		public static uint Crc32(uint crc, uint data)
		{
			return Crc32(crc, data);
		}
	}
	[Intrinsic]
	[CLSCompliant(false)]
	public abstract class Ssse3 : Sse3
	{
		[Intrinsic]
		public new abstract class X64 : Sse3.X64
		{
			public new static bool IsSupported => IsSupported;
		}

		public new static bool IsSupported => IsSupported;

		public static Vector128<byte> Abs(Vector128<sbyte> value)
		{
			return Abs(value);
		}

		public static Vector128<ushort> Abs(Vector128<short> value)
		{
			return Abs(value);
		}

		public static Vector128<uint> Abs(Vector128<int> value)
		{
			return Abs(value);
		}

		public static Vector128<sbyte> AlignRight(Vector128<sbyte> left, Vector128<sbyte> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector128<byte> AlignRight(Vector128<byte> left, Vector128<byte> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector128<short> AlignRight(Vector128<short> left, Vector128<short> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector128<ushort> AlignRight(Vector128<ushort> left, Vector128<ushort> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector128<int> AlignRight(Vector128<int> left, Vector128<int> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector128<uint> AlignRight(Vector128<uint> left, Vector128<uint> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector128<long> AlignRight(Vector128<long> left, Vector128<long> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector128<ulong> AlignRight(Vector128<ulong> left, Vector128<ulong> right, byte mask)
		{
			return AlignRight(left, right, mask);
		}

		public static Vector128<short> HorizontalAdd(Vector128<short> left, Vector128<short> right)
		{
			return HorizontalAdd(left, right);
		}

		public static Vector128<int> HorizontalAdd(Vector128<int> left, Vector128<int> right)
		{
			return HorizontalAdd(left, right);
		}

		public static Vector128<short> HorizontalAddSaturate(Vector128<short> left, Vector128<short> right)
		{
			return HorizontalAddSaturate(left, right);
		}

		public static Vector128<short> HorizontalSubtract(Vector128<short> left, Vector128<short> right)
		{
			return HorizontalSubtract(left, right);
		}

		public static Vector128<int> HorizontalSubtract(Vector128<int> left, Vector128<int> right)
		{
			return HorizontalSubtract(left, right);
		}

		public static Vector128<short> HorizontalSubtractSaturate(Vector128<short> left, Vector128<short> right)
		{
			return HorizontalSubtractSaturate(left, right);
		}

		public static Vector128<short> MultiplyAddAdjacent(Vector128<byte> left, Vector128<sbyte> right)
		{
			return MultiplyAddAdjacent(left, right);
		}

		public static Vector128<short> MultiplyHighRoundScale(Vector128<short> left, Vector128<short> right)
		{
			return MultiplyHighRoundScale(left, right);
		}

		public static Vector128<sbyte> Shuffle(Vector128<sbyte> value, Vector128<sbyte> mask)
		{
			return Shuffle(value, mask);
		}

		public static Vector128<byte> Shuffle(Vector128<byte> value, Vector128<byte> mask)
		{
			return Shuffle(value, mask);
		}

		public static Vector128<sbyte> Sign(Vector128<sbyte> left, Vector128<sbyte> right)
		{
			return Sign(left, right);
		}

		public static Vector128<short> Sign(Vector128<short> left, Vector128<short> right)
		{
			return Sign(left, right);
		}

		public static Vector128<int> Sign(Vector128<int> left, Vector128<int> right)
		{
			return Sign(left, right);
		}
	}
}
namespace System.Runtime.InteropServices
{
	internal static class DynamicInterfaceCastableHelpers
	{
		[StackTraceHidden]
		internal static bool IsInterfaceImplemented(IDynamicInterfaceCastable castable, RuntimeType interfaceType, bool throwIfNotImplemented)
		{
			bool flag = castable.IsInterfaceImplemented(new RuntimeTypeHandle(interfaceType), throwIfNotImplemented);
			if (!flag && throwIfNotImplemented)
			{
				throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, castable.GetType(), interfaceType));
			}
			return flag;
		}

		[StackTraceHidden]
		internal static RuntimeType GetInterfaceImplementation(IDynamicInterfaceCastable castable, RuntimeType interfaceType)
		{
			RuntimeTypeHandle interfaceImplementation = castable.GetInterfaceImplementation(new RuntimeTypeHandle(interfaceType));
			if (interfaceImplementation.Equals(default(RuntimeTypeHandle)))
			{
				throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, castable.GetType(), interfaceType));
			}
			RuntimeType runtimeType = interfaceImplementation.GetRuntimeType();
			if (!runtimeType.IsInterface)
			{
				throw new InvalidOperationException(SR.Format(SR.IDynamicInterfaceCastable_NotInterface, runtimeType.ToString()));
			}
			if (!runtimeType.IsDefined(typeof(DynamicInterfaceCastableImplementationAttribute), inherit: false))
			{
				throw new InvalidOperationException(SR.Format(SR.IDynamicInterfaceCastable_MissingImplementationAttribute, runtimeType, "DynamicInterfaceCastableImplementationAttribute"));
			}
			if (!runtimeType.IsAssignableTo(interfaceType))
			{
				throw new InvalidOperationException(SR.Format(SR.IDynamicInterfaceCastable_DoesNotImplementRequested, runtimeType, interfaceType));
			}
			return runtimeType;
		}
	}
	public struct GCHandle
	{
		private IntPtr _handle;

		public object? Target
		{
			get
			{
				IntPtr handle = _handle;
				ThrowIfInvalid(handle);
				return InternalGet(GetHandleValue(handle));
			}
			set
			{
				IntPtr handle = _handle;
				ThrowIfInvalid(handle);
				if (IsPinned(handle) && !Marshal.IsPinnable(value))
				{
					throw new ArgumentException(SR.ArgumentException_NotIsomorphic, "value");
				}
				InternalSet(GetHandleValue(handle), value);
			}
		}

		public bool IsAllocated => _handle != (IntPtr)0;

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr InternalAlloc(object value, GCHandleType type);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void InternalFree(IntPtr handle);

		internal unsafe static object InternalGet(IntPtr handle)
		{
			return Unsafe.As<IntPtr, object>(ref *(IntPtr*)handle);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void InternalSet(IntPtr handle, object value);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern object InternalCompareExchange(IntPtr handle, object value, object oldValue);

		private GCHandle(object value, GCHandleType type)
		{
			switch (type)
			{
			default:
				throw new ArgumentOutOfRangeException("type", SR.ArgumentOutOfRange_Enum);
			case GCHandleType.Pinned:
				if (!Marshal.IsPinnable(value))
				{
					throw new ArgumentException(SR.ArgumentException_NotIsomorphic, "value");
				}
				break;
			case GCHandleType.Weak:
			case GCHandleType.WeakTrackResurrection:
			case GCHandleType.Normal:
				break;
			}
			nint num = InternalAlloc(value, type);
			if (type == GCHandleType.Pinned)
			{
				num |= 1;
			}
			_handle = num;
		}

		private GCHandle(IntPtr handle)
		{
			_handle = handle;
		}

		public static GCHandle Alloc(object? value)
		{
			return new GCHandle(value, GCHandleType.Normal);
		}

		public static GCHandle Alloc(object? value, GCHandleType type)
		{
			return new GCHandle(value, type);
		}

		public void Free()
		{
			IntPtr handle = Interlocked.Exchange(ref _handle, IntPtr.Zero);
			ThrowIfInvalid(handle);
			InternalFree(GetHandleValue(handle));
		}

		public unsafe IntPtr AddrOfPinnedObject()
		{
			IntPtr handle = _handle;
			ThrowIfInvalid(handle);
			if (!IsPinned(handle))
			{
				ThrowHelper.ThrowInvalidOperationException_HandleIsNotPinned();
			}
			object obj = InternalGet(GetHandleValue(handle));
			if (obj == null)
			{
				return (IntPtr)0;
			}
			if (RuntimeHelpers.ObjectHasComponentSize(obj))
			{
				if (obj.GetType() == typeof(string))
				{
					return (IntPtr)Unsafe.AsPointer(ref Unsafe.As<string>(obj).GetRawStringData());
				}
				return (IntPtr)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<Array>(obj)));
			}
			return (IntPtr)Unsafe.AsPointer(ref obj.GetRawData());
		}

		public static explicit operator GCHandle(IntPtr value)
		{
			return FromIntPtr(value);
		}

		public static GCHandle FromIntPtr(IntPtr value)
		{
			ThrowIfInvalid(value);
			return new GCHandle(value);
		}

		public static explicit operator IntPtr(GCHandle value)
		{
			return ToIntPtr(value);
		}

		public static IntPtr ToIntPtr(GCHandle value)
		{
			return value._handle;
		}

		public override int GetHashCode()
		{
			return _handle.GetHashCode();
		}

		public override bool Equals([NotNullWhen(true)] object? o)
		{
			if (o is GCHandle)
			{
				return _handle == ((GCHandle)o)._handle;
			}
			return false;
		}

		public static bool operator ==(GCHandle a, GCHandle b)
		{
			return a._handle == b._handle;
		}

		public static bool operator !=(GCHandle a, GCHandle b)
		{
			return a._handle != b._handle;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static IntPtr GetHandleValue(IntPtr handle)
		{
			return new IntPtr((nint)handle & ~(nint)1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsPinned(IntPtr handle)
		{
			return ((nint)handle & 1) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void ThrowIfInvalid(IntPtr handle)
		{
			if (handle == (IntPtr)0)
			{
				ThrowHelper.ThrowInvalidOperationException_HandleIsNotInitialized();
			}
		}
	}
	public static class Marshal
	{
		internal static Guid IID_IUnknown = new Guid(0, 0, 0, 192, 0, 0, 0, 0, 0, 0, 70);

		public static readonly int SystemDefaultCharSize = 2;

		public static readonly int SystemMaxDBCSCharSize = GetSystemMaxDBCSCharSize();

		internal static bool IsBuiltInComSupported { get; } = IsBuiltInComSupportedInternal();


		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int SizeOfHelper(Type t, bool throwIfNotMarshalable);

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "Trimming doesn't affect types eligible for marshalling. Different exception for invalid inputs doesn't matter.")]
		public static IntPtr OffsetOf(Type t, string fieldName)
		{
			if ((object)t == null)
			{
				throw new ArgumentNullException("t");
			}
			FieldInfo field = t.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if ((object)field == null)
			{
				throw new ArgumentException(SR.Format(SR.Argument_OffsetOfFieldNotFound, t.FullName), "fieldName");
			}
			if (!(field is RtFieldInfo f))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, "fieldName");
			}
			return OffsetOfHelper(f);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr OffsetOfHelper(IRuntimeFieldInfo f);

		public static byte ReadByte(object ptr, int ofs)
		{
			return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => ReadByte(nativeHome, offset));
		}

		public static short ReadInt16(object ptr, int ofs)
		{
			return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => ReadInt16(nativeHome, offset));
		}

		public static int ReadInt32(object ptr, int ofs)
		{
			return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => ReadInt32(nativeHome, offset));
		}

		public static long ReadInt64([In][MarshalAs(UnmanagedType.AsAny)] object ptr, int ofs)
		{
			return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => ReadInt64(nativeHome, offset));
		}

		private unsafe static T ReadValueSlow<T>(object ptr, int ofs, Func<IntPtr, int, T> readValueHelper)
		{
			if (ptr == null)
			{
				throw new AccessViolationException();
			}
			MngdNativeArrayMarshaler.MarshalerState marshalerState = default(MngdNativeArrayMarshaler.MarshalerState);
			AsAnyMarshaler asAnyMarshaler = new AsAnyMarshaler(new IntPtr(&marshalerState));
			IntPtr intPtr = IntPtr.Zero;
			try
			{
				intPtr = asAnyMarshaler.ConvertToNative(ptr, 285147391);
				return readValueHelper(intPtr, ofs);
			}
			finally
			{
				asAnyMarshaler.ClearNative(intPtr);
			}
		}

		public static void WriteByte(object ptr, int ofs, byte val)
		{
			WriteValueSlow(ptr, ofs, val, delegate(IntPtr nativeHome, int offset, byte value)
			{
				WriteByte(nativeHome, offset, value);
			});
		}

		public static void WriteInt16(object ptr, int ofs, short val)
		{
			WriteValueSlow(ptr, ofs, val, delegate(IntPtr nativeHome, int offset, short value)
			{
				WriteInt16(nativeHome, offset, value);
			});
		}

		public static void WriteInt32(object ptr, int ofs, int val)
		{
			WriteValueSlow(ptr, ofs, val, delegate(IntPtr nativeHome, int offset, int value)
			{
				WriteInt32(nativeHome, offset, value);
			});
		}

		public static void WriteInt64(object ptr, int ofs, long val)
		{
			WriteValueSlow(ptr, ofs, val, delegate(IntPtr nativeHome, int offset, long value)
			{
				WriteInt64(nativeHome, offset, value);
			});
		}

		private unsafe static void WriteValueSlow<T>(object ptr, int ofs, T val, Action<IntPtr, int, T> writeValueHelper)
		{
			if (ptr == null)
			{
				throw new AccessViolationException();
			}
			MngdNativeArrayMarshaler.MarshalerState marshalerState = default(MngdNativeArrayMarshaler.MarshalerState);
			AsAnyMarshaler asAnyMarshaler = new AsAnyMarshaler(new IntPtr(&marshalerState));
			IntPtr intPtr = IntPtr.Zero;
			try
			{
				intPtr = asAnyMarshaler.ConvertToNative(ptr, 822018303);
				writeValueHelper(intPtr, ofs, val);
				asAnyMarshaler.ConvertToManaged(ptr, intPtr);
			}
			finally
			{
				asAnyMarshaler.ClearNative(intPtr);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern int GetLastPInvokeError();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern void SetLastPInvokeError(int error);

		private static void PrelinkCore(MethodInfo m)
		{
			if (!(m is RuntimeMethodInfo runtimeMethodInfo))
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, "m");
			}
			InternalPrelink(((IRuntimeMethodInfo)runtimeMethodInfo).Value);
			GC.KeepAlive(runtimeMethodInfo);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void InternalPrelink(RuntimeMethodHandleInternal m);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern IntPtr GetExceptionPointers();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern int GetExceptionCode();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern void StructureToPtr(object structure, IntPtr ptr, bool fDeleteOld);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void PtrToStructureHelper(IntPtr ptr, object structure, bool allowValueClasses);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern void DestroyStructure(IntPtr ptr, Type structuretype);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern bool IsPinnable(object obj);

		[DllImport("QCall")]
		private static extern bool IsBuiltInComSupportedInternal();

		public static IntPtr GetHINSTANCE(Module m)
		{
			if ((object)m == null)
			{
				throw new ArgumentNullException("m");
			}
			RuntimeModule module = m as RuntimeModule;
			if ((object)module != null)
			{
				return GetHINSTANCE(new QCallModule(ref module));
			}
			return (IntPtr)(-1);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern IntPtr GetHINSTANCE(QCallModule m);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern Exception GetExceptionForHRInternal(int errorCode, IntPtr errorInfo);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern int GetHRForException(Exception? e);

		[SupportedOSPlatform("windows")]
		public static string GetTypeInfoName(ITypeInfo typeInfo)
		{
			if (typeInfo == null)
			{
				throw new ArgumentNullException("typeInfo");
			}
			typeInfo.GetDocumentation(-1, out string strName, out string _, out int _, out string _);
			return strName;
		}

		internal static Type GetTypeFromCLSID(Guid clsid, string server, bool throwOnError)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			Type o = null;
			GetTypeFromCLSID(in clsid, server, ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetTypeFromCLSID(in Guid clsid, string server, ObjectHandleOnStack retType);

		[SupportedOSPlatform("windows")]
		public static IntPtr GetIUnknownForObject(object o)
		{
			if (o == null)
			{
				throw new ArgumentNullException("o");
			}
			return GetIUnknownForObjectNative(o);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr GetIUnknownForObjectNative(object o);

		[SupportedOSPlatform("windows")]
		public static IntPtr GetIDispatchForObject(object o)
		{
			if (o == null)
			{
				throw new ArgumentNullException("o");
			}
			return GetIDispatchForObjectNative(o);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr GetIDispatchForObjectNative(object o);

		[SupportedOSPlatform("windows")]
		public static IntPtr GetComInterfaceForObject(object o, Type T)
		{
			if (o == null)
			{
				throw new ArgumentNullException("o");
			}
			if ((object)T == null)
			{
				throw new ArgumentNullException("T");
			}
			return GetComInterfaceForObjectNative(o, T, fEnableCustomizedQueryInterface: true);
		}

		[SupportedOSPlatform("windows")]
		public static IntPtr GetComInterfaceForObject<T, TInterface>([DisallowNull] T o)
		{
			return GetComInterfaceForObject(o, typeof(TInterface));
		}

		[SupportedOSPlatform("windows")]
		public static IntPtr GetComInterfaceForObject(object o, Type T, CustomQueryInterfaceMode mode)
		{
			if (o == null)
			{
				throw new ArgumentNullException("o");
			}
			if ((object)T == null)
			{
				throw new ArgumentNullException("T");
			}
			bool fEnableCustomizedQueryInterface = mode == CustomQueryInterfaceMode.Allow;
			return GetComInterfaceForObjectNative(o, T, fEnableCustomizedQueryInterface);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr GetComInterfaceForObjectNative(object o, Type t, bool fEnableCustomizedQueryInterface);

		[SupportedOSPlatform("windows")]
		public static object GetObjectForIUnknown(IntPtr pUnk)
		{
			if (pUnk == IntPtr.Zero)
			{
				throw new ArgumentNullException("pUnk");
			}
			return GetObjectForIUnknownNative(pUnk);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object GetObjectForIUnknownNative(IntPtr pUnk);

		[SupportedOSPlatform("windows")]
		public static object GetUniqueObjectForIUnknown(IntPtr unknown)
		{
			if (unknown == IntPtr.Zero)
			{
				throw new ArgumentNullException("unknown");
			}
			return GetUniqueObjectForIUnknownNative(unknown);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object GetUniqueObjectForIUnknownNative(IntPtr unknown);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SupportedOSPlatform("windows")]
		public static extern object GetTypedObjectForIUnknown(IntPtr pUnk, Type t);

		[SupportedOSPlatform("windows")]
		public static IntPtr CreateAggregatedObject(IntPtr pOuter, object o)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			return CreateAggregatedObjectNative(pOuter, o);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr CreateAggregatedObjectNative(IntPtr pOuter, object o);

		[SupportedOSPlatform("windows")]
		public static IntPtr CreateAggregatedObject<T>(IntPtr pOuter, T o) where T : notnull
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			return CreateAggregatedObject(pOuter, (object)o);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern void CleanupUnusedObjectsInCurrentContext();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern bool AreComObjectsAvailableForCleanup();

		public static bool IsComObject(object o)
		{
			if (o == null)
			{
				throw new ArgumentNullException("o");
			}
			return o is __ComObject;
		}

		[SupportedOSPlatform("windows")]
		public static int ReleaseComObject(object o)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			if (o == null)
			{
				throw new NullReferenceException();
			}
			if (!(o is __ComObject _ComObject))
			{
				throw new ArgumentException(SR.Argument_ObjNotComObject, "o");
			}
			return _ComObject.ReleaseSelf();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int InternalReleaseComObject(object o);

		[SupportedOSPlatform("windows")]
		public static int FinalReleaseComObject(object o)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			if (o == null)
			{
				throw new ArgumentNullException("o");
			}
			if (!(o is __ComObject _ComObject))
			{
				throw new ArgumentException(SR.Argument_ObjNotComObject, "o");
			}
			_ComObject.FinalReleaseSelf();
			return 0;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void InternalFinalReleaseComObject(object o);

		[SupportedOSPlatform("windows")]
		public static object? GetComObjectData(object obj, object key)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (!(obj is __ComObject _ComObject))
			{
				throw new ArgumentException(SR.Argument_ObjNotComObject, "obj");
			}
			return _ComObject.GetData(key);
		}

		[SupportedOSPlatform("windows")]
		public static bool SetComObjectData(object obj, object key, object? data)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (!(obj is __ComObject _ComObject))
			{
				throw new ArgumentException(SR.Argument_ObjNotComObject, "obj");
			}
			return _ComObject.SetData(key, data);
		}

		[SupportedOSPlatform("windows")]
		[return: NotNullIfNotNull("o")]
		public static object? CreateWrapperOfType(object? o, Type t)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			if ((object)t == null)
			{
				throw new ArgumentNullException("t");
			}
			if (!t.IsCOMObject)
			{
				throw new ArgumentException(SR.Argument_TypeNotComObject, "t");
			}
			if (t.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "t");
			}
			if (o == null)
			{
				return null;
			}
			if (!o.GetType().IsCOMObject)
			{
				throw new ArgumentException(SR.Argument_ObjNotComObject, "o");
			}
			if (o.GetType() == t)
			{
				return o;
			}
			object obj = GetComObjectData(o, t);
			if (obj == null)
			{
				obj = InternalCreateWrapperOfType(o, t);
				if (!SetComObjectData(o, t, obj))
				{
					obj = GetComObjectData(o, t);
				}
			}
			return obj;
		}

		[SupportedOSPlatform("windows")]
		public static TWrapper CreateWrapperOfType<T, TWrapper>(T? o)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			return (TWrapper)CreateWrapperOfType(o, typeof(TWrapper));
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object InternalCreateWrapperOfType(object o, Type t);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern bool IsTypeVisibleFromCom(Type t);

		[SupportedOSPlatform("windows")]
		public static void GetNativeVariantForObject(object? obj, IntPtr pDstNativeVariant)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			GetNativeVariantForObjectNative(obj, pDstNativeVariant);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void GetNativeVariantForObjectNative(object obj, IntPtr pDstNativeVariant);

		[SupportedOSPlatform("windows")]
		public static void GetNativeVariantForObject<T>(T? obj, IntPtr pDstNativeVariant)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			GetNativeVariantForObject((object?)obj, pDstNativeVariant);
		}

		[SupportedOSPlatform("windows")]
		public static object? GetObjectForNativeVariant(IntPtr pSrcNativeVariant)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			return GetObjectForNativeVariantNative(pSrcNativeVariant);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object GetObjectForNativeVariantNative(IntPtr pSrcNativeVariant);

		[SupportedOSPlatform("windows")]
		public static T? GetObjectForNativeVariant<T>(IntPtr pSrcNativeVariant)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			return (T)GetObjectForNativeVariant(pSrcNativeVariant);
		}

		[SupportedOSPlatform("windows")]
		public static object?[] GetObjectsForNativeVariants(IntPtr aSrcNativeVariant, int cVars)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			return GetObjectsForNativeVariantsNative(aSrcNativeVariant, cVars);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern object[] GetObjectsForNativeVariantsNative(IntPtr aSrcNativeVariant, int cVars);

		[SupportedOSPlatform("windows")]
		public static T[] GetObjectsForNativeVariants<T>(IntPtr aSrcNativeVariant, int cVars)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			object[] objectsForNativeVariants = GetObjectsForNativeVariants(aSrcNativeVariant, cVars);
			T[] array = new T[objectsForNativeVariants.Length];
			Array.Copy(objectsForNativeVariants, array, objectsForNativeVariants.Length);
			return array;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SupportedOSPlatform("windows")]
		public static extern int GetStartComSlot(Type t);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SupportedOSPlatform("windows")]
		public static extern int GetEndComSlot(Type t);

		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		[SupportedOSPlatform("windows")]
		public static object BindToMoniker(string monikerName)
		{
			if (!IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			CreateBindCtx(0u, out var ppbc);
			MkParseDisplayName(ppbc, monikerName, out var _, out var ppmk);
			BindMoniker(ppmk, 0u, ref IID_IUnknown, out var ppvResult);
			return ppvResult;
		}

		[DllImport("ole32.dll", PreserveSig = false)]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2050:UnrecognizedReflectionPattern", Justification = "The calling method is annotated with RequiresUnreferencedCode")]
		private static extern void CreateBindCtx(uint reserved, out IBindCtx ppbc);

		[DllImport("ole32.dll", PreserveSig = false)]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2050:UnrecognizedReflectionPattern", Justification = "The calling method is annotated with RequiresUnreferencedCode")]
		private static extern void MkParseDisplayName(IBindCtx pbc, [MarshalAs(UnmanagedType.LPWStr)] string szUserName, out uint pchEaten, out IMoniker ppmk);

		[DllImport("ole32.dll", PreserveSig = false)]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2050:UnrecognizedReflectionPattern", Justification = "The calling method is annotated with RequiresUnreferencedCode")]
		private static extern void BindMoniker(IMoniker pmk, uint grfOpt, ref Guid iidResult, [MarshalAs(UnmanagedType.Interface)] out object ppvResult);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[SupportedOSPlatform("windows")]
		public static extern void ChangeWrapperHandleStrength(object otp, bool fIsWeak);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, Type t);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern IntPtr GetFunctionPointerForDelegateInternal(Delegate d);

		public static IntPtr AllocHGlobal(int cb)
		{
			return AllocHGlobal((IntPtr)cb);
		}

		public unsafe static string? PtrToStringAnsi(IntPtr ptr)
		{
			if (IsNullOrWin32Atom(ptr))
			{
				return null;
			}
			return new string((sbyte*)(void*)ptr);
		}

		public unsafe static string PtrToStringAnsi(IntPtr ptr, int len)
		{
			if (ptr == IntPtr.Zero)
			{
				throw new ArgumentNullException("ptr");
			}
			if (len < 0)
			{
				throw new ArgumentOutOfRangeException("len", len, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return new string((sbyte*)(void*)ptr, 0, len);
		}

		public unsafe static string? PtrToStringUni(IntPtr ptr)
		{
			if (IsNullOrWin32Atom(ptr))
			{
				return null;
			}
			return new string((char*)(void*)ptr);
		}

		public unsafe static string PtrToStringUni(IntPtr ptr, int len)
		{
			if (ptr == IntPtr.Zero)
			{
				throw new ArgumentNullException("ptr");
			}
			if (len < 0)
			{
				throw new ArgumentOutOfRangeException("len", len, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return new string((char*)(void*)ptr, 0, len);
		}

		public unsafe static string? PtrToStringUTF8(IntPtr ptr)
		{
			if (IsNullOrWin32Atom(ptr))
			{
				return null;
			}
			int byteLength = string.strlen((byte*)(void*)ptr);
			return string.CreateStringFromEncoding((byte*)(void*)ptr, byteLength, Encoding.UTF8);
		}

		public unsafe static string PtrToStringUTF8(IntPtr ptr, int byteLen)
		{
			if (ptr == IntPtr.Zero)
			{
				throw new ArgumentNullException("ptr");
			}
			if (byteLen < 0)
			{
				throw new ArgumentOutOfRangeException("byteLen", byteLen, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			return string.CreateStringFromEncoding((byte*)(void*)ptr, byteLen, Encoding.UTF8);
		}

		public static int SizeOf(object structure)
		{
			if (structure == null)
			{
				throw new ArgumentNullException("structure");
			}
			return SizeOfHelper(structure.GetType(), throwIfNotMarshalable: true);
		}

		public static int SizeOf<T>(T structure)
		{
			if (structure == null)
			{
				throw new ArgumentNullException("structure");
			}
			return SizeOfHelper(structure.GetType(), throwIfNotMarshalable: true);
		}

		public static int SizeOf(Type t)
		{
			if ((object)t == null)
			{
				throw new ArgumentNullException("t");
			}
			if (!t.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "t");
			}
			if (t.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "t");
			}
			return SizeOfHelper(t, throwIfNotMarshalable: true);
		}

		public static int SizeOf<T>()
		{
			Type typeFromHandle = typeof(T);
			if (typeFromHandle.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "T");
			}
			return SizeOfHelper(typeFromHandle, throwIfNotMarshalable: true);
		}

		public unsafe static int QueryInterface(IntPtr pUnk, ref Guid iid, out IntPtr ppv)
		{
			if (pUnk == IntPtr.Zero)
			{
				throw new ArgumentNullException("pUnk");
			}
			fixed (Guid* ptr = &iid)
			{
				fixed (IntPtr* ptr2 = &ppv)
				{
					return ((delegate* unmanaged<IntPtr, Guid*, IntPtr*, int>)(*(*(IntPtr**)(void*)pUnk)))(pUnk, ptr, ptr2);
				}
			}
		}

		public unsafe static int AddRef(IntPtr pUnk)
		{
			if (pUnk == IntPtr.Zero)
			{
				throw new ArgumentNullException("pUnk");
			}
			return ((delegate* unmanaged<IntPtr, int>)(*(IntPtr*)((nint)(*(IntPtr*)(void*)pUnk) + sizeof(void*))))(pUnk);
		}

		public unsafe static int Release(IntPtr pUnk)
		{
			if (pUnk == IntPtr.Zero)
			{
				throw new ArgumentNullException("pUnk");
			}
			return ((delegate* unmanaged<IntPtr, int>)(*(IntPtr*)((nint)(*(IntPtr*)(void*)pUnk) + (nint)2 * (nint)sizeof(void*))))(pUnk);
		}

		public unsafe static IntPtr UnsafeAddrOfPinnedArrayElement(Array arr, int index)
		{
			if (arr == null)
			{
				throw new ArgumentNullException("arr");
			}
			void* ptr = Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(arr));
			return (IntPtr)((byte*)ptr + (nuint)((nint)(uint)index * (nint)arr.GetElementSize()));
		}

		public unsafe static IntPtr UnsafeAddrOfPinnedArrayElement<T>(T[] arr, int index)
		{
			if (arr == null)
			{
				throw new ArgumentNullException("arr");
			}
			void* ptr = Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(arr));
			return (IntPtr)((byte*)ptr + (nuint)((nint)(uint)index * (nint)Unsafe.SizeOf<T>()));
		}

		public static IntPtr OffsetOf<T>(string fieldName)
		{
			return OffsetOf(typeof(T), fieldName);
		}

		public static void Copy(int[] source, int startIndex, IntPtr destination, int length)
		{
			CopyToNative(source, startIndex, destination, length);
		}

		public static void Copy(char[] source, int startIndex, IntPtr destination, int length)
		{
			CopyToNative(source, startIndex, destination, length);
		}

		public static void Copy(short[] source, int startIndex, IntPtr destination, int length)
		{
			CopyToNative(source, startIndex, destination, length);
		}

		public static void Copy(long[] source, int startIndex, IntPtr destination, int length)
		{
			CopyToNative(source, startIndex, destination, length);
		}

		public static void Copy(float[] source, int startIndex, IntPtr destination, int length)
		{
			CopyToNative(source, startIndex, destination, length);
		}

		public static void Copy(double[] source, int startIndex, IntPtr destination, int length)
		{
			CopyToNative(source, startIndex, destination, length);
		}

		public static void Copy(byte[] source, int startIndex, IntPtr destination, int length)
		{
			CopyToNative(source, startIndex, destination, length);
		}

		public static void Copy(IntPtr[] source, int startIndex, IntPtr destination, int length)
		{
			CopyToNative(source, startIndex, destination, length);
		}

		private unsafe static void CopyToNative<T>(T[] source, int startIndex, IntPtr destination, int length)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (destination == IntPtr.Zero)
			{
				throw new ArgumentNullException("destination");
			}
			new Span<T>(source, startIndex, length).CopyTo(new Span<T>((void*)destination, length));
		}

		public static void Copy(IntPtr source, int[] destination, int startIndex, int length)
		{
			CopyToManaged(source, destination, startIndex, length);
		}

		public static void Copy(IntPtr source, char[] destination, int startIndex, int length)
		{
			CopyToManaged(source, destination, startIndex, length);
		}

		public static void Copy(IntPtr source, short[] destination, int startIndex, int length)
		{
			CopyToManaged(source, destination, startIndex, length);
		}

		public static void Copy(IntPtr source, long[] destination, int startIndex, int length)
		{
			CopyToManaged(source, destination, startIndex, length);
		}

		public static void Copy(IntPtr source, float[] destination, int startIndex, int length)
		{
			CopyToManaged(source, destination, startIndex, length);
		}

		public static void Copy(IntPtr source, double[] destination, int startIndex, int length)
		{
			CopyToManaged(source, destination, startIndex, length);
		}

		public static void Copy(IntPtr source, byte[] destination, int startIndex, int length)
		{
			CopyToManaged(source, destination, startIndex, length);
		}

		public static void Copy(IntPtr source, IntPtr[] destination, int startIndex, int length)
		{
			CopyToManaged(source, destination, startIndex, length);
		}

		private unsafe static void CopyToManaged<T>(IntPtr source, T[] destination, int startIndex, int length)
		{
			if (source == IntPtr.Zero)
			{
				throw new ArgumentNullException("source");
			}
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			if (startIndex < 0)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_StartIndex);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			new Span<T>((void*)source, length).CopyTo(new Span<T>(destination, startIndex, length));
		}

		public unsafe static byte ReadByte(IntPtr ptr, int ofs)
		{
			try
			{
				byte* ptr2 = (byte*)(void*)ptr + ofs;
				return *ptr2;
			}
			catch (NullReferenceException)
			{
				throw new AccessViolationException();
			}
		}

		public static byte ReadByte(IntPtr ptr)
		{
			return ReadByte(ptr, 0);
		}

		public unsafe static short ReadInt16(IntPtr ptr, int ofs)
		{
			try
			{
				byte* ptr2 = (byte*)(void*)ptr + ofs;
				if (((int)ptr2 & 1) == 0)
				{
					return *(short*)ptr2;
				}
				return Unsafe.ReadUnaligned<short>(ptr2);
			}
			catch (NullReferenceException)
			{
				throw new AccessViolationException();
			}
		}

		public static short ReadInt16(IntPtr ptr)
		{
			return ReadInt16(ptr, 0);
		}

		public unsafe static int ReadInt32(IntPtr ptr, int ofs)
		{
			try
			{
				byte* ptr2 = (byte*)(void*)ptr + ofs;
				if (((int)ptr2 & 3) == 0)
				{
					return *(int*)ptr2;
				}
				return Unsafe.ReadUnaligned<int>(ptr2);
			}
			catch (NullReferenceException)
			{
				throw new AccessViolationException();
			}
		}

		public static int ReadInt32(IntPtr ptr)
		{
			return ReadInt32(ptr, 0);
		}

		public static IntPtr ReadIntPtr(object ptr, int ofs)
		{
			return (IntPtr)ReadInt32(ptr, ofs);
		}

		public static IntPtr ReadIntPtr(IntPtr ptr, int ofs)
		{
			return (IntPtr)ReadInt32(ptr, ofs);
		}

		public static IntPtr ReadIntPtr(IntPtr ptr)
		{
			return ReadIntPtr(ptr, 0);
		}

		public unsafe static long ReadInt64(IntPtr ptr, int ofs)
		{
			try
			{
				byte* ptr2 = (byte*)(void*)ptr + ofs;
				if (((int)ptr2 & 7) == 0)
				{
					return *(long*)ptr2;
				}
				return Unsafe.ReadUnaligned<long>(ptr2);
			}
			catch (NullReferenceException)
			{
				throw new AccessViolationException();
			}
		}

		public static long ReadInt64(IntPtr ptr)
		{
			return ReadInt64(ptr, 0);
		}

		public unsafe static void WriteByte(IntPtr ptr, int ofs, byte val)
		{
			try
			{
				byte* ptr2 = (byte*)(void*)ptr + ofs;
				*ptr2 = val;
			}
			catch (NullReferenceException)
			{
				throw new AccessViolationException();
			}
		}

		public static void WriteByte(IntPtr ptr, byte val)
		{
			WriteByte(ptr, 0, val);
		}

		public unsafe static void WriteInt16(IntPtr ptr, int ofs, short val)
		{
			try
			{
				byte* ptr2 = (byte*)(void*)ptr + ofs;
				if (((int)ptr2 & 1) == 0)
				{
					*(short*)ptr2 = val;
				}
				else
				{
					Unsafe.WriteUnaligned(ptr2, val);
				}
			}
			catch (NullReferenceException)
			{
				throw new AccessViolationException();
			}
		}

		public static void WriteInt16(IntPtr ptr, short val)
		{
			WriteInt16(ptr, 0, val);
		}

		public static void WriteInt16(IntPtr ptr, int ofs, char val)
		{
			WriteInt16(ptr, ofs, (short)val);
		}

		public static void WriteInt16([In][Out] object ptr, int ofs, char val)
		{
			WriteInt16(ptr, ofs, (short)val);
		}

		public static void WriteInt16(IntPtr ptr, char val)
		{
			WriteInt16(ptr, 0, (short)val);
		}

		public unsafe static void WriteInt32(IntPtr ptr, int ofs, int val)
		{
			try
			{
				byte* ptr2 = (byte*)(void*)ptr + ofs;
				if (((int)ptr2 & 3) == 0)
				{
					*(int*)ptr2 = val;
				}
				else
				{
					Unsafe.WriteUnaligned(ptr2, val);
				}
			}
			catch (NullReferenceException)
			{
				throw new AccessViolationException();
			}
		}

		public static void WriteInt32(IntPtr ptr, int val)
		{
			WriteInt32(ptr, 0, val);
		}

		public static void WriteIntPtr(IntPtr ptr, int ofs, IntPtr val)
		{
			WriteInt32(ptr, ofs, (int)val);
		}

		public static void WriteIntPtr(object ptr, int ofs, IntPtr val)
		{
			WriteInt32(ptr, ofs, (int)val);
		}

		public static void WriteIntPtr(IntPtr ptr, IntPtr val)
		{
			WriteIntPtr(ptr, 0, val);
		}

		public unsafe static void WriteInt64(IntPtr ptr, int ofs, long val)
		{
			try
			{
				byte* ptr2 = (byte*)(void*)ptr + ofs;
				if (((int)ptr2 & 7) == 0)
				{
					*(long*)ptr2 = val;
				}
				else
				{
					Unsafe.WriteUnaligned(ptr2, val);
				}
			}
			catch (NullReferenceException)
			{
				throw new AccessViolationException();
			}
		}

		public static void WriteInt64(IntPtr ptr, long val)
		{
			WriteInt64(ptr, 0, val);
		}

		public static void Prelink(MethodInfo m)
		{
			if ((object)m == null)
			{
				throw new ArgumentNullException("m");
			}
			PrelinkCore(m);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "This only needs to prelink methods that are actually used")]
		public static void PrelinkAll(Type c)
		{
			if ((object)c == null)
			{
				throw new ArgumentNullException("c");
			}
			MethodInfo[] methods = c.GetMethods();
			for (int i = 0; i < methods.Length; i++)
			{
				Prelink(methods[i]);
			}
		}

		public static void StructureToPtr<T>([DisallowNull] T structure, IntPtr ptr, bool fDeleteOld)
		{
			StructureToPtr((object)structure, ptr, fDeleteOld);
		}

		public static object? PtrToStructure(IntPtr ptr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type structureType)
		{
			if (ptr == IntPtr.Zero)
			{
				return null;
			}
			if ((object)structureType == null)
			{
				throw new ArgumentNullException("structureType");
			}
			if (structureType.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "structureType");
			}
			if (!structureType.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "structureType");
			}
			object obj = Activator.CreateInstance(structureType, nonPublic: true);
			PtrToStructureHelper(ptr, obj, allowValueClasses: true);
			return obj;
		}

		public static void PtrToStructure(IntPtr ptr, object structure)
		{
			PtrToStructureHelper(ptr, structure, allowValueClasses: false);
		}

		public static void PtrToStructure<T>(IntPtr ptr, [DisallowNull] T structure)
		{
			PtrToStructureHelper(ptr, structure, allowValueClasses: false);
		}

		public static T? PtrToStructure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] T>(IntPtr ptr)
		{
			if (ptr == IntPtr.Zero)
			{
				return (T)(object)null;
			}
			Type typeFromHandle = typeof(T);
			if (typeFromHandle.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "T");
			}
			object obj = Activator.CreateInstance(typeFromHandle, nonPublic: true);
			PtrToStructureHelper(ptr, obj, allowValueClasses: true);
			return (T)obj;
		}

		public static void DestroyStructure<T>(IntPtr ptr)
		{
			DestroyStructure(ptr, typeof(T));
		}

		public static Exception? GetExceptionForHR(int errorCode)
		{
			return GetExceptionForHR(errorCode, IntPtr.Zero);
		}

		public static Exception? GetExceptionForHR(int errorCode, IntPtr errorInfo)
		{
			if (errorCode >= 0)
			{
				return null;
			}
			return GetExceptionForHRInternal(errorCode, errorInfo);
		}

		public static void ThrowExceptionForHR(int errorCode)
		{
			if (errorCode < 0)
			{
				throw GetExceptionForHR(errorCode);
			}
		}

		public static void ThrowExceptionForHR(int errorCode, IntPtr errorInfo)
		{
			if (errorCode < 0)
			{
				throw GetExceptionForHR(errorCode, errorInfo);
			}
		}

		public static IntPtr SecureStringToBSTR(SecureString s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return s.MarshalToBSTR();
		}

		public static IntPtr SecureStringToCoTaskMemAnsi(SecureString s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return s.MarshalToString(globalAlloc: false, unicode: false);
		}

		public static IntPtr SecureStringToCoTaskMemUnicode(SecureString s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return s.MarshalToString(globalAlloc: false, unicode: true);
		}

		public static IntPtr SecureStringToGlobalAllocAnsi(SecureString s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return s.MarshalToString(globalAlloc: true, unicode: false);
		}

		public static IntPtr SecureStringToGlobalAllocUnicode(SecureString s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			return s.MarshalToString(globalAlloc: true, unicode: true);
		}

		public unsafe static IntPtr StringToHGlobalAnsi(string? s)
		{
			if (s == null)
			{
				return IntPtr.Zero;
			}
			long num = (long)(s.Length + 1) * (long)SystemMaxDBCSCharSize;
			int num2 = (int)num;
			if (num2 != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.s);
			}
			IntPtr intPtr = AllocHGlobal((IntPtr)num2);
			StringToAnsiString(s, (byte*)(void*)intPtr, num2);
			return intPtr;
		}

		public unsafe static IntPtr StringToHGlobalUni(string? s)
		{
			if (s == null)
			{
				return IntPtr.Zero;
			}
			int num = (s.Length + 1) * 2;
			if (num < s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.s);
			}
			IntPtr intPtr = AllocHGlobal((IntPtr)num);
			s.CopyTo(new Span<char>((void*)intPtr, s.Length));
			*(short*)((byte*)(void*)intPtr + (nint)s.Length * (nint)2) = 0;
			return intPtr;
		}

		public unsafe static IntPtr StringToCoTaskMemUni(string? s)
		{
			if (s == null)
			{
				return IntPtr.Zero;
			}
			int num = (s.Length + 1) * 2;
			if (num < s.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.s);
			}
			IntPtr intPtr = AllocCoTaskMem(num);
			s.CopyTo(new Span<char>((void*)intPtr, s.Length));
			*(short*)((byte*)(void*)intPtr + (nint)s.Length * (nint)2) = 0;
			return intPtr;
		}

		public unsafe static IntPtr StringToCoTaskMemUTF8(string? s)
		{
			if (s == null)
			{
				return IntPtr.Zero;
			}
			int maxByteCount = Encoding.UTF8.GetMaxByteCount(s.Length);
			IntPtr intPtr = AllocCoTaskMem(maxByteCount + 1);
			byte* ptr = (byte*)(void*)intPtr;
			int bytes;
			fixed (char* chars = s)
			{
				bytes = Encoding.UTF8.GetBytes(chars, s.Length, ptr, maxByteCount);
			}
			ptr[bytes] = 0;
			return intPtr;
		}

		public unsafe static IntPtr StringToCoTaskMemAnsi(string? s)
		{
			if (s == null)
			{
				return IntPtr.Zero;
			}
			long num = (long)(s.Length + 1) * (long)SystemMaxDBCSCharSize;
			int num2 = (int)num;
			if (num2 != num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.s);
			}
			IntPtr intPtr = AllocCoTaskMem(num2);
			StringToAnsiString(s, (byte*)(void*)intPtr, num2);
			return intPtr;
		}

		public static Guid GenerateGuidForType(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!type.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "type");
			}
			return type.GUID;
		}

		public static string? GenerateProgIdForType(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (type.IsImport)
			{
				throw new ArgumentException(SR.Argument_TypeMustNotBeComImport, "type");
			}
			if (type.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "type");
			}
			ProgIdAttribute customAttribute = type.GetCustomAttribute<ProgIdAttribute>();
			if (customAttribute != null)
			{
				return customAttribute.Value ?? string.Empty;
			}
			return type.FullName;
		}

		public static Delegate GetDelegateForFunctionPointer(IntPtr ptr, Type t)
		{
			if (ptr == IntPtr.Zero)
			{
				throw new ArgumentNullException("ptr");
			}
			if ((object)t == null)
			{
				throw new ArgumentNullException("t");
			}
			if (!t.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "t");
			}
			if (t.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "t");
			}
			if (t.BaseType != typeof(MulticastDelegate) && t != typeof(MulticastDelegate))
			{
				throw new ArgumentException(SR.Arg_MustBeDelegate, "t");
			}
			return GetDelegateForFunctionPointerInternal(ptr, t);
		}

		public static TDelegate GetDelegateForFunctionPointer<TDelegate>(IntPtr ptr)
		{
			if (ptr == IntPtr.Zero)
			{
				throw new ArgumentNullException("ptr");
			}
			Type typeFromHandle = typeof(TDelegate);
			if (typeFromHandle.IsGenericType)
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "TDelegate");
			}
			if (typeFromHandle.BaseType != typeof(MulticastDelegate) && typeFromHandle != typeof(MulticastDelegate))
			{
				throw new ArgumentException(SR.Arg_MustBeDelegate, "TDelegate");
			}
			return (TDelegate)(object)GetDelegateForFunctionPointerInternal(ptr, typeFromHandle);
		}

		public static IntPtr GetFunctionPointerForDelegate(Delegate d)
		{
			if ((object)d == null)
			{
				throw new ArgumentNullException("d");
			}
			return GetFunctionPointerForDelegateInternal(d);
		}

		public static IntPtr GetFunctionPointerForDelegate<TDelegate>(TDelegate d) where TDelegate : notnull
		{
			return GetFunctionPointerForDelegate((Delegate)(object)d);
		}

		public static int GetHRForLastWin32Error()
		{
			int lastPInvokeError = GetLastPInvokeError();
			if ((lastPInvokeError & 0x80000000u) == 2147483648u)
			{
				return lastPInvokeError;
			}
			return (lastPInvokeError & 0xFFFF) | -2147024896;
		}

		public unsafe static void ZeroFreeBSTR(IntPtr s)
		{
			if (!(s == IntPtr.Zero))
			{
				Buffer.ZeroMemory((byte*)(void*)s, SysStringByteLen(s));
				FreeBSTR(s);
			}
		}

		public static void ZeroFreeCoTaskMemAnsi(IntPtr s)
		{
			ZeroFreeCoTaskMemUTF8(s);
		}

		public unsafe static void ZeroFreeCoTaskMemUnicode(IntPtr s)
		{
			if (!(s == IntPtr.Zero))
			{
				Buffer.ZeroMemory((byte*)(void*)s, (nuint)string.wcslen((char*)(void*)s) * (nuint)2u);
				FreeCoTaskMem(s);
			}
		}

		public unsafe static void ZeroFreeCoTaskMemUTF8(IntPtr s)
		{
			if (!(s == IntPtr.Zero))
			{
				Buffer.ZeroMemory((byte*)(void*)s, (nuint)string.strlen((byte*)(void*)s));
				FreeCoTaskMem(s);
			}
		}

		public unsafe static void ZeroFreeGlobalAllocAnsi(IntPtr s)
		{
			if (!(s == IntPtr.Zero))
			{
				Buffer.ZeroMemory((byte*)(void*)s, (nuint)string.strlen((byte*)(void*)s));
				FreeHGlobal(s);
			}
		}

		public unsafe static void ZeroFreeGlobalAllocUnicode(IntPtr s)
		{
			if (!(s == IntPtr.Zero))
			{
				Buffer.ZeroMemory((byte*)(void*)s, (nuint)string.wcslen((char*)(void*)s) * (nuint)2u);
				FreeHGlobal(s);
			}
		}

		public unsafe static IntPtr StringToBSTR(string? s)
		{
			if (s == null)
			{
				return IntPtr.Zero;
			}
			IntPtr intPtr = AllocBSTR(s.Length);
			s.CopyTo(new Span<char>((void*)intPtr, s.Length));
			return intPtr;
		}

		public static string PtrToStringBSTR(IntPtr ptr)
		{
			if (ptr == IntPtr.Zero)
			{
				throw new ArgumentNullException("ptr");
			}
			return PtrToStringUni(ptr, (int)(SysStringByteLen(ptr) / 2));
		}

		internal unsafe static uint SysStringByteLen(IntPtr s)
		{
			return *(uint*)((byte*)(void*)s - 4);
		}

		[SupportedOSPlatform("windows")]
		public static Type? GetTypeFromCLSID(Guid clsid)
		{
			return GetTypeFromCLSID(clsid, null, throwOnError: false);
		}

		public static void InitHandle(SafeHandle safeHandle, IntPtr handle)
		{
			safeHandle.SetHandle(handle);
		}

		public static int GetLastWin32Error()
		{
			return GetLastPInvokeError();
		}

		public static string? PtrToStringAuto(IntPtr ptr, int len)
		{
			return PtrToStringUni(ptr, len);
		}

		public static string? PtrToStringAuto(IntPtr ptr)
		{
			return PtrToStringUni(ptr);
		}

		public static IntPtr StringToHGlobalAuto(string? s)
		{
			return StringToHGlobalUni(s);
		}

		public static IntPtr StringToCoTaskMemAuto(string? s)
		{
			return StringToCoTaskMemUni(s);
		}

		private unsafe static int GetSystemMaxDBCSCharSize()
		{
			Interop.Kernel32.CPINFO cPINFO = default(Interop.Kernel32.CPINFO);
			if (Interop.Kernel32.GetCPInfo(0u, &cPINFO) == Interop.BOOL.FALSE)
			{
				return 2;
			}
			return cPINFO.MaxCharSize;
		}

		private static bool IsNullOrWin32Atom(IntPtr ptr)
		{
			long num = (long)ptr;
			return (num & -65536) == 0;
		}

		internal unsafe static int StringToAnsiString(string s, byte* buffer, int bufferLength, bool bestFit = false, bool throwOnUnmappableChar = false)
		{
			uint dwFlags = ((!bestFit) ? 1024u : 0u);
			uint num = 0u;
			int num2;
			fixed (char* lpWideCharStr = s)
			{
				num2 = Interop.Kernel32.WideCharToMultiByte(0u, dwFlags, lpWideCharStr, s.Length, buffer, bufferLength, IntPtr.Zero, throwOnUnmappableChar ? new IntPtr(&num) : IntPtr.Zero);
			}
			if (num != 0)
			{
				throw new ArgumentException(SR.Interop_Marshal_Unmappable_Char);
			}
			buffer[num2] = 0;
			return num2;
		}

		internal unsafe static int GetAnsiStringByteCount(ReadOnlySpan<char> chars)
		{
			int num;
			if (chars.Length == 0)
			{
				num = 0;
			}
			else
			{
				fixed (char* lpWideCharStr = chars)
				{
					num = Interop.Kernel32.WideCharToMultiByte(0u, 1024u, lpWideCharStr, chars.Length, null, 0, IntPtr.Zero, IntPtr.Zero);
					if (num <= 0)
					{
						throw new ArgumentException();
					}
				}
			}
			return checked(num + 1);
		}

		internal unsafe static void GetAnsiStringBytes(ReadOnlySpan<char> chars, Span<byte> bytes)
		{
			int num;
			if (chars.Length == 0)
			{
				num = 0;
			}
			else
			{
				fixed (char* lpWideCharStr = chars)
				{
					fixed (byte* lpMultiByteStr = bytes)
					{
						num = Interop.Kernel32.WideCharToMultiByte(0u, 1024u, lpWideCharStr, chars.Length, lpMultiByteStr, bytes.Length, IntPtr.Zero, IntPtr.Zero);
						if (num <= 0)
						{
							throw new ArgumentException();
						}
					}
				}
			}
			bytes[num] = 0;
		}

		public static IntPtr AllocHGlobal(IntPtr cb)
		{
			IntPtr intPtr = Interop.Kernel32.LocalAlloc(0u, (nuint)(nint)cb);
			if (intPtr == IntPtr.Zero)
			{
				throw new OutOfMemoryException();
			}
			return intPtr;
		}

		public static void FreeHGlobal(IntPtr hglobal)
		{
			if (!IsNullOrWin32Atom(hglobal))
			{
				Interop.Kernel32.LocalFree(hglobal);
			}
		}

		public static IntPtr ReAllocHGlobal(IntPtr pv, IntPtr cb)
		{
			if (pv == IntPtr.Zero)
			{
				return AllocHGlobal(cb);
			}
			IntPtr intPtr = Interop.Kernel32.LocalReAlloc(pv, (nuint)(nint)cb, 2u);
			if (intPtr == IntPtr.Zero)
			{
				throw new OutOfMemoryException();
			}
			return intPtr;
		}

		public static IntPtr AllocCoTaskMem(int cb)
		{
			IntPtr intPtr = Interop.Ole32.CoTaskMemAlloc((uint)cb);
			if (intPtr == IntPtr.Zero)
			{
				throw new OutOfMemoryException();
			}
			return intPtr;
		}

		public static void FreeCoTaskMem(IntPtr ptr)
		{
			if (!IsNullOrWin32Atom(ptr))
			{
				Interop.Ole32.CoTaskMemFree(ptr);
			}
		}

		public static IntPtr ReAllocCoTaskMem(IntPtr pv, int cb)
		{
			IntPtr intPtr = Interop.Ole32.CoTaskMemRealloc(pv, (uint)cb);
			if (intPtr == IntPtr.Zero && cb != 0)
			{
				throw new OutOfMemoryException();
			}
			return intPtr;
		}

		internal static IntPtr AllocBSTR(int length)
		{
			IntPtr intPtr = Interop.OleAut32.SysAllocStringLen(IntPtr.Zero, (uint)length);
			if (intPtr == IntPtr.Zero)
			{
				throw new OutOfMemoryException();
			}
			return intPtr;
		}

		internal static IntPtr AllocBSTRByteLen(uint length)
		{
			IntPtr intPtr = Interop.OleAut32.SysAllocStringByteLen(null, length);
			if (intPtr == IntPtr.Zero)
			{
				throw new OutOfMemoryException();
			}
			return intPtr;
		}

		public static void FreeBSTR(IntPtr ptr)
		{
			if (!IsNullOrWin32Atom(ptr))
			{
				Interop.OleAut32.SysFreeString(ptr);
			}
		}

		internal static Type GetTypeFromProgID(string progID, string server, bool throwOnError)
		{
			if (progID == null)
			{
				throw new ArgumentNullException("progID");
			}
			Guid lpclsid;
			int num = Interop.Ole32.CLSIDFromProgID(progID, out lpclsid);
			if (num < 0)
			{
				if (throwOnError)
				{
					throw GetExceptionForHR(num, new IntPtr(-1));
				}
				return null;
			}
			return GetTypeFromCLSID(lpclsid, server, throwOnError);
		}

		public static int GetLastSystemError()
		{
			return Interop.Kernel32.GetLastError();
		}

		public static void SetLastSystemError(int error)
		{
			Interop.Kernel32.SetLastError(error);
		}
	}
	public static class MemoryMarshal
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static ref T GetArrayDataReference<T>(T[] array)
		{
			return ref Unsafe.As<byte, T>(ref Unsafe.As<RawArrayData>(array).Data);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static ref byte GetArrayDataReference(Array array)
		{
			return ref Unsafe.AddByteOffset(ref Unsafe.As<RawData>(array).Data, (nuint)RuntimeHelpers.GetMethodTable(array)->BaseSize - (nuint)(2 * sizeof(IntPtr)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<byte> AsBytes<T>(Span<T> span) where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			return new Span<byte>(ref Unsafe.As<T, byte>(ref GetReference(span)), checked(span.Length * Unsafe.SizeOf<T>()));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<byte> AsBytes<T>(ReadOnlySpan<T> span) where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			return new ReadOnlySpan<byte>(ref Unsafe.As<T, byte>(ref GetReference(span)), checked(span.Length * Unsafe.SizeOf<T>()));
		}

		public static Memory<T> AsMemory<T>(ReadOnlyMemory<T> memory)
		{
			return Unsafe.As<ReadOnlyMemory<T>, Memory<T>>(ref memory);
		}

		public static ref T GetReference<T>(Span<T> span)
		{
			return ref span._pointer.Value;
		}

		public static ref T GetReference<T>(ReadOnlySpan<T> span)
		{
			return ref span._pointer.Value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal unsafe static ref T GetNonNullPinnableReference<T>(Span<T> span)
		{
			if (span.Length == 0)
			{
				return ref Unsafe.AsRef<T>((void*)1);
			}
			return ref span._pointer.Value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal unsafe static ref T GetNonNullPinnableReference<T>(ReadOnlySpan<T> span)
		{
			if (span.Length == 0)
			{
				return ref Unsafe.AsRef<T>((void*)1);
			}
			return ref span._pointer.Value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<TTo> Cast<TFrom, TTo>(Span<TFrom> span) where TFrom : struct where TTo : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<TFrom>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(TFrom));
			}
			if (RuntimeHelpers.IsReferenceOrContainsReferences<TTo>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(TTo));
			}
			uint num = (uint)Unsafe.SizeOf<TFrom>();
			uint num2 = (uint)Unsafe.SizeOf<TTo>();
			uint length = (uint)span.Length;
			int length2;
			if (num == num2)
			{
				length2 = (int)length;
			}
			else if (num == 1)
			{
				length2 = (int)(length / num2);
			}
			else
			{
				ulong num3 = (ulong)((long)length * (long)num) / (ulong)num2;
				length2 = checked((int)num3);
			}
			return new Span<TTo>(ref Unsafe.As<TFrom, TTo>(ref span._pointer.Value), length2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<TTo> Cast<TFrom, TTo>(ReadOnlySpan<TFrom> span) where TFrom : struct where TTo : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<TFrom>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(TFrom));
			}
			if (RuntimeHelpers.IsReferenceOrContainsReferences<TTo>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(TTo));
			}
			uint num = (uint)Unsafe.SizeOf<TFrom>();
			uint num2 = (uint)Unsafe.SizeOf<TTo>();
			uint length = (uint)span.Length;
			int length2;
			if (num == num2)
			{
				length2 = (int)length;
			}
			else if (num == 1)
			{
				length2 = (int)(length / num2);
			}
			else
			{
				ulong num3 = (ulong)((long)length * (long)num) / (ulong)num2;
				length2 = checked((int)num3);
			}
			return new ReadOnlySpan<TTo>(ref Unsafe.As<TFrom, TTo>(ref GetReference(span)), length2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> CreateSpan<T>(ref T reference, int length)
		{
			return new Span<T>(ref reference, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<T> CreateReadOnlySpan<T>(ref T reference, int length)
		{
			return new ReadOnlySpan<T>(ref reference, length);
		}

		[CLSCompliant(false)]
		public unsafe static ReadOnlySpan<char> CreateReadOnlySpanFromNullTerminated(char* value)
		{
			if (value == null)
			{
				return default(ReadOnlySpan<char>);
			}
			return new ReadOnlySpan<char>(value, string.wcslen(value));
		}

		[CLSCompliant(false)]
		public unsafe static ReadOnlySpan<byte> CreateReadOnlySpanFromNullTerminated(byte* value)
		{
			if (value == null)
			{
				return default(ReadOnlySpan<byte>);
			}
			return new ReadOnlySpan<byte>(value, string.strlen(value));
		}

		public static bool TryGetArray<T>(ReadOnlyMemory<T> memory, out ArraySegment<T> segment)
		{
			int start;
			int length;
			object objectStartLength = memory.GetObjectStartLength(out start, out length);
			if (objectStartLength != null && (!(typeof(T) == typeof(char)) || !(objectStartLength.GetType() == typeof(string))))
			{
				if (RuntimeHelpers.ObjectHasComponentSize(objectStartLength))
				{
					segment = new ArraySegment<T>(Unsafe.As<T[]>(objectStartLength), start & 0x7FFFFFFF, length);
					return true;
				}
				if (Unsafe.As<MemoryManager<T>>(objectStartLength).TryGetArray(out var segment2))
				{
					segment = new ArraySegment<T>(segment2.Array, segment2.Offset + start, length);
					return true;
				}
			}
			if (length == 0)
			{
				segment = ArraySegment<T>.Empty;
				return true;
			}
			segment = default(ArraySegment<T>);
			return false;
		}

		public static bool TryGetMemoryManager<T, TManager>(ReadOnlyMemory<T> memory, [NotNullWhen(true)] out TManager? manager) where TManager : MemoryManager<T>
		{
			int start;
			int length;
			return (manager = memory.GetObjectStartLength(out start, out length) as TManager) != null;
		}

		public static bool TryGetMemoryManager<T, TManager>(ReadOnlyMemory<T> memory, [NotNullWhen(true)] out TManager? manager, out int start, out int length) where TManager : MemoryManager<T>
		{
			if ((manager = memory.GetObjectStartLength(out start, out length) as TManager) == null)
			{
				start = 0;
				length = 0;
				return false;
			}
			return true;
		}

		public static IEnumerable<T> ToEnumerable<T>(ReadOnlyMemory<T> memory)
		{
			for (int i = 0; i < memory.Length; i++)
			{
				yield return memory.Span[i];
			}
		}

		public static bool TryGetString(ReadOnlyMemory<char> memory, [NotNullWhen(true)] out string? text, out int start, out int length)
		{
			if (memory.GetObjectStartLength(out var start2, out var length2) is string text2)
			{
				text = text2;
				start = start2;
				length = length2;
				return true;
			}
			text = null;
			start = 0;
			length = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T Read<T>(ReadOnlySpan<byte> source) where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (Unsafe.SizeOf<T>() > source.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
			}
			return Unsafe.ReadUnaligned<T>(ref GetReference(source));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryRead<T>(ReadOnlySpan<byte> source, out T value) where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (Unsafe.SizeOf<T>() > (uint)source.Length)
			{
				value = default(T);
				return false;
			}
			value = Unsafe.ReadUnaligned<T>(ref GetReference(source));
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Write<T>(Span<byte> destination, ref T value) where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			if ((uint)Unsafe.SizeOf<T>() > (uint)destination.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
			}
			Unsafe.WriteUnaligned(ref GetReference(destination), value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWrite<T>(Span<byte> destination, ref T value) where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (Unsafe.SizeOf<T>() > (uint)destination.Length)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref GetReference(destination), value);
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T AsRef<T>(Span<byte> span) where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (Unsafe.SizeOf<T>() > (uint)span.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
			}
			return ref Unsafe.As<byte, T>(ref GetReference(span));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref readonly T AsRef<T>(ReadOnlySpan<byte> span) where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (Unsafe.SizeOf<T>() > (uint)span.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length);
			}
			return ref Unsafe.As<byte, T>(ref GetReference(span));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory<T> CreateFromPinnedArray<T>(T[]? array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				return default(Memory<T>);
			}
			if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
			{
				ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new Memory<T>((object)array, start | int.MinValue, length);
		}
	}
	public static class NativeLibrary
	{
		private static ConditionalWeakTable<Assembly, DllImportResolver> s_nativeDllResolveMap;

		internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, DllImportSearchPath? searchPath, bool throwOnError)
		{
			RuntimeAssembly assembly2 = (RuntimeAssembly)assembly;
			return LoadByName(libraryName, new QCallAssembly(ref assembly2), searchPath.HasValue, (uint)searchPath.GetValueOrDefault(), throwOnError);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern IntPtr LoadFromPath(string libraryName, bool throwOnError);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern IntPtr LoadByName(string libraryName, QCallAssembly callingAssembly, bool hasDllImportSearchPathFlag, uint dllImportSearchPathFlag, bool throwOnError);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void FreeLib(IntPtr handle);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern IntPtr GetSymbol(IntPtr handle, string symbolName, bool throwOnError);

		public static IntPtr Load(string libraryPath)
		{
			if (libraryPath == null)
			{
				throw new ArgumentNullException("libraryPath");
			}
			return LoadFromPath(libraryPath, throwOnError: true);
		}

		public static bool TryLoad(string libraryPath, out IntPtr handle)
		{
			if (libraryPath == null)
			{
				throw new ArgumentNullException("libraryPath");
			}
			handle = LoadFromPath(libraryPath, throwOnError: false);
			return handle != IntPtr.Zero;
		}

		public static IntPtr Load(string libraryName, Assembly assembly, DllImportSearchPath? searchPath)
		{
			if (libraryName == null)
			{
				throw new ArgumentNullException("libraryName");
			}
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			if (!assembly.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeAssembly);
			}
			return LoadLibraryByName(libraryName, assembly, searchPath, throwOnError: true);
		}

		public static bool TryLoad(string libraryName, Assembly assembly, DllImportSearchPath? searchPath, out IntPtr handle)
		{
			if (libraryName == null)
			{
				throw new ArgumentNullException("libraryName");
			}
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			if (!assembly.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeAssembly);
			}
			handle = LoadLibraryByName(libraryName, assembly, searchPath, throwOnError: false);
			return handle != IntPtr.Zero;
		}

		public static void Free(IntPtr handle)
		{
			if (!(handle == IntPtr.Zero))
			{
				FreeLib(handle);
			}
		}

		public static IntPtr GetExport(IntPtr handle, string name)
		{
			if (handle == IntPtr.Zero)
			{
				throw new ArgumentNullException("handle");
			}
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			return GetSymbol(handle, name, throwOnError: true);
		}

		public static bool TryGetExport(IntPtr handle, string name, out IntPtr address)
		{
			if (handle == IntPtr.Zero)
			{
				throw new ArgumentNullException("handle");
			}
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			address = GetSymbol(handle, name, throwOnError: false);
			return address != IntPtr.Zero;
		}

		public static void SetDllImportResolver(Assembly assembly, DllImportResolver resolver)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			if (resolver == null)
			{
				throw new ArgumentNullException("resolver");
			}
			if (!assembly.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeAssembly);
			}
			if (s_nativeDllResolveMap == null)
			{
				Interlocked.CompareExchange(ref s_nativeDllResolveMap, new ConditionalWeakTable<Assembly, DllImportResolver>(), null);
			}
			try
			{
				s_nativeDllResolveMap.Add(assembly, resolver);
			}
			catch (ArgumentException)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CannotRegisterSecondResolver);
			}
		}

		internal static IntPtr LoadLibraryCallbackStub(string libraryName, Assembly assembly, bool hasDllImportSearchPathFlags, uint dllImportSearchPathFlags)
		{
			if (s_nativeDllResolveMap == null)
			{
				return IntPtr.Zero;
			}
			if (!s_nativeDllResolveMap.TryGetValue(assembly, out var value))
			{
				return IntPtr.Zero;
			}
			return value(libraryName, assembly, hasDllImportSearchPathFlags ? new DllImportSearchPath?((DllImportSearchPath)dllImportSearchPathFlags) : null);
		}
	}
	internal enum ComWrappersScenario
	{
		Instance,
		TrackerSupportGlobalInstance,
		MarshallingGlobalInstance
	}
	[UnsupportedOSPlatform("android")]
	[UnsupportedOSPlatform("browser")]
	[UnsupportedOSPlatform("ios")]
	[UnsupportedOSPlatform("tvos")]
	[CLSCompliant(false)]
	public abstract class ComWrappers
	{
		public struct ComInterfaceDispatch
		{
			private struct ComInterfaceInstance
			{
				public IntPtr GcHandle;
			}

			public IntPtr Vtable;

			public unsafe static T GetInstance<T>(ComInterfaceDispatch* dispatchPtr) where T : class
			{
				ComInterfaceInstance* ptr = *(ComInterfaceInstance**)((ulong)dispatchPtr & 0xFFFFFFFFFFFFFFF0uL);
				return Unsafe.As<T>(GCHandle.InternalGet(ptr->GcHandle));
			}
		}

		public struct ComInterfaceEntry
		{
			public Guid IID;

			public IntPtr Vtable;
		}

		private static ComWrappers s_globalInstanceForTrackerSupport;

		private static ComWrappers s_globalInstanceForMarshalling;

		private static long s_instanceCounter;

		private readonly long id = Interlocked.Increment(ref s_instanceCounter);

		public IntPtr GetOrCreateComInterfaceForObject(object instance, CreateComInterfaceFlags flags)
		{
			if (!TryGetOrCreateComInterfaceForObjectInternal(this, instance, flags, out var retValue))
			{
				throw new ArgumentException(null, "instance");
			}
			return retValue;
		}

		private static bool TryGetOrCreateComInterfaceForObjectInternal(ComWrappers impl, object instance, CreateComInterfaceFlags flags, out IntPtr retValue)
		{
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			return TryGetOrCreateComInterfaceForObjectInternal(ObjectHandleOnStack.Create(ref impl), impl.id, ObjectHandleOnStack.Create(ref instance), flags, out retValue);
		}

		[DllImport("QCall")]
		private static extern bool TryGetOrCreateComInterfaceForObjectInternal(ObjectHandleOnStack comWrappersImpl, long wrapperId, ObjectHandleOnStack instance, CreateComInterfaceFlags flags, out IntPtr retValue);

		internal unsafe static void* CallComputeVtables(ComWrappersScenario scenario, ComWrappers comWrappersImpl, object obj, CreateComInterfaceFlags flags, out int count)
		{
			ComWrappers comWrappers = null;
			switch (scenario)
			{
			case ComWrappersScenario.Instance:
				comWrappers = comWrappersImpl;
				break;
			case ComWrappersScenario.TrackerSupportGlobalInstance:
				comWrappers = s_globalInstanceForTrackerSupport;
				break;
			case ComWrappersScenario.MarshallingGlobalInstance:
				comWrappers = s_globalInstanceForMarshalling;
				break;
			}
			if (comWrappers == null)
			{
				count = -1;
				return null;
			}
			return comWrappers.ComputeVtables(obj, flags, out count);
		}

		public object GetOrCreateObjectForComInstance(IntPtr externalComObject, CreateObjectFlags flags)
		{
			if (!TryGetOrCreateObjectForComInstanceInternal(this, externalComObject, IntPtr.Zero, flags, null, out var retValue))
			{
				throw new ArgumentNullException("externalComObject");
			}
			return retValue;
		}

		internal static object CallCreateObject(ComWrappersScenario scenario, ComWrappers comWrappersImpl, IntPtr externalComObject, CreateObjectFlags flags)
		{
			ComWrappers comWrappers = null;
			switch (scenario)
			{
			case ComWrappersScenario.Instance:
				comWrappers = comWrappersImpl;
				break;
			case ComWrappersScenario.TrackerSupportGlobalInstance:
				comWrappers = s_globalInstanceForTrackerSupport;
				break;
			case ComWrappersScenario.MarshallingGlobalInstance:
				comWrappers = s_globalInstanceForMarshalling;
				break;
			}
			return comWrappers?.CreateObject(externalComObject, flags);
		}

		public object GetOrRegisterObjectForComInstance(IntPtr externalComObject, CreateObjectFlags flags, object wrapper)
		{
			return GetOrRegisterObjectForComInstance(externalComObject, flags, wrapper, IntPtr.Zero);
		}

		public object GetOrRegisterObjectForComInstance(IntPtr externalComObject, CreateObjectFlags flags, object wrapper, IntPtr inner)
		{
			if (wrapper == null)
			{
				throw new ArgumentNullException("wrapper");
			}
			if (!TryGetOrCreateObjectForComInstanceInternal(this, externalComObject, inner, flags, wrapper, out var retValue))
			{
				throw new ArgumentNullException("externalComObject");
			}
			return retValue;
		}

		private static bool TryGetOrCreateObjectForComInstanceInternal(ComWrappers impl, IntPtr externalComObject, IntPtr innerMaybe, CreateObjectFlags flags, object wrapperMaybe, out object retValue)
		{
			if (externalComObject == IntPtr.Zero)
			{
				throw new ArgumentNullException("externalComObject");
			}
			if (innerMaybe != IntPtr.Zero && !flags.HasFlag(CreateObjectFlags.Aggregation))
			{
				throw new InvalidOperationException(SR.InvalidOperation_SuppliedInnerMustBeMarkedAggregation);
			}
			object o = wrapperMaybe;
			retValue = null;
			return TryGetOrCreateObjectForComInstanceInternal(ObjectHandleOnStack.Create(ref impl), impl.id, externalComObject, innerMaybe, flags, ObjectHandleOnStack.Create(ref o), ObjectHandleOnStack.Create(ref retValue));
		}

		[DllImport("QCall")]
		private static extern bool TryGetOrCreateObjectForComInstanceInternal(ObjectHandleOnStack comWrappersImpl, long wrapperId, IntPtr externalComObject, IntPtr innerMaybe, CreateObjectFlags flags, ObjectHandleOnStack wrapper, ObjectHandleOnStack retValue);

		internal static void CallReleaseObjects(ComWrappers comWrappersImpl, System.Collections.IEnumerable objects)
		{
			(comWrappersImpl ?? s_globalInstanceForTrackerSupport).ReleaseObjects(objects);
		}

		public static void RegisterForTrackerSupport(ComWrappers instance)
		{
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			if (Interlocked.CompareExchange(ref s_globalInstanceForTrackerSupport, instance, null) != null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ResetGlobalComWrappersInstance);
			}
			SetGlobalInstanceRegisteredForTrackerSupport(instance.id);
		}

		[DllImport("QCall")]
		[SuppressGCTransition]
		private static extern void SetGlobalInstanceRegisteredForTrackerSupport(long id);

		[SupportedOSPlatform("windows")]
		public static void RegisterForMarshalling(ComWrappers instance)
		{
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			if (Interlocked.CompareExchange(ref s_globalInstanceForMarshalling, instance, null) != null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ResetGlobalComWrappersInstance);
			}
			SetGlobalInstanceRegisteredForMarshalling(instance.id);
		}

		[DllImport("QCall")]
		[SuppressGCTransition]
		private static extern void SetGlobalInstanceRegisteredForMarshalling(long id);

		protected static void GetIUnknownImpl(out IntPtr fpQueryInterface, out IntPtr fpAddRef, out IntPtr fpRelease)
		{
			GetIUnknownImplInternal(out fpQueryInterface, out fpAddRef, out fpRelease);
		}

		[DllImport("QCall")]
		private static extern void GetIUnknownImplInternal(out IntPtr fpQueryInterface, out IntPtr fpAddRef, out IntPtr fpRelease);

		internal static int CallICustomQueryInterface(object customQueryInterfaceMaybe, ref Guid iid, out IntPtr ppObject)
		{
			if (!(customQueryInterfaceMaybe is ICustomQueryInterface customQueryInterface))
			{
				ppObject = IntPtr.Zero;
				return -1;
			}
			return (int)customQueryInterface.GetInterface(ref iid, out ppObject);
		}

		protected unsafe abstract ComInterfaceEntry* ComputeVtables(object obj, CreateComInterfaceFlags flags, out int count);

		protected abstract object? CreateObject(IntPtr externalComObject, CreateObjectFlags flags);

		protected abstract void ReleaseObjects(System.Collections.IEnumerable objects);
	}
	[ComImport]
	[Guid("00020400-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IDispatch
	{
		int GetTypeInfoCount();

		ITypeInfo GetTypeInfo(int iTInfo, int lcid);

		void GetIDsOfNames(ref Guid riid, [In][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 2)] string[] rgszNames, int cNames, int lcid, [Out] int[] rgDispId);

		void Invoke(int dispIdMember, ref Guid riid, int lcid, InvokeFlags wFlags, ref DISPPARAMS pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr);
	}
	[Flags]
	internal enum InvokeFlags : short
	{
		DISPATCH_METHOD = 1,
		DISPATCH_PROPERTYGET = 2,
		DISPATCH_PROPERTYPUT = 4,
		DISPATCH_PROPERTYPUTREF = 8
	}
	internal sealed class ComEventsMethod
	{
		public class DelegateWrapper
		{
			private bool _once;

			private int _expectedParamsCount;

			private Type[] _cachedTargetTypes;

			public Delegate Delegate { get; set; }

			public bool WrapArgs { get; }

			public DelegateWrapper(Delegate d, bool wrapArgs)
			{
				Delegate = d;
				WrapArgs = wrapArgs;
			}

			public object Invoke(object[] args)
			{
				if ((object)Delegate == null)
				{
					return null;
				}
				if (!_once)
				{
					PreProcessSignature();
					_once = true;
				}
				if (_cachedTargetTypes != null && _expectedParamsCount == args.Length)
				{
					for (int i = 0; i < _expectedParamsCount; i++)
					{
						Type type = _cachedTargetTypes[i];
						if ((object)type != null)
						{
							args[i] = Enum.ToObject(type, args[i]);
						}
					}
				}
				return Delegate.DynamicInvoke((!WrapArgs) ? args : new object[1] { args });
			}

			private void PreProcessSignature()
			{
				ParameterInfo[] parameters = Delegate.Method.GetParameters();
				_expectedParamsCount = parameters.Length;
				Type[] array = null;
				for (int i = 0; i < _expectedParamsCount; i++)
				{
					ParameterInfo parameterInfo = parameters[i];
					if (parameterInfo.ParameterType.IsByRef && parameterInfo.ParameterType.HasElementType && parameterInfo.ParameterType.GetElementType().IsEnum)
					{
						if (array == null)
						{
							array = new Type[_expectedParamsCount];
						}
						array[i] = parameterInfo.ParameterType.GetElementType();
					}
				}
				if (array != null)
				{
					_cachedTargetTypes = array;
				}
			}
		}

		private readonly List<DelegateWrapper> _delegateWrappers = new List<DelegateWrapper>();

		private readonly int _dispid;

		private ComEventsMethod _next;

		public bool Empty
		{
			get
			{
				lock (_delegateWrappers)
				{
					return _delegateWrappers.Count == 0;
				}
			}
		}

		public ComEventsMethod(int dispid)
		{
			_dispid = dispid;
		}

		public static ComEventsMethod Find(ComEventsMethod methods, int dispid)
		{
			while (methods != null && methods._dispid != dispid)
			{
				methods = methods._next;
			}
			return methods;
		}

		public static ComEventsMethod Add(ComEventsMethod methods, ComEventsMethod method)
		{
			method._next = methods;
			return method;
		}

		public static ComEventsMethod Remove(ComEventsMethod methods, ComEventsMethod method)
		{
			if (methods == method)
			{
				return methods._next;
			}
			ComEventsMethod comEventsMethod = methods;
			while (comEventsMethod != null && comEventsMethod._next != method)
			{
				comEventsMethod = comEventsMethod._next;
			}
			if (comEventsMethod != null)
			{
				comEventsMethod._next = method._next;
			}
			return methods;
		}

		public void AddDelegate(Delegate d, bool wrapArgs = false)
		{
			lock (_delegateWrappers)
			{
				foreach (DelegateWrapper delegateWrapper in _delegateWrappers)
				{
					if (delegateWrapper.Delegate.GetType() == d.GetType() && delegateWrapper.WrapArgs == wrapArgs)
					{
						delegateWrapper.Delegate = Delegate.Combine(delegateWrapper.Delegate, d);
						return;
					}
				}
				DelegateWrapper item = new DelegateWrapper(d, wrapArgs);
				_delegateWrappers.Add(item);
			}
		}

		public void RemoveDelegate(Delegate d, bool wrapArgs = false)
		{
			lock (_delegateWrappers)
			{
				int num = -1;
				DelegateWrapper delegateWrapper = null;
				for (int i = 0; i < _delegateWrappers.Count; i++)
				{
					DelegateWrapper delegateWrapper2 = _delegateWrappers[i];
					if (delegateWrapper2.Delegate.GetType() == d.GetType() && delegateWrapper2.WrapArgs == wrapArgs)
					{
						num = i;
						delegateWrapper = delegateWrapper2;
						break;
					}
				}
				if (num >= 0)
				{
					Delegate @delegate = Delegate.Remove(delegateWrapper.Delegate, d);
					if ((object)@delegate != null)
					{
						delegateWrapper.Delegate = @delegate;
					}
					else
					{
						_delegateWrappers.RemoveAt(num);
					}
				}
			}
		}

		public object Invoke(object[] args)
		{
			object result = null;
			lock (_delegateWrappers)
			{
				foreach (DelegateWrapper delegateWrapper in _delegateWrappers)
				{
					result = delegateWrapper.Invoke(args);
				}
				return result;
			}
		}
	}
	[SupportedOSPlatform("windows")]
	internal sealed class ComEventsSink : IDispatch, ICustomQueryInterface
	{
		private Guid _iidSourceItf;

		private IConnectionPoint _connectionPoint;

		private int _cookie;

		private ComEventsMethod _methods;

		private ComEventsSink _next;

		public ComEventsSink(object rcw, Guid iid)
		{
			_iidSourceItf = iid;
			Advise(rcw);
		}

		public static ComEventsSink Find(ComEventsSink sinks, ref Guid iid)
		{
			ComEventsSink comEventsSink = sinks;
			while (comEventsSink != null && comEventsSink._iidSourceItf != iid)
			{
				comEventsSink = comEventsSink._next;
			}
			return comEventsSink;
		}

		public static ComEventsSink Add(ComEventsSink sinks, ComEventsSink sink)
		{
			sink._next = sinks;
			return sink;
		}

		public static ComEventsSink RemoveAll(ComEventsSink sinks)
		{
			while (sinks != null)
			{
				sinks.Unadvise();
				sinks = sinks._next;
			}
			return null;
		}

		public static ComEventsSink Remove(ComEventsSink sinks, ComEventsSink sink)
		{
			ComEventsSink result = sinks;
			if (sink == sinks)
			{
				result = sinks._next;
			}
			else
			{
				ComEventsSink comEventsSink = sinks;
				while (comEventsSink != null && comEventsSink._next != sink)
				{
					comEventsSink = comEventsSink._next;
				}
				if (comEventsSink != null)
				{
					comEventsSink._next = sink._next;
				}
			}
			sink.Unadvise();
			return result;
		}

		public ComEventsMethod RemoveMethod(ComEventsMethod method)
		{
			_methods = ComEventsMethod.Remove(_methods, method);
			return _methods;
		}

		public ComEventsMethod FindMethod(int dispid)
		{
			return ComEventsMethod.Find(_methods, dispid);
		}

		public ComEventsMethod AddMethod(int dispid)
		{
			ComEventsMethod comEventsMethod = new ComEventsMethod(dispid);
			_methods = ComEventsMethod.Add(_methods, comEventsMethod);
			return comEventsMethod;
		}

		int IDispatch.GetTypeInfoCount()
		{
			return 0;
		}

		ITypeInfo IDispatch.GetTypeInfo(int iTInfo, int lcid)
		{
			throw new NotImplementedException();
		}

		void IDispatch.GetIDsOfNames(ref Guid iid, string[] names, int cNames, int lcid, int[] rgDispId)
		{
			throw new NotImplementedException();
		}

		private unsafe static ref Variant GetVariant(ref Variant pSrc)
		{
			if (pSrc.VariantType == (VarEnum)16396)
			{
				Span<Variant> span = new Span<Variant>(pSrc.AsByRefVariant.ToPointer(), 1);
				if ((span[0].VariantType & (VarEnum)20479) == (VarEnum)16396)
				{
					return ref span[0];
				}
			}
			return ref pSrc;
		}

		unsafe void IDispatch.Invoke(int dispid, ref Guid riid, int lcid, InvokeFlags wFlags, ref DISPPARAMS pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
		{
			ComEventsMethod comEventsMethod = FindMethod(dispid);
			if (comEventsMethod == null)
			{
				return;
			}
			object[] array = new object[pDispParams.cArgs];
			int[] array2 = new int[pDispParams.cArgs];
			bool[] array3 = new bool[pDispParams.cArgs];
			int length = pDispParams.cNamedArgs + pDispParams.cArgs;
			Span<Variant> span = new Span<Variant>(pDispParams.rgvarg.ToPointer(), length);
			Span<int> span2 = new Span<int>(pDispParams.rgdispidNamedArgs.ToPointer(), length);
			int num;
			int i;
			for (i = 0; i < pDispParams.cNamedArgs; i++)
			{
				num = span2[i];
				ref Variant variant = ref GetVariant(ref span[i]);
				array[num] = variant.ToObject();
				array3[num] = true;
				int num2 = -1;
				if (variant.IsByRef)
				{
					num2 = i;
				}
				array2[num] = num2;
			}
			num = 0;
			for (; i < pDispParams.cArgs; i++)
			{
				for (; array3[num]; num++)
				{
				}
				ref Variant variant2 = ref GetVariant(ref span[pDispParams.cArgs - 1 - i]);
				array[num] = variant2.ToObject();
				int num3 = -1;
				if (variant2.IsByRef)
				{
					num3 = pDispParams.cArgs - 1 - i;
				}
				array2[num] = num3;
				num++;
			}
			object obj = comEventsMethod.Invoke(array);
			if (pVarResult != IntPtr.Zero)
			{
				Marshal.GetNativeVariantForObject(obj, pVarResult);
			}
			for (i = 0; i < pDispParams.cArgs; i++)
			{
				int num4 = array2[i];
				if (num4 != -1)
				{
					GetVariant(ref span[num4]).CopyFromIndirect(array[i]);
				}
			}
		}

		CustomQueryInterfaceResult ICustomQueryInterface.GetInterface(ref Guid iid, out IntPtr ppv)
		{
			ppv = IntPtr.Zero;
			if (iid == _iidSourceItf || iid == typeof(IDispatch).GUID)
			{
				ppv = Marshal.GetComInterfaceForObject(this, typeof(IDispatch), CustomQueryInterfaceMode.Ignore);
				return CustomQueryInterfaceResult.Handled;
			}
			return CustomQueryInterfaceResult.NotHandled;
		}

		private void Advise(object rcw)
		{
			IConnectionPointContainer connectionPointContainer = (IConnectionPointContainer)rcw;
			connectionPointContainer.FindConnectionPoint(ref _iidSourceItf, out IConnectionPoint ppCP);
			ppCP.Advise(this, out _cookie);
			_connectionPoint = ppCP;
		}

		private void Unadvise()
		{
			if (_connectionPoint == null)
			{
				return;
			}
			try
			{
				_connectionPoint.Unadvise(_cookie);
				Marshal.ReleaseComObject(_connectionPoint);
			}
			catch
			{
			}
			finally
			{
				_connectionPoint = null;
			}
		}
	}
	[StructLayout(LayoutKind.Explicit)]
	[SupportedOSPlatform("windows")]
	internal struct Variant
	{
		private struct TypeUnion
		{
			public ushort _vt;

			public ushort _wReserved1;

			public ushort _wReserved2;

			public ushort _wReserved3;

			public UnionTypes _unionTypes;
		}

		private struct Record
		{
			public IntPtr _record;

			public IntPtr _recordInfo;
		}

		[StructLayout(LayoutKind.Explicit)]
		private struct UnionTypes
		{
			[FieldOffset(0)]
			public sbyte _i1;

			[FieldOffset(0)]
			public short _i2;

			[FieldOffset(0)]
			public int _i4;

			[FieldOffset(0)]
			public long _i8;

			[FieldOffset(0)]
			public byte _ui1;

			[FieldOffset(0)]
			public ushort _ui2;

			[FieldOffset(0)]
			public uint _ui4;

			[FieldOffset(0)]
			public ulong _ui8;

			[FieldOffset(0)]
			public int _int;

			[FieldOffset(0)]
			public uint _uint;

			[FieldOffset(0)]
			public short _bool;

			[FieldOffset(0)]
			public int _error;

			[FieldOffset(0)]
			public float _r4;

			[FieldOffset(0)]
			public double _r8;

			[FieldOffset(0)]
			public long _cy;

			[FieldOffset(0)]
			public double _date;

			[FieldOffset(0)]
			public IntPtr _bstr;

			[FieldOffset(0)]
			public IntPtr _unknown;

			[FieldOffset(0)]
			public IntPtr _dispatch;

			[FieldOffset(0)]
			public IntPtr _pvarVal;

			[FieldOffset(0)]
			public IntPtr _byref;

			[FieldOffset(0)]
			public Record _record;
		}

		[FieldOffset(0)]
		private TypeUnion _typeUnion;

		[FieldOffset(0)]
		private decimal _decimal;

		public VarEnum VariantType
		{
			get
			{
				return (VarEnum)_typeUnion._vt;
			}
			set
			{
				_typeUnion._vt = (ushort)value;
			}
		}

		public bool IsEmpty => _typeUnion._vt == 0;

		public bool IsByRef => (_typeUnion._vt & 0x4000) != 0;

		public sbyte AsI1 => _typeUnion._unionTypes._i1;

		public short AsI2 => _typeUnion._unionTypes._i2;

		public int AsI4 => _typeUnion._unionTypes._i4;

		public long AsI8 => _typeUnion._unionTypes._i8;

		public byte AsUi1 => _typeUnion._unionTypes._ui1;

		public ushort AsUi2 => _typeUnion._unionTypes._ui2;

		public uint AsUi4 => _typeUnion._unionTypes._ui4;

		public ulong AsUi8 => _typeUnion._unionTypes._ui8;

		public int AsInt => _typeUnion._unionTypes._int;

		public uint AsUint => _typeUnion._unionTypes._uint;

		public bool AsBool => _typeUnion._unionTypes._bool != 0;

		public int AsError => _typeUnion._unionTypes._error;

		public float AsR4 => _typeUnion._unionTypes._r4;

		public double AsR8 => _typeUnion._unionTypes._r8;

		public decimal AsDecimal
		{
			get
			{
				Variant variant = this;
				variant._typeUnion._vt = 0;
				return variant._decimal;
			}
		}

		public decimal AsCy => decimal.FromOACurrency(_typeUnion._unionTypes._cy);

		public DateTime AsDate => DateTime.FromOADate(_typeUnion._unionTypes._date);

		public string AsBstr
		{
			get
			{
				if (_typeUnion._unionTypes._bstr == IntPtr.Zero)
				{
					return null;
				}
				return Marshal.PtrToStringBSTR(_typeUnion._unionTypes._bstr);
			}
		}

		public object AsUnknown
		{
			get
			{
				if (_typeUnion._unionTypes._unknown == IntPtr.Zero)
				{
					return null;
				}
				return Marshal.GetObjectForIUnknown(_typeUnion._unionTypes._unknown);
			}
		}

		public object AsDispatch
		{
			get
			{
				if (_typeUnion._unionTypes._dispatch == IntPtr.Zero)
				{
					return null;
				}
				return Marshal.GetObjectForIUnknown(_typeUnion._unionTypes._dispatch);
			}
		}

		public IntPtr AsByRefVariant => _typeUnion._unionTypes._pvarVal;

		public unsafe void CopyFromIndirect(object value)
		{
			VarEnum varEnum = VariantType & (VarEnum)(-16385);
			if (value == null)
			{
				if (varEnum == VarEnum.VT_DISPATCH || varEnum == VarEnum.VT_UNKNOWN || varEnum == VarEnum.VT_BSTR)
				{
					*(IntPtr*)(void*)_typeUnion._unionTypes._byref = IntPtr.Zero;
				}
				return;
			}
			if ((varEnum & VarEnum.VT_ARRAY) != 0)
			{
				System.Runtime.CompilerServices.Unsafe.SkipInit(out Variant variant);
				Marshal.GetNativeVariantForObject(value, (IntPtr)(&variant));
				*(IntPtr*)(void*)_typeUnion._unionTypes._byref = variant._typeUnion._unionTypes._byref;
				return;
			}
			switch (varEnum)
			{
			case VarEnum.VT_I1:
				*(sbyte*)(void*)_typeUnion._unionTypes._byref = (sbyte)value;
				break;
			case VarEnum.VT_UI1:
				*(byte*)(void*)_typeUnion._unionTypes._byref = (byte)value;
				break;
			case VarEnum.VT_I2:
				*(short*)(void*)_typeUnion._unionTypes._byref = (short)value;
				break;
			case VarEnum.VT_UI2:
				*(ushort*)(void*)_typeUnion._unionTypes._byref = (ushort)value;
				break;
			case VarEnum.VT_BOOL:
				*(short*)(void*)_typeUnion._unionTypes._byref = (short)(((bool)value) ? (-1) : 0);
				break;
			case VarEnum.VT_I4:
			case VarEnum.VT_INT:
				*(int*)(void*)_typeUnion._unionTypes._byref = (int)value;
				break;
			case VarEnum.VT_UI4:
			case VarEnum.VT_UINT:
				*(uint*)(void*)_typeUnion._unionTypes._byref = (uint)value;
				break;
			case VarEnum.VT_ERROR:
				*(int*)(void*)_typeUnion._unionTypes._byref = ((ErrorWrapper)value).ErrorCode;
				break;
			case VarEnum.VT_I8:
				*(long*)(void*)_typeUnion._unionTypes._byref = (long)value;
				break;
			case VarEnum.VT_UI8:
				*(ulong*)(void*)_typeUnion._unionTypes._byref = (ulong)value;
				break;
			case VarEnum.VT_R4:
				*(float*)(void*)_typeUnion._unionTypes._byref = (float)value;
				break;
			case VarEnum.VT_R8:
				*(double*)(void*)_typeUnion._unionTypes._byref = (double)value;
				break;
			case VarEnum.VT_DATE:
				*(double*)(void*)_typeUnion._unionTypes._byref = ((DateTime)value).ToOADate();
				break;
			case VarEnum.VT_UNKNOWN:
				*(IntPtr*)(void*)_typeUnion._unionTypes._byref = Marshal.GetIUnknownForObject(value);
				break;
			case VarEnum.VT_DISPATCH:
				*(IntPtr*)(void*)_typeUnion._unionTypes._byref = Marshal.GetIDispatchForObject(value);
				break;
			case VarEnum.VT_BSTR:
				*(IntPtr*)(void*)_typeUnion._unionTypes._byref = Marshal.StringToBSTR((string)value);
				break;
			case VarEnum.VT_CY:
				*(long*)(void*)_typeUnion._unionTypes._byref = decimal.ToOACurrency((decimal)value);
				break;
			case VarEnum.VT_DECIMAL:
				*(decimal*)(void*)_typeUnion._unionTypes._byref = (decimal)value;
				break;
			case VarEnum.VT_VARIANT:
				Marshal.GetNativeVariantForObject(value, _typeUnion._unionTypes._byref);
				break;
			default:
				throw new ArgumentException();
			}
		}

		public unsafe object ToObject()
		{
			if (IsEmpty)
			{
				return null;
			}
			switch (VariantType)
			{
			case VarEnum.VT_NULL:
				return DBNull.Value;
			case VarEnum.VT_I1:
				return AsI1;
			case VarEnum.VT_I2:
				return AsI2;
			case VarEnum.VT_I4:
				return AsI4;
			case VarEnum.VT_I8:
				return AsI8;
			case VarEnum.VT_UI1:
				return AsUi1;
			case VarEnum.VT_UI2:
				return AsUi2;
			case VarEnum.VT_UI4:
				return AsUi4;
			case VarEnum.VT_UI8:
				return AsUi8;
			case VarEnum.VT_INT:
				return AsInt;
			case VarEnum.VT_UINT:
				return AsUint;
			case VarEnum.VT_BOOL:
				return AsBool;
			case VarEnum.VT_ERROR:
				return AsError;
			case VarEnum.VT_R4:
				return AsR4;
			case VarEnum.VT_R8:
				return AsR8;
			case VarEnum.VT_DECIMAL:
				return AsDecimal;
			case VarEnum.VT_CY:
				return AsCy;
			case VarEnum.VT_DATE:
				return AsDate;
			case VarEnum.VT_BSTR:
				return AsBstr;
			case VarEnum.VT_UNKNOWN:
				return AsUnknown;
			case VarEnum.VT_DISPATCH:
				return AsDispatch;
			default:
				fixed (Variant* ptr = &this)
				{
					void* ptr2 = ptr;
					return Marshal.GetObjectForNativeVariant((IntPtr)ptr2);
				}
			}
		}

		public unsafe void Clear()
		{
			VarEnum variantType = VariantType;
			if ((variantType & VarEnum.VT_BYREF) != 0)
			{
				VariantType = VarEnum.VT_EMPTY;
			}
			else if ((variantType & VarEnum.VT_ARRAY) != 0 || variantType == VarEnum.VT_BSTR || variantType == VarEnum.VT_UNKNOWN || variantType == VarEnum.VT_DISPATCH || variantType == VarEnum.VT_VARIANT || variantType == VarEnum.VT_RECORD)
			{
				fixed (Variant* ptr = &this)
				{
					void* ptr2 = ptr;
					Interop.OleAut32.VariantClear((IntPtr)ptr2);
				}
			}
			else
			{
				VariantType = VarEnum.VT_EMPTY;
			}
		}
	}
	[SupportedOSPlatform("windows")]
	public static class ComEventsHelper
	{
		public static void Combine(object rcw, Guid iid, int dispid, Delegate d)
		{
			lock (rcw)
			{
				ComEventsInfo comEventsInfo = ComEventsInfo.FromObject(rcw);
				ComEventsSink comEventsSink = comEventsInfo.FindSink(ref iid) ?? comEventsInfo.AddSink(ref iid);
				ComEventsMethod comEventsMethod = comEventsSink.FindMethod(dispid) ?? comEventsSink.AddMethod(dispid);
				comEventsMethod.AddDelegate(d);
			}
		}

		public static Delegate? Remove(object rcw, Guid iid, int dispid, Delegate d)
		{
			lock (rcw)
			{
				ComEventsInfo comEventsInfo = ComEventsInfo.Find(rcw);
				if (comEventsInfo == null)
				{
					return null;
				}
				ComEventsSink comEventsSink = comEventsInfo.FindSink(ref iid);
				if (comEventsSink == null)
				{
					return null;
				}
				ComEventsMethod comEventsMethod = comEventsSink.FindMethod(dispid);
				if (comEventsMethod == null)
				{
					return null;
				}
				comEventsMethod.RemoveDelegate(d);
				if (comEventsMethod.Empty)
				{
					comEventsMethod = comEventsSink.RemoveMethod(comEventsMethod);
				}
				if (comEventsMethod == null)
				{
					comEventsSink = comEventsInfo.RemoveSink(comEventsSink);
				}
				if (comEventsSink == null)
				{
					Marshal.SetComObjectData(rcw, typeof(ComEventsInfo), null);
					GC.SuppressFinalize(comEventsInfo);
				}
				return d;
			}
		}
	}
	[SupportedOSPlatform("windows")]
	internal sealed class ComEventsInfo
	{
		private ComEventsSink _sinks;

		private readonly object _rcw;

		private ComEventsInfo(object rcw)
		{
			_rcw = rcw;
		}

		~ComEventsInfo()
		{
			_sinks = ComEventsSink.RemoveAll(_sinks);
		}

		public static ComEventsInfo Find(object rcw)
		{
			return (ComEventsInfo)Marshal.GetComObjectData(rcw, typeof(ComEventsInfo));
		}

		public static ComEventsInfo FromObject(object rcw)
		{
			ComEventsInfo comEventsInfo = Find(rcw);
			if (comEventsInfo == null)
			{
				comEventsInfo = new ComEventsInfo(rcw);
				Marshal.SetComObjectData(rcw, typeof(ComEventsInfo), comEventsInfo);
			}
			return comEventsInfo;
		}

		public ComEventsSink FindSink(ref Guid iid)
		{
			return ComEventsSink.Find(_sinks, ref iid);
		}

		public ComEventsSink AddSink(ref Guid iid)
		{
			ComEventsSink sink = new ComEventsSink(_rcw, iid);
			_sinks = ComEventsSink.Add(_sinks, sink);
			return _sinks;
		}

		internal ComEventsSink RemoveSink(ComEventsSink sink)
		{
			_sinks = ComEventsSink.Remove(_sinks, sink);
			return _sinks;
		}
	}
	[Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId = "SYSLIB0003", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public sealed class AllowReversePInvokeCallsAttribute : Attribute
	{
	}
	public readonly struct ArrayWithOffset
	{
		private readonly object m_array;

		private readonly int m_offset;

		private readonly int m_count;

		public ArrayWithOffset(object? array, int offset)
		{
			int num = 0;
			if (array != null)
			{
				if (!(array is Array array2) || array2.Rank != 1 || !Marshal.IsPinnable(array2))
				{
					throw new ArgumentException(SR.ArgumentException_NotIsomorphic);
				}
				nuint num2 = array2.NativeLength * array2.GetElementSize();
				if (num2 > 2147483632)
				{
					throw new ArgumentException(SR.Argument_StructArrayTooLarge);
				}
				num = (int)num2;
			}
			if ((uint)offset > (uint)num)
			{
				throw new IndexOutOfRangeException(SR.IndexOutOfRange_ArrayWithOffset);
			}
			m_array = array;
			m_offset = offset;
			m_count = num - offset;
		}

		public object? GetArray()
		{
			return m_array;
		}

		public int GetOffset()
		{
			return m_offset;
		}

		public override int GetHashCode()
		{
			return m_count + m_offset;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is ArrayWithOffset)
			{
				return Equals((ArrayWithOffset)obj);
			}
			return false;
		}

		public bool Equals(ArrayWithOffset obj)
		{
			if (obj.m_array == m_array && obj.m_offset == m_offset)
			{
				return obj.m_count == m_count;
			}
			return false;
		}

		public static bool operator ==(ArrayWithOffset a, ArrayWithOffset b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(ArrayWithOffset a, ArrayWithOffset b)
		{
			return !(a == b);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	public sealed class BestFitMappingAttribute : Attribute
	{
		public bool ThrowOnUnmappableChar;

		public bool BestFitMapping { get; }

		public BestFitMappingAttribute(bool BestFitMapping)
		{
			this.BestFitMapping = BestFitMapping;
		}
	}
	public sealed class BStrWrapper
	{
		public string? WrappedObject { get; }

		public BStrWrapper(string? value)
		{
			WrappedObject = value;
		}

		public BStrWrapper(object? value)
		{
			WrappedObject = (string)value;
		}
	}
	public enum CallingConvention
	{
		Winapi = 1,
		Cdecl,
		StdCall,
		ThisCall,
		FastCall
	}
	public enum CharSet
	{
		None = 1,
		Ansi,
		Unicode,
		Auto
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, Inherited = false)]
	public sealed class ClassInterfaceAttribute : Attribute
	{
		public ClassInterfaceType Value { get; }

		public ClassInterfaceAttribute(ClassInterfaceType classInterfaceType)
		{
			Value = classInterfaceType;
		}

		public ClassInterfaceAttribute(short classInterfaceType)
		{
			Value = (ClassInterfaceType)classInterfaceType;
		}
	}
	public enum ClassInterfaceType
	{
		None,
		AutoDispatch,
		AutoDual
	}
	[CLSCompliant(false)]
	[Intrinsic]
	public readonly struct CLong : IEquatable<CLong>
	{
		private readonly int _value;

		public nint Value => _value;

		public CLong(int value)
		{
			_value = value;
		}

		public CLong(nint value)
		{
			_value = checked((int)value);
		}

		public override bool Equals([NotNullWhen(true)] object? o)
		{
			if (o is CLong other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(CLong other)
		{
			return _value == other._value;
		}

		public override int GetHashCode()
		{
			return _value.GetHashCode();
		}

		public override string ToString()
		{
			return _value.ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Interface, Inherited = false)]
	public sealed class CoClassAttribute : Attribute
	{
		public Type CoClass { get; }

		public CoClassAttribute(Type coClass)
		{
			CoClass = coClass;
		}
	}
	public static class CollectionsMarshal
	{
		public static Span<T> AsSpan<T>(List<T>? list)
		{
			if (list != null)
			{
				return new Span<T>(list._items, 0, list._size);
			}
			return default(Span<T>);
		}

		public static ref TValue GetValueRefOrNullRef<TKey, TValue>(Dictionary<TKey, TValue> dictionary, TKey key) where TKey : notnull
		{
			return ref dictionary.FindValue(key);
		}

		public static ref TValue? GetValueRefOrAddDefault<TKey, TValue>(Dictionary<TKey, TValue> dictionary, TKey key, out bool exists) where TKey : notnull
		{
			return ref Dictionary<TKey, TValue>.CollectionsMarshalHelper.GetValueRefOrAddDefault(dictionary, key, out exists);
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public sealed class ComDefaultInterfaceAttribute : Attribute
	{
		public Type Value { get; }

		public ComDefaultInterfaceAttribute(Type defaultInterface)
		{
			Value = defaultInterface;
		}
	}
	[AttributeUsage(AttributeTargets.Interface, Inherited = false)]
	public sealed class ComEventInterfaceAttribute : Attribute
	{
		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
		public Type SourceInterface { get; }

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)]
		public Type EventProvider { get; }

		public ComEventInterfaceAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] Type SourceInterface, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] Type EventProvider)
		{
			this.SourceInterface = SourceInterface;
			this.EventProvider = EventProvider;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class COMException : ExternalException
	{
		public COMException()
			: base(SR.Arg_COMException)
		{
			base.HResult = -2147467259;
		}

		public COMException(string? message)
			: base(message)
		{
			base.HResult = -2147467259;
		}

		public COMException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147467259;
		}

		public COMException(string? message, int errorCode)
			: base(message)
		{
			base.HResult = errorCode;
		}

		protected COMException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			StringBuilder stringBuilder2 = stringBuilder;
			StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(5, 2, stringBuilder2);
			handler.AppendFormatted(GetType());
			handler.AppendLiteral(" (0x");
			handler.AppendFormatted(base.HResult, "X8");
			handler.AppendLiteral(")");
			stringBuilder2.Append(ref handler);
			string message = Message;
			if (!string.IsNullOrEmpty(message))
			{
				stringBuilder.Append(": ").Append(message);
			}
			Exception innerException = base.InnerException;
			if (innerException != null)
			{
				stringBuilder.Append("\r\n ---> ").Append(innerException.ToString());
			}
			string stackTrace = StackTrace;
			if (stackTrace != null)
			{
				stringBuilder.AppendLine().Append(stackTrace);
			}
			return stringBuilder.ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
	public sealed class ComImportAttribute : Attribute
	{
	}
	public enum ComInterfaceType
	{
		InterfaceIsDual,
		InterfaceIsIUnknown,
		InterfaceIsIDispatch,
		InterfaceIsIInspectable
	}
	public enum ComMemberType
	{
		Method,
		PropGet,
		PropSet
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = true)]
	public sealed class ComSourceInterfacesAttribute : Attribute
	{
		public string Value { get; }

		public ComSourceInterfacesAttribute(string sourceInterfaces)
		{
			Value = sourceInterfaces;
		}

		public ComSourceInterfacesAttribute(Type sourceInterface)
		{
			Value = sourceInterface.FullName;
		}

		public ComSourceInterfacesAttribute(Type sourceInterface1, Type sourceInterface2)
		{
			Value = sourceInterface1.FullName + "\0" + sourceInterface2.FullName;
		}

		public ComSourceInterfacesAttribute(Type sourceInterface1, Type sourceInterface2, Type sourceInterface3)
		{
			Value = sourceInterface1.FullName + "\0" + sourceInterface2.FullName + "\0" + sourceInterface3.FullName;
		}

		public ComSourceInterfacesAttribute(Type sourceInterface1, Type sourceInterface2, Type sourceInterface3, Type sourceInterface4)
		{
			Value = sourceInterface1.FullName + "\0" + sourceInterface2.FullName + "\0" + sourceInterface3.FullName + "\0" + sourceInterface4.FullName;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	public sealed class ComVisibleAttribute : Attribute
	{
		public bool Value { get; }

		public ComVisibleAttribute(bool visibility)
		{
			Value = visibility;
		}
	}
	[Flags]
	public enum CreateComInterfaceFlags
	{
		None = 0,
		CallerDefinedIUnknown = 1,
		TrackerSupport = 2
	}
	[Flags]
	public enum CreateObjectFlags
	{
		None = 0,
		TrackerObject = 1,
		UniqueInstance = 2,
		Aggregation = 4,
		Unwrap = 8
	}
	public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
	{
		protected IntPtr handle;

		private bool _isClosed;

		public bool IsClosed => _isClosed;

		public abstract bool IsInvalid { get; }

		protected CriticalHandle(IntPtr invalidHandleValue)
		{
			handle = invalidHandleValue;
		}

		~CriticalHandle()
		{
			Dispose(disposing: false);
		}

		private void Cleanup()
		{
			if (!IsClosed)
			{
				_isClosed = true;
				if (!IsInvalid)
				{
					int lastPInvokeError = Marshal.GetLastPInvokeError();
					ReleaseHandle();
					Marshal.SetLastPInvokeError(lastPInvokeError);
					GC.SuppressFinalize(this);
				}
			}
		}

		protected void SetHandle(IntPtr handle)
		{
			this.handle = handle;
		}

		public void Close()
		{
			Dispose(disposing: true);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
		}

		protected virtual void Dispose(bool disposing)
		{
			Cleanup();
		}

		public void SetHandleAsInvalid()
		{
			_isClosed = true;
			GC.SuppressFinalize(this);
		}

		protected abstract bool ReleaseHandle();
	}
	[CLSCompliant(false)]
	[Intrinsic]
	public readonly struct CULong : IEquatable<CULong>
	{
		private readonly uint _value;

		public nuint Value => _value;

		public CULong(uint value)
		{
			_value = value;
		}

		public CULong(nuint value)
		{
			_value = checked((uint)value);
		}

		public override bool Equals([NotNullWhen(true)] object? o)
		{
			if (o is CULong other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(CULong other)
		{
			return _value == other._value;
		}

		public override int GetHashCode()
		{
			return _value.GetHashCode();
		}

		public override string ToString()
		{
			return _value.ToString();
		}
	}
	public sealed class CurrencyWrapper
	{
		public decimal WrappedObject { get; }

		public CurrencyWrapper(decimal obj)
		{
			WrappedObject = obj;
		}

		public CurrencyWrapper(object obj)
		{
			if (!(obj is decimal))
			{
				throw new ArgumentException(SR.Arg_MustBeDecimal, "obj");
			}
			WrappedObject = (decimal)obj;
		}
	}
	public enum CustomQueryInterfaceMode
	{
		Ignore,
		Allow
	}
	public enum CustomQueryInterfaceResult
	{
		Handled,
		NotHandled,
		Failed
	}
	[AttributeUsage(AttributeTargets.Module, Inherited = false)]
	public sealed class DefaultCharSetAttribute : Attribute
	{
		public CharSet CharSet { get; }

		public DefaultCharSetAttribute(CharSet charSet)
		{
			CharSet = charSet;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Method, AllowMultiple = false)]
	public sealed class DefaultDllImportSearchPathsAttribute : Attribute
	{
		public DllImportSearchPath Paths { get; }

		public DefaultDllImportSearchPathsAttribute(DllImportSearchPath paths)
		{
			Paths = paths;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter)]
	public sealed class DefaultParameterValueAttribute : Attribute
	{
		public object? Value { get; }

		public DefaultParameterValueAttribute(object? value)
		{
			Value = value;
		}
	}
	[SupportedOSPlatform("windows")]
	public sealed class DispatchWrapper
	{
		public object? WrappedObject { get; }

		public DispatchWrapper(object? obj)
		{
			if (obj != null)
			{
				IntPtr iDispatchForObject = Marshal.GetIDispatchForObject(obj);
				Marshal.Release(iDispatchForObject);
				WrappedObject = obj;
			}
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event, Inherited = false)]
	public sealed class DispIdAttribute : Attribute
	{
		public int Value { get; }

		public DispIdAttribute(int dispId)
		{
			Value = dispId;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class DllImportAttribute : Attribute
	{
		public string? EntryPoint;

		public CharSet CharSet;

		public bool SetLastError;

		public bool ExactSpelling;

		public CallingConvention CallingConvention;

		public bool BestFitMapping;

		public bool PreserveSig;

		public bool ThrowOnUnmappableChar;

		public string Value { get; }

		public DllImportAttribute(string dllName)
		{
			Value = dllName;
		}
	}
	[Flags]
	public enum DllImportSearchPath
	{
		UseDllDirectoryForDependencies = 0x100,
		ApplicationDirectory = 0x200,
		UserDirectories = 0x400,
		System32 = 0x800,
		SafeDirectories = 0x1000,
		AssemblyDirectory = 2,
		LegacyBehavior = 0
	}
	public sealed class ErrorWrapper
	{
		public int ErrorCode { get; }

		public ErrorWrapper(int errorCode)
		{
			ErrorCode = errorCode;
		}

		public ErrorWrapper(object errorCode)
		{
			if (!(errorCode is int))
			{
				throw new ArgumentException(SR.Arg_MustBeInt32, "errorCode");
			}
			ErrorCode = (int)errorCode;
		}

		public ErrorWrapper(Exception e)
		{
			ErrorCode = Marshal.GetHRForException(e);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ExternalException : SystemException
	{
		public virtual int ErrorCode => base.HResult;

		public ExternalException()
			: base(SR.Arg_ExternalException)
		{
			base.HResult = -2147467259;
		}

		public ExternalException(string? message)
			: base(message)
		{
			base.HResult = -2147467259;
		}

		public ExternalException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147467259;
		}

		public ExternalException(string? message, int errorCode)
			: base(message)
		{
			base.HResult = errorCode;
		}

		protected ExternalException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public override string ToString()
		{
			string message = Message;
			string text = $"{GetType()} (0x{base.HResult:X8})";
			if (!string.IsNullOrEmpty(message))
			{
				text = text + ": " + message;
			}
			Exception innerException = base.InnerException;
			if (innerException != null)
			{
				text = text + "\r\n ---> " + innerException.ToString();
			}
			if (StackTrace != null)
			{
				text = text + "\r\n" + StackTrace;
			}
			return text;
		}
	}
	[AttributeUsage(AttributeTargets.Field, Inherited = false)]
	public sealed class FieldOffsetAttribute : Attribute
	{
		public int Value { get; }

		public FieldOffsetAttribute(int offset)
		{
			Value = offset;
		}
	}
	public enum GCHandleType
	{
		Weak,
		WeakTrackResurrection,
		Normal,
		Pinned
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	public sealed class GuidAttribute : Attribute
	{
		public string Value { get; }

		public GuidAttribute(string guid)
		{
			Value = guid;
		}
	}
	public readonly struct HandleRef
	{
		private readonly object _wrapper;

		private readonly IntPtr _handle;

		public object? Wrapper => _wrapper;

		public IntPtr Handle => _handle;

		public HandleRef(object? wrapper, IntPtr handle)
		{
			_wrapper = wrapper;
			_handle = handle;
		}

		public static explicit operator IntPtr(HandleRef value)
		{
			return value._handle;
		}

		public static IntPtr ToIntPtr(HandleRef value)
		{
			return value._handle;
		}
	}
	public interface ICustomAdapter
	{
		[return: MarshalAs(UnmanagedType.IUnknown)]
		object GetUnderlyingObject();
	}
	public interface ICustomFactory
	{
		MarshalByRefObject CreateInstance(Type serverType);
	}
	public interface ICustomMarshaler
	{
		object MarshalNativeToManaged(IntPtr pNativeData);

		IntPtr MarshalManagedToNative(object ManagedObj);

		void CleanUpNativeData(IntPtr pNativeData);

		void CleanUpManagedData(object ManagedObj);

		int GetNativeDataSize();
	}
	public interface ICustomQueryInterface
	{
		CustomQueryInterfaceResult GetInterface([In] ref Guid iid, out IntPtr ppv);
	}
	public interface IDynamicInterfaceCastable
	{
		bool IsInterfaceImplemented(RuntimeTypeHandle interfaceType, bool throwIfNotImplemented);

		RuntimeTypeHandle GetInterfaceImplementation(RuntimeTypeHandle interfaceType);
	}
	[AttributeUsage(AttributeTargets.Interface, AllowMultiple = false, Inherited = false)]
	public sealed class DynamicInterfaceCastableImplementationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class InAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Interface, Inherited = false)]
	public sealed class InterfaceTypeAttribute : Attribute
	{
		public ComInterfaceType Value { get; }

		public InterfaceTypeAttribute(ComInterfaceType interfaceType)
		{
			Value = interfaceType;
		}

		public InterfaceTypeAttribute(short interfaceType)
		{
			Value = (ComInterfaceType)interfaceType;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class InvalidComObjectException : SystemException
	{
		public InvalidComObjectException()
			: base(SR.Arg_InvalidComObjectException)
		{
			base.HResult = -2146233049;
		}

		public InvalidComObjectException(string? message)
			: base(message)
		{
			base.HResult = -2146233049;
		}

		public InvalidComObjectException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233049;
		}

		protected InvalidComObjectException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class InvalidOleVariantTypeException : SystemException
	{
		public InvalidOleVariantTypeException()
			: base(SR.Arg_InvalidOleVariantTypeException)
		{
			base.HResult = -2146233039;
		}

		public InvalidOleVariantTypeException(string? message)
			: base(message)
		{
			base.HResult = -2146233039;
		}

		public InvalidOleVariantTypeException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233039;
		}

		protected InvalidOleVariantTypeException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public enum LayoutKind
	{
		Sequential = 0,
		Explicit = 2,
		Auto = 3
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class LCIDConversionAttribute : Attribute
	{
		public int Value { get; }

		public LCIDConversionAttribute(int lcid)
		{
			Value = lcid;
		}
	}
	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	public sealed class MarshalAsAttribute : Attribute
	{
		public VarEnum SafeArraySubType;

		public Type? SafeArrayUserDefinedSubType;

		public int IidParameterIndex;

		public UnmanagedType ArraySubType;

		public short SizeParamIndex;

		public int SizeConst;

		public string? MarshalType;

		public Type? MarshalTypeRef;

		public string? MarshalCookie;

		public UnmanagedType Value { get; }

		public MarshalAsAttribute(UnmanagedType unmanagedType)
		{
			Value = unmanagedType;
		}

		public MarshalAsAttribute(short unmanagedType)
		{
			Value = (UnmanagedType)unmanagedType;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class MarshalDirectiveException : SystemException
	{
		public MarshalDirectiveException()
			: base(SR.Arg_MarshalDirectiveException)
		{
			base.HResult = -2146233035;
		}

		public MarshalDirectiveException(string? message)
			: base(message)
		{
			base.HResult = -2146233035;
		}

		public MarshalDirectiveException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233035;
		}

		protected MarshalDirectiveException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public static class NativeMemory
	{
		[CLSCompliant(false)]
		public unsafe static void* Alloc(nuint elementCount, nuint elementSize)
		{
			nuint byteCount = GetByteCount(elementCount, elementSize);
			return Alloc(byteCount);
		}

		[CLSCompliant(false)]
		public unsafe static void* AllocZeroed(nuint byteCount)
		{
			return AllocZeroed(byteCount, 1u);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static nuint GetByteCount(nuint elementCount, nuint elementSize)
		{
			nuint num = (nuint)((nint)1 << 4 * sizeof(UIntPtr));
			if ((elementSize < num && elementCount < num) || elementSize == 0 || (nuint)UIntPtr.MaxValue / elementSize >= elementCount)
			{
				return elementCount * elementSize;
			}
			return UIntPtr.MaxValue;
		}

		[CLSCompliant(false)]
		public unsafe static void* AlignedAlloc(nuint byteCount, nuint alignment)
		{
			if (!BitOperations.IsPow2(alignment))
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AlignmentMustBePow2);
			}
			void* ptr = Interop.Ucrtbase._aligned_malloc((byteCount != 0) ? byteCount : 1, alignment);
			if (ptr == null)
			{
				ThrowHelper.ThrowOutOfMemoryException();
			}
			return ptr;
		}

		[CLSCompliant(false)]
		public unsafe static void AlignedFree(void* ptr)
		{
			if (ptr != null)
			{
				Interop.Ucrtbase._aligned_free(ptr);
			}
		}

		[CLSCompliant(false)]
		public unsafe static void* AlignedRealloc(void* ptr, nuint byteCount, nuint alignment)
		{
			if (!BitOperations.IsPow2(alignment))
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AlignmentMustBePow2);
			}
			void* ptr2 = Interop.Ucrtbase._aligned_realloc(ptr, (byteCount != 0) ? byteCount : 1, alignment);
			if (ptr2 == null)
			{
				ThrowHelper.ThrowOutOfMemoryException();
			}
			return ptr2;
		}

		[CLSCompliant(false)]
		public unsafe static void* Alloc(nuint byteCount)
		{
			void* ptr = Interop.Ucrtbase.malloc(byteCount);
			if (ptr == null)
			{
				ThrowHelper.ThrowOutOfMemoryException();
			}
			return ptr;
		}

		[CLSCompliant(false)]
		public unsafe static void* AllocZeroed(nuint elementCount, nuint elementSize)
		{
			void* ptr = Interop.Ucrtbase.calloc(elementCount, elementSize);
			if (ptr == null)
			{
				ThrowHelper.ThrowOutOfMemoryException();
			}
			return ptr;
		}

		[CLSCompliant(false)]
		public unsafe static void Free(void* ptr)
		{
			if (ptr != null)
			{
				Interop.Ucrtbase.free(ptr);
			}
		}

		[CLSCompliant(false)]
		public unsafe static void* Realloc(void* ptr, nuint byteCount)
		{
			void* ptr2 = Interop.Ucrtbase.realloc(ptr, (byteCount != 0) ? byteCount : 1);
			if (ptr2 == null)
			{
				ThrowHelper.ThrowOutOfMemoryException();
			}
			return ptr2;
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public sealed class UnmanagedCallConvAttribute : Attribute
	{
		public Type[]? CallConvs;
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class UnmanagedCallersOnlyAttribute : Attribute
	{
		public Type[]? CallConvs;

		public string? EntryPoint;
	}
	public delegate IntPtr DllImportResolver(string libraryName, Assembly assembly, DllImportSearchPath? searchPath);
	[Intrinsic]
	public readonly struct NFloat : IComparable, IComparable<NFloat>, IEquatable<NFloat>, ISpanFormattable, IFormattable
	{
		private readonly float _value;

		public static NFloat Epsilon
		{
			[NonVersionable]
			get
			{
				return new NFloat(float.Epsilon);
			}
		}

		public static NFloat MaxValue
		{
			[NonVersionable]
			get
			{
				return new NFloat(float.MaxValue);
			}
		}

		public static NFloat MinValue
		{
			[NonVersionable]
			get
			{
				return new NFloat(float.MinValue);
			}
		}

		public static NFloat NaN
		{
			[NonVersionable]
			get
			{
				return new NFloat(float.NaN);
			}
		}

		public static NFloat NegativeInfinity
		{
			[NonVersionable]
			get
			{
				return new NFloat(float.NegativeInfinity);
			}
		}

		public static NFloat PositiveInfinity
		{
			[NonVersionable]
			get
			{
				return new NFloat(float.PositiveInfinity);
			}
		}

		public static int Size
		{
			[NonVersionable]
			get
			{
				return 4;
			}
		}

		public double Value
		{
			[NonVersionable]
			get
			{
				return _value;
			}
		}

		[NonVersionable]
		public NFloat(float value)
		{
			_value = value;
		}

		[NonVersionable]
		public NFloat(double value)
		{
			_value = (float)value;
		}

		[NonVersionable]
		public static NFloat operator +(NFloat value)
		{
			return value;
		}

		[NonVersionable]
		public static NFloat operator -(NFloat value)
		{
			return new NFloat(0f - value._value);
		}

		[NonVersionable]
		public static NFloat operator ++(NFloat value)
		{
			return new NFloat(value._value + 1f);
		}

		[NonVersionable]
		public static NFloat operator --(NFloat value)
		{
			return new NFloat(value._value - 1f);
		}

		[NonVersionable]
		public static NFloat operator +(NFloat left, NFloat right)
		{
			return new NFloat(left._value + right._value);
		}

		[NonVersionable]
		public static NFloat operator -(NFloat left, NFloat right)
		{
			return new NFloat(left._value - right._value);
		}

		[NonVersionable]
		public static NFloat operator *(NFloat left, NFloat right)
		{
			return new NFloat(left._value * right._value);
		}

		[NonVersionable]
		public static NFloat operator /(NFloat left, NFloat right)
		{
			return new NFloat(left._value / right._value);
		}

		[NonVersionable]
		public static NFloat operator %(NFloat left, NFloat right)
		{
			return new NFloat(left._value % right._value);
		}

		[NonVersionable]
		public static bool operator ==(NFloat left, NFloat right)
		{
			return left._value == right._value;
		}

		[NonVersionable]
		public static bool operator !=(NFloat left, NFloat right)
		{
			return left._value != right._value;
		}

		[NonVersionable]
		public static bool operator <(NFloat left, NFloat right)
		{
			return left._value < right._value;
		}

		[NonVersionable]
		public static bool operator <=(NFloat left, NFloat right)
		{
			return left._value <= right._value;
		}

		[NonVersionable]
		public static bool operator >(NFloat left, NFloat right)
		{
			return left._value > right._value;
		}

		[NonVersionable]
		public static bool operator >=(NFloat left, NFloat right)
		{
			return left._value >= right._value;
		}

		[NonVersionable]
		public static explicit operator NFloat(decimal value)
		{
			return new NFloat((float)value);
		}

		[NonVersionable]
		public static explicit operator NFloat(double value)
		{
			return new NFloat((float)value);
		}

		[NonVersionable]
		public static explicit operator byte(NFloat value)
		{
			return (byte)value._value;
		}

		[NonVersionable]
		public static explicit operator char(NFloat value)
		{
			return (char)value._value;
		}

		[NonVersionable]
		public static explicit operator decimal(NFloat value)
		{
			return (decimal)value._value;
		}

		[NonVersionable]
		public static explicit operator short(NFloat value)
		{
			return (short)value._value;
		}

		[NonVersionable]
		public static explicit operator int(NFloat value)
		{
			return (int)value._value;
		}

		[NonVersionable]
		public static explicit operator long(NFloat value)
		{
			return (long)value._value;
		}

		[NonVersionable]
		public static explicit operator nint(NFloat value)
		{
			return (nint)value._value;
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static explicit operator sbyte(NFloat value)
		{
			return (sbyte)value._value;
		}

		[NonVersionable]
		public static explicit operator float(NFloat value)
		{
			return value._value;
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static explicit operator ushort(NFloat value)
		{
			return (ushort)value._value;
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static explicit operator uint(NFloat value)
		{
			return (uint)value._value;
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static explicit operator ulong(NFloat value)
		{
			return (ulong)value._value;
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static explicit operator nuint(NFloat value)
		{
			return (nuint)value._value;
		}

		[NonVersionable]
		public static implicit operator NFloat(byte value)
		{
			return new NFloat((int)value);
		}

		[NonVersionable]
		public static implicit operator NFloat(char value)
		{
			return new NFloat((int)value);
		}

		[NonVersionable]
		public static implicit operator NFloat(short value)
		{
			return new NFloat(value);
		}

		[NonVersionable]
		public static implicit operator NFloat(int value)
		{
			return new NFloat(value);
		}

		[NonVersionable]
		public static implicit operator NFloat(long value)
		{
			return new NFloat(value);
		}

		[NonVersionable]
		public static implicit operator NFloat(nint value)
		{
			return new NFloat(value);
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static implicit operator NFloat(sbyte value)
		{
			return new NFloat(value);
		}

		[NonVersionable]
		public static implicit operator NFloat(float value)
		{
			return new NFloat(value);
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static implicit operator NFloat(ushort value)
		{
			return new NFloat((int)value);
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static implicit operator NFloat(uint value)
		{
			return new NFloat(value);
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static implicit operator NFloat(ulong value)
		{
			return new NFloat(value);
		}

		[NonVersionable]
		[CLSCompliant(false)]
		public static implicit operator NFloat(nuint value)
		{
			return new NFloat((nint)value);
		}

		public static implicit operator double(NFloat value)
		{
			return value._value;
		}

		[NonVersionable]
		public static bool IsFinite(NFloat value)
		{
			return float.IsFinite(value._value);
		}

		[NonVersionable]
		public static bool IsInfinity(NFloat value)
		{
			return float.IsInfinity(value._value);
		}

		[NonVersionable]
		public static bool IsNaN(NFloat value)
		{
			return float.IsNaN(value._value);
		}

		[NonVersionable]
		public static bool IsNegative(NFloat value)
		{
			return float.IsNegative(value._value);
		}

		[NonVersionable]
		public static bool IsNegativeInfinity(NFloat value)
		{
			return float.IsNegativeInfinity(value._value);
		}

		[NonVersionable]
		public static bool IsNormal(NFloat value)
		{
			return float.IsNormal(value._value);
		}

		[NonVersionable]
		public static bool IsPositiveInfinity(NFloat value)
		{
			return float.IsPositiveInfinity(value._value);
		}

		[NonVersionable]
		public static bool IsSubnormal(NFloat value)
		{
			return float.IsSubnormal(value._value);
		}

		public static NFloat Parse(string s)
		{
			float value = float.Parse(s);
			return new NFloat(value);
		}

		public static NFloat Parse(string s, NumberStyles style)
		{
			float value = float.Parse(s, style);
			return new NFloat(value);
		}

		public static NFloat Parse(string s, IFormatProvider? provider)
		{
			float value = float.Parse(s, provider);
			return new NFloat(value);
		}

		public static NFloat Parse(string s, NumberStyles style, IFormatProvider? provider)
		{
			float value = float.Parse(s, style, provider);
			return new NFloat(value);
		}

		public static NFloat Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Float | NumberStyles.AllowThousands, IFormatProvider? provider = null)
		{
			float value = float.Parse(s, style, provider);
			return new NFloat(value);
		}

		public static bool TryParse([NotNullWhen(true)] string? s, out NFloat result)
		{
			Unsafe.SkipInit<NFloat>(out result);
			return float.TryParse(s, out Unsafe.As<NFloat, float>(ref result));
		}

		public static bool TryParse(ReadOnlySpan<char> s, out NFloat result)
		{
			Unsafe.SkipInit<NFloat>(out result);
			return float.TryParse(s, out Unsafe.As<NFloat, float>(ref result));
		}

		public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out NFloat result)
		{
			Unsafe.SkipInit<NFloat>(out result);
			return float.TryParse(s, style, provider, out Unsafe.As<NFloat, float>(ref result));
		}

		public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out NFloat result)
		{
			Unsafe.SkipInit<NFloat>(out result);
			return float.TryParse(s, style, provider, out Unsafe.As<NFloat, float>(ref result));
		}

		public int CompareTo(object? obj)
		{
			if (obj is NFloat nFloat)
			{
				if (_value < nFloat._value)
				{
					return -1;
				}
				if (_value > nFloat._value)
				{
					return 1;
				}
				if (_value == nFloat._value)
				{
					return 0;
				}
				if (float.IsNaN(_value))
				{
					if (!float.IsNaN(nFloat._value))
					{
						return -1;
					}
					return 0;
				}
				return 1;
			}
			if (obj == null)
			{
				return 1;
			}
			throw new ArgumentException(SR.Arg_MustBeNFloat);
		}

		public int CompareTo(NFloat other)
		{
			return _value.CompareTo(other._value);
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is NFloat other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(NFloat other)
		{
			return _value.Equals(other._value);
		}

		public override int GetHashCode()
		{
			return _value.GetHashCode();
		}

		public override string ToString()
		{
			return _value.ToString();
		}

		public string ToString(string? format)
		{
			return _value.ToString(format);
		}

		public string ToString(IFormatProvider? provider)
		{
			return _value.ToString(provider);
		}

		public string ToString(string? format, IFormatProvider? provider)
		{
			return _value.ToString(format, provider);
		}

		public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider? provider = null)
		{
			return _value.TryFormat(destination, out charsWritten, format, provider);
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class OptionalAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class OutAttribute : Attribute
	{
	}
	public enum PosixSignal
	{
		SIGHUP = -1,
		SIGINT = -2,
		SIGQUIT = -3,
		SIGTERM = -4,
		[UnsupportedOSPlatform("windows")]
		SIGCHLD = -5,
		[UnsupportedOSPlatform("windows")]
		SIGCONT = -6,
		[UnsupportedOSPlatform("windows")]
		SIGWINCH = -7,
		[UnsupportedOSPlatform("windows")]
		SIGTTIN = -8,
		[UnsupportedOSPlatform("windows")]
		SIGTTOU = -9,
		[UnsupportedOSPlatform("windows")]
		SIGTSTP = -10
	}
	public sealed class PosixSignalContext
	{
		public PosixSignal Signal { get; internal set; }

		public bool Cancel { get; set; }

		public PosixSignalContext(PosixSignal signal)
		{
			Signal = signal;
		}
	}
	public sealed class PosixSignalRegistration : IDisposable
	{
		private sealed class Token
		{
			public PosixSignal Signal { get; }

			public Action<PosixSignalContext> Handler { get; }

			public Token(PosixSignal signal, Action<PosixSignalContext> handler)
			{
				Signal = signal;
				Handler = handler;
			}
		}

		private Token _token;

		private static readonly HashSet<Token> s_registrations = new HashSet<Token>();

		[UnsupportedOSPlatform("android")]
		[UnsupportedOSPlatform("browser")]
		[UnsupportedOSPlatform("ios")]
		[UnsupportedOSPlatform("tvos")]
		public static PosixSignalRegistration Create(PosixSignal signal, Action<PosixSignalContext> handler)
		{
			if (handler == null)
			{
				throw new ArgumentNullException("handler");
			}
			return Register(signal, handler);
		}

		private PosixSignalRegistration(Token token)
		{
			_token = token;
		}

		public void Dispose()
		{
			Unregister();
			GC.SuppressFinalize(this);
		}

		~PosixSignalRegistration()
		{
			Unregister();
		}

		private unsafe static PosixSignalRegistration Register(PosixSignal signal, Action<PosixSignalContext> handler)
		{
			if ((uint)(signal - -4) > 3u)
			{
				throw new PlatformNotSupportedException();
			}
			Token token = new Token(signal, handler);
			PosixSignalRegistration result = new PosixSignalRegistration(token);
			lock (s_registrations)
			{
				if (s_registrations.Count == 0 && !Interop.Kernel32.SetConsoleCtrlHandler((delegate* unmanaged<int, Interop.BOOL>)(delegate*<int, Interop.BOOL>)(&HandlerRoutine), Add: true))
				{
					throw Win32Marshal.GetExceptionForLastWin32Error();
				}
				s_registrations.Add(token);
				return result;
			}
		}

		private unsafe void Unregister()
		{
			lock (s_registrations)
			{
				Token token = _token;
				if (token != null)
				{
					_token = null;
					s_registrations.Remove(token);
					if (s_registrations.Count == 0 && !Interop.Kernel32.SetConsoleCtrlHandler((delegate* unmanaged<int, Interop.BOOL>)(delegate*<int, Interop.BOOL>)(&HandlerRoutine), Add: false))
					{
						throw Win32Marshal.GetExceptionForLastWin32Error();
					}
				}
			}
		}

		[UnmanagedCallersOnly]
		private static Interop.BOOL HandlerRoutine(int dwCtrlType)
		{
			PosixSignal posixSignal;
			switch (dwCtrlType)
			{
			case 0:
				posixSignal = PosixSignal.SIGINT;
				break;
			case 1:
				posixSignal = PosixSignal.SIGQUIT;
				break;
			case 6:
				posixSignal = PosixSignal.SIGTERM;
				break;
			case 2:
				posixSignal = PosixSignal.SIGHUP;
				break;
			default:
				return Interop.BOOL.FALSE;
			}
			List<Token> list = null;
			lock (s_registrations)
			{
				foreach (Token s_registration in s_registrations)
				{
					if (s_registration.Signal == posixSignal)
					{
						(list ?? (list = new List<Token>())).Add(s_registration);
					}
				}
			}
			if (list == null)
			{
				return Interop.BOOL.FALSE;
			}
			PosixSignalContext posixSignalContext = new PosixSignalContext(posixSignal);
			foreach (Token item in list)
			{
				item.Handler(posixSignalContext);
			}
			if (!posixSignalContext.Cancel)
			{
				return Interop.BOOL.FALSE;
			}
			return Interop.BOOL.TRUE;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class PreserveSigAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	public sealed class ProgIdAttribute : Attribute
	{
		public string Value { get; }

		public ProgIdAttribute(string progId)
		{
			Value = progId;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class SafeArrayRankMismatchException : SystemException
	{
		public SafeArrayRankMismatchException()
			: base(SR.Arg_SafeArrayRankMismatchException)
		{
			base.HResult = -2146233032;
		}

		public SafeArrayRankMismatchException(string? message)
			: base(message)
		{
			base.HResult = -2146233032;
		}

		public SafeArrayRankMismatchException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233032;
		}

		protected SafeArrayRankMismatchException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class SafeArrayTypeMismatchException : SystemException
	{
		public SafeArrayTypeMismatchException()
			: base(SR.Arg_SafeArrayTypeMismatchException)
		{
			base.HResult = -2146233037;
		}

		public SafeArrayTypeMismatchException(string? message)
			: base(message)
		{
			base.HResult = -2146233037;
		}

		public SafeArrayTypeMismatchException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233037;
		}

		protected SafeArrayTypeMismatchException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public abstract class SafeBuffer : SafeHandleZeroOrMinusOneIsInvalid
	{
		private nuint _numBytes;

		private static nuint Uninitialized => UIntPtr.MaxValue;

		[CLSCompliant(false)]
		public ulong ByteLength
		{
			get
			{
				if (_numBytes == Uninitialized)
				{
					throw NotInitialized();
				}
				return _numBytes;
			}
		}

		protected SafeBuffer(bool ownsHandle)
			: base(ownsHandle)
		{
			_numBytes = Uninitialized;
		}

		[CLSCompliant(false)]
		public void Initialize(ulong numBytes)
		{
			_ = IntPtr.Size;
			if (numBytes > uint.MaxValue)
			{
				throw new ArgumentOutOfRangeException("numBytes", SR.ArgumentOutOfRange_AddressSpace);
			}
			if (numBytes >= Uninitialized)
			{
				throw new ArgumentOutOfRangeException("numBytes", SR.ArgumentOutOfRange_UIntPtrMax);
			}
			_numBytes = (nuint)numBytes;
		}

		[CLSCompliant(false)]
		public void Initialize(uint numElements, uint sizeOfEachElement)
		{
			Initialize((ulong)numElements * (ulong)sizeOfEachElement);
		}

		[CLSCompliant(false)]
		public void Initialize<T>(uint numElements) where T : struct
		{
			Initialize(numElements, AlignedSizeOf<T>());
		}

		[CLSCompliant(false)]
		public unsafe void AcquirePointer(ref byte* pointer)
		{
			if (_numBytes == Uninitialized)
			{
				throw NotInitialized();
			}
			pointer = null;
			bool success = false;
			DangerousAddRef(ref success);
			pointer = (byte*)(void*)handle;
		}

		public void ReleasePointer()
		{
			if (_numBytes == Uninitialized)
			{
				throw NotInitialized();
			}
			DangerousRelease();
		}

		[CLSCompliant(false)]
		public unsafe T Read<T>(ulong byteOffset) where T : struct
		{
			if (_numBytes == Uninitialized)
			{
				throw NotInitialized();
			}
			uint num = SizeOf<T>();
			byte* ptr = (byte*)(void*)handle + byteOffset;
			SpaceCheck(ptr, num);
			T source = default(T);
			bool success = false;
			try
			{
				DangerousAddRef(ref success);
				Buffer.Memmove(ref Unsafe.As<T, byte>(ref source), ref *ptr, num);
				return source;
			}
			finally
			{
				if (success)
				{
					DangerousRelease();
				}
			}
		}

		[CLSCompliant(false)]
		public void ReadArray<T>(ulong byteOffset, T[] array, int index, int count) where T : struct
		{
			if (array == null)
			{
				throw new ArgumentNullException("array", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (array.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			ReadSpan(byteOffset, new Span<T>(array, index, count));
		}

		[CLSCompliant(false)]
		public unsafe void ReadSpan<T>(ulong byteOffset, Span<T> buffer) where T : struct
		{
			if (_numBytes == Uninitialized)
			{
				throw NotInitialized();
			}
			uint num = AlignedSizeOf<T>();
			byte* ptr = (byte*)(void*)handle + byteOffset;
			SpaceCheck(ptr, checked((nuint)(num * buffer.Length)));
			bool success = false;
			try
			{
				DangerousAddRef(ref success);
				ref T reference = ref MemoryMarshal.GetReference(buffer);
				for (int i = 0; i < buffer.Length; i++)
				{
					Buffer.Memmove(ref Unsafe.Add(ref reference, i), ref Unsafe.AsRef<T>(ptr + num * i), 1u);
				}
			}
			finally
			{
				if (success)
				{
					DangerousRelease();
				}
			}
		}

		[CLSCompliant(false)]
		public unsafe void Write<T>(ulong byteOffset, T value) where T : struct
		{
			if (_numBytes == Uninitialized)
			{
				throw NotInitialized();
			}
			uint num = SizeOf<T>();
			byte* ptr = (byte*)(void*)handle + byteOffset;
			SpaceCheck(ptr, num);
			bool success = false;
			try
			{
				DangerousAddRef(ref success);
				Buffer.Memmove(ref *ptr, ref Unsafe.As<T, byte>(ref value), num);
			}
			finally
			{
				if (success)
				{
					DangerousRelease();
				}
			}
		}

		[CLSCompliant(false)]
		public void WriteArray<T>(ulong byteOffset, T[] array, int index, int count) where T : struct
		{
			if (array == null)
			{
				throw new ArgumentNullException("array", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (array.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			WriteSpan(byteOffset, new ReadOnlySpan<T>(array, index, count));
		}

		[CLSCompliant(false)]
		public unsafe void WriteSpan<T>(ulong byteOffset, ReadOnlySpan<T> data) where T : struct
		{
			if (_numBytes == Uninitialized)
			{
				throw NotInitialized();
			}
			uint num = AlignedSizeOf<T>();
			byte* ptr = (byte*)(void*)handle + byteOffset;
			SpaceCheck(ptr, checked((nuint)(num * data.Length)));
			bool success = false;
			try
			{
				DangerousAddRef(ref success);
				ref T reference = ref MemoryMarshal.GetReference(data);
				for (int i = 0; i < data.Length; i++)
				{
					Buffer.Memmove(ref Unsafe.AsRef<T>(ptr + num * i), ref Unsafe.Add(ref reference, i), 1u);
				}
			}
			finally
			{
				if (success)
				{
					DangerousRelease();
				}
			}
		}

		private unsafe void SpaceCheck(byte* ptr, nuint sizeInBytes)
		{
			if (_numBytes < sizeInBytes)
			{
				NotEnoughRoom();
			}
			if ((ulong)(ptr - (byte*)(void*)handle) > (ulong)(_numBytes - sizeInBytes))
			{
				NotEnoughRoom();
			}
		}

		private static void NotEnoughRoom()
		{
			throw new ArgumentException(SR.Arg_BufferTooSmall);
		}

		private static InvalidOperationException NotInitialized()
		{
			return new InvalidOperationException(SR.InvalidOperation_MustCallInitialize);
		}

		internal static uint AlignedSizeOf<T>() where T : struct
		{
			uint num = SizeOf<T>();
			if (num == 1 || num == 2)
			{
				return num;
			}
			return (uint)((num + 3) & -4);
		}

		internal static uint SizeOf<T>() where T : struct
		{
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				throw new ArgumentException(SR.Argument_NeedStructWithNoRefs);
			}
			return (uint)Unsafe.SizeOf<T>();
		}
	}
	public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
	{
		protected IntPtr handle;

		private volatile int _state;

		private readonly bool _ownsHandle;

		private volatile bool _fullyInitialized;

		internal bool OwnsHandle => _ownsHandle;

		public bool IsClosed => (_state & 1) == 1;

		public abstract bool IsInvalid { get; }

		protected SafeHandle(IntPtr invalidHandleValue, bool ownsHandle)
		{
			handle = invalidHandleValue;
			_state = 4;
			_ownsHandle = ownsHandle;
			if (!ownsHandle)
			{
				GC.SuppressFinalize(this);
			}
			_fullyInitialized = true;
		}

		~SafeHandle()
		{
			if (_fullyInitialized)
			{
				Dispose(disposing: false);
			}
		}

		protected internal void SetHandle(IntPtr handle)
		{
			this.handle = handle;
		}

		public IntPtr DangerousGetHandle()
		{
			return handle;
		}

		public void Close()
		{
			Dispose();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			InternalRelease(disposeOrFinalizeOperation: true);
		}

		public void SetHandleAsInvalid()
		{
			Interlocked.Or(ref _state, 1);
			GC.SuppressFinalize(this);
		}

		protected abstract bool ReleaseHandle();

		public void DangerousAddRef(ref bool success)
		{
			int state;
			int value;
			do
			{
				state = _state;
				if (((uint)state & (true ? 1u : 0u)) != 0)
				{
					throw new ObjectDisposedException("SafeHandle", SR.ObjectDisposed_SafeHandleClosed);
				}
				value = state + 4;
			}
			while (Interlocked.CompareExchange(ref _state, value, state) != state);
			success = true;
		}

		public void DangerousRelease()
		{
			InternalRelease(disposeOrFinalizeOperation: false);
		}

		private void InternalRelease(bool disposeOrFinalizeOperation)
		{
			bool flag = false;
			int state;
			int num;
			do
			{
				state = _state;
				if (disposeOrFinalizeOperation && ((uint)state & 2u) != 0)
				{
					return;
				}
				if ((state & -4) == 0)
				{
					throw new ObjectDisposedException("SafeHandle", SR.ObjectDisposed_SafeHandleClosed);
				}
				flag = (state & -3) == 4 && _ownsHandle && !IsInvalid;
				num = state - 4;
				if ((state & -4) == 4)
				{
					num |= 1;
				}
				if (disposeOrFinalizeOperation)
				{
					num |= 2;
				}
			}
			while (Interlocked.CompareExchange(ref _state, num, state) != state);
			if (flag)
			{
				int lastPInvokeError = Marshal.GetLastPInvokeError();
				ReleaseHandle();
				Marshal.SetLastPInvokeError(lastPInvokeError);
			}
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class SEHException : ExternalException
	{
		public SEHException()
		{
			base.HResult = -2147467259;
		}

		public SEHException(string? message)
			: base(message)
		{
			base.HResult = -2147467259;
		}

		public SEHException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147467259;
		}

		protected SEHException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		public virtual bool CanResume()
		{
			return false;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
	public sealed class StructLayoutAttribute : Attribute
	{
		public int Pack;

		public int Size;

		public CharSet CharSet;

		public LayoutKind Value { get; }

		public StructLayoutAttribute(LayoutKind layoutKind)
		{
			Value = layoutKind;
		}

		public StructLayoutAttribute(short layoutKind)
		{
			Value = (LayoutKind)layoutKind;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class SuppressGCTransitionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	public sealed class TypeIdentifierAttribute : Attribute
	{
		public string? Scope { get; }

		public string? Identifier { get; }

		public TypeIdentifierAttribute()
		{
		}

		public TypeIdentifierAttribute(string? scope, string? identifier)
		{
			Scope = scope;
			Identifier = identifier;
		}
	}
	public sealed class UnknownWrapper
	{
		public object? WrappedObject { get; }

		public UnknownWrapper(object? obj)
		{
			WrappedObject = obj;
		}
	}
	[AttributeUsage(AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	public sealed class UnmanagedFunctionPointerAttribute : Attribute
	{
		public bool BestFitMapping;

		public bool SetLastError;

		public bool ThrowOnUnmappableChar;

		public CharSet CharSet;

		public CallingConvention CallingConvention { get; }

		public UnmanagedFunctionPointerAttribute()
		{
			CallingConvention = CallingConvention.Winapi;
		}

		public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention)
		{
			CallingConvention = callingConvention;
		}
	}
	public enum UnmanagedType
	{
		Bool = 2,
		I1 = 3,
		U1 = 4,
		I2 = 5,
		U2 = 6,
		I4 = 7,
		U4 = 8,
		I8 = 9,
		U8 = 10,
		R4 = 11,
		R8 = 12,
		Currency = 15,
		BStr = 19,
		LPStr = 20,
		LPWStr = 21,
		LPTStr = 22,
		ByValTStr = 23,
		IUnknown = 25,
		IDispatch = 26,
		Struct = 27,
		Interface = 28,
		SafeArray = 29,
		ByValArray = 30,
		SysInt = 31,
		SysUInt = 32,
		VBByRefStr = 34,
		AnsiBStr = 35,
		TBStr = 36,
		VariantBool = 37,
		FunctionPtr = 38,
		AsAny = 40,
		LPArray = 42,
		LPStruct = 43,
		CustomMarshaler = 44,
		Error = 45,
		IInspectable = 46,
		HString = 47,
		LPUTF8Str = 48
	}
	public enum VarEnum
	{
		VT_EMPTY = 0,
		VT_NULL = 1,
		VT_I2 = 2,
		VT_I4 = 3,
		VT_R4 = 4,
		VT_R8 = 5,
		VT_CY = 6,
		VT_DATE = 7,
		VT_BSTR = 8,
		VT_DISPATCH = 9,
		VT_ERROR = 10,
		VT_BOOL = 11,
		VT_VARIANT = 12,
		VT_UNKNOWN = 13,
		VT_DECIMAL = 14,
		VT_I1 = 16,
		VT_UI1 = 17,
		VT_UI2 = 18,
		VT_UI4 = 19,
		VT_I8 = 20,
		VT_UI8 = 21,
		VT_INT = 22,
		VT_UINT = 23,
		VT_VOID = 24,
		VT_HRESULT = 25,
		VT_PTR = 26,
		VT_SAFEARRAY = 27,
		VT_CARRAY = 28,
		VT_USERDEFINED = 29,
		VT_LPSTR = 30,
		VT_LPWSTR = 31,
		VT_RECORD = 36,
		VT_FILETIME = 64,
		VT_BLOB = 65,
		VT_STREAM = 66,
		VT_STORAGE = 67,
		VT_STREAMED_OBJECT = 68,
		VT_STORED_OBJECT = 69,
		VT_BLOB_OBJECT = 70,
		VT_CF = 71,
		VT_CLSID = 72,
		VT_VECTOR = 4096,
		VT_ARRAY = 8192,
		VT_BYREF = 16384
	}
	public sealed class VariantWrapper
	{
		public object? WrappedObject { get; }

		public VariantWrapper(object? obj)
		{
			WrappedObject = obj;
		}
	}
	public class StandardOleMarshalObject : MarshalByRefObject, IMarshal
	{
		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int GetMarshalSizeMaxDelegate(IntPtr _this, ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags, out int pSize);

		[UnmanagedFunctionPointer(CallingConvention.StdCall)]
		private delegate int MarshalInterfaceDelegate(IntPtr _this, IntPtr pStm, ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags);

		private static readonly Guid CLSID_StdMarshal = new Guid("00000017-0000-0000-c000-000000000046");

		protected StandardOleMarshalObject()
		{
		}

		private IntPtr GetStdMarshaler(ref Guid riid, int dwDestContext, int mshlflags)
		{
			IntPtr iUnknownForObject = Marshal.GetIUnknownForObject(this);
			if (iUnknownForObject != IntPtr.Zero)
			{
				try
				{
					IntPtr ppMarshal = IntPtr.Zero;
					if (Interop.Ole32.CoGetStandardMarshal(ref riid, iUnknownForObject, dwDestContext, IntPtr.Zero, mshlflags, out ppMarshal) == 0)
					{
						return ppMarshal;
					}
				}
				finally
				{
					Marshal.Release(iUnknownForObject);
				}
			}
			throw new InvalidOperationException(SR.Format(SR.StandardOleMarshalObjectGetMarshalerFailed, riid));
		}

		int IMarshal.GetUnmarshalClass(ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags, out Guid pCid)
		{
			pCid = CLSID_StdMarshal;
			return 0;
		}

		unsafe int IMarshal.GetMarshalSizeMax(ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags, out int pSize)
		{
			IntPtr stdMarshaler = GetStdMarshaler(ref riid, dwDestContext, mshlflags);
			try
			{
				IntPtr intPtr = *(IntPtr*)stdMarshaler.ToPointer();
				IntPtr ptr = *(IntPtr*)((byte*)intPtr.ToPointer() + (nint)4 * (nint)sizeof(IntPtr));
				GetMarshalSizeMaxDelegate getMarshalSizeMaxDelegate = (GetMarshalSizeMaxDelegate)Marshal.GetDelegateForFunctionPointer(ptr, typeof(GetMarshalSizeMaxDelegate));
				return getMarshalSizeMaxDelegate(stdMarshaler, ref riid, pv, dwDestContext, pvDestContext, mshlflags, out pSize);
			}
			finally
			{
				Marshal.Release(stdMarshaler);
			}
		}

		unsafe int IMarshal.MarshalInterface(IntPtr pStm, ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags)
		{
			IntPtr stdMarshaler = GetStdMarshaler(ref riid, dwDestContext, mshlflags);
			try
			{
				IntPtr intPtr = *(IntPtr*)stdMarshaler.ToPointer();
				IntPtr ptr = *(IntPtr*)((byte*)intPtr.ToPointer() + (nint)5 * (nint)sizeof(IntPtr));
				MarshalInterfaceDelegate marshalInterfaceDelegate = (MarshalInterfaceDelegate)Marshal.GetDelegateForFunctionPointer(ptr, typeof(MarshalInterfaceDelegate));
				return marshalInterfaceDelegate(stdMarshaler, pStm, ref riid, pv, dwDestContext, pvDestContext, mshlflags);
			}
			finally
			{
				Marshal.Release(stdMarshaler);
			}
		}

		int IMarshal.UnmarshalInterface(IntPtr pStm, ref Guid riid, out IntPtr ppv)
		{
			ppv = IntPtr.Zero;
			return -2147467263;
		}

		int IMarshal.ReleaseMarshalData(IntPtr pStm)
		{
			return -2147467263;
		}

		int IMarshal.DisconnectObject(int dwReserved)
		{
			return -2147467263;
		}
	}
	[ComImport]
	[Guid("00000003-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IMarshal
	{
		[PreserveSig]
		int GetUnmarshalClass(ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags, out Guid pCid);

		[PreserveSig]
		int GetMarshalSizeMax(ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags, out int pSize);

		[PreserveSig]
		int MarshalInterface(IntPtr pStm, ref Guid riid, IntPtr pv, int dwDestContext, IntPtr pvDestContext, int mshlflags);

		[PreserveSig]
		int UnmarshalInterface(IntPtr pStm, ref Guid riid, out IntPtr ppv);

		[PreserveSig]
		int ReleaseMarshalData(IntPtr pStm);

		[PreserveSig]
		int DisconnectObject(int dwReserved);
	}
}
namespace System.Runtime.InteropServices.ObjectiveC
{
	[SupportedOSPlatform("macos")]
	[CLSCompliant(false)]
	public static class ObjectiveCMarshal
	{
		public unsafe delegate delegate* unmanaged<IntPtr, void> UnhandledExceptionPropagationHandler(Exception exception, RuntimeMethodHandle lastMethod, out IntPtr context);

		public enum MessageSendFunction
		{
			MsgSend,
			MsgSendFpret,
			MsgSendStret,
			MsgSendSuper,
			MsgSendSuperStret
		}

		public unsafe static void Initialize(delegate* unmanaged<void> beginEndCallback, delegate* unmanaged<IntPtr, int> isReferencedCallback, delegate* unmanaged<IntPtr, void> trackedObjectEnteredFinalization, UnhandledExceptionPropagationHandler unhandledExceptionPropagationHandler)
		{
			throw new PlatformNotSupportedException();
		}

		public static GCHandle CreateReferenceTrackingHandle(object obj, out Span<IntPtr> taggedMemory)
		{
			throw new PlatformNotSupportedException();
		}

		public static void SetMessageSendCallback(MessageSendFunction msgSendFunction, IntPtr func)
		{
			throw new PlatformNotSupportedException();
		}

		public static void SetMessageSendPendingException(Exception? exception)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[SupportedOSPlatform("macos")]
	[AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
	public sealed class ObjectiveCTrackedTypeAttribute : Attribute
	{
	}
}
namespace System.Runtime.InteropServices.CustomMarshalers
{
	internal static class ComDataHelpers
	{
		[SupportedOSPlatform("windows")]
		public static TView GetOrCreateManagedViewFromComData<T, TView>(object comObject, Func<T, TView> createCallback)
		{
			object typeFromHandle = typeof(TView);
			object comObjectData = Marshal.GetComObjectData(comObject, typeFromHandle);
			if (comObjectData is TView)
			{
				return (TView)comObjectData;
			}
			TView val = createCallback((T)comObject);
			if (!Marshal.SetComObjectData(comObject, typeFromHandle, val))
			{
				val = (TView)Marshal.GetComObjectData(comObject, typeFromHandle);
			}
			return val;
		}
	}
	internal sealed class EnumVariantViewOfEnumerator : IEnumVARIANT, ICustomAdapter
	{
		public System.Collections.IEnumerator Enumerator { get; }

		public EnumVariantViewOfEnumerator(System.Collections.IEnumerator enumerator)
		{
			if (enumerator == null)
			{
				throw new ArgumentNullException("enumerator");
			}
			Enumerator = enumerator;
		}

		public IEnumVARIANT Clone()
		{
			if (Enumerator is ICloneable cloneable)
			{
				return new EnumVariantViewOfEnumerator((System.Collections.IEnumerator)cloneable.Clone());
			}
			throw new COMException(SR.Arg_EnumNotCloneable, -2147467259);
		}

		public int Next(int celt, object[] rgVar, IntPtr pceltFetched)
		{
			int num = 0;
			try
			{
				if (celt > 0 && rgVar == null)
				{
					return -2147024809;
				}
				while (num < celt && Enumerator.MoveNext())
				{
					rgVar[num++] = Enumerator.Current;
				}
				if (pceltFetched != IntPtr.Zero)
				{
					Marshal.WriteInt32(pceltFetched, num);
				}
			}
			catch (Exception ex)
			{
				return ex.HResult;
			}
			if (num != celt)
			{
				return 1;
			}
			return 0;
		}

		public int Reset()
		{
			try
			{
				Enumerator.Reset();
			}
			catch (Exception ex)
			{
				return ex.HResult;
			}
			return 0;
		}

		public int Skip(int celt)
		{
			try
			{
				while (celt > 0 && Enumerator.MoveNext())
				{
					celt--;
				}
			}
			catch (Exception ex)
			{
				return ex.HResult;
			}
			if (celt != 0)
			{
				return 1;
			}
			return 0;
		}

		public object GetUnderlyingObject()
		{
			return Enumerator;
		}
	}
	[SupportedOSPlatform("windows")]
	internal sealed class EnumerableToDispatchMarshaler : ICustomMarshaler
	{
		private static readonly EnumerableToDispatchMarshaler s_enumerableToDispatchMarshaler = new EnumerableToDispatchMarshaler();

		public static ICustomMarshaler GetInstance(string cookie)
		{
			return s_enumerableToDispatchMarshaler;
		}

		private EnumerableToDispatchMarshaler()
		{
		}

		public void CleanUpManagedData(object ManagedObj)
		{
		}

		public void CleanUpNativeData(IntPtr pNativeData)
		{
			Marshal.Release(pNativeData);
		}

		public int GetNativeDataSize()
		{
			return -1;
		}

		public IntPtr MarshalManagedToNative(object ManagedObj)
		{
			if (ManagedObj == null)
			{
				throw new ArgumentNullException("ManagedObj");
			}
			return Marshal.GetComInterfaceForObject<object, System.Collections.IEnumerable>(ManagedObj);
		}

		public object MarshalNativeToManaged(IntPtr pNativeData)
		{
			if (pNativeData == IntPtr.Zero)
			{
				throw new ArgumentNullException("pNativeData");
			}
			object objectForIUnknown = Marshal.GetObjectForIUnknown(pNativeData);
			return ComDataHelpers.GetOrCreateManagedViewFromComData(objectForIUnknown, (object obj) => new EnumerableViewOfDispatch(obj));
		}
	}
	internal sealed class EnumerableViewOfDispatch : ICustomAdapter, System.Collections.IEnumerable
	{
		private const int DISPID_NEWENUM = -4;

		private const int LCID_DEFAULT = 1;

		private readonly object _dispatch;

		private IDispatch Dispatch => (IDispatch)_dispatch;

		public EnumerableViewOfDispatch(object dispatch)
		{
			_dispatch = dispatch;
		}

		public unsafe System.Collections.IEnumerator GetEnumerator()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Variant variant);
			void* value = &variant;
			DISPPARAMS pDispParams = default(DISPPARAMS);
			Guid riid = Guid.Empty;
			Dispatch.Invoke(-4, ref riid, 1, InvokeFlags.DISPATCH_METHOD | InvokeFlags.DISPATCH_PROPERTYGET, ref pDispParams, new IntPtr(value), IntPtr.Zero, IntPtr.Zero);
			IntPtr intPtr = IntPtr.Zero;
			try
			{
				object obj = variant.ToObject();
				if (!(obj is IEnumVARIANT o))
				{
					throw new InvalidOperationException(SR.InvalidOp_InvalidNewEnumVariant);
				}
				intPtr = Marshal.GetIUnknownForObject(o);
				return (System.Collections.IEnumerator)EnumeratorToEnumVariantMarshaler.GetInstance(null).MarshalNativeToManaged(intPtr);
			}
			finally
			{
				variant.Clear();
				if (intPtr != IntPtr.Zero)
				{
					Marshal.Release(intPtr);
				}
			}
		}

		public object GetUnderlyingObject()
		{
			return _dispatch;
		}
	}
	[SupportedOSPlatform("windows")]
	internal sealed class EnumeratorToEnumVariantMarshaler : ICustomMarshaler
	{
		private static readonly EnumeratorToEnumVariantMarshaler s_enumeratorToEnumVariantMarshaler = new EnumeratorToEnumVariantMarshaler();

		public static ICustomMarshaler GetInstance(string cookie)
		{
			return s_enumeratorToEnumVariantMarshaler;
		}

		private EnumeratorToEnumVariantMarshaler()
		{
		}

		public void CleanUpManagedData(object ManagedObj)
		{
		}

		public void CleanUpNativeData(IntPtr pNativeData)
		{
			Marshal.Release(pNativeData);
		}

		public int GetNativeDataSize()
		{
			return -1;
		}

		public IntPtr MarshalManagedToNative(object ManagedObj)
		{
			if (ManagedObj == null)
			{
				throw new ArgumentNullException("ManagedObj");
			}
			if (ManagedObj is EnumeratorViewOfEnumVariant enumeratorViewOfEnumVariant)
			{
				return Marshal.GetComInterfaceForObject<object, IEnumVARIANT>(enumeratorViewOfEnumVariant.GetUnderlyingObject());
			}
			EnumVariantViewOfEnumerator o = new EnumVariantViewOfEnumerator((System.Collections.IEnumerator)ManagedObj);
			return Marshal.GetComInterfaceForObject<EnumVariantViewOfEnumerator, IEnumVARIANT>(o);
		}

		public object MarshalNativeToManaged(IntPtr pNativeData)
		{
			if (pNativeData == IntPtr.Zero)
			{
				throw new ArgumentNullException("pNativeData");
			}
			object objectForIUnknown = Marshal.GetObjectForIUnknown(pNativeData);
			if (!objectForIUnknown.GetType().IsCOMObject)
			{
				if (objectForIUnknown is EnumVariantViewOfEnumerator enumVariantViewOfEnumerator)
				{
					return enumVariantViewOfEnumerator.Enumerator;
				}
				return objectForIUnknown as System.Collections.IEnumerator;
			}
			return ComDataHelpers.GetOrCreateManagedViewFromComData(objectForIUnknown, (IEnumVARIANT var) => new EnumeratorViewOfEnumVariant(var));
		}
	}
	internal sealed class EnumeratorViewOfEnumVariant : ICustomAdapter, System.Collections.IEnumerator
	{
		private readonly IEnumVARIANT _enumVariantObject;

		private bool _fetchedLastObject;

		private readonly object[] _nextArray = new object[1];

		private object _current;

		public object Current => _current;

		public EnumeratorViewOfEnumVariant(IEnumVARIANT enumVariantObject)
		{
			_enumVariantObject = enumVariantObject;
			_fetchedLastObject = false;
			_current = null;
		}

		public unsafe bool MoveNext()
		{
			if (_fetchedLastObject)
			{
				_current = null;
				return false;
			}
			int num = 0;
			if (_enumVariantObject.Next(1, _nextArray, (IntPtr)(&num)) == 1)
			{
				_fetchedLastObject = true;
				if (num == 0)
				{
					_current = null;
					return false;
				}
			}
			_current = _nextArray[0];
			return true;
		}

		public void Reset()
		{
			int num = _enumVariantObject.Reset();
			if (num < 0)
			{
				Marshal.ThrowExceptionForHR(num);
			}
			_fetchedLastObject = false;
			_current = null;
		}

		public object GetUnderlyingObject()
		{
			return _enumVariantObject;
		}
	}
	internal sealed class ExpandoToDispatchExMarshaler : ICustomMarshaler
	{
		private static readonly ExpandoToDispatchExMarshaler s_ExpandoToDispatchExMarshaler = new ExpandoToDispatchExMarshaler();

		public static ICustomMarshaler GetInstance(string cookie)
		{
			return s_ExpandoToDispatchExMarshaler;
		}

		private ExpandoToDispatchExMarshaler()
		{
		}

		public void CleanUpManagedData(object ManagedObj)
		{
		}

		public void CleanUpNativeData(IntPtr pNativeData)
		{
		}

		public int GetNativeDataSize()
		{
			return -1;
		}

		public IntPtr MarshalManagedToNative(object ManagedObj)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_IExpando);
		}

		public object MarshalNativeToManaged(IntPtr pNativeData)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_IExpando);
		}
	}
	internal sealed class TypeToTypeInfoMarshaler : ICustomMarshaler
	{
		private static readonly TypeToTypeInfoMarshaler s_typeToTypeInfoMarshaler = new TypeToTypeInfoMarshaler();

		public static ICustomMarshaler GetInstance(string cookie)
		{
			return s_typeToTypeInfoMarshaler;
		}

		private TypeToTypeInfoMarshaler()
		{
		}

		public void CleanUpManagedData(object ManagedObj)
		{
		}

		public void CleanUpNativeData(IntPtr pNativeData)
		{
		}

		public int GetNativeDataSize()
		{
			return -1;
		}

		public IntPtr MarshalManagedToNative(object ManagedObj)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ITypeInfo);
		}

		public object MarshalNativeToManaged(IntPtr pNativeData)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ITypeInfo);
		}
	}
}
namespace System.Runtime.InteropServices.ComTypes
{
	[Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
	internal interface IEnumerable
	{
		[DispId(-4)]
		System.Collections.IEnumerator GetEnumerator();
	}
	[Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")]
	internal interface IEnumerator
	{
		object Current { get; }

		bool MoveNext();

		void Reset();
	}
	public struct BIND_OPTS
	{
		public int cbStruct;

		public int grfFlags;

		public int grfMode;

		public int dwTickCountDeadline;
	}
	[ComImport]
	[Guid("0000000e-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IBindCtx
	{
		void RegisterObjectBound([MarshalAs(UnmanagedType.Interface)] object punk);

		void RevokeObjectBound([MarshalAs(UnmanagedType.Interface)] object punk);

		void ReleaseBoundObjects();

		void SetBindOptions([In] ref BIND_OPTS pbindopts);

		void GetBindOptions(ref BIND_OPTS pbindopts);

		void GetRunningObjectTable(out IRunningObjectTable? pprot);

		void RegisterObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey, [MarshalAs(UnmanagedType.Interface)] object punk);

		void GetObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey, [MarshalAs(UnmanagedType.Interface)] out object? ppunk);

		void EnumObjectParam(out IEnumString? ppenum);

		[PreserveSig]
		int RevokeObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey);
	}
	[ComImport]
	[Guid("B196B286-BAB4-101A-B69C-00AA00341D07")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IConnectionPoint
	{
		void GetConnectionInterface(out Guid pIID);

		void GetConnectionPointContainer(out IConnectionPointContainer ppCPC);

		void Advise([MarshalAs(UnmanagedType.Interface)] object pUnkSink, out int pdwCookie);

		void Unadvise(int dwCookie);

		void EnumConnections(out IEnumConnections ppEnum);
	}
	[ComImport]
	[Guid("B196B284-BAB4-101A-B69C-00AA00341D07")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IConnectionPointContainer
	{
		void EnumConnectionPoints(out IEnumConnectionPoints ppEnum);

		void FindConnectionPoint([In] ref Guid riid, out IConnectionPoint? ppCP);
	}
	[ComImport]
	[Guid("B196B285-BAB4-101A-B69C-00AA00341D07")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IEnumConnectionPoints
	{
		[PreserveSig]
		int Next(int celt, [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] IConnectionPoint[] rgelt, IntPtr pceltFetched);

		[PreserveSig]
		int Skip(int celt);

		void Reset();

		void Clone(out IEnumConnectionPoints ppenum);
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct CONNECTDATA
	{
		[MarshalAs(UnmanagedType.Interface)]
		public object pUnk;

		public int dwCookie;
	}
	[ComImport]
	[Guid("B196B287-BAB4-101A-B69C-00AA00341D07")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IEnumConnections
	{
		[PreserveSig]
		int Next(int celt, [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] CONNECTDATA[] rgelt, IntPtr pceltFetched);

		[PreserveSig]
		int Skip(int celt);

		void Reset();

		void Clone(out IEnumConnections ppenum);
	}
	[ComImport]
	[Guid("00000102-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IEnumMoniker
	{
		[PreserveSig]
		int Next(int celt, [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] IMoniker[] rgelt, IntPtr pceltFetched);

		[PreserveSig]
		int Skip(int celt);

		void Reset();

		void Clone(out IEnumMoniker ppenum);
	}
	[ComImport]
	[Guid("00000101-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IEnumString
	{
		[PreserveSig]
		int Next(int celt, [Out][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 0)] string[] rgelt, IntPtr pceltFetched);

		[PreserveSig]
		int Skip(int celt);

		void Reset();

		void Clone(out IEnumString ppenum);
	}
	[ComImport]
	[Guid("00020404-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IEnumVARIANT
	{
		[PreserveSig]
		int Next(int celt, [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] object?[] rgVar, IntPtr pceltFetched);

		[PreserveSig]
		int Skip(int celt);

		[PreserveSig]
		int Reset();

		IEnumVARIANT Clone();
	}
	public struct FILETIME
	{
		public int dwLowDateTime;

		public int dwHighDateTime;
	}
	[ComImport]
	[Guid("0000000f-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IMoniker
	{
		void GetClassID(out Guid pClassID);

		[PreserveSig]
		int IsDirty();

		void Load(IStream pStm);

		void Save(IStream pStm, [MarshalAs(UnmanagedType.Bool)] bool fClearDirty);

		void GetSizeMax(out long pcbSize);

		void BindToObject(IBindCtx pbc, IMoniker? pmkToLeft, [In] ref Guid riidResult, [MarshalAs(UnmanagedType.Interface)] out object ppvResult);

		void BindToStorage(IBindCtx pbc, IMoniker? pmkToLeft, [In] ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out object ppvObj);

		void Reduce(IBindCtx pbc, int dwReduceHowFar, ref IMoniker? ppmkToLeft, out IMoniker? ppmkReduced);

		void ComposeWith(IMoniker pmkRight, [MarshalAs(UnmanagedType.Bool)] bool fOnlyIfNotGeneric, out IMoniker? ppmkComposite);

		void Enum([MarshalAs(UnmanagedType.Bool)] bool fForward, out IEnumMoniker? ppenumMoniker);

		[PreserveSig]
		int IsEqual(IMoniker pmkOtherMoniker);

		void Hash(out int pdwHash);

		[PreserveSig]
		int IsRunning(IBindCtx pbc, IMoniker? pmkToLeft, IMoniker? pmkNewlyRunning);

		void GetTimeOfLastChange(IBindCtx pbc, IMoniker? pmkToLeft, out FILETIME pFileTime);

		void Inverse(out IMoniker ppmk);

		void CommonPrefixWith(IMoniker pmkOther, out IMoniker? ppmkPrefix);

		void RelativePathTo(IMoniker pmkOther, out IMoniker? ppmkRelPath);

		void GetDisplayName(IBindCtx pbc, IMoniker? pmkToLeft, [MarshalAs(UnmanagedType.LPWStr)] out string ppszDisplayName);

		void ParseDisplayName(IBindCtx pbc, IMoniker pmkToLeft, [MarshalAs(UnmanagedType.LPWStr)] string pszDisplayName, out int pchEaten, out IMoniker ppmkOut);

		[PreserveSig]
		int IsSystemMoniker(out int pdwMksys);
	}
	[ComImport]
	[Guid("0000010b-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IPersistFile
	{
		void GetClassID(out Guid pClassID);

		[PreserveSig]
		int IsDirty();

		void Load([MarshalAs(UnmanagedType.LPWStr)] string pszFileName, int dwMode);

		void Save([MarshalAs(UnmanagedType.LPWStr)] string? pszFileName, [MarshalAs(UnmanagedType.Bool)] bool fRemember);

		void SaveCompleted([MarshalAs(UnmanagedType.LPWStr)] string pszFileName);

		void GetCurFile([MarshalAs(UnmanagedType.LPWStr)] out string ppszFileName);
	}
	[ComImport]
	[Guid("00000010-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IRunningObjectTable
	{
		int Register(int grfFlags, [MarshalAs(UnmanagedType.Interface)] object punkObject, IMoniker pmkObjectName);

		void Revoke(int dwRegister);

		[PreserveSig]
		int IsRunning(IMoniker pmkObjectName);

		[PreserveSig]
		int GetObject(IMoniker pmkObjectName, [MarshalAs(UnmanagedType.Interface)] out object ppunkObject);

		void NoteChangeTime(int dwRegister, ref FILETIME pfiletime);

		[PreserveSig]
		int GetTimeOfLastChange(IMoniker pmkObjectName, out FILETIME pfiletime);

		void EnumRunning(out IEnumMoniker ppenumMoniker);
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct STATSTG
	{
		public string pwcsName;

		public int type;

		public long cbSize;

		public FILETIME mtime;

		public FILETIME ctime;

		public FILETIME atime;

		public int grfMode;

		public int grfLocksSupported;

		public Guid clsid;

		public int grfStateBits;

		public int reserved;
	}
	[ComImport]
	[Guid("0000000c-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IStream
	{
		void Read([Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pv, int cb, IntPtr pcbRead);

		void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pv, int cb, IntPtr pcbWritten);

		void Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition);

		void SetSize(long libNewSize);

		void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten);

		void Commit(int grfCommitFlags);

		void Revert();

		void LockRegion(long libOffset, long cb, int dwLockType);

		void UnlockRegion(long libOffset, long cb, int dwLockType);

		void Stat(out STATSTG pstatstg, int grfStatFlag);

		void Clone(out IStream ppstm);
	}
	public enum DESCKIND
	{
		DESCKIND_NONE,
		DESCKIND_FUNCDESC,
		DESCKIND_VARDESC,
		DESCKIND_TYPECOMP,
		DESCKIND_IMPLICITAPPOBJ,
		DESCKIND_MAX
	}
	[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
	public struct BINDPTR
	{
		[FieldOffset(0)]
		public IntPtr lpfuncdesc;

		[FieldOffset(0)]
		public IntPtr lpvardesc;

		[FieldOffset(0)]
		public IntPtr lptcomp;
	}
	[ComImport]
	[Guid("00020403-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface ITypeComp
	{
		void Bind([MarshalAs(UnmanagedType.LPWStr)] string szName, int lHashVal, short wFlags, out ITypeInfo ppTInfo, out DESCKIND pDescKind, out BINDPTR pBindPtr);

		void BindType([MarshalAs(UnmanagedType.LPWStr)] string szName, int lHashVal, out ITypeInfo ppTInfo, out ITypeComp ppTComp);
	}
	public enum TYPEKIND
	{
		TKIND_ENUM,
		TKIND_RECORD,
		TKIND_MODULE,
		TKIND_INTERFACE,
		TKIND_DISPATCH,
		TKIND_COCLASS,
		TKIND_ALIAS,
		TKIND_UNION,
		TKIND_MAX
	}
	[Flags]
	public enum TYPEFLAGS : short
	{
		TYPEFLAG_FAPPOBJECT = 1,
		TYPEFLAG_FCANCREATE = 2,
		TYPEFLAG_FLICENSED = 4,
		TYPEFLAG_FPREDECLID = 8,
		TYPEFLAG_FHIDDEN = 0x10,
		TYPEFLAG_FCONTROL = 0x20,
		TYPEFLAG_FDUAL = 0x40,
		TYPEFLAG_FNONEXTENSIBLE = 0x80,
		TYPEFLAG_FOLEAUTOMATION = 0x100,
		TYPEFLAG_FRESTRICTED = 0x200,
		TYPEFLAG_FAGGREGATABLE = 0x400,
		TYPEFLAG_FREPLACEABLE = 0x800,
		TYPEFLAG_FDISPATCHABLE = 0x1000,
		TYPEFLAG_FREVERSEBIND = 0x2000,
		TYPEFLAG_FPROXY = 0x4000
	}
	[Flags]
	public enum IMPLTYPEFLAGS
	{
		IMPLTYPEFLAG_FDEFAULT = 1,
		IMPLTYPEFLAG_FSOURCE = 2,
		IMPLTYPEFLAG_FRESTRICTED = 4,
		IMPLTYPEFLAG_FDEFAULTVTABLE = 8
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct TYPEATTR
	{
		public const int MEMBER_ID_NIL = -1;

		public Guid guid;

		public int lcid;

		public int dwReserved;

		public int memidConstructor;

		public int memidDestructor;

		public IntPtr lpstrSchema;

		public int cbSizeInstance;

		public TYPEKIND typekind;

		public short cFuncs;

		public short cVars;

		public short cImplTypes;

		public short cbSizeVft;

		public short cbAlignment;

		public TYPEFLAGS wTypeFlags;

		public short wMajorVerNum;

		public short wMinorVerNum;

		public TYPEDESC tdescAlias;

		public IDLDESC idldescType;
	}
	public struct FUNCDESC
	{
		public int memid;

		public IntPtr lprgscode;

		public IntPtr lprgelemdescParam;

		public FUNCKIND funckind;

		public INVOKEKIND invkind;

		public CALLCONV callconv;

		public short cParams;

		public short cParamsOpt;

		public short oVft;

		public short cScodes;

		public ELEMDESC elemdescFunc;

		public short wFuncFlags;
	}
	[Flags]
	public enum IDLFLAG : short
	{
		IDLFLAG_NONE = 0,
		IDLFLAG_FIN = 1,
		IDLFLAG_FOUT = 2,
		IDLFLAG_FLCID = 4,
		IDLFLAG_FRETVAL = 8
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct IDLDESC
	{
		public IntPtr dwReserved;

		public IDLFLAG wIDLFlags;
	}
	[Flags]
	public enum PARAMFLAG : short
	{
		PARAMFLAG_NONE = 0,
		PARAMFLAG_FIN = 1,
		PARAMFLAG_FOUT = 2,
		PARAMFLAG_FLCID = 4,
		PARAMFLAG_FRETVAL = 8,
		PARAMFLAG_FOPT = 0x10,
		PARAMFLAG_FHASDEFAULT = 0x20,
		PARAMFLAG_FHASCUSTDATA = 0x40
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct PARAMDESC
	{
		public IntPtr lpVarValue;

		public PARAMFLAG wParamFlags;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct TYPEDESC
	{
		public IntPtr lpValue;

		public short vt;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct ELEMDESC
	{
		[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
		public struct DESCUNION
		{
			[FieldOffset(0)]
			public IDLDESC idldesc;

			[FieldOffset(0)]
			public PARAMDESC paramdesc;
		}

		public TYPEDESC tdesc;

		public DESCUNION desc;
	}
	public enum VARKIND
	{
		VAR_PERINSTANCE,
		VAR_STATIC,
		VAR_CONST,
		VAR_DISPATCH
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct VARDESC
	{
		[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
		public struct DESCUNION
		{
			[FieldOffset(0)]
			public int oInst;

			[FieldOffset(0)]
			public IntPtr lpvarValue;
		}

		public int memid;

		public string lpstrSchema;

		public DESCUNION desc;

		public ELEMDESC elemdescVar;

		public short wVarFlags;

		public VARKIND varkind;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct DISPPARAMS
	{
		public IntPtr rgvarg;

		public IntPtr rgdispidNamedArgs;

		public int cArgs;

		public int cNamedArgs;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct EXCEPINFO
	{
		public short wCode;

		public short wReserved;

		[MarshalAs(UnmanagedType.BStr)]
		public string bstrSource;

		[MarshalAs(UnmanagedType.BStr)]
		public string bstrDescription;

		[MarshalAs(UnmanagedType.BStr)]
		public string bstrHelpFile;

		public int dwHelpContext;

		public IntPtr pvReserved;

		public IntPtr pfnDeferredFillIn;

		public int scode;
	}
	public enum FUNCKIND
	{
		FUNC_VIRTUAL,
		FUNC_PUREVIRTUAL,
		FUNC_NONVIRTUAL,
		FUNC_STATIC,
		FUNC_DISPATCH
	}
	[Flags]
	public enum INVOKEKIND
	{
		INVOKE_FUNC = 1,
		INVOKE_PROPERTYGET = 2,
		INVOKE_PROPERTYPUT = 4,
		INVOKE_PROPERTYPUTREF = 8
	}
	public enum CALLCONV
	{
		CC_CDECL = 1,
		CC_MSCPASCAL = 2,
		CC_PASCAL = 2,
		CC_MACPASCAL = 3,
		CC_STDCALL = 4,
		CC_RESERVED = 5,
		CC_SYSCALL = 6,
		CC_MPWCDECL = 7,
		CC_MPWPASCAL = 8,
		CC_MAX = 9
	}
	[Flags]
	public enum FUNCFLAGS : short
	{
		FUNCFLAG_FRESTRICTED = 1,
		FUNCFLAG_FSOURCE = 2,
		FUNCFLAG_FBINDABLE = 4,
		FUNCFLAG_FREQUESTEDIT = 8,
		FUNCFLAG_FDISPLAYBIND = 0x10,
		FUNCFLAG_FDEFAULTBIND = 0x20,
		FUNCFLAG_FHIDDEN = 0x40,
		FUNCFLAG_FUSESGETLASTERROR = 0x80,
		FUNCFLAG_FDEFAULTCOLLELEM = 0x100,
		FUNCFLAG_FUIDEFAULT = 0x200,
		FUNCFLAG_FNONBROWSABLE = 0x400,
		FUNCFLAG_FREPLACEABLE = 0x800,
		FUNCFLAG_FIMMEDIATEBIND = 0x1000
	}
	[Flags]
	public enum VARFLAGS : short
	{
		VARFLAG_FREADONLY = 1,
		VARFLAG_FSOURCE = 2,
		VARFLAG_FBINDABLE = 4,
		VARFLAG_FREQUESTEDIT = 8,
		VARFLAG_FDISPLAYBIND = 0x10,
		VARFLAG_FDEFAULTBIND = 0x20,
		VARFLAG_FHIDDEN = 0x40,
		VARFLAG_FRESTRICTED = 0x80,
		VARFLAG_FDEFAULTCOLLELEM = 0x100,
		VARFLAG_FUIDEFAULT = 0x200,
		VARFLAG_FNONBROWSABLE = 0x400,
		VARFLAG_FREPLACEABLE = 0x800,
		VARFLAG_FIMMEDIATEBIND = 0x1000
	}
	[ComImport]
	[Guid("00020401-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface ITypeInfo
	{
		void GetTypeAttr(out IntPtr ppTypeAttr);

		void GetTypeComp(out ITypeComp ppTComp);

		void GetFuncDesc(int index, out IntPtr ppFuncDesc);

		void GetVarDesc(int index, out IntPtr ppVarDesc);

		void GetNames(int memid, [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] string[] rgBstrNames, int cMaxNames, out int pcNames);

		void GetRefTypeOfImplType(int index, out int href);

		void GetImplTypeFlags(int index, out IMPLTYPEFLAGS pImplTypeFlags);

		void GetIDsOfNames([In][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 1)] string[] rgszNames, int cNames, [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] int[] pMemId);

		void Invoke([MarshalAs(UnmanagedType.IUnknown)] object pvInstance, int memid, short wFlags, ref DISPPARAMS pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, out int puArgErr);

		void GetDocumentation(int index, out string strName, out string strDocString, out int dwHelpContext, out string strHelpFile);

		void GetDllEntry(int memid, INVOKEKIND invKind, IntPtr pBstrDllName, IntPtr pBstrName, IntPtr pwOrdinal);

		void GetRefTypeInfo(int hRef, out ITypeInfo ppTI);

		void AddressOfMember(int memid, INVOKEKIND invKind, out IntPtr ppv);

		void CreateInstance([MarshalAs(UnmanagedType.IUnknown)] object? pUnkOuter, [In] ref Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppvObj);

		void GetMops(int memid, out string? pBstrMops);

		void GetContainingTypeLib(out ITypeLib ppTLB, out int pIndex);

		[PreserveSig]
		void ReleaseTypeAttr(IntPtr pTypeAttr);

		[PreserveSig]
		void ReleaseFuncDesc(IntPtr pFuncDesc);

		[PreserveSig]
		void ReleaseVarDesc(IntPtr pVarDesc);
	}
	[ComImport]
	[Guid("00020412-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface ITypeInfo2 : ITypeInfo
	{
		new void GetTypeAttr(out IntPtr ppTypeAttr);

		new void GetTypeComp(out ITypeComp ppTComp);

		new void GetFuncDesc(int index, out IntPtr ppFuncDesc);

		new void GetVarDesc(int index, out IntPtr ppVarDesc);

		new void GetNames(int memid, [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] string[] rgBstrNames, int cMaxNames, out int pcNames);

		new void GetRefTypeOfImplType(int index, out int href);

		new void GetImplTypeFlags(int index, out IMPLTYPEFLAGS pImplTypeFlags);

		new void GetIDsOfNames([In][MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 1)] string[] rgszNames, int cNames, [Out][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] int[] pMemId);

		new void Invoke([MarshalAs(UnmanagedType.IUnknown)] object pvInstance, int memid, short wFlags, ref DISPPARAMS pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, out int puArgErr);

		new void GetDocumentation(int index, out string strName, out string strDocString, out int dwHelpContext, out string strHelpFile);

		new void GetDllEntry(int memid, INVOKEKIND invKind, IntPtr pBstrDllName, IntPtr pBstrName, IntPtr pwOrdinal);

		new void GetRefTypeInfo(int hRef, out ITypeInfo ppTI);

		new void AddressOfMember(int memid, INVOKEKIND invKind, out IntPtr ppv);

		new void CreateInstance([MarshalAs(UnmanagedType.IUnknown)] object? pUnkOuter, [In] ref Guid riid, [MarshalAs(UnmanagedType.IUnknown)] out object ppvObj);

		new void GetMops(int memid, out string? pBstrMops);

		new void GetContainingTypeLib(out ITypeLib ppTLB, out int pIndex);

		[PreserveSig]
		new void ReleaseTypeAttr(IntPtr pTypeAttr);

		[PreserveSig]
		new void ReleaseFuncDesc(IntPtr pFuncDesc);

		[PreserveSig]
		new void ReleaseVarDesc(IntPtr pVarDesc);

		void GetTypeKind(out TYPEKIND pTypeKind);

		void GetTypeFlags(out int pTypeFlags);

		void GetFuncIndexOfMemId(int memid, INVOKEKIND invKind, out int pFuncIndex);

		void GetVarIndexOfMemId(int memid, out int pVarIndex);

		void GetCustData(ref Guid guid, out object pVarVal);

		void GetFuncCustData(int index, ref Guid guid, out object pVarVal);

		void GetParamCustData(int indexFunc, int indexParam, ref Guid guid, out object pVarVal);

		void GetVarCustData(int index, ref Guid guid, out object pVarVal);

		void GetImplTypeCustData(int index, ref Guid guid, out object pVarVal);

		[LCIDConversion(1)]
		void GetDocumentation2(int memid, out string pbstrHelpString, out int pdwHelpStringContext, out string pbstrHelpStringDll);

		void GetAllCustData(IntPtr pCustData);

		void GetAllFuncCustData(int index, IntPtr pCustData);

		void GetAllParamCustData(int indexFunc, int indexParam, IntPtr pCustData);

		void GetAllVarCustData(int index, IntPtr pCustData);

		void GetAllImplTypeCustData(int index, IntPtr pCustData);
	}
	public enum SYSKIND
	{
		SYS_WIN16,
		SYS_WIN32,
		SYS_MAC,
		SYS_WIN64
	}
	[Flags]
	public enum LIBFLAGS : short
	{
		LIBFLAG_FRESTRICTED = 1,
		LIBFLAG_FCONTROL = 2,
		LIBFLAG_FHIDDEN = 4,
		LIBFLAG_FHASDISKIMAGE = 8
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
	public struct TYPELIBATTR
	{
		public Guid guid;

		public int lcid;

		public SYSKIND syskind;

		public short wMajorVerNum;

		public short wMinorVerNum;

		public LIBFLAGS wLibFlags;
	}
	[ComImport]
	[Guid("00020402-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface ITypeLib
	{
		[PreserveSig]
		int GetTypeInfoCount();

		void GetTypeInfo(int index, out ITypeInfo ppTI);

		void GetTypeInfoType(int index, out TYPEKIND pTKind);

		void GetTypeInfoOfGuid(ref Guid guid, out ITypeInfo ppTInfo);

		void GetLibAttr(out IntPtr ppTLibAttr);

		void GetTypeComp(out ITypeComp ppTComp);

		void GetDocumentation(int index, out string strName, out string strDocString, out int dwHelpContext, out string strHelpFile);

		[return: MarshalAs(UnmanagedType.Bool)]
		bool IsName([MarshalAs(UnmanagedType.LPWStr)] string szNameBuf, int lHashVal);

		void FindName([MarshalAs(UnmanagedType.LPWStr)] string szNameBuf, int lHashVal, [Out][MarshalAs(UnmanagedType.LPArray)] ITypeInfo[] ppTInfo, [Out][MarshalAs(UnmanagedType.LPArray)] int[] rgMemId, ref short pcFound);

		[PreserveSig]
		void ReleaseTLibAttr(IntPtr pTLibAttr);
	}
	[ComImport]
	[Guid("00020411-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface ITypeLib2 : ITypeLib
	{
		[PreserveSig]
		new int GetTypeInfoCount();

		new void GetTypeInfo(int index, out ITypeInfo ppTI);

		new void GetTypeInfoType(int index, out TYPEKIND pTKind);

		new void GetTypeInfoOfGuid(ref Guid guid, out ITypeInfo ppTInfo);

		new void GetLibAttr(out IntPtr ppTLibAttr);

		new void GetTypeComp(out ITypeComp ppTComp);

		new void GetDocumentation(int index, out string strName, out string strDocString, out int dwHelpContext, out string strHelpFile);

		[return: MarshalAs(UnmanagedType.Bool)]
		new bool IsName([MarshalAs(UnmanagedType.LPWStr)] string szNameBuf, int lHashVal);

		new void FindName([MarshalAs(UnmanagedType.LPWStr)] string szNameBuf, int lHashVal, [Out][MarshalAs(UnmanagedType.LPArray)] ITypeInfo[] ppTInfo, [Out][MarshalAs(UnmanagedType.LPArray)] int[] rgMemId, ref short pcFound);

		[PreserveSig]
		new void ReleaseTLibAttr(IntPtr pTLibAttr);

		void GetCustData(ref Guid guid, out object pVarVal);

		[LCIDConversion(1)]
		void GetDocumentation2(int index, out string pbstrHelpString, out int pdwHelpStringContext, out string pbstrHelpStringDll);

		void GetLibStatistics(IntPtr pcUniqueNames, out int pcchUniqueNames);

		void GetAllCustData(IntPtr pCustData);
	}
}
namespace System.Runtime.CompilerServices
{
	[StructLayout(LayoutKind.Sequential)]
	internal sealed class LAHashDependentHashTracker
	{
		private GCHandle _dependentHandle;

		private IntPtr _loaderAllocator;

		~LAHashDependentHashTracker()
		{
			if (_dependentHandle.IsAllocated)
			{
				_dependentHandle.Free();
			}
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	internal sealed class LAHashKeyToTrackers
	{
		private object _trackerOrTrackerSet;

		private object _laLocalKeyValueStore;
	}
	[StructLayout(LayoutKind.Sequential)]
	internal sealed class GCHeapHash
	{
		private Array _data;

		private int _count;

		private int _deletedCount;
	}
	internal static class CastHelpers
	{
		[DebuggerDisplay("Source = {_source}; Target = {_targetAndResult & ~1}; Result = {_targetAndResult & 1}; VersionNum = {_version & ((1 << 29) - 1)}; Distance = {_version >> 29};")]
		private struct CastCacheEntry
		{
			internal int _version;

			internal nuint _source;

			internal nuint _targetAndResult;
		}

		private enum CastResult
		{
			CannotCast,
			CanCast,
			MaybeCast
		}

		internal struct ArrayElement
		{
			public object Value;
		}

		private static int[] s_table;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int KeyToBucket(ref int tableData, nuint source, nuint target)
		{
			int num = HashShift(ref tableData);
			uint num2 = BitOperations.RotateLeft((uint)source, 16) ^ (uint)(int)target;
			return (int)num2 * -1640531527 >>> num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ref int TableData(int[] table)
		{
			return ref MemoryMarshal.GetArrayDataReference(table);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static ref CastCacheEntry Element(ref int tableData, int index)
		{
			return ref Unsafe.Add(ref Unsafe.As<int, CastCacheEntry>(ref tableData), index + 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int HashShift(ref int tableData)
		{
			return tableData;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int TableMask(ref int tableData)
		{
			return Unsafe.Add(ref tableData, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static CastResult TryGet(nuint source, nuint target)
		{
			ref int tableData = ref TableData(s_table);
			int num = KeyToBucket(ref tableData, source, target);
			int num2 = 0;
			while (num2 < 8)
			{
				ref CastCacheEntry reference = ref Element(ref tableData, num);
				int num3 = Volatile.Read(ref reference._version);
				nuint source2 = reference._source;
				num3 &= -2;
				if (source2 == source)
				{
					nuint targetAndResult = reference._targetAndResult;
					targetAndResult ^= target;
					if (targetAndResult <= 1)
					{
						Interlocked.ReadMemoryBarrier();
						if (num3 != reference._version)
						{
							break;
						}
						return (CastResult)targetAndResult;
					}
				}
				if (num3 == 0)
				{
					break;
				}
				num2++;
				num = (num + num2) & TableMask(ref tableData);
			}
			return CastResult.MaybeCast;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern object IsInstanceOfAny_NoCacheLookup(void* toTypeHnd, object obj);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern object ChkCastAny_NoCacheLookup(void* toTypeHnd, object obj);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern ref byte Unbox_Helper(void* toTypeHnd, object obj);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void WriteBarrier(ref object dst, object obj);

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object IsInstanceOfAny(void* toTypeHnd, object obj)
		{
			if (obj != null)
			{
				void* methodTable = RuntimeHelpers.GetMethodTable(obj);
				if (methodTable != toTypeHnd)
				{
					CastResult castResult = TryGet((nuint)methodTable, (nuint)toTypeHnd);
					if (castResult != CastResult.CanCast)
					{
						if (castResult != 0)
						{
							return IsInstanceOfAny_NoCacheLookup(toTypeHnd, obj);
						}
						obj = null;
					}
				}
			}
			return obj;
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object IsInstanceOfInterface(void* toTypeHnd, object obj)
		{
			MethodTable* methodTable;
			nint num;
			MethodTable** ptr;
			if (obj != null)
			{
				methodTable = RuntimeHelpers.GetMethodTable(obj);
				num = methodTable->InterfaceCount;
				if (num == 0)
				{
					goto IL_0083;
				}
				ptr = methodTable->InterfaceMap;
				if (num < 4)
				{
					goto IL_006c;
				}
				while (*ptr != toTypeHnd && ptr[1] != toTypeHnd && ptr[2] != toTypeHnd && ptr[3] != toTypeHnd)
				{
					ptr += 4;
					num -= 4;
					if (num >= 4)
					{
						continue;
					}
					goto IL_0069;
				}
			}
			goto IL_008e;
			IL_0069:
			if (num != 0)
			{
				goto IL_006c;
			}
			goto IL_0083;
			IL_0083:
			if (!methodTable->NonTrivialInterfaceCast)
			{
				obj = null;
				goto IL_008e;
			}
			return IsInstance_Helper(toTypeHnd, obj);
			IL_008e:
			return obj;
			IL_006c:
			while (*ptr != toTypeHnd)
			{
				ptr++;
				num--;
				if (num > 0)
				{
					continue;
				}
				goto IL_0083;
			}
			goto IL_008e;
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object IsInstanceOfClass(void* toTypeHnd, object obj)
		{
			if (obj == null || RuntimeHelpers.GetMethodTable(obj) == toTypeHnd)
			{
				return obj;
			}
			MethodTable* parentMethodTable = RuntimeHelpers.GetMethodTable(obj)->ParentMethodTable;
			while (parentMethodTable != toTypeHnd)
			{
				if (parentMethodTable != null)
				{
					parentMethodTable = parentMethodTable->ParentMethodTable;
					if (parentMethodTable == toTypeHnd)
					{
						break;
					}
					if (parentMethodTable != null)
					{
						parentMethodTable = parentMethodTable->ParentMethodTable;
						if (parentMethodTable == toTypeHnd)
						{
							break;
						}
						if (parentMethodTable != null)
						{
							parentMethodTable = parentMethodTable->ParentMethodTable;
							if (parentMethodTable == toTypeHnd)
							{
								break;
							}
							if (parentMethodTable != null)
							{
								parentMethodTable = parentMethodTable->ParentMethodTable;
								continue;
							}
						}
					}
				}
				obj = null;
				break;
			}
			return obj;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object IsInstance_Helper(void* toTypeHnd, object obj)
		{
			return TryGet((nuint)RuntimeHelpers.GetMethodTable(obj), (nuint)toTypeHnd) switch
			{
				CastResult.CanCast => obj, 
				CastResult.CannotCast => null, 
				_ => IsInstanceOfAny_NoCacheLookup(toTypeHnd, obj), 
			};
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object ChkCastAny(void* toTypeHnd, object obj)
		{
			if (obj != null)
			{
				void* methodTable = RuntimeHelpers.GetMethodTable(obj);
				if (methodTable != toTypeHnd)
				{
					CastResult castResult = TryGet((nuint)methodTable, (nuint)toTypeHnd);
					if (castResult != CastResult.CanCast)
					{
						return ChkCastAny_NoCacheLookup(toTypeHnd, obj);
					}
				}
			}
			return obj;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object ChkCast_Helper(void* toTypeHnd, object obj)
		{
			CastResult castResult = TryGet((nuint)RuntimeHelpers.GetMethodTable(obj), (nuint)toTypeHnd);
			if (castResult == CastResult.CanCast)
			{
				return obj;
			}
			return ChkCastAny_NoCacheLookup(toTypeHnd, obj);
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object ChkCastInterface(void* toTypeHnd, object obj)
		{
			nint num;
			MethodTable** ptr;
			if (obj != null)
			{
				MethodTable* methodTable = RuntimeHelpers.GetMethodTable(obj);
				num = methodTable->InterfaceCount;
				if (num == 0)
				{
					goto IL_0084;
				}
				ptr = methodTable->InterfaceMap;
				if (num < 4)
				{
					goto IL_0069;
				}
				while (*ptr != toTypeHnd && ptr[1] != toTypeHnd && ptr[2] != toTypeHnd && ptr[3] != toTypeHnd)
				{
					ptr += 4;
					num -= 4;
					if (num >= 4)
					{
						continue;
					}
					goto IL_0066;
				}
			}
			goto IL_0082;
			IL_0082:
			return obj;
			IL_0069:
			while (*ptr != toTypeHnd)
			{
				ptr++;
				num--;
				if (num > 0)
				{
					continue;
				}
				goto IL_0084;
			}
			goto IL_0082;
			IL_0066:
			if (num != 0)
			{
				goto IL_0069;
			}
			goto IL_0084;
			IL_0084:
			return ChkCast_Helper(toTypeHnd, obj);
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object ChkCastClass(void* toTypeHnd, object obj)
		{
			if (obj == null || RuntimeHelpers.GetMethodTable(obj) == toTypeHnd)
			{
				return obj;
			}
			return ChkCastClassSpecial(toTypeHnd, obj);
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static object ChkCastClassSpecial(void* toTypeHnd, object obj)
		{
			MethodTable* ptr = RuntimeHelpers.GetMethodTable(obj);
			while (true)
			{
				ptr = ptr->ParentMethodTable;
				if (ptr != toTypeHnd)
				{
					if (ptr == null)
					{
						break;
					}
					ptr = ptr->ParentMethodTable;
					if (ptr != toTypeHnd)
					{
						if (ptr == null)
						{
							break;
						}
						ptr = ptr->ParentMethodTable;
						if (ptr != toTypeHnd)
						{
							if (ptr == null)
							{
								break;
							}
							ptr = ptr->ParentMethodTable;
							if (ptr != toTypeHnd)
							{
								if (ptr == null)
								{
									break;
								}
								continue;
							}
						}
					}
				}
				return obj;
			}
			return ChkCast_Helper(toTypeHnd, obj);
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static ref byte Unbox(void* toTypeHnd, object obj)
		{
			if (RuntimeHelpers.GetMethodTable(obj) == toTypeHnd)
			{
				return ref obj.GetRawData();
			}
			return ref Unbox_Helper(toTypeHnd, obj);
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private static ref object ThrowArrayMismatchException()
		{
			throw new ArrayTypeMismatchException();
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static ref object LdelemaRef(Array array, int index, void* type)
		{
			ref object value = ref Unsafe.As<ArrayElement[]>(array)[index].Value;
			void* elementType = RuntimeHelpers.GetMethodTable(array)->ElementType;
			if (elementType == type)
			{
				return ref value;
			}
			return ref ThrowArrayMismatchException();
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static void StelemRef(Array array, int index, object obj)
		{
			ref object value = ref Unsafe.As<ArrayElement[]>(array)[index].Value;
			void* elementType = RuntimeHelpers.GetMethodTable(array)->ElementType;
			if (obj != null)
			{
				if (elementType == RuntimeHelpers.GetMethodTable(obj) || array.GetType() == typeof(object[]))
				{
					WriteBarrier(ref value, obj);
				}
				else
				{
					StelemRef_Helper(ref value, elementType, obj);
				}
			}
			else
			{
				value = null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static void StelemRef_Helper(ref object element, void* elementType, object obj)
		{
			CastResult castResult = TryGet((nuint)RuntimeHelpers.GetMethodTable(obj), (nuint)elementType);
			if (castResult == CastResult.CanCast)
			{
				WriteBarrier(ref element, obj);
			}
			else
			{
				StelemRef_Helper_NoCacheLookup(ref element, elementType, obj);
			}
		}

		[DebuggerHidden]
		[StackTraceHidden]
		[DebuggerStepThrough]
		private unsafe static void StelemRef_Helper_NoCacheLookup(ref object element, void* elementType, object obj)
		{
			obj = IsInstanceOfAny_NoCacheLookup(elementType, obj);
			if (obj != null)
			{
				WriteBarrier(ref element, obj);
				return;
			}
			throw new ArrayTypeMismatchException();
		}
	}
	internal static class ICastableHelpers
	{
		internal static bool IsInstanceOfInterface(ICastable castable, RuntimeType type, [NotNullWhen(true)] out Exception castError)
		{
			return castable.IsInstanceOfInterface(new RuntimeTypeHandle(type), out castError);
		}

		internal static RuntimeType GetImplType(ICastable castable, RuntimeType interfaceType)
		{
			return castable.GetImplType(new RuntimeTypeHandle(interfaceType)).GetRuntimeType();
		}
	}
	public static class RuntimeFeature
	{
		public const string PortablePdb = "PortablePdb";

		public const string DefaultImplementationsOfInterfaces = "DefaultImplementationsOfInterfaces";

		public const string UnmanagedSignatureCallingConvention = "UnmanagedSignatureCallingConvention";

		public const string CovariantReturnsOfClasses = "CovariantReturnsOfClasses";

		[RequiresPreviewFeatures("Generic Math is in preview.", Url = "https://aka.ms/dotnet-warnings/generic-math-preview")]
		public const string VirtualStaticsInInterfaces = "VirtualStaticsInInterfaces";

		public static bool IsDynamicCodeSupported => true;

		public static bool IsDynamicCodeCompiled => true;

		public static bool IsSupported(string feature)
		{
			switch (feature)
			{
			case "PortablePdb":
			case "CovariantReturnsOfClasses":
			case "UnmanagedSignatureCallingConvention":
			case "DefaultImplementationsOfInterfaces":
			case "VirtualStaticsInInterfaces":
				return true;
			case "IsDynamicCodeSupported":
				return IsDynamicCodeSupported;
			case "IsDynamicCodeCompiled":
				return IsDynamicCodeCompiled;
			default:
				return false;
			}
		}
	}
	public static class RuntimeHelpers
	{
		public delegate void TryCode(object? userData);

		public delegate void CleanupCode(object? userData, bool exceptionThrown);

		public static int OffsetToStringData
		{
			[NonVersionable]
			get
			{
				return 8;
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		[Intrinsic]
		public static extern void InitializeArray(Array array, RuntimeFieldHandle fldHandle);

		[MethodImpl(MethodImplOptions.InternalCall)]
		[return: NotNullIfNotNull("obj")]
		public static extern object? GetObjectValue(object? obj);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void RunClassConstructor(QCallTypeHandle type);

		[RequiresUnreferencedCode("Trimmer can't guarantee existence of class constructor")]
		public static void RunClassConstructor(RuntimeTypeHandle type)
		{
			RuntimeType type2 = type.GetRuntimeType();
			if ((object)type2 == null)
			{
				throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, "type");
			}
			RunClassConstructor(new QCallTypeHandle(ref type2));
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void RunModuleConstructor(QCallModule module);

		public static void RunModuleConstructor(ModuleHandle module)
		{
			RuntimeModule module2 = module.GetRuntimeModule();
			if ((object)module2 == null)
			{
				throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, "module");
			}
			RunModuleConstructor(new QCallModule(ref module2));
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void CompileMethod(RuntimeMethodHandleInternal method);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void PrepareMethod(RuntimeMethodHandleInternal method, IntPtr* pInstantiation, int cInstantiation);

		public static void PrepareMethod(RuntimeMethodHandle method)
		{
			PrepareMethod(method, null);
		}

		public unsafe static void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeHandle[]? instantiation)
		{
			IRuntimeMethodInfo methodInfo = method.GetMethodInfo();
			if (methodInfo == null)
			{
				throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, "method");
			}
			instantiation = (RuntimeTypeHandle[])instantiation?.Clone();
			int length;
			fixed (IntPtr* pInstantiation = RuntimeTypeHandle.CopyRuntimeTypeHandles(instantiation, out length))
			{
				PrepareMethod(methodInfo.Value, pInstantiation, length);
				GC.KeepAlive(instantiation);
				GC.KeepAlive(methodInfo);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern void PrepareDelegate(Delegate d);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern int GetHashCode(object? o);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public new static extern bool Equals(object? o1, object? o2);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern void EnsureSufficientExecutionStack();

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern bool TryEnsureSufficientExecutionStack();

		public static object GetUninitializedObject([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type type)
		{
			RuntimeType type2 = type as RuntimeType;
			if ((object)type2 == null)
			{
				if ((object)type == null)
				{
					throw new ArgumentNullException("type", SR.ArgumentNull_Type);
				}
				throw new SerializationException(SR.Format(SR.Serialization_InvalidType, type));
			}
			object o = null;
			GetUninitializedObject(new QCallTypeHandle(ref type2), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall")]
		private static extern void GetUninitializedObject(QCallTypeHandle type, ObjectHandleOnStack retObject);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern object AllocateUninitializedClone(object obj);

		[Intrinsic]
		public static bool IsReferenceOrContainsReferences<T>()
		{
			throw new InvalidOperationException();
		}

		[Intrinsic]
		internal static bool IsBitwiseEquatable<T>()
		{
			throw new InvalidOperationException();
		}

		[Intrinsic]
		internal static bool EnumEquals<T>(T x, T y) where T : struct, Enum
		{
			return x.Equals(y);
		}

		[Intrinsic]
		internal static int EnumCompareTo<T>(T x, T y) where T : struct, Enum
		{
			return x.CompareTo(y);
		}

		internal static ref byte GetRawData(this object obj)
		{
			return ref Unsafe.As<RawData>(obj).Data;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal unsafe static nuint GetRawObjectDataSize(object obj)
		{
			MethodTable* methodTable = GetMethodTable(obj);
			nuint num = (nuint)methodTable->BaseSize - (nuint)(2 * sizeof(IntPtr));
			if (methodTable->HasComponentSize)
			{
				num += (nuint)((nint)Unsafe.As<RawArrayData>(obj).Length * (nint)methodTable->ComponentSize);
			}
			GC.KeepAlive(obj);
			return num;
		}

		internal unsafe static ushort GetElementSize(this Array array)
		{
			return GetMethodTable(array)->ComponentSize;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ref int GetMultiDimensionalArrayBounds(Array array)
		{
			return ref Unsafe.As<byte, int>(ref Unsafe.As<RawArrayData>(array).Data);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal unsafe static int GetMultiDimensionalArrayRank(Array array)
		{
			int multiDimensionalArrayRank = GetMethodTable(array)->MultiDimensionalArrayRank;
			GC.KeepAlive(array);
			return multiDimensionalArrayRank;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal unsafe static bool ObjectHasComponentSize(object obj)
		{
			return GetMethodTable(obj)->HasComponentSize;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		internal unsafe static MethodTable* GetMethodTable(object obj)
		{
			return (MethodTable*)(void*)Unsafe.Add(ref Unsafe.As<byte, IntPtr>(ref obj.GetRawData()), -1);
		}

		public static IntPtr AllocateTypeAssociatedMemory(Type type, int size)
		{
			RuntimeType type2 = type as RuntimeType;
			if (type2 == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "type");
			}
			if (size < 0)
			{
				throw new ArgumentOutOfRangeException("size");
			}
			return AllocateTypeAssociatedMemory(new QCallTypeHandle(ref type2), (uint)size);
		}

		[DllImport("QCall")]
		private static extern IntPtr AllocateTypeAssociatedMemory(QCallTypeHandle type, uint size);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern IntPtr AllocTailCallArgBuffer(int size, IntPtr gcDesc);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern TailCallTls* GetTailCallInfo(IntPtr retAddrSlot, IntPtr* retAddr);

		[StackTraceHidden]
		private unsafe static void DispatchTailCalls(IntPtr callersRetAddrSlot, delegate*<IntPtr, IntPtr, PortableTailCallFrame*, void> callTarget, IntPtr retVal)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out IntPtr intPtr);
			TailCallTls* tailCallInfo = GetTailCallInfo(callersRetAddrSlot, &intPtr);
			PortableTailCallFrame* frame = tailCallInfo->Frame;
			if (intPtr == frame->TailCallAwareReturnAddress)
			{
				frame->NextCall = callTarget;
				return;
			}
			System.Runtime.CompilerServices.Unsafe.SkipInit(out PortableTailCallFrame portableTailCallFrame);
			portableTailCallFrame.NextCall = null;
			try
			{
				tailCallInfo->Frame = &portableTailCallFrame;
				do
				{
					callTarget(tailCallInfo->ArgBuffer, retVal, &portableTailCallFrame);
					callTarget = portableTailCallFrame.NextCall;
				}
				while (callTarget != (delegate*<IntPtr, IntPtr, PortableTailCallFrame*, void>)null);
			}
			finally
			{
				tailCallInfo->Frame = frame;
				if (tailCallInfo->ArgBuffer != IntPtr.Zero && *(int*)(void*)tailCallInfo->ArgBuffer == 1)
				{
					*(int*)(void*)tailCallInfo->ArgBuffer = 2;
				}
			}
		}

		public static T[] GetSubArray<T>(T[] array, Range range)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			var (elementOffset, num) = range.GetOffsetAndLength(array.Length);
			T[] array2;
			if (typeof(T).IsValueType || typeof(T[]) == array.GetType())
			{
				if (num == 0)
				{
					return Array.Empty<T>();
				}
				array2 = new T[num];
			}
			else
			{
				array2 = Unsafe.As<T[]>(Array.CreateInstance(array.GetType().GetElementType(), num));
			}
			Buffer.Memmove(ref MemoryMarshal.GetArrayDataReference(array2), ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), elementOffset), (uint)num);
			return array2;
		}

		[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static void ExecuteCodeWithGuaranteedCleanup(TryCode code, CleanupCode backoutCode, object? userData)
		{
			if (code == null)
			{
				throw new ArgumentNullException("code");
			}
			if (backoutCode == null)
			{
				throw new ArgumentNullException("backoutCode");
			}
			bool exceptionThrown = true;
			try
			{
				code(userData);
				exceptionThrown = false;
			}
			finally
			{
				backoutCode(userData, exceptionThrown);
			}
		}

		[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static void PrepareContractedDelegate(Delegate d)
		{
		}

		[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static void ProbeForSufficientStack()
		{
		}

		[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static void PrepareConstrainedRegions()
		{
		}

		[Obsolete("The Constrained Execution Region (CER) feature is not supported.", DiagnosticId = "SYSLIB0004", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public static void PrepareConstrainedRegionsNoOP()
		{
		}

		internal static bool IsPrimitiveType(this CorElementType et)
		{
			return ((1 << (int)et) & 0x3003FFC) != 0;
		}
	}
	internal sealed class RawData
	{
		public byte Data;
	}
	internal sealed class RawArrayData
	{
		public uint Length;

		public byte Data;
	}
	[StructLayout(LayoutKind.Explicit)]
	internal struct MethodTable
	{
		[FieldOffset(0)]
		public ushort ComponentSize;

		[FieldOffset(0)]
		private uint Flags;

		[FieldOffset(4)]
		public uint BaseSize;

		[FieldOffset(14)]
		public ushort InterfaceCount;

		[FieldOffset(16)]
		public unsafe MethodTable* ParentMethodTable;

		[FieldOffset(32)]
		public unsafe void* ElementType;

		[FieldOffset(36)]
		public unsafe MethodTable** InterfaceMap;

		public bool HasComponentSize => (Flags & 0x80000000u) != 0;

		public bool ContainsGCPointers => (Flags & 0x1000000) != 0;

		public bool NonTrivialInterfaceCast => (Flags & 0x406C0000) != 0;

		public unsafe bool IsMultiDimensionalArray
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return BaseSize > (uint)(3 * sizeof(IntPtr));
			}
		}

		public unsafe int MultiDimensionalArrayRank
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (int)((uint)((int)BaseSize - 3 * sizeof(IntPtr)) / 8u);
			}
		}
	}
	internal struct PortableTailCallFrame
	{
		public IntPtr TailCallAwareReturnAddress;

		public unsafe delegate*<IntPtr, IntPtr, PortableTailCallFrame*, void> NextCall;
	}
	internal struct TailCallTls
	{
		public unsafe PortableTailCallFrame* Frame;

		public IntPtr ArgBuffer;
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	internal sealed class TypeDependencyAttribute : Attribute
	{
		private readonly string typeName;

		public TypeDependencyAttribute(string typeName)
		{
			if (typeName == null)
			{
				throw new ArgumentNullException("typeName");
			}
			this.typeName = typeName;
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	public sealed class AccessedThroughPropertyAttribute : Attribute
	{
		public string PropertyName { get; }

		public AccessedThroughPropertyAttribute(string propertyName)
		{
			PropertyName = propertyName;
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public struct AsyncIteratorMethodBuilder
	{
		private Task<VoidTaskResult> m_task;

		internal object ObjectIdForDebugger => m_task ?? (m_task = AsyncTaskMethodBuilder<VoidTaskResult>.CreateWeaklyTypedStateMachineBox());

		public static AsyncIteratorMethodBuilder Create()
		{
			return default(AsyncIteratorMethodBuilder);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void MoveNext<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			AsyncMethodBuilderCore.Start(ref stateMachine);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.AwaitOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		public void Complete()
		{
			if (m_task == null)
			{
				m_task = Task.s_cachedCompleted;
				return;
			}
			AsyncTaskMethodBuilder<VoidTaskResult>.SetExistingTaskResult(m_task, default(VoidTaskResult));
			if (m_task is IAsyncStateMachineBox asyncStateMachineBox)
			{
				asyncStateMachineBox.ClearStateUponCompletion();
			}
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
	public sealed class AsyncIteratorStateMachineAttribute : StateMachineAttribute
	{
		public AsyncIteratorStateMachineAttribute(Type stateMachineType)
			: base(stateMachineType)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false, AllowMultiple = false)]
	public sealed class AsyncMethodBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public AsyncMethodBuilderAttribute(Type builderType)
		{
			BuilderType = builderType;
		}
	}
	internal static class AsyncMethodBuilderCore
	{
		private sealed class ContinuationWrapper
		{
			private readonly Action<Action, Task> _invokeAction;

			internal readonly Action _continuation;

			internal readonly Task _innerTask;

			internal ContinuationWrapper(Action continuation, Action<Action, Task> invokeAction, Task innerTask)
			{
				_invokeAction = invokeAction;
				_continuation = continuation;
				_innerTask = innerTask;
			}

			internal void Invoke()
			{
				_invokeAction(_continuation, _innerTask);
			}
		}

		internal static bool TrackAsyncMethodCompletion
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return TplEventSource.Log.IsEnabled(EventLevel.Warning, (EventKeywords)256L);
			}
		}

		[DebuggerStepThrough]
		public static void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			if (stateMachine == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
			}
			Thread currentThread = Thread.CurrentThread;
			ExecutionContext executionContext = currentThread._executionContext;
			SynchronizationContext synchronizationContext = currentThread._synchronizationContext;
			try
			{
				stateMachine.MoveNext();
			}
			finally
			{
				if (synchronizationContext != currentThread._synchronizationContext)
				{
					currentThread._synchronizationContext = synchronizationContext;
				}
				ExecutionContext executionContext2 = currentThread._executionContext;
				if (executionContext != executionContext2)
				{
					ExecutionContext.RestoreChangedContextToThread(currentThread, executionContext, executionContext2);
				}
			}
		}

		public static void SetStateMachine(IAsyncStateMachine stateMachine, Task task)
		{
			if (stateMachine == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
			}
			if (task != null)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.AsyncMethodBuilder_InstanceNotInitialized);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "It's okay if unused fields disappear from debug views")]
		internal static string GetAsyncStateMachineDescription(IAsyncStateMachine stateMachine)
		{
			Type type = stateMachine.GetType();
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(type.FullName);
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				stringBuilder.Append("    ").Append(fieldInfo.Name).Append(": ")
					.Append(fieldInfo.GetValue(stateMachine))
					.AppendLine();
			}
			return stringBuilder.ToString();
		}

		internal static Action CreateContinuationWrapper(Action continuation, Action<Action, Task> invokeAction, Task innerTask)
		{
			return new ContinuationWrapper(continuation, invokeAction, innerTask).Invoke;
		}

		internal static Action TryGetStateMachineForDebugger(Action action)
		{
			object target = action.Target;
			if (!(target is IAsyncStateMachineBox asyncStateMachineBox))
			{
				if (!(target is ContinuationWrapper continuationWrapper))
				{
					return action;
				}
				return TryGetStateMachineForDebugger(continuationWrapper._continuation);
			}
			return asyncStateMachineBox.GetStateMachineObject().MoveNext;
		}

		internal static Task TryGetContinuationTask(Action continuation)
		{
			if (!(continuation.Target is ContinuationWrapper continuationWrapper))
			{
				return continuation.Target as Task;
			}
			return continuationWrapper._innerTask;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
	public sealed class AsyncStateMachineAttribute : StateMachineAttribute
	{
		public AsyncStateMachineAttribute(Type stateMachineType)
			: base(stateMachineType)
		{
		}
	}
	public struct AsyncTaskMethodBuilder
	{
		private Task<VoidTaskResult> m_task;

		public Task Task
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return m_task ?? InitializeTaskAsPromise();
			}
		}

		internal object ObjectIdForDebugger => m_task ?? (m_task = AsyncTaskMethodBuilder<VoidTaskResult>.CreateWeaklyTypedStateMachineBox());

		public static AsyncTaskMethodBuilder Create()
		{
			return default(AsyncTaskMethodBuilder);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerStepThrough]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			AsyncMethodBuilderCore.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			AsyncMethodBuilderCore.SetStateMachine(stateMachine, null);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.AwaitOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private Task<VoidTaskResult> InitializeTaskAsPromise()
		{
			return m_task = new Task<VoidTaskResult>();
		}

		public void SetResult()
		{
			if (m_task == null)
			{
				m_task = System.Threading.Tasks.Task.s_cachedCompleted;
			}
			else
			{
				AsyncTaskMethodBuilder<VoidTaskResult>.SetExistingTaskResult(m_task, default(VoidTaskResult));
			}
		}

		public void SetException(Exception exception)
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.SetException(exception, ref m_task);
		}

		internal void SetNotificationForWaitCompletion(bool enabled)
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.SetNotificationForWaitCompletion(enabled, ref m_task);
		}
	}
	public struct AsyncTaskMethodBuilder<TResult>
	{
		private sealed class DebugFinalizableAsyncStateMachineBox<TStateMachine> : AsyncStateMachineBox<TStateMachine> where TStateMachine : IAsyncStateMachine
		{
			~DebugFinalizableAsyncStateMachineBox()
			{
				if (!base.IsCompleted)
				{
					TplEventSource.Log.IncompleteAsyncMethod(this);
				}
			}
		}

		private class AsyncStateMachineBox<TStateMachine> : Task<TResult>, IAsyncStateMachineBox where TStateMachine : IAsyncStateMachine
		{
			private static readonly ContextCallback s_callback = ExecutionContextCallback;

			private Action _moveNextAction;

			public TStateMachine StateMachine;

			public ExecutionContext Context;

			public Action MoveNextAction => _moveNextAction ?? (_moveNextAction = MoveNext);

			private static void ExecutionContextCallback(object s)
			{
				Unsafe.As<AsyncStateMachineBox<TStateMachine>>(s).StateMachine.MoveNext();
			}

			internal sealed override void ExecuteFromThreadPool(Thread threadPoolThread)
			{
				MoveNext(threadPoolThread);
			}

			public void MoveNext()
			{
				MoveNext(null);
			}

			private void MoveNext(Thread threadPoolThread)
			{
				bool flag = TplEventSource.Log.IsEnabled();
				if (flag)
				{
					TplEventSource.Log.TraceSynchronousWorkBegin(base.Id, CausalitySynchronousWork.Execution);
				}
				ExecutionContext context = Context;
				if (context == null)
				{
					StateMachine.MoveNext();
				}
				else if (threadPoolThread == null)
				{
					ExecutionContext.RunInternal(context, s_callback, this);
				}
				else
				{
					ExecutionContext.RunFromThreadPoolDispatchLoop(threadPoolThread, context, s_callback, this);
				}
				if (base.IsCompleted)
				{
					ClearStateUponCompletion();
				}
				if (flag)
				{
					TplEventSource.Log.TraceSynchronousWorkEnd(CausalitySynchronousWork.Execution);
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void ClearStateUponCompletion()
			{
				if (System.Threading.Tasks.Task.s_asyncDebuggingEnabled)
				{
					System.Threading.Tasks.Task.RemoveFromActiveTasks(this);
				}
				StateMachine = default(TStateMachine);
				Context = null;
				if (AsyncMethodBuilderCore.TrackAsyncMethodCompletion)
				{
					GC.SuppressFinalize(this);
				}
			}

			IAsyncStateMachine IAsyncStateMachineBox.GetStateMachineObject()
			{
				return StateMachine;
			}
		}

		private Task<TResult> m_task;

		public Task<TResult> Task
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return m_task ?? InitializeTaskAsPromise();
			}
		}

		internal object ObjectIdForDebugger => m_task ?? (m_task = CreateWeaklyTypedStateMachineBox());

		public static AsyncTaskMethodBuilder<TResult> Create()
		{
			return default(AsyncTaskMethodBuilder<TResult>);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerStepThrough]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			AsyncMethodBuilderCore.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			AsyncMethodBuilderCore.SetStateMachine(stateMachine, m_task);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AwaitOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		internal static void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine, ref Task<TResult> taskField) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			try
			{
				awaiter.OnCompleted(GetStateMachineBox(ref stateMachine, ref taskField).MoveNextAction);
			}
			catch (Exception exception)
			{
				System.Threading.Tasks.Task.ThrowAsync(exception, null);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine, [NotNull] ref Task<TResult> taskField) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			IAsyncStateMachineBox stateMachineBox = GetStateMachineBox(ref stateMachine, ref taskField);
			AwaitUnsafeOnCompleted(ref awaiter, stateMachineBox);
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		internal static void AwaitUnsafeOnCompleted<TAwaiter>(ref TAwaiter awaiter, IAsyncStateMachineBox box) where TAwaiter : ICriticalNotifyCompletion
		{
			if (default(TAwaiter) != null && awaiter is ITaskAwaiter)
			{
				TaskAwaiter.UnsafeOnCompletedInternal(Unsafe.As<TAwaiter, TaskAwaiter>(ref awaiter).m_task, box, continueOnCapturedContext: true);
				return;
			}
			if (default(TAwaiter) != null && awaiter is IConfiguredTaskAwaiter)
			{
				ref ConfiguredTaskAwaitable.ConfiguredTaskAwaiter reference = ref Unsafe.As<TAwaiter, ConfiguredTaskAwaitable.ConfiguredTaskAwaiter>(ref awaiter);
				TaskAwaiter.UnsafeOnCompletedInternal(reference.m_task, box, reference.m_continueOnCapturedContext);
				return;
			}
			if (default(TAwaiter) != null && awaiter is IStateMachineBoxAwareAwaiter)
			{
				try
				{
					((IStateMachineBoxAwareAwaiter)(object)awaiter).AwaitUnsafeOnCompleted(box);
					return;
				}
				catch (Exception exception)
				{
					System.Threading.Tasks.Task.ThrowAsync(exception, null);
					return;
				}
			}
			try
			{
				awaiter.UnsafeOnCompleted(box.MoveNextAction);
			}
			catch (Exception exception2)
			{
				System.Threading.Tasks.Task.ThrowAsync(exception2, null);
			}
		}

		private static IAsyncStateMachineBox GetStateMachineBox<TStateMachine>(ref TStateMachine stateMachine, [NotNull] ref Task<TResult> taskField) where TStateMachine : IAsyncStateMachine
		{
			ExecutionContext executionContext = ExecutionContext.Capture();
			if (taskField is AsyncStateMachineBox<TStateMachine> asyncStateMachineBox)
			{
				if (asyncStateMachineBox.Context != executionContext)
				{
					asyncStateMachineBox.Context = executionContext;
				}
				return asyncStateMachineBox;
			}
			if (taskField is AsyncStateMachineBox<IAsyncStateMachine> asyncStateMachineBox2)
			{
				if (asyncStateMachineBox2.StateMachine == null)
				{
					Debugger.NotifyOfCrossThreadDependency();
					asyncStateMachineBox2.StateMachine = stateMachine;
				}
				asyncStateMachineBox2.Context = executionContext;
				return asyncStateMachineBox2;
			}
			Debugger.NotifyOfCrossThreadDependency();
			AsyncStateMachineBox<TStateMachine> asyncStateMachineBox3 = (AsyncStateMachineBox<TStateMachine>)(taskField = (AsyncMethodBuilderCore.TrackAsyncMethodCompletion ? CreateDebugFinalizableAsyncStateMachineBox<TStateMachine>() : new AsyncStateMachineBox<TStateMachine>()));
			asyncStateMachineBox3.StateMachine = stateMachine;
			asyncStateMachineBox3.Context = executionContext;
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationBegin(asyncStateMachineBox3.Id, "Async: " + stateMachine.GetType().Name, 0L);
			}
			if (System.Threading.Tasks.Task.s_asyncDebuggingEnabled)
			{
				System.Threading.Tasks.Task.AddToActiveTasks(asyncStateMachineBox3);
			}
			return asyncStateMachineBox3;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static AsyncStateMachineBox<TStateMachine> CreateDebugFinalizableAsyncStateMachineBox<TStateMachine>() where TStateMachine : IAsyncStateMachine
		{
			return new DebugFinalizableAsyncStateMachineBox<TStateMachine>();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private Task<TResult> InitializeTaskAsPromise()
		{
			return m_task = new Task<TResult>();
		}

		internal static Task<TResult> CreateWeaklyTypedStateMachineBox()
		{
			if (!AsyncMethodBuilderCore.TrackAsyncMethodCompletion)
			{
				return new AsyncStateMachineBox<IAsyncStateMachine>();
			}
			return CreateDebugFinalizableAsyncStateMachineBox<IAsyncStateMachine>();
		}

		public void SetResult(TResult result)
		{
			if (m_task == null)
			{
				m_task = System.Threading.Tasks.Task.FromResult(result);
			}
			else
			{
				SetExistingTaskResult(m_task, result);
			}
		}

		internal static void SetExistingTaskResult(Task<TResult> task, TResult result)
		{
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationEnd(task.Id, AsyncCausalityStatus.Completed);
			}
			if (!task.TrySetResult(result))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		public void SetException(Exception exception)
		{
			SetException(exception, ref m_task);
		}

		internal static void SetException(Exception exception, ref Task<TResult> taskField)
		{
			if (exception == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exception);
			}
			Task<TResult> task = taskField ?? (taskField = new Task<TResult>());
			if (!((exception is OperationCanceledException ex) ? task.TrySetCanceled(ex.CancellationToken, ex) : task.TrySetException(exception)))
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.TaskT_TransitionToFinal_AlreadyCompleted);
			}
		}

		internal void SetNotificationForWaitCompletion(bool enabled)
		{
			SetNotificationForWaitCompletion(enabled, ref m_task);
		}

		internal static void SetNotificationForWaitCompletion(bool enabled, [NotNull] ref Task<TResult> taskField)
		{
			(taskField ?? (taskField = CreateWeaklyTypedStateMachineBox())).SetNotificationForWaitCompletion(enabled);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public struct AsyncValueTaskMethodBuilder
	{
		private static readonly Task<VoidTaskResult> s_syncSuccessSentinel = AsyncValueTaskMethodBuilder<VoidTaskResult>.s_syncSuccessSentinel;

		private Task<VoidTaskResult> m_task;

		public ValueTask Task
		{
			get
			{
				if (m_task == s_syncSuccessSentinel)
				{
					return default(ValueTask);
				}
				Task<VoidTaskResult> task = m_task ?? (m_task = new Task<VoidTaskResult>());
				return new ValueTask(task);
			}
		}

		internal object ObjectIdForDebugger => m_task ?? (m_task = AsyncTaskMethodBuilder<VoidTaskResult>.CreateWeaklyTypedStateMachineBox());

		public static AsyncValueTaskMethodBuilder Create()
		{
			return default(AsyncValueTaskMethodBuilder);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			AsyncMethodBuilderCore.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			AsyncMethodBuilderCore.SetStateMachine(stateMachine, null);
		}

		public void SetResult()
		{
			if (m_task == null)
			{
				m_task = s_syncSuccessSentinel;
			}
			else
			{
				AsyncTaskMethodBuilder<VoidTaskResult>.SetExistingTaskResult(m_task, default(VoidTaskResult));
			}
		}

		public void SetException(Exception exception)
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.SetException(exception, ref m_task);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.AwaitOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AsyncTaskMethodBuilder<VoidTaskResult>.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public struct AsyncValueTaskMethodBuilder<TResult>
	{
		internal static readonly Task<TResult> s_syncSuccessSentinel = new Task<TResult>(default(TResult));

		private Task<TResult> m_task;

		private TResult _result;

		public ValueTask<TResult> Task
		{
			get
			{
				if (m_task == s_syncSuccessSentinel)
				{
					return new ValueTask<TResult>(_result);
				}
				Task<TResult> task = m_task ?? (m_task = new Task<TResult>());
				return new ValueTask<TResult>(task);
			}
		}

		internal object ObjectIdForDebugger => m_task ?? (m_task = AsyncTaskMethodBuilder<TResult>.CreateWeaklyTypedStateMachineBox());

		public static AsyncValueTaskMethodBuilder<TResult> Create()
		{
			return default(AsyncValueTaskMethodBuilder<TResult>);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			AsyncMethodBuilderCore.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			AsyncMethodBuilderCore.SetStateMachine(stateMachine, null);
		}

		public void SetResult(TResult result)
		{
			if (m_task == null)
			{
				_result = result;
				m_task = s_syncSuccessSentinel;
			}
			else
			{
				AsyncTaskMethodBuilder<TResult>.SetExistingTaskResult(m_task, result);
			}
		}

		public void SetException(Exception exception)
		{
			AsyncTaskMethodBuilder<TResult>.SetException(exception, ref m_task);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AsyncTaskMethodBuilder<TResult>.AwaitOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AsyncTaskMethodBuilder<TResult>.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}
	}
	public struct AsyncVoidMethodBuilder
	{
		private SynchronizationContext _synchronizationContext;

		private AsyncTaskMethodBuilder _builder;

		private Task Task => _builder.Task;

		internal object ObjectIdForDebugger => _builder.ObjectIdForDebugger;

		public static AsyncVoidMethodBuilder Create()
		{
			SynchronizationContext current = SynchronizationContext.Current;
			current?.OperationStarted();
			AsyncVoidMethodBuilder result = default(AsyncVoidMethodBuilder);
			result._synchronizationContext = current;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[DebuggerStepThrough]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			AsyncMethodBuilderCore.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			_builder.SetStateMachine(stateMachine);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			_builder.AwaitOnCompleted(ref awaiter, ref stateMachine);
		}

		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			_builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
		}

		public void SetResult()
		{
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationEnd(Task.Id, AsyncCausalityStatus.Completed);
			}
			_builder.SetResult();
			if (_synchronizationContext != null)
			{
				NotifySynchronizationContextOfCompletion();
			}
		}

		public void SetException(Exception exception)
		{
			if (exception == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exception);
			}
			if (TplEventSource.Log.IsEnabled())
			{
				TplEventSource.Log.TraceOperationEnd(Task.Id, AsyncCausalityStatus.Error);
			}
			if (_synchronizationContext != null)
			{
				try
				{
					System.Threading.Tasks.Task.ThrowAsync(exception, _synchronizationContext);
				}
				finally
				{
					NotifySynchronizationContextOfCompletion();
				}
			}
			else
			{
				System.Threading.Tasks.Task.ThrowAsync(exception, null);
			}
			_builder.SetResult();
		}

		private void NotifySynchronizationContextOfCompletion()
		{
			try
			{
				_synchronizationContext.OperationCompleted();
			}
			catch (Exception exception)
			{
				System.Threading.Tasks.Task.ThrowAsync(exception, null);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	public sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class CallerFilePathAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class CallerLineNumberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class CallerMemberNameAttribute : Attribute
	{
	}
	public class CallConvCdecl
	{
	}
	public class CallConvFastcall
	{
	}
	public class CallConvStdcall
	{
	}
	public class CallConvSuppressGCTransition
	{
	}
	public class CallConvThiscall
	{
	}
	public class CallConvMemberFunction
	{
	}
	[Flags]
	public enum CompilationRelaxations
	{
		NoStringInterning = 8
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Method)]
	public class CompilationRelaxationsAttribute : Attribute
	{
		public int CompilationRelaxations { get; }

		public CompilationRelaxationsAttribute(int relaxations)
		{
			CompilationRelaxations = relaxations;
		}

		public CompilationRelaxationsAttribute(CompilationRelaxations relaxations)
		{
			CompilationRelaxations = (int)relaxations;
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = true)]
	public sealed class CompilerGeneratedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class CompilerGlobalScopeAttribute : Attribute
	{
	}
	public sealed class ConditionalWeakTable<TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, System.Collections.IEnumerable where TKey : class where TValue : class?
	{
		public delegate TValue CreateValueCallback(TKey key);

		private sealed class Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IDisposable, System.Collections.IEnumerator
		{
			private ConditionalWeakTable<TKey, TValue> _table;

			private readonly int _maxIndexInclusive;

			private int _currentIndex;

			private KeyValuePair<TKey, TValue> _current;

			public KeyValuePair<TKey, TValue> Current
			{
				get
				{
					if (_currentIndex < 0)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return _current;
				}
			}

			object System.Collections.IEnumerator.Current => Current;

			public Enumerator(ConditionalWeakTable<TKey, TValue> table)
			{
				_table = table;
				table._activeEnumeratorRefCount++;
				_maxIndexInclusive = table._container.FirstFreeEntry - 1;
				_currentIndex = -1;
			}

			~Enumerator()
			{
				Dispose();
			}

			public void Dispose()
			{
				ConditionalWeakTable<TKey, TValue> conditionalWeakTable = Interlocked.Exchange(ref _table, null);
				if (conditionalWeakTable != null)
				{
					_current = default(KeyValuePair<TKey, TValue>);
					lock (conditionalWeakTable._lock)
					{
						conditionalWeakTable._activeEnumeratorRefCount--;
					}
					GC.SuppressFinalize(this);
				}
			}

			public bool MoveNext()
			{
				ConditionalWeakTable<TKey, TValue> table = _table;
				if (table != null)
				{
					lock (table._lock)
					{
						Container container = table._container;
						if (container != null)
						{
							while (_currentIndex < _maxIndexInclusive)
							{
								_currentIndex++;
								if (container.TryGetEntry(_currentIndex, out var key, out var value))
								{
									_current = new KeyValuePair<TKey, TValue>(key, value);
									return true;
								}
							}
						}
					}
				}
				return false;
			}

			public void Reset()
			{
			}
		}

		private struct Entry
		{
			public DependentHandle depHnd;

			public int HashCode;

			public int Next;
		}

		private sealed class Container
		{
			private readonly ConditionalWeakTable<TKey, TValue> _parent;

			private int[] _buckets;

			private Entry[] _entries;

			private int _firstFreeEntry;

			private bool _invalid;

			private bool _finalized;

			private volatile object _oldKeepAlive;

			internal bool HasCapacity => _firstFreeEntry < _entries.Length;

			internal int FirstFreeEntry => _firstFreeEntry;

			internal Container(ConditionalWeakTable<TKey, TValue> parent)
			{
				_buckets = new int[8];
				for (int i = 0; i < _buckets.Length; i++)
				{
					_buckets[i] = -1;
				}
				_entries = new Entry[8];
				_parent = parent;
			}

			private Container(ConditionalWeakTable<TKey, TValue> parent, int[] buckets, Entry[] entries, int firstFreeEntry)
			{
				_parent = parent;
				_buckets = buckets;
				_entries = entries;
				_firstFreeEntry = firstFreeEntry;
			}

			internal void CreateEntryNoResize(TKey key, TValue value)
			{
				VerifyIntegrity();
				_invalid = true;
				int num = RuntimeHelpers.GetHashCode(key) & 0x7FFFFFFF;
				int num2 = _firstFreeEntry++;
				_entries[num2].HashCode = num;
				_entries[num2].depHnd = new DependentHandle(key, value);
				int num3 = num & (_buckets.Length - 1);
				_entries[num2].Next = _buckets[num3];
				Volatile.Write(ref _buckets[num3], num2);
				_invalid = false;
			}

			internal bool TryGetValueWorker(TKey key, [MaybeNullWhen(false)] out TValue value)
			{
				object value2;
				int num = FindEntry(key, out value2);
				value = Unsafe.As<TValue>(value2);
				return num != -1;
			}

			internal int FindEntry(TKey key, out object value)
			{
				int num = RuntimeHelpers.GetHashCode(key) & 0x7FFFFFFF;
				int num2 = num & (_buckets.Length - 1);
				for (int num3 = Volatile.Read(ref _buckets[num2]); num3 != -1; num3 = _entries[num3].Next)
				{
					if (_entries[num3].HashCode == num && _entries[num3].depHnd.UnsafeGetTargetAndDependent(out value) == key)
					{
						GC.KeepAlive(this);
						return num3;
					}
				}
				GC.KeepAlive(this);
				value = null;
				return -1;
			}

			internal bool TryGetEntry(int index, [NotNullWhen(true)] out TKey key, [MaybeNullWhen(false)] out TValue value)
			{
				if (index < _entries.Length)
				{
					object dependent;
					object obj = _entries[index].depHnd.UnsafeGetTargetAndDependent(out dependent);
					GC.KeepAlive(this);
					if (obj != null)
					{
						key = Unsafe.As<TKey>(obj);
						value = Unsafe.As<TValue>(dependent);
						return true;
					}
				}
				key = null;
				value = null;
				return false;
			}

			internal void RemoveAllKeys()
			{
				for (int i = 0; i < _firstFreeEntry; i++)
				{
					RemoveIndex(i);
				}
			}

			internal bool Remove(TKey key)
			{
				VerifyIntegrity();
				object value;
				int num = FindEntry(key, out value);
				if (num != -1)
				{
					RemoveIndex(num);
					return true;
				}
				return false;
			}

			private void RemoveIndex(int entryIndex)
			{
				ref Entry reference = ref _entries[entryIndex];
				Volatile.Write(ref reference.HashCode, -1);
				reference.depHnd.UnsafeSetTargetToNull();
			}

			internal void UpdateValue(int entryIndex, TValue newValue)
			{
				VerifyIntegrity();
				_invalid = true;
				_entries[entryIndex].depHnd.UnsafeSetDependent(newValue);
				_invalid = false;
			}

			internal Container Resize()
			{
				bool flag = false;
				int newSize = _buckets.Length;
				if (_parent == null || _parent._activeEnumeratorRefCount == 0)
				{
					for (int i = 0; i < _entries.Length; i++)
					{
						ref Entry reference = ref _entries[i];
						if (reference.HashCode == -1)
						{
							flag = true;
							break;
						}
						if (reference.depHnd.IsAllocated && reference.depHnd.UnsafeGetTarget() == null)
						{
							flag = true;
							break;
						}
					}
				}
				if (!flag)
				{
					newSize = _buckets.Length * 2;
				}
				return Resize(newSize);
			}

			internal Container Resize(int newSize)
			{
				int[] array = new int[newSize];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = -1;
				}
				Entry[] array2 = new Entry[newSize];
				int j = 0;
				bool flag = _parent != null && _parent._activeEnumeratorRefCount > 0;
				if (flag)
				{
					for (; j < _entries.Length; j++)
					{
						ref Entry reference = ref _entries[j];
						ref Entry reference2 = ref array2[j];
						int num = (reference2.HashCode = reference.HashCode);
						reference2.depHnd = reference.depHnd;
						int num2 = num & (array.Length - 1);
						reference2.Next = array[num2];
						array[num2] = j;
					}
				}
				else
				{
					for (int k = 0; k < _entries.Length; k++)
					{
						ref Entry reference3 = ref _entries[k];
						int hashCode = reference3.HashCode;
						DependentHandle depHnd = reference3.depHnd;
						if (hashCode != -1 && depHnd.IsAllocated)
						{
							if (depHnd.UnsafeGetTarget() != null)
							{
								ref Entry reference4 = ref array2[j];
								reference4.HashCode = hashCode;
								reference4.depHnd = depHnd;
								int num3 = hashCode & (array.Length - 1);
								reference4.Next = array[num3];
								array[num3] = j;
								j++;
							}
							else
							{
								Volatile.Write(ref reference3.HashCode, -1);
							}
						}
					}
				}
				Container container = new Container(_parent, array, array2, j);
				if (flag)
				{
					GC.SuppressFinalize(this);
				}
				_oldKeepAlive = container;
				GC.KeepAlive(this);
				return container;
			}

			private void VerifyIntegrity()
			{
				if (_invalid)
				{
					throw new InvalidOperationException(SR.InvalidOperation_CollectionCorrupted);
				}
			}

			~Container()
			{
				if (_invalid || _parent == null)
				{
					return;
				}
				if (!_finalized)
				{
					_finalized = true;
					lock (_parent._lock)
					{
						if (_parent._container == this)
						{
							_parent._container = null;
						}
					}
					GC.ReRegisterForFinalize(this);
					return;
				}
				Entry[] entries = _entries;
				_invalid = true;
				_entries = null;
				_buckets = null;
				if (entries == null)
				{
					return;
				}
				int i = 0;
				for (; i < entries.Length; i++)
				{
					if (_oldKeepAlive == null || entries[i].HashCode == -1)
					{
						entries[i].depHnd.Dispose();
					}
				}
			}
		}

		private readonly object _lock;

		private volatile Container _container;

		private int _activeEnumeratorRefCount;

		public ConditionalWeakTable()
		{
			_lock = new object();
			_container = new Container(this);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			return _container.TryGetValueWorker(key, out value);
		}

		public void Add(TKey key, TValue value)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			lock (_lock)
			{
				object value2;
				int num = _container.FindEntry(key, out value2);
				if (num != -1)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
				}
				CreateEntry(key, value);
			}
		}

		public void AddOrUpdate(TKey key, TValue value)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			lock (_lock)
			{
				object value2;
				int num = _container.FindEntry(key, out value2);
				if (num != -1)
				{
					_container.UpdateValue(num, value);
				}
				else
				{
					CreateEntry(key, value);
				}
			}
		}

		public bool Remove(TKey key)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			lock (_lock)
			{
				return _container.Remove(key);
			}
		}

		public void Clear()
		{
			lock (_lock)
			{
				if (_activeEnumeratorRefCount > 0)
				{
					_container.RemoveAllKeys();
				}
				else
				{
					_container = new Container(this);
				}
			}
		}

		public TValue GetValue(TKey key, CreateValueCallback createValueCallback)
		{
			if (createValueCallback == null)
			{
				throw new ArgumentNullException("createValueCallback");
			}
			if (!TryGetValue(key, out var value))
			{
				return GetValueLocked(key, createValueCallback);
			}
			return value;
		}

		private TValue GetValueLocked(TKey key, CreateValueCallback createValueCallback)
		{
			TValue val = createValueCallback(key);
			lock (_lock)
			{
				if (_container.TryGetValueWorker(key, out var value))
				{
					return value;
				}
				CreateEntry(key, val);
				return val;
			}
		}

		public TValue GetOrCreateValue(TKey key)
		{
			return GetValue(key, (TKey _) => Activator.CreateInstance<TValue>());
		}

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			lock (_lock)
			{
				Container container = _container;
				IEnumerator<KeyValuePair<TKey, TValue>> result;
				if (container != null && container.FirstFreeEntry != 0)
				{
					IEnumerator<KeyValuePair<TKey, TValue>> enumerator = new Enumerator(this);
					result = enumerator;
				}
				else
				{
					result = ((IEnumerable<KeyValuePair<TKey, TValue>>)Array.Empty<KeyValuePair<TKey, TValue>>()).GetEnumerator();
				}
				return result;
			}
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<KeyValuePair<TKey, TValue>>)this).GetEnumerator();
		}

		private void CreateEntry(TKey key, TValue value)
		{
			Container container = _container;
			if (!container.HasCapacity)
			{
				container = (_container = container.Resize());
			}
			container.CreateEntryNoResize(key, value);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct ConfiguredAsyncDisposable
	{
		private readonly IAsyncDisposable _source;

		private readonly bool _continueOnCapturedContext;

		internal ConfiguredAsyncDisposable(IAsyncDisposable source, bool continueOnCapturedContext)
		{
			_source = source;
			_continueOnCapturedContext = continueOnCapturedContext;
		}

		public ConfiguredValueTaskAwaitable DisposeAsync()
		{
			return _source.DisposeAsync().ConfigureAwait(_continueOnCapturedContext);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct ConfiguredCancelableAsyncEnumerable<T>
	{
		[StructLayout(LayoutKind.Auto)]
		public readonly struct Enumerator
		{
			private readonly IAsyncEnumerator<T> _enumerator;

			private readonly bool _continueOnCapturedContext;

			public T Current => _enumerator.Current;

			internal Enumerator(IAsyncEnumerator<T> enumerator, bool continueOnCapturedContext)
			{
				_enumerator = enumerator;
				_continueOnCapturedContext = continueOnCapturedContext;
			}

			public ConfiguredValueTaskAwaitable<bool> MoveNextAsync()
			{
				return _enumerator.MoveNextAsync().ConfigureAwait(_continueOnCapturedContext);
			}

			public ConfiguredValueTaskAwaitable DisposeAsync()
			{
				return _enumerator.DisposeAsync().ConfigureAwait(_continueOnCapturedContext);
			}
		}

		private readonly IAsyncEnumerable<T> _enumerable;

		private readonly CancellationToken _cancellationToken;

		private readonly bool _continueOnCapturedContext;

		internal ConfiguredCancelableAsyncEnumerable(IAsyncEnumerable<T> enumerable, bool continueOnCapturedContext, CancellationToken cancellationToken)
		{
			_enumerable = enumerable;
			_continueOnCapturedContext = continueOnCapturedContext;
			_cancellationToken = cancellationToken;
		}

		public ConfiguredCancelableAsyncEnumerable<T> ConfigureAwait(bool continueOnCapturedContext)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(_enumerable, continueOnCapturedContext, _cancellationToken);
		}

		public ConfiguredCancelableAsyncEnumerable<T> WithCancellation(CancellationToken cancellationToken)
		{
			return new ConfiguredCancelableAsyncEnumerable<T>(_enumerable, _continueOnCapturedContext, cancellationToken);
		}

		public Enumerator GetAsyncEnumerator()
		{
			return new Enumerator(_enumerable.GetAsyncEnumerator(_cancellationToken), _continueOnCapturedContext);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct ConfiguredValueTaskAwaitable
	{
		[StructLayout(LayoutKind.Auto)]
		public readonly struct ConfiguredValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion, IStateMachineBoxAwareAwaiter
		{
			private readonly ValueTask _value;

			public bool IsCompleted
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return _value.IsCompleted;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal ConfiguredValueTaskAwaiter(in ValueTask value)
			{
				_value = value;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void GetResult()
			{
				_value.ThrowIfCompletedUnsuccessfully();
			}

			public void OnCompleted(Action continuation)
			{
				object obj = _value._obj;
				if (obj is Task task)
				{
					task.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
				}
				else if (obj != null)
				{
					Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.FlowExecutionContext | (_value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));
				}
				else
				{
					Task.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
				}
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				object obj = _value._obj;
				if (obj is Task task)
				{
					task.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
				}
				else if (obj != null)
				{
					Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
				}
				else
				{
					Task.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
				}
			}

			void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
			{
				object obj = _value._obj;
				if (obj is Task task)
				{
					TaskAwaiter.UnsafeOnCompletedInternal(task, box, _value._continueOnCapturedContext);
				}
				else if (obj != null)
				{
					Unsafe.As<IValueTaskSource>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token, _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
				}
				else
				{
					TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value._continueOnCapturedContext);
				}
			}
		}

		private readonly ValueTask _value;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ConfiguredValueTaskAwaitable(in ValueTask value)
		{
			_value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ConfiguredValueTaskAwaiter GetAwaiter()
		{
			return new ConfiguredValueTaskAwaiter(in _value);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct ConfiguredValueTaskAwaitable<TResult>
	{
		[StructLayout(LayoutKind.Auto)]
		public readonly struct ConfiguredValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion, IStateMachineBoxAwareAwaiter
		{
			private readonly ValueTask<TResult> _value;

			public bool IsCompleted
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return _value.IsCompleted;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal ConfiguredValueTaskAwaiter(in ValueTask<TResult> value)
			{
				_value = value;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public TResult GetResult()
			{
				return _value.Result;
			}

			public void OnCompleted(Action continuation)
			{
				object obj = _value._obj;
				if (obj is Task<TResult> task)
				{
					task.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
				}
				else if (obj != null)
				{
					Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.FlowExecutionContext | (_value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None));
				}
				else
				{
					Task.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation);
				}
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				object obj = _value._obj;
				if (obj is Task<TResult> task)
				{
					task.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
				}
				else if (obj != null)
				{
					Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
				}
				else
				{
					Task.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);
				}
			}

			void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
			{
				object obj = _value._obj;
				if (obj is Task<TResult> task)
				{
					TaskAwaiter.UnsafeOnCompletedInternal(task, box, _value._continueOnCapturedContext);
				}
				else if (obj != null)
				{
					Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token, _value._continueOnCapturedContext ? ValueTaskSourceOnCompletedFlags.UseSchedulingContext : ValueTaskSourceOnCompletedFlags.None);
				}
				else
				{
					TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, _value._continueOnCapturedContext);
				}
			}
		}

		private readonly ValueTask<TResult> _value;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ConfiguredValueTaskAwaitable(in ValueTask<TResult> value)
		{
			_value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ConfiguredValueTaskAwaiter GetAwaiter()
		{
			return new ConfiguredValueTaskAwaiter(in _value);
		}
	}
	public static class ContractHelper
	{
		internal static event EventHandler<ContractFailedEventArgs>? InternalContractFailed;

		[DebuggerNonUserCode]
		public static string? RaiseContractFailedEvent(ContractFailureKind failureKind, string? userMessage, string? conditionText, Exception? innerException)
		{
			if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, failureKind), "failureKind");
			}
			string text = "contract failed.";
			ContractFailedEventArgs contractFailedEventArgs = null;
			string result;
			try
			{
				text = GetDisplayMessage(failureKind, userMessage, conditionText);
				EventHandler<ContractFailedEventArgs> internalContractFailed = ContractHelper.InternalContractFailed;
				if (internalContractFailed != null)
				{
					contractFailedEventArgs = new ContractFailedEventArgs(failureKind, text, conditionText, innerException);
					Delegate[] invocationList = internalContractFailed.GetInvocationList();
					for (int i = 0; i < invocationList.Length; i++)
					{
						EventHandler<ContractFailedEventArgs> eventHandler = (EventHandler<ContractFailedEventArgs>)invocationList[i];
						try
						{
							eventHandler(null, contractFailedEventArgs);
						}
						catch (Exception thrownDuringHandler)
						{
							contractFailedEventArgs.thrownDuringHandler = thrownDuringHandler;
							contractFailedEventArgs.SetUnwind();
						}
					}
					if (contractFailedEventArgs.Unwind)
					{
						if (innerException == null)
						{
							innerException = contractFailedEventArgs.thrownDuringHandler;
						}
						throw new ContractException(failureKind, text, userMessage, conditionText, innerException);
					}
				}
			}
			finally
			{
				result = ((contractFailedEventArgs == null || !contractFailedEventArgs.Handled) ? text : null);
			}
			return result;
		}

		[DebuggerNonUserCode]
		public static void TriggerFailure(ContractFailureKind kind, string? displayMessage, string? userMessage, string? conditionText, Exception? innerException)
		{
			if (string.IsNullOrEmpty(displayMessage))
			{
				displayMessage = GetDisplayMessage(kind, userMessage, conditionText);
			}
			Debug.ContractFailure(displayMessage, string.Empty, GetFailureMessage(kind, null));
		}

		private static string GetFailureMessage(ContractFailureKind failureKind, string conditionText)
		{
			bool flag = !string.IsNullOrEmpty(conditionText);
			switch (failureKind)
			{
			case ContractFailureKind.Assert:
				if (!flag)
				{
					return SR.AssertionFailed;
				}
				return SR.Format(SR.AssertionFailed_Cnd, conditionText);
			case ContractFailureKind.Assume:
				if (!flag)
				{
					return SR.AssumptionFailed;
				}
				return SR.Format(SR.AssumptionFailed_Cnd, conditionText);
			case ContractFailureKind.Precondition:
				if (!flag)
				{
					return SR.PreconditionFailed;
				}
				return SR.Format(SR.PreconditionFailed_Cnd, conditionText);
			case ContractFailureKind.Postcondition:
				if (!flag)
				{
					return SR.PostconditionFailed;
				}
				return SR.Format(SR.PostconditionFailed_Cnd, conditionText);
			case ContractFailureKind.Invariant:
				if (!flag)
				{
					return SR.InvariantFailed;
				}
				return SR.Format(SR.InvariantFailed_Cnd, conditionText);
			case ContractFailureKind.PostconditionOnException:
				if (!flag)
				{
					return SR.PostconditionOnExceptionFailed;
				}
				return SR.Format(SR.PostconditionOnExceptionFailed_Cnd, conditionText);
			default:
				Contract.Assume(condition: false, "Unreachable code");
				return SR.AssumptionFailed;
			}
		}

		private static string GetDisplayMessage(ContractFailureKind failureKind, string userMessage, string conditionText)
		{
			string text = (string.IsNullOrEmpty(conditionText) ? "" : GetFailureMessage(failureKind, conditionText));
			if (!string.IsNullOrEmpty(userMessage))
			{
				return text + "  " + userMessage;
			}
			return text;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false)]
	public sealed class CreateNewOnMetadataUpdateAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	public abstract class CustomConstantAttribute : Attribute
	{
		public abstract object? Value { get; }
	}
	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	public sealed class DateTimeConstantAttribute : CustomConstantAttribute
	{
		private readonly DateTime _date;

		public override object Value => _date;

		public DateTimeConstantAttribute(long ticks)
		{
			_date = new DateTime(ticks);
		}
	}
	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	public sealed class DecimalConstantAttribute : Attribute
	{
		private readonly decimal _dec;

		public decimal Value => _dec;

		[CLSCompliant(false)]
		public DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low)
		{
			_dec = new decimal((int)low, (int)mid, (int)hi, sign != 0, scale);
		}

		public DecimalConstantAttribute(byte scale, byte sign, int hi, int mid, int low)
		{
			_dec = new decimal(low, mid, hi, sign != 0, scale);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly)]
	public sealed class DefaultDependencyAttribute : Attribute
	{
		public LoadHint LoadHint { get; }

		public DefaultDependencyAttribute(LoadHint loadHintArgument)
		{
			LoadHint = loadHintArgument;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	public sealed class DependencyAttribute : Attribute
	{
		public string DependentAssembly { get; }

		public LoadHint LoadHint { get; }

		public DependencyAttribute(string dependentAssemblyArgument, LoadHint loadHintArgument)
		{
			DependentAssembly = dependentAssemblyArgument;
			LoadHint = loadHintArgument;
		}
	}
	[Obsolete("DisablePrivateReflectionAttribute has no effect in .NET 6.0+.", DiagnosticId = "SYSLIB0015", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	public sealed class DisablePrivateReflectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.All)]
	public class DiscardableAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class EnumeratorCancellationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
	public sealed class ExtensionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field)]
	public sealed class FixedAddressValueTypeAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field, Inherited = false)]
	public sealed class FixedBufferAttribute : Attribute
	{
		public Type ElementType { get; }

		public int Length { get; }

		public FixedBufferAttribute(Type elementType, int length)
		{
			ElementType = elementType;
			Length = length;
		}
	}
	public static class FormattableStringFactory
	{
		private sealed class ConcreteFormattableString : FormattableString
		{
			private readonly string _format;

			private readonly object[] _arguments;

			public override string Format => _format;

			public override int ArgumentCount => _arguments.Length;

			internal ConcreteFormattableString(string format, object[] arguments)
			{
				_format = format;
				_arguments = arguments;
			}

			public override object[] GetArguments()
			{
				return _arguments;
			}

			public override object GetArgument(int index)
			{
				return _arguments[index];
			}

			public override string ToString(IFormatProvider formatProvider)
			{
				return string.Format(formatProvider, _format, _arguments);
			}
		}

		public static FormattableString Create(string format, params object?[] arguments)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			if (arguments == null)
			{
				throw new ArgumentNullException("arguments");
			}
			return new ConcreteFormattableString(format, arguments);
		}
	}
	public interface IAsyncStateMachine
	{
		void MoveNext();

		void SetStateMachine(IAsyncStateMachine stateMachine);
	}
	internal interface IAsyncStateMachineBox
	{
		Action MoveNextAction { get; }

		void MoveNext();

		IAsyncStateMachine GetStateMachineObject();

		void ClearStateUponCompletion();
	}
	public interface ICastable
	{
		bool IsInstanceOfInterface(RuntimeTypeHandle interfaceType, [NotNullWhen(true)] out Exception? castError);

		RuntimeTypeHandle GetImplType(RuntimeTypeHandle interfaceType);
	}
	[AttributeUsage(AttributeTargets.Property, Inherited = true)]
	public sealed class IndexerNameAttribute : Attribute
	{
		public IndexerNameAttribute(string indexerName)
		{
		}
	}
	public interface INotifyCompletion
	{
		void OnCompleted(Action continuation);
	}
	public interface ICriticalNotifyCompletion : INotifyCompletion
	{
		void UnsafeOnCompleted(Action continuation);
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true, Inherited = false)]
	public sealed class InternalsVisibleToAttribute : Attribute
	{
		public string AssemblyName { get; }

		public bool AllInternalsVisible { get; set; } = true;


		public InternalsVisibleToAttribute(string assemblyName)
		{
			AssemblyName = assemblyName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Field, Inherited = false)]
	internal sealed class IntrinsicAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[AttributeUsage(AttributeTargets.Struct)]
	public sealed class IsByRefLikeAttribute : Attribute
	{
	}
	public static class IsConst
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[AttributeUsage(AttributeTargets.All, Inherited = false)]
	public sealed class IsReadOnlyAttribute : Attribute
	{
	}
	public static class IsVolatile
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	public sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	public sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[InterpolatedStringHandler]
	public ref struct DefaultInterpolatedStringHandler
	{
		private readonly IFormatProvider _provider;

		private char[] _arrayToReturnToPool;

		private Span<char> _chars;

		private int _pos;

		private readonly bool _hasCustomFormatter;

		internal ReadOnlySpan<char> Text => _chars.Slice(0, _pos);

		public DefaultInterpolatedStringHandler(int literalLength, int formattedCount)
		{
			_provider = null;
			_chars = (_arrayToReturnToPool = ArrayPool<char>.Shared.Rent(GetDefaultLength(literalLength, formattedCount)));
			_pos = 0;
			_hasCustomFormatter = false;
		}

		public DefaultInterpolatedStringHandler(int literalLength, int formattedCount, IFormatProvider? provider)
		{
			_provider = provider;
			_chars = (_arrayToReturnToPool = ArrayPool<char>.Shared.Rent(GetDefaultLength(literalLength, formattedCount)));
			_pos = 0;
			_hasCustomFormatter = provider != null && HasCustomFormatter(provider);
		}

		public DefaultInterpolatedStringHandler(int literalLength, int formattedCount, IFormatProvider? provider, Span<char> initialBuffer)
		{
			_provider = provider;
			_chars = initialBuffer;
			_arrayToReturnToPool = null;
			_pos = 0;
			_hasCustomFormatter = provider != null && HasCustomFormatter(provider);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetDefaultLength(int literalLength, int formattedCount)
		{
			return Math.Max(256, literalLength + formattedCount * 11);
		}

		public override string ToString()
		{
			return new string(Text);
		}

		public string ToStringAndClear()
		{
			string result = new string(Text);
			Clear();
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void Clear()
		{
			char[] arrayToReturnToPool = _arrayToReturnToPool;
			this = default(DefaultInterpolatedStringHandler);
			if (arrayToReturnToPool != null)
			{
				ArrayPool<char>.Shared.Return(arrayToReturnToPool);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLiteral(string value)
		{
			if (value.Length == 1)
			{
				Span<char> chars = _chars;
				int pos = _pos;
				if ((uint)pos < (uint)chars.Length)
				{
					chars[pos] = value[0];
					_pos = pos + 1;
				}
				else
				{
					GrowThenCopyString(value);
				}
			}
			else if (value.Length == 2)
			{
				Span<char> chars2 = _chars;
				int pos2 = _pos;
				if ((uint)pos2 < chars2.Length - 1)
				{
					Unsafe.WriteUnaligned(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(chars2), pos2)), Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref value.GetRawStringData())));
					_pos = pos2 + 2;
				}
				else
				{
					GrowThenCopyString(value);
				}
			}
			else
			{
				AppendStringDirect(value);
			}
		}

		private void AppendStringDirect(string value)
		{
			if (value.TryCopyTo(_chars.Slice(_pos)))
			{
				_pos += value.Length;
			}
			else
			{
				GrowThenCopyString(value);
			}
		}

		public void AppendFormatted<T>(T value)
		{
			if (_hasCustomFormatter)
			{
				AppendCustomFormatter(value, null);
				return;
			}
			string text;
			if (value is IFormattable)
			{
				if (value is ISpanFormattable)
				{
					int charsWritten;
					while (!((ISpanFormattable)(object)value).TryFormat(_chars.Slice(_pos), out charsWritten, default(ReadOnlySpan<char>), _provider))
					{
						Grow();
					}
					_pos += charsWritten;
					return;
				}
				text = ((IFormattable)(object)value).ToString(null, _provider);
			}
			else
			{
				text = value?.ToString();
			}
			if (text != null)
			{
				AppendStringDirect(text);
			}
		}

		public void AppendFormatted<T>(T value, string? format)
		{
			if (_hasCustomFormatter)
			{
				AppendCustomFormatter(value, format);
				return;
			}
			string text;
			if (value is IFormattable)
			{
				if (value is ISpanFormattable)
				{
					int charsWritten;
					while (!((ISpanFormattable)(object)value).TryFormat(_chars.Slice(_pos), out charsWritten, format, _provider))
					{
						Grow();
					}
					_pos += charsWritten;
					return;
				}
				text = ((IFormattable)(object)value).ToString(format, _provider);
			}
			else
			{
				text = value?.ToString();
			}
			if (text != null)
			{
				AppendStringDirect(text);
			}
		}

		public void AppendFormatted<T>(T value, int alignment)
		{
			int pos = _pos;
			AppendFormatted(value);
			if (alignment != 0)
			{
				AppendOrInsertAlignmentIfNeeded(pos, alignment);
			}
		}

		public void AppendFormatted<T>(T value, int alignment, string? format)
		{
			int pos = _pos;
			AppendFormatted(value, format);
			if (alignment != 0)
			{
				AppendOrInsertAlignmentIfNeeded(pos, alignment);
			}
		}

		public void AppendFormatted(ReadOnlySpan<char> value)
		{
			if (value.TryCopyTo(_chars.Slice(_pos)))
			{
				_pos += value.Length;
			}
			else
			{
				GrowThenCopySpan(value);
			}
		}

		public void AppendFormatted(ReadOnlySpan<char> value, int alignment = 0, string? format = null)
		{
			bool flag = false;
			if (alignment < 0)
			{
				flag = true;
				alignment = -alignment;
			}
			int num = alignment - value.Length;
			if (num <= 0)
			{
				AppendFormatted(value);
				return;
			}
			EnsureCapacityForAdditionalChars(value.Length + num);
			if (flag)
			{
				value.CopyTo(_chars.Slice(_pos));
				_pos += value.Length;
				_chars.Slice(_pos, num).Fill(' ');
				_pos += num;
			}
			else
			{
				_chars.Slice(_pos, num).Fill(' ');
				_pos += num;
				value.CopyTo(_chars.Slice(_pos));
				_pos += value.Length;
			}
		}

		public void AppendFormatted(string? value)
		{
			if (!_hasCustomFormatter && value != null && value.TryCopyTo(_chars.Slice(_pos)))
			{
				_pos += value.Length;
			}
			else
			{
				AppendFormattedSlow(value);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void AppendFormattedSlow(string value)
		{
			if (_hasCustomFormatter)
			{
				AppendCustomFormatter(value, null);
			}
			else if (value != null)
			{
				EnsureCapacityForAdditionalChars(value.Length);
				value.CopyTo(_chars.Slice(_pos));
				_pos += value.Length;
			}
		}

		public void AppendFormatted(string? value, int alignment = 0, string? format = null)
		{
			this.AppendFormatted<string>(value, alignment, format);
		}

		public void AppendFormatted(object? value, int alignment = 0, string? format = null)
		{
			this.AppendFormatted<object>(value, alignment, format);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool HasCustomFormatter(IFormatProvider provider)
		{
			if (provider.GetType() != typeof(CultureInfo))
			{
				return provider.GetFormat(typeof(ICustomFormatter)) != null;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void AppendCustomFormatter<T>(T value, string format)
		{
			ICustomFormatter customFormatter = (ICustomFormatter)_provider.GetFormat(typeof(ICustomFormatter));
			if (customFormatter != null)
			{
				string text = customFormatter.Format(format, value, _provider);
				if (text != null)
				{
					AppendStringDirect(text);
				}
			}
		}

		private void AppendOrInsertAlignmentIfNeeded(int startingPos, int alignment)
		{
			int num = _pos - startingPos;
			bool flag = false;
			if (alignment < 0)
			{
				flag = true;
				alignment = -alignment;
			}
			int num2 = alignment - num;
			if (num2 > 0)
			{
				EnsureCapacityForAdditionalChars(num2);
				if (flag)
				{
					_chars.Slice(_pos, num2).Fill(' ');
				}
				else
				{
					_chars.Slice(startingPos, num).CopyTo(_chars.Slice(startingPos + num2));
					_chars.Slice(startingPos, num2).Fill(' ');
				}
				_pos += num2;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void EnsureCapacityForAdditionalChars(int additionalChars)
		{
			if (_chars.Length - _pos < additionalChars)
			{
				Grow(additionalChars);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void GrowThenCopyString(string value)
		{
			Grow(value.Length);
			value.CopyTo(_chars.Slice(_pos));
			_pos += value.Length;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void GrowThenCopySpan(ReadOnlySpan<char> value)
		{
			Grow(value.Length);
			value.CopyTo(_chars.Slice(_pos));
			_pos += value.Length;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void Grow(int additionalChars)
		{
			GrowCore((uint)(_pos + additionalChars));
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void Grow()
		{
			GrowCore((uint)(_chars.Length + 1));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void GrowCore(uint requiredMinCapacity)
		{
			uint value = Math.Max(requiredMinCapacity, Math.Min((uint)(_chars.Length * 2), 1073741791u));
			int minimumLength = (int)Math.Clamp(value, 256u, 2147483647u);
			char[] array = ArrayPool<char>.Shared.Rent(minimumLength);
			_chars.Slice(0, _pos).CopyTo(array);
			char[] arrayToReturnToPool = _arrayToReturnToPool;
			_chars = (_arrayToReturnToPool = array);
			if (arrayToReturnToPool != null)
			{
				ArrayPool<char>.Shared.Return(arrayToReturnToPool);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
	public sealed class IteratorStateMachineAttribute : StateMachineAttribute
	{
		public IteratorStateMachineAttribute(Type stateMachineType)
			: base(stateMachineType)
		{
		}
	}
	public interface ITuple
	{
		int Length { get; }

		object? this[int index] { get; }
	}
	public enum LoadHint
	{
		Default,
		Always,
		Sometimes
	}
	public enum MethodCodeType
	{
		IL,
		Native,
		OPTIL,
		Runtime
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	public sealed class MethodImplAttribute : Attribute
	{
		public MethodCodeType MethodCodeType;

		public MethodImplOptions Value { get; }

		public MethodImplAttribute(MethodImplOptions methodImplOptions)
		{
			Value = methodImplOptions;
		}

		public MethodImplAttribute(short value)
		{
			Value = (MethodImplOptions)value;
		}

		public MethodImplAttribute()
		{
		}
	}
	[Flags]
	public enum MethodImplOptions
	{
		Unmanaged = 4,
		NoInlining = 8,
		ForwardRef = 0x10,
		Synchronized = 0x20,
		NoOptimization = 0x40,
		PreserveSig = 0x80,
		AggressiveInlining = 0x100,
		AggressiveOptimization = 0x200,
		InternalCall = 0x1000
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false)]
	public sealed class ReferenceAssemblyAttribute : Attribute
	{
		public string? Description { get; }

		public ReferenceAssemblyAttribute()
		{
		}

		public ReferenceAssemblyAttribute(string? description)
		{
			Description = description;
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public struct PoolingAsyncValueTaskMethodBuilder
	{
		private static readonly PoolingAsyncValueTaskMethodBuilder<VoidTaskResult>.StateMachineBox s_syncSuccessSentinel = PoolingAsyncValueTaskMethodBuilder<VoidTaskResult>.s_syncSuccessSentinel;

		private PoolingAsyncValueTaskMethodBuilder<VoidTaskResult>.StateMachineBox m_task;

		public ValueTask Task
		{
			get
			{
				if (m_task == s_syncSuccessSentinel)
				{
					return default(ValueTask);
				}
				PoolingAsyncValueTaskMethodBuilder<VoidTaskResult>.StateMachineBox stateMachineBox = m_task ?? (m_task = PoolingAsyncValueTaskMethodBuilder<VoidTaskResult>.CreateWeaklyTypedStateMachineBox());
				return new ValueTask(stateMachineBox, stateMachineBox.Version);
			}
		}

		public static PoolingAsyncValueTaskMethodBuilder Create()
		{
			return default(PoolingAsyncValueTaskMethodBuilder);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			AsyncMethodBuilderCore.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			AsyncMethodBuilderCore.SetStateMachine(stateMachine, null);
		}

		public void SetResult()
		{
			if (m_task == null)
			{
				m_task = s_syncSuccessSentinel;
			}
			else
			{
				m_task.SetResult(default(VoidTaskResult));
			}
		}

		public void SetException(Exception exception)
		{
			PoolingAsyncValueTaskMethodBuilder<VoidTaskResult>.SetException(exception, ref m_task);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			PoolingAsyncValueTaskMethodBuilder<VoidTaskResult>.AwaitOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			PoolingAsyncValueTaskMethodBuilder<VoidTaskResult>.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	public struct PoolingAsyncValueTaskMethodBuilder<TResult>
	{
		internal abstract class StateMachineBox : IValueTaskSource<TResult>, IValueTaskSource
		{
			protected Action _moveNextAction;

			public ExecutionContext Context;

			protected ManualResetValueTaskSourceCore<TResult> _valueTaskSource;

			public short Version => _valueTaskSource.Version;

			public void SetResult(TResult result)
			{
				_valueTaskSource.SetResult(result);
			}

			public void SetException(Exception error)
			{
				_valueTaskSource.SetException(error);
			}

			public ValueTaskSourceStatus GetStatus(short token)
			{
				return _valueTaskSource.GetStatus(token);
			}

			public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags)
			{
				_valueTaskSource.OnCompleted(continuation, state, token, flags);
			}

			TResult IValueTaskSource<TResult>.GetResult(short token)
			{
				throw NotImplemented.ByDesign;
			}

			void IValueTaskSource.GetResult(short token)
			{
				throw NotImplemented.ByDesign;
			}
		}

		private sealed class SyncSuccessSentinelStateMachineBox : StateMachineBox
		{
			public SyncSuccessSentinelStateMachineBox()
			{
				SetResult(default(TResult));
			}
		}

		private sealed class StateMachineBox<TStateMachine> : StateMachineBox, IValueTaskSource<TResult>, IValueTaskSource, IAsyncStateMachineBox, IThreadPoolWorkItem where TStateMachine : IAsyncStateMachine
		{
			private static readonly ContextCallback s_callback = ExecutionContextCallback;

			private static readonly PaddedReference[] s_perCoreCache = new PaddedReference[Environment.ProcessorCount];

			[ThreadStatic]
			private static StateMachineBox<TStateMachine> t_tlsCache;

			public TStateMachine StateMachine;

			private static ref StateMachineBox<TStateMachine> PerCoreCacheSlot
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					int num = (int)((uint)Thread.GetCurrentProcessorId() % (uint)Environment.ProcessorCount);
					return ref Unsafe.As<object, StateMachineBox<TStateMachine>>(ref s_perCoreCache[num].Object);
				}
			}

			public Action MoveNextAction => _moveNextAction ?? (_moveNextAction = MoveNext);

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal static StateMachineBox<TStateMachine> RentFromCache()
			{
				StateMachineBox<TStateMachine> stateMachineBox = t_tlsCache;
				if (stateMachineBox != null)
				{
					t_tlsCache = null;
				}
				else
				{
					ref StateMachineBox<TStateMachine> perCoreCacheSlot = ref PerCoreCacheSlot;
					if (perCoreCacheSlot == null || (stateMachineBox = Interlocked.Exchange(ref perCoreCacheSlot, null)) == null)
					{
						stateMachineBox = new StateMachineBox<TStateMachine>();
					}
				}
				return stateMachineBox;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private void ReturnToCache()
			{
				ClearStateUponCompletion();
				_valueTaskSource.Reset();
				if (t_tlsCache == null)
				{
					t_tlsCache = this;
					return;
				}
				ref StateMachineBox<TStateMachine> perCoreCacheSlot = ref PerCoreCacheSlot;
				if (perCoreCacheSlot == null)
				{
					Volatile.Write(ref perCoreCacheSlot, this);
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void ClearStateUponCompletion()
			{
				StateMachine = default(TStateMachine);
				Context = null;
			}

			private static void ExecutionContextCallback(object s)
			{
				Unsafe.As<StateMachineBox<TStateMachine>>(s).StateMachine.MoveNext();
			}

			void IThreadPoolWorkItem.Execute()
			{
				MoveNext();
			}

			public void MoveNext()
			{
				ExecutionContext context = Context;
				if (context == null)
				{
					StateMachine.MoveNext();
				}
				else
				{
					ExecutionContext.RunInternal(context, s_callback, this);
				}
			}

			TResult IValueTaskSource<TResult>.GetResult(short token)
			{
				try
				{
					return _valueTaskSource.GetResult(token);
				}
				finally
				{
					ReturnToCache();
				}
			}

			void IValueTaskSource.GetResult(short token)
			{
				try
				{
					_valueTaskSource.GetResult(token);
				}
				finally
				{
					ReturnToCache();
				}
			}

			IAsyncStateMachine IAsyncStateMachineBox.GetStateMachineObject()
			{
				return StateMachine;
			}
		}

		internal static readonly StateMachineBox s_syncSuccessSentinel = new SyncSuccessSentinelStateMachineBox();

		private StateMachineBox m_task;

		private TResult _result;

		public ValueTask<TResult> Task
		{
			get
			{
				if (m_task == s_syncSuccessSentinel)
				{
					return new ValueTask<TResult>(_result);
				}
				StateMachineBox stateMachineBox = m_task ?? (m_task = CreateWeaklyTypedStateMachineBox());
				return new ValueTask<TResult>(stateMachineBox, stateMachineBox.Version);
			}
		}

		public static PoolingAsyncValueTaskMethodBuilder<TResult> Create()
		{
			return default(PoolingAsyncValueTaskMethodBuilder<TResult>);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
		{
			AsyncMethodBuilderCore.Start(ref stateMachine);
		}

		public void SetStateMachine(IAsyncStateMachine stateMachine)
		{
			AsyncMethodBuilderCore.SetStateMachine(stateMachine, null);
		}

		public void SetResult(TResult result)
		{
			if (m_task == null)
			{
				_result = result;
				m_task = s_syncSuccessSentinel;
			}
			else
			{
				m_task.SetResult(result);
			}
		}

		public void SetException(Exception exception)
		{
			SetException(exception, ref m_task);
		}

		internal static void SetException(Exception exception, [NotNull] ref StateMachineBox boxFieldRef)
		{
			if (exception == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.exception);
			}
			(boxFieldRef ?? (boxFieldRef = CreateWeaklyTypedStateMachineBox())).SetException(exception);
		}

		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AwaitOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		internal static void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine, ref StateMachineBox box) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			try
			{
				awaiter.OnCompleted(GetStateMachineBox(ref stateMachine, ref box).MoveNextAction);
			}
			catch (Exception exception)
			{
				System.Threading.Tasks.Task.ThrowAsync(exception, null);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine, ref m_task);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine, [NotNull] ref StateMachineBox boxRef) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
		{
			IAsyncStateMachineBox stateMachineBox = GetStateMachineBox(ref stateMachine, ref boxRef);
			AsyncTaskMethodBuilder<VoidTaskResult>.AwaitUnsafeOnCompleted(ref awaiter, stateMachineBox);
		}

		private static IAsyncStateMachineBox GetStateMachineBox<TStateMachine>(ref TStateMachine stateMachine, [NotNull] ref StateMachineBox boxFieldRef) where TStateMachine : IAsyncStateMachine
		{
			ExecutionContext executionContext = ExecutionContext.Capture();
			if (boxFieldRef is StateMachineBox<TStateMachine> stateMachineBox)
			{
				if (stateMachineBox.Context != executionContext)
				{
					stateMachineBox.Context = executionContext;
				}
				return stateMachineBox;
			}
			if (boxFieldRef is StateMachineBox<IAsyncStateMachine> stateMachineBox2)
			{
				if (stateMachineBox2.StateMachine == null)
				{
					Debugger.NotifyOfCrossThreadDependency();
					stateMachineBox2.StateMachine = stateMachine;
				}
				stateMachineBox2.Context = executionContext;
				return stateMachineBox2;
			}
			Debugger.NotifyOfCrossThreadDependency();
			StateMachineBox<TStateMachine> stateMachineBox3 = (StateMachineBox<TStateMachine>)(boxFieldRef = StateMachineBox<TStateMachine>.RentFromCache());
			stateMachineBox3.StateMachine = stateMachine;
			stateMachineBox3.Context = executionContext;
			return stateMachineBox3;
		}

		internal static StateMachineBox CreateWeaklyTypedStateMachineBox()
		{
			return new StateMachineBox<IAsyncStateMachine>();
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public sealed class PreserveBaseOverridesAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = false)]
	public sealed class RuntimeCompatibilityAttribute : Attribute
	{
		public bool WrapNonExceptionThrows { get; set; }
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class RuntimeWrappedException : Exception
	{
		private object _wrappedException;

		public object WrappedException => _wrappedException;

		public RuntimeWrappedException(object thrownObject)
			: base(SR.RuntimeWrappedException)
		{
			base.HResult = -2146233026;
			_wrappedException = thrownObject;
		}

		private RuntimeWrappedException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_wrappedException = info.GetValue("WrappedException", typeof(object));
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("WrappedException", _wrappedException, typeof(object));
		}
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	public sealed class SkipLocalsInitAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event)]
	public sealed class SpecialNameAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
	public class StateMachineAttribute : Attribute
	{
		public Type StateMachineType { get; }

		public StateMachineAttribute(Type stateMachineType)
		{
			StateMachineType = stateMachineType;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class StringFreezingAttribute : Attribute
	{
	}
	public class StrongBox<T> : IStrongBox
	{
		[MaybeNull]
		public T Value;

		object? IStrongBox.Value
		{
			get
			{
				return Value;
			}
			set
			{
				Value = (T)value;
			}
		}

		public StrongBox()
		{
		}

		public StrongBox(T value)
		{
			Value = value;
		}
	}
	public interface IStrongBox
	{
		object? Value { get; set; }
	}
	[Obsolete("SuppressIldasmAttribute has no effect in .NET 6.0+.", DiagnosticId = "SYSLIB0025", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module)]
	public sealed class SuppressIldasmAttribute : Attribute
	{
	}
	[Serializable]
	[TypeForwardedFrom("System.Runtime.Extensions, Version=4.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
	public sealed class SwitchExpressionException : InvalidOperationException
	{
		public object? UnmatchedValue { get; }

		public override string Message
		{
			get
			{
				if (UnmatchedValue == null)
				{
					return base.Message;
				}
				string text = SR.Format(SR.SwitchExpressionException_UnmatchedValue, UnmatchedValue);
				return base.Message + Environment.NewLine + text;
			}
		}

		public SwitchExpressionException()
			: base(SR.Arg_SwitchExpressionException)
		{
		}

		public SwitchExpressionException(Exception? innerException)
			: base(SR.Arg_SwitchExpressionException, innerException)
		{
		}

		public SwitchExpressionException(object? unmatchedValue)
			: this()
		{
			UnmatchedValue = unmatchedValue;
		}

		private SwitchExpressionException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			UnmatchedValue = info.GetValue("UnmatchedValue", typeof(object));
		}

		public SwitchExpressionException(string? message)
			: base(message)
		{
		}

		public SwitchExpressionException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("UnmatchedValue", UnmatchedValue, typeof(object));
		}
	}
	public readonly struct TaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion, ITaskAwaiter
	{
		internal readonly Task m_task;

		public bool IsCompleted => m_task.IsCompleted;

		internal TaskAwaiter(Task task)
		{
			m_task = task;
		}

		public void OnCompleted(Action continuation)
		{
			OnCompletedInternal(m_task, continuation, continueOnCapturedContext: true, flowExecutionContext: true);
		}

		public void UnsafeOnCompleted(Action continuation)
		{
			OnCompletedInternal(m_task, continuation, continueOnCapturedContext: true, flowExecutionContext: false);
		}

		[StackTraceHidden]
		public void GetResult()
		{
			ValidateEnd(m_task);
		}

		[StackTraceHidden]
		internal static void ValidateEnd(Task task)
		{
			if (task.IsWaitNotificationEnabledOrNotRanToCompletion)
			{
				HandleNonSuccessAndDebuggerNotification(task);
			}
		}

		[StackTraceHidden]
		private static void HandleNonSuccessAndDebuggerNotification(Task task)
		{
			if (!task.IsCompleted)
			{
				bool flag = task.InternalWait(-1, default(CancellationToken));
			}
			task.NotifyDebuggerOfWaitCompletionIfNecessary();
			if (!task.IsCompletedSuccessfully)
			{
				ThrowForNonSuccess(task);
			}
		}

		[StackTraceHidden]
		private static void ThrowForNonSuccess(Task task)
		{
			switch (task.Status)
			{
			case TaskStatus.Canceled:
				task.GetCancellationExceptionDispatchInfo()?.Throw();
				throw new TaskCanceledException(task);
			case TaskStatus.Faulted:
			{
				List<ExceptionDispatchInfo> exceptionDispatchInfos = task.GetExceptionDispatchInfos();
				if (exceptionDispatchInfos.Count > 0)
				{
					exceptionDispatchInfos[0].Throw();
					break;
				}
				throw task.Exception;
			}
			}
		}

		internal static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext, bool flowExecutionContext)
		{
			if (continuation == null)
			{
				throw new ArgumentNullException("continuation");
			}
			if (TplEventSource.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
			{
				continuation = OutputWaitEtwEvents(task, continuation);
			}
			task.SetContinuationForAwait(continuation, continueOnCapturedContext, flowExecutionContext);
		}

		internal static void UnsafeOnCompletedInternal(Task task, IAsyncStateMachineBox stateMachineBox, bool continueOnCapturedContext)
		{
			if (TplEventSource.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
			{
				task.SetContinuationForAwait(OutputWaitEtwEvents(task, stateMachineBox.MoveNextAction), continueOnCapturedContext, flowExecutionContext: false);
			}
			else
			{
				task.UnsafeSetContinuationForAwait(stateMachineBox, continueOnCapturedContext);
			}
		}

		private static Action OutputWaitEtwEvents(Task task, Action continuation)
		{
			if (Task.s_asyncDebuggingEnabled)
			{
				Task.AddToActiveTasks(task);
			}
			TplEventSource log = TplEventSource.Log;
			if (log.IsEnabled())
			{
				Task internalCurrent = Task.InternalCurrent;
				Task task2 = AsyncMethodBuilderCore.TryGetContinuationTask(continuation);
				log.TaskWaitBegin(internalCurrent?.m_taskScheduler.Id ?? TaskScheduler.Default.Id, internalCurrent?.Id ?? 0, task.Id, TplEventSource.TaskWaitBehavior.Asynchronous, task2?.Id ?? 0);
			}
			return AsyncMethodBuilderCore.CreateContinuationWrapper(continuation, delegate(Action innerContinuation, Task innerTask)
			{
				if (Task.s_asyncDebuggingEnabled)
				{
					Task.RemoveFromActiveTasks(innerTask);
				}
				TplEventSource log2 = TplEventSource.Log;
				Guid oldActivityThatWillContinue = default(Guid);
				bool flag = log2.IsEnabled();
				if (flag)
				{
					Task internalCurrent2 = Task.InternalCurrent;
					log2.TaskWaitEnd(internalCurrent2?.m_taskScheduler.Id ?? TaskScheduler.Default.Id, internalCurrent2?.Id ?? 0, innerTask.Id);
					if (log2.TasksSetActivityIds && (innerTask.Options & (TaskCreationOptions)1024) != 0)
					{
						EventSource.SetCurrentThreadActivityId(TplEventSource.CreateGuidForTaskID(innerTask.Id), out oldActivityThatWillContinue);
					}
				}
				innerContinuation();
				if (flag)
				{
					log2.TaskWaitContinuationComplete(innerTask.Id);
					if (log2.TasksSetActivityIds && (innerTask.Options & (TaskCreationOptions)1024) != 0)
					{
						EventSource.SetCurrentThreadActivityId(oldActivityThatWillContinue);
					}
				}
			}, task);
		}
	}
	public readonly struct TaskAwaiter<TResult> : ICriticalNotifyCompletion, INotifyCompletion, ITaskAwaiter
	{
		private readonly Task<TResult> m_task;

		public bool IsCompleted => m_task.IsCompleted;

		internal TaskAwaiter(Task<TResult> task)
		{
			m_task = task;
		}

		public void OnCompleted(Action continuation)
		{
			TaskAwaiter.OnCompletedInternal(m_task, continuation, continueOnCapturedContext: true, flowExecutionContext: true);
		}

		public void UnsafeOnCompleted(Action continuation)
		{
			TaskAwaiter.OnCompletedInternal(m_task, continuation, continueOnCapturedContext: true, flowExecutionContext: false);
		}

		[StackTraceHidden]
		public TResult GetResult()
		{
			TaskAwaiter.ValidateEnd(m_task);
			return m_task.ResultOnSuccess;
		}
	}
	internal interface ITaskAwaiter
	{
	}
	internal interface IConfiguredTaskAwaiter
	{
	}
	public readonly struct ConfiguredTaskAwaitable
	{
		public readonly struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion, IConfiguredTaskAwaiter
		{
			internal readonly Task m_task;

			internal readonly bool m_continueOnCapturedContext;

			public bool IsCompleted => m_task.IsCompleted;

			internal ConfiguredTaskAwaiter(Task task, bool continueOnCapturedContext)
			{
				m_task = task;
				m_continueOnCapturedContext = continueOnCapturedContext;
			}

			public void OnCompleted(Action continuation)
			{
				TaskAwaiter.OnCompletedInternal(m_task, continuation, m_continueOnCapturedContext, flowExecutionContext: true);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				TaskAwaiter.OnCompletedInternal(m_task, continuation, m_continueOnCapturedContext, flowExecutionContext: false);
			}

			[StackTraceHidden]
			public void GetResult()
			{
				TaskAwaiter.ValidateEnd(m_task);
			}
		}

		private readonly ConfiguredTaskAwaiter m_configuredTaskAwaiter;

		internal ConfiguredTaskAwaitable(Task task, bool continueOnCapturedContext)
		{
			m_configuredTaskAwaiter = new ConfiguredTaskAwaiter(task, continueOnCapturedContext);
		}

		public ConfiguredTaskAwaiter GetAwaiter()
		{
			return m_configuredTaskAwaiter;
		}
	}
	public readonly struct ConfiguredTaskAwaitable<TResult>
	{
		public readonly struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion, IConfiguredTaskAwaiter
		{
			private readonly Task<TResult> m_task;

			private readonly bool m_continueOnCapturedContext;

			public bool IsCompleted => m_task.IsCompleted;

			internal ConfiguredTaskAwaiter(Task<TResult> task, bool continueOnCapturedContext)
			{
				m_task = task;
				m_continueOnCapturedContext = continueOnCapturedContext;
			}

			public void OnCompleted(Action continuation)
			{
				TaskAwaiter.OnCompletedInternal(m_task, continuation, m_continueOnCapturedContext, flowExecutionContext: true);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				TaskAwaiter.OnCompletedInternal(m_task, continuation, m_continueOnCapturedContext, flowExecutionContext: false);
			}

			[StackTraceHidden]
			public TResult GetResult()
			{
				TaskAwaiter.ValidateEnd(m_task);
				return m_task.ResultOnSuccess;
			}
		}

		private readonly ConfiguredTaskAwaiter m_configuredTaskAwaiter;

		internal ConfiguredTaskAwaitable(Task<TResult> task, bool continueOnCapturedContext)
		{
			m_configuredTaskAwaiter = new ConfiguredTaskAwaiter(task, continueOnCapturedContext);
		}

		public ConfiguredTaskAwaitable<TResult>.ConfiguredTaskAwaiter GetAwaiter()
		{
			return m_configuredTaskAwaiter;
		}
	}
	[CLSCompliant(false)]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
	public sealed class TupleElementNamesAttribute : Attribute
	{
		private readonly string[] _transformNames;

		public IList<string?> TransformNames => _transformNames;

		public TupleElementNamesAttribute(string?[] transformNames)
		{
			if (transformNames == null)
			{
				throw new ArgumentNullException("transformNames");
			}
			_transformNames = transformNames;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false, AllowMultiple = false)]
	public sealed class TypeForwardedFromAttribute : Attribute
	{
		public string AssemblyFullName { get; }

		public TypeForwardedFromAttribute(string assemblyFullName)
		{
			if (string.IsNullOrEmpty(assemblyFullName))
			{
				throw new ArgumentNullException("assemblyFullName");
			}
			AssemblyFullName = assemblyFullName;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true, Inherited = false)]
	public sealed class TypeForwardedToAttribute : Attribute
	{
		public Type Destination { get; }

		public TypeForwardedToAttribute(Type destination)
		{
			Destination = destination;
		}
	}
	[AttributeUsage(AttributeTargets.Struct)]
	public sealed class UnsafeValueTypeAttribute : Attribute
	{
	}
	public readonly struct ValueTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion, IStateMachineBoxAwareAwaiter
	{
		internal static readonly Action<object> s_invokeActionDelegate = delegate(object state)
		{
			if (!(state is Action action))
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.state);
			}
			else
			{
				action();
			}
		};

		private readonly ValueTask _value;

		public bool IsCompleted
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _value.IsCompleted;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ValueTaskAwaiter(in ValueTask value)
		{
			_value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void GetResult()
		{
			_value.ThrowIfCompletedUnsuccessfully();
		}

		public void OnCompleted(Action continuation)
		{
			object obj = _value._obj;
			if (obj is Task task)
			{
				task.GetAwaiter().OnCompleted(continuation);
			}
			else if (obj != null)
			{
				Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext | ValueTaskSourceOnCompletedFlags.FlowExecutionContext);
			}
			else
			{
				Task.CompletedTask.GetAwaiter().OnCompleted(continuation);
			}
		}

		public void UnsafeOnCompleted(Action continuation)
		{
			object obj = _value._obj;
			if (obj is Task task)
			{
				task.GetAwaiter().UnsafeOnCompleted(continuation);
			}
			else if (obj != null)
			{
				Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
			}
			else
			{
				Task.CompletedTask.GetAwaiter().UnsafeOnCompleted(continuation);
			}
		}

		void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
		{
			object obj = _value._obj;
			if (obj is Task task)
			{
				TaskAwaiter.UnsafeOnCompletedInternal(task, box, continueOnCapturedContext: true);
			}
			else if (obj != null)
			{
				Unsafe.As<IValueTaskSource>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
			}
			else
			{
				TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, continueOnCapturedContext: true);
			}
		}
	}
	public readonly struct ValueTaskAwaiter<TResult> : ICriticalNotifyCompletion, INotifyCompletion, IStateMachineBoxAwareAwaiter
	{
		private readonly ValueTask<TResult> _value;

		public bool IsCompleted
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _value.IsCompleted;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ValueTaskAwaiter(in ValueTask<TResult> value)
		{
			_value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public TResult GetResult()
		{
			return _value.Result;
		}

		public void OnCompleted(Action continuation)
		{
			object obj = _value._obj;
			if (obj is Task<TResult> task)
			{
				task.GetAwaiter().OnCompleted(continuation);
			}
			else if (obj != null)
			{
				Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext | ValueTaskSourceOnCompletedFlags.FlowExecutionContext);
			}
			else
			{
				Task.CompletedTask.GetAwaiter().OnCompleted(continuation);
			}
		}

		public void UnsafeOnCompleted(Action continuation)
		{
			object obj = _value._obj;
			if (obj is Task<TResult> task)
			{
				task.GetAwaiter().UnsafeOnCompleted(continuation);
			}
			else if (obj != null)
			{
				Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
			}
			else
			{
				Task.CompletedTask.GetAwaiter().UnsafeOnCompleted(continuation);
			}
		}

		void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
		{
			object obj = _value._obj;
			if (obj is Task<TResult> task)
			{
				TaskAwaiter.UnsafeOnCompletedInternal(task, box, continueOnCapturedContext: true);
			}
			else if (obj != null)
			{
				Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
			}
			else
			{
				TaskAwaiter.UnsafeOnCompletedInternal(Task.CompletedTask, box, continueOnCapturedContext: true);
			}
		}
	}
	internal interface IStateMachineBoxAwareAwaiter
	{
		void AwaitUnsafeOnCompleted(IAsyncStateMachineBox box);
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public readonly struct YieldAwaitable
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public readonly struct YieldAwaiter : ICriticalNotifyCompletion, INotifyCompletion, IStateMachineBoxAwareAwaiter
		{
			private static readonly WaitCallback s_waitCallbackRunAction = RunAction;

			private static readonly SendOrPostCallback s_sendOrPostCallbackRunAction = RunAction;

			public bool IsCompleted => false;

			public void OnCompleted(Action continuation)
			{
				QueueContinuation(continuation, flowContext: true);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				QueueContinuation(continuation, flowContext: false);
			}

			private static void QueueContinuation(Action continuation, bool flowContext)
			{
				if (continuation == null)
				{
					throw new ArgumentNullException("continuation");
				}
				if (TplEventSource.Log.IsEnabled())
				{
					continuation = OutputCorrelationEtwEvent(continuation);
				}
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && current.GetType() != typeof(SynchronizationContext))
				{
					current.Post(s_sendOrPostCallbackRunAction, continuation);
					return;
				}
				TaskScheduler current2 = TaskScheduler.Current;
				if (current2 == TaskScheduler.Default)
				{
					if (flowContext)
					{
						ThreadPool.QueueUserWorkItem(s_waitCallbackRunAction, continuation);
					}
					else
					{
						ThreadPool.UnsafeQueueUserWorkItem(s_waitCallbackRunAction, continuation);
					}
				}
				else
				{
					Task.Factory.StartNew(continuation, default(CancellationToken), TaskCreationOptions.PreferFairness, current2);
				}
			}

			void IStateMachineBoxAwareAwaiter.AwaitUnsafeOnCompleted(IAsyncStateMachineBox box)
			{
				if (TplEventSource.Log.IsEnabled())
				{
					QueueContinuation(box.MoveNextAction, flowContext: false);
					return;
				}
				SynchronizationContext current = SynchronizationContext.Current;
				if (current != null && current.GetType() != typeof(SynchronizationContext))
				{
					current.Post(delegate(object s)
					{
						((IAsyncStateMachineBox)s).MoveNext();
					}, box);
					return;
				}
				TaskScheduler current2 = TaskScheduler.Current;
				if (current2 == TaskScheduler.Default)
				{
					ThreadPool.UnsafeQueueUserWorkItemInternal(box, preferLocal: false);
					return;
				}
				Task.Factory.StartNew(delegate(object s)
				{
					((IAsyncStateMachineBox)s).MoveNext();
				}, box, default(CancellationToken), TaskCreationOptions.PreferFairness, current2);
			}

			private static Action OutputCorrelationEtwEvent(Action continuation)
			{
				int num = Task.NewId();
				Task internalCurrent = Task.InternalCurrent;
				TplEventSource.Log.AwaitTaskContinuationScheduled(TaskScheduler.Current.Id, internalCurrent?.Id ?? 0, num);
				return AsyncMethodBuilderCore.CreateContinuationWrapper(continuation, delegate(Action innerContinuation, Task continuationIdTask)
				{
					TplEventSource log = TplEventSource.Log;
					log.TaskWaitContinuationStarted(((Task<int>)continuationIdTask).Result);
					Guid oldActivityThatWillContinue = default(Guid);
					if (log.TasksSetActivityIds)
					{
						EventSource.SetCurrentThreadActivityId(TplEventSource.CreateGuidForTaskID(((Task<int>)continuationIdTask).Result), out oldActivityThatWillContinue);
					}
					innerContinuation();
					if (log.TasksSetActivityIds)
					{
						EventSource.SetCurrentThreadActivityId(oldActivityThatWillContinue);
					}
					log.TaskWaitContinuationComplete(((Task<int>)continuationIdTask).Result);
				}, Task.FromResult(num));
			}

			private static void RunAction(object state)
			{
				((Action)state)();
			}

			public void GetResult()
			{
			}
		}

		public YieldAwaiter GetAwaiter()
		{
			return default(YieldAwaiter);
		}
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	public static class IsExternalInit
	{
	}
	internal ref struct StringHandleOnStack
	{
		private unsafe void* _ptr;

		internal unsafe StringHandleOnStack(ref string s)
		{
			_ptr = Unsafe.AsPointer(ref s);
		}
	}
	internal ref struct ObjectHandleOnStack
	{
		private unsafe void* _ptr;

		private unsafe ObjectHandleOnStack(void* pObject)
		{
			_ptr = pObject;
		}

		internal unsafe static ObjectHandleOnStack Create<T>(ref T o) where T : class
		{
			return new ObjectHandleOnStack(Unsafe.AsPointer(ref o));
		}
	}
	internal ref struct StackCrawlMarkHandle
	{
		private unsafe void* _ptr;

		internal unsafe StackCrawlMarkHandle(ref StackCrawlMark stackMark)
		{
			_ptr = Unsafe.AsPointer(ref stackMark);
		}
	}
	internal ref struct QCallModule
	{
		private unsafe void* _ptr;

		private IntPtr _module;

		internal unsafe QCallModule(ref RuntimeModule module)
		{
			_ptr = Unsafe.AsPointer(ref module);
			_module = module.GetUnderlyingNativeHandle();
		}

		internal unsafe QCallModule(ref ModuleBuilder module)
		{
			_ptr = Unsafe.AsPointer(ref module);
			_module = module.InternalModule.GetUnderlyingNativeHandle();
		}
	}
	internal ref struct QCallAssembly
	{
		private unsafe void* _ptr;

		private IntPtr _assembly;

		internal unsafe QCallAssembly(ref RuntimeAssembly assembly)
		{
			_ptr = Unsafe.AsPointer(ref assembly);
			_assembly = assembly.GetUnderlyingNativeHandle();
		}
	}
	internal ref struct QCallTypeHandle
	{
		private unsafe void* _ptr;

		private IntPtr _handle;

		internal unsafe QCallTypeHandle(ref RuntimeType type)
		{
			_ptr = Unsafe.AsPointer(ref type);
			if (type != null)
			{
				_handle = type.GetUnderlyingNativeHandle();
			}
			else
			{
				_handle = IntPtr.Zero;
			}
		}

		internal unsafe QCallTypeHandle(ref RuntimeTypeHandle rth)
		{
			_ptr = Unsafe.AsPointer(ref rth);
			_handle = rth.Value;
		}
	}
}
namespace System.Resources
{
	internal sealed class ManifestBasedResourceGroveler : IResourceGroveler
	{
		private readonly ResourceManager.ResourceManagerMediator _mediator;

		private static Assembly InternalGetSatelliteAssembly(Assembly mainAssembly, CultureInfo culture, Version version)
		{
			return ((RuntimeAssembly)mainAssembly).InternalGetSatelliteAssembly(culture, version, throwOnFileNotFound: false);
		}

		public ManifestBasedResourceGroveler(ResourceManager.ResourceManagerMediator mediator)
		{
			_mediator = mediator;
		}

		public ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<string, ResourceSet> localResourceSets, bool tryParents, bool createIfNotExists)
		{
			ResourceSet value = null;
			Stream stream = null;
			CultureInfo cultureInfo = UltimateFallbackFixup(culture);
			Assembly assembly;
			if (cultureInfo.HasInvariantCultureName && _mediator.FallbackLoc == UltimateResourceFallbackLocation.MainAssembly)
			{
				assembly = _mediator.MainAssembly;
			}
			else
			{
				assembly = GetSatelliteAssembly(cultureInfo);
				if (assembly == null && culture.HasInvariantCultureName && _mediator.FallbackLoc == UltimateResourceFallbackLocation.Satellite)
				{
					HandleSatelliteMissing();
				}
			}
			string resourceFileName = _mediator.GetResourceFileName(cultureInfo);
			if (assembly != null)
			{
				lock (localResourceSets)
				{
					localResourceSets.TryGetValue(culture.Name, out value);
				}
				stream = GetManifestResourceStream(assembly, resourceFileName);
			}
			if (createIfNotExists && stream != null && value == null)
			{
				value = CreateResourceSet(stream, assembly);
			}
			else if (stream == null && tryParents && culture.HasInvariantCultureName)
			{
				HandleResourceStreamMissing(resourceFileName);
			}
			return value;
		}

		private CultureInfo UltimateFallbackFixup(CultureInfo lookForCulture)
		{
			CultureInfo result = lookForCulture;
			if (lookForCulture.Name == _mediator.NeutralResourcesCulture.Name && _mediator.FallbackLoc == UltimateResourceFallbackLocation.MainAssembly)
			{
				result = CultureInfo.InvariantCulture;
			}
			else if (lookForCulture.HasInvariantCultureName && _mediator.FallbackLoc == UltimateResourceFallbackLocation.Satellite)
			{
				result = _mediator.NeutralResourcesCulture;
			}
			return result;
		}

		internal static CultureInfo GetNeutralResourcesLanguage(Assembly a, out UltimateResourceFallbackLocation fallbackLocation)
		{
			NeutralResourcesLanguageAttribute customAttribute = a.GetCustomAttribute<NeutralResourcesLanguageAttribute>();
			if (customAttribute == null || (GlobalizationMode.Invariant && GlobalizationMode.PredefinedCulturesOnly))
			{
				fallbackLocation = UltimateResourceFallbackLocation.MainAssembly;
				return CultureInfo.InvariantCulture;
			}
			fallbackLocation = customAttribute.Location;
			if (fallbackLocation < UltimateResourceFallbackLocation.MainAssembly || fallbackLocation > UltimateResourceFallbackLocation.Satellite)
			{
				throw new ArgumentException(SR.Format(SR.Arg_InvalidNeutralResourcesLanguage_FallbackLoc, fallbackLocation));
			}
			try
			{
				return CultureInfo.GetCultureInfo(customAttribute.CultureName);
			}
			catch (ArgumentException innerException)
			{
				if (a == typeof(object).Assembly)
				{
					return CultureInfo.InvariantCulture;
				}
				throw new ArgumentException(SR.Format(SR.Arg_InvalidNeutralResourcesLanguage_Asm_Culture, a, customAttribute.CultureName), innerException);
			}
		}

		internal ResourceSet CreateResourceSet(Stream store, Assembly assembly)
		{
			if (store.CanSeek && store.Length > 4)
			{
				long position = store.Position;
				BinaryReader binaryReader = new BinaryReader(store);
				int num = binaryReader.ReadInt32();
				if (num == ResourceManager.MagicNumber)
				{
					int num2 = binaryReader.ReadInt32();
					string text = null;
					string text2 = null;
					if (num2 == ResourceManager.HeaderVersionNumber)
					{
						binaryReader.ReadInt32();
						text = binaryReader.ReadString();
						text2 = binaryReader.ReadString();
					}
					else
					{
						if (num2 <= ResourceManager.HeaderVersionNumber)
						{
							throw new NotSupportedException(SR.Format(SR.NotSupported_ObsoleteResourcesFile, _mediator.MainAssembly.GetName().Name));
						}
						int num3 = binaryReader.ReadInt32();
						long offset = binaryReader.BaseStream.Position + num3;
						text = binaryReader.ReadString();
						text2 = binaryReader.ReadString();
						binaryReader.BaseStream.Seek(offset, SeekOrigin.Begin);
					}
					store.Position = position;
					if (CanUseDefaultResourceClasses(text, text2))
					{
						return new RuntimeResourceSet(store, permitDeserialization: true);
					}
					if (ResourceReader.AllowCustomResourceTypes)
					{
						return InternalGetResourceSetFromSerializedData(store, text, text2, _mediator);
					}
					throw new NotSupportedException(SR.ResourceManager_ReflectionNotAllowed);
				}
				store.Position = position;
			}
			if (_mediator.UserResourceSet == null)
			{
				return new RuntimeResourceSet(store, permitDeserialization: true);
			}
			object[] args = new object[2] { store, assembly };
			try
			{
				try
				{
					return (ResourceSet)Activator.CreateInstance(_mediator.UserResourceSet, args);
				}
				catch (MissingMethodException)
				{
				}
				return (ResourceSet)Activator.CreateInstance(args: new object[1] { store }, type: _mediator.UserResourceSet);
			}
			catch (MissingMethodException innerException)
			{
				throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResMgrBadResSet_Type, _mediator.UserResourceSet.AssemblyQualifiedName), innerException);
			}
		}

		[RequiresUnreferencedCode("The CustomResourceTypesSupport feature switch has been enabled for this app which is being trimmed. Custom readers as well as custom objects on the resources file are not observable by the trimmer and so required assemblies, types and members may be removed.")]
		private static ResourceSet InternalGetResourceSetFromSerializedData(Stream store, string readerTypeName, string resSetTypeName, ResourceManager.ResourceManagerMediator mediator)
		{
			IResourceReader resourceReader;
			if (ResourceManager.IsDefaultType(readerTypeName, "System.Resources.ResourceReader"))
			{
				resourceReader = new ResourceReader(store, new Dictionary<string, ResourceLocator>(FastResourceComparer.Default), permitDeserialization: true);
			}
			else
			{
				Type type = Type.GetType(readerTypeName, throwOnError: true);
				resourceReader = (IResourceReader)Activator.CreateInstance(type, store);
			}
			object[] args = new object[1] { resourceReader };
			Type type2 = mediator.UserResourceSet;
			if (type2 == null)
			{
				type2 = Type.GetType(resSetTypeName, throwOnError: true, ignoreCase: false);
			}
			return (ResourceSet)Activator.CreateInstance(type2, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance, null, args, null, null);
		}

		private Stream GetManifestResourceStream(Assembly satellite, string fileName)
		{
			return satellite.GetManifestResourceStream(_mediator.LocationInfo, fileName) ?? CaseInsensitiveManifestResourceStreamLookup(satellite, fileName);
		}

		private Stream CaseInsensitiveManifestResourceStreamLookup(Assembly satellite, string name)
		{
			string text = _mediator.LocationInfo?.Namespace;
			char ptr = Type.Delimiter;
			string text2 = ((text != null && name != null) ? string.Concat(text, new ReadOnlySpan<char>(ref ptr, 1), name) : (text + name));
			string text3 = null;
			string[] manifestResourceNames = satellite.GetManifestResourceNames();
			foreach (string text4 in manifestResourceNames)
			{
				if (string.Equals(text4, text2, StringComparison.InvariantCultureIgnoreCase))
				{
					if (text3 != null)
					{
						throw new MissingManifestResourceException(SR.Format(SR.MissingManifestResource_MultipleBlobs, text2, satellite.ToString()));
					}
					text3 = text4;
				}
			}
			if (text3 == null)
			{
				return null;
			}
			return satellite.GetManifestResourceStream(text3);
		}

		private Assembly GetSatelliteAssembly(CultureInfo lookForCulture)
		{
			if (!_mediator.LookedForSatelliteContractVersion)
			{
				_mediator.SatelliteContractVersion = ResourceManager.ResourceManagerMediator.ObtainSatelliteContractVersion(_mediator.MainAssembly);
				_mediator.LookedForSatelliteContractVersion = true;
			}
			Assembly result = null;
			try
			{
				result = InternalGetSatelliteAssembly(_mediator.MainAssembly, lookForCulture, _mediator.SatelliteContractVersion);
			}
			catch (FileLoadException)
			{
			}
			catch (BadImageFormatException)
			{
			}
			return result;
		}

		private bool CanUseDefaultResourceClasses(string readerTypeName, string resSetTypeName)
		{
			if (_mediator.UserResourceSet != null)
			{
				return false;
			}
			if (readerTypeName != null && !ResourceManager.IsDefaultType(readerTypeName, "System.Resources.ResourceReader"))
			{
				return false;
			}
			if (resSetTypeName != null && !ResourceManager.IsDefaultType(resSetTypeName, "System.Resources.RuntimeResourceSet"))
			{
				return false;
			}
			return true;
		}

		private void HandleSatelliteMissing()
		{
			AssemblyName name = _mediator.MainAssembly.GetName();
			string p = AssemblyNameFormatter.ComputeDisplayName(name.Name + ".resources.dll", _mediator.SatelliteContractVersion, null, name.GetPublicKeyToken());
			string text = _mediator.NeutralResourcesCulture.Name;
			if (text.Length == 0)
			{
				text = "<invariant>";
			}
			throw new MissingSatelliteAssemblyException(SR.Format(SR.MissingSatelliteAssembly_Culture_Name, _mediator.NeutralResourcesCulture, p), text);
		}

		private static string GetManifestResourceNamesList(Assembly assembly)
		{
			try
			{
				string[] manifestResourceNames = assembly.GetManifestResourceNames();
				int num = manifestResourceNames.Length;
				string text = "\"";
				if (num > 10)
				{
					num = 10;
					text = "\", ...";
				}
				return "\"" + string.Join("\", \"", manifestResourceNames, 0, num) + text;
			}
			catch
			{
				return "\"\"";
			}
		}

		private void HandleResourceStreamMissing(string fileName)
		{
			if (_mediator.MainAssembly == typeof(object).Assembly && _mediator.BaseName.Equals("System.Private.CoreLib"))
			{
				Environment.FailFast("System.Private.CoreLib.resources couldn't be found!  Large parts of the BCL won't work!");
			}
			string text = string.Empty;
			if (_mediator.LocationInfo != null && _mediator.LocationInfo.Namespace != null)
			{
				text = _mediator.LocationInfo.Namespace + Type.Delimiter;
			}
			text += fileName;
			throw new MissingManifestResourceException(SR.Format(SR.MissingManifestResource_NoNeutralAsm, text, _mediator.MainAssembly.GetName().Name, GetManifestResourceNamesList(_mediator.MainAssembly)));
		}
	}
	internal sealed class FastResourceComparer : IComparer, IEqualityComparer, IComparer<string>, IEqualityComparer<string>
	{
		internal static readonly FastResourceComparer Default = new FastResourceComparer();

		public int GetHashCode(object key)
		{
			string key2 = (string)key;
			return HashFunction(key2);
		}

		public int GetHashCode([DisallowNull] string key)
		{
			return HashFunction(key);
		}

		internal static int HashFunction(string key)
		{
			uint num = 5381u;
			for (int i = 0; i < key.Length; i++)
			{
				num = ((num << 5) + num) ^ key[i];
			}
			return (int)num;
		}

		public int Compare(object a, object b)
		{
			if (a == b)
			{
				return 0;
			}
			string strA = (string)a;
			string strB = (string)b;
			return string.CompareOrdinal(strA, strB);
		}

		public int Compare(string a, string b)
		{
			return string.CompareOrdinal(a, b);
		}

		public bool Equals(string a, string b)
		{
			return string.Equals(a, b);
		}

		public new bool Equals(object a, object b)
		{
			if (a == b)
			{
				return true;
			}
			string a2 = (string)a;
			string b2 = (string)b;
			return string.Equals(a2, b2);
		}

		public unsafe static int CompareOrdinal(string a, byte[] bytes, int bCharLength)
		{
			int num = 0;
			int num2 = 0;
			int num3 = a.Length;
			if (num3 > bCharLength)
			{
				num3 = bCharLength;
			}
			if (bCharLength == 0)
			{
				if (a.Length != 0)
				{
					return -1;
				}
				return 0;
			}
			fixed (byte* ptr = bytes)
			{
				byte* ptr2 = ptr;
				while (num < num3 && num2 == 0)
				{
					int num4 = *ptr2 | (ptr2[1] << 8);
					num2 = a[num++] - num4;
					ptr2 += 2;
				}
			}
			if (num2 != 0)
			{
				return num2;
			}
			return a.Length - bCharLength;
		}

		public static int CompareOrdinal(byte[] bytes, int aCharLength, string b)
		{
			return -CompareOrdinal(b, bytes, aCharLength);
		}

		internal unsafe static int CompareOrdinal(byte* a, int byteLen, string b)
		{
			int num = 0;
			int num2 = 0;
			int num3 = byteLen >> 1;
			if (num3 > b.Length)
			{
				num3 = b.Length;
			}
			while (num2 < num3 && num == 0)
			{
				char c = (char)(*(a++) | (*(a++) << 8));
				num = c - b[num2++];
			}
			if (num != 0)
			{
				return num;
			}
			return byteLen - b.Length * 2;
		}
	}
	internal sealed class FileBasedResourceGroveler : IResourceGroveler
	{
		private readonly ResourceManager.ResourceManagerMediator _mediator;

		public FileBasedResourceGroveler(ResourceManager.ResourceManagerMediator mediator)
		{
			_mediator = mediator;
		}

		public ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<string, ResourceSet> localResourceSets, bool tryParents, bool createIfNotExists)
		{
			ResourceSet result = null;
			string resourceFileName = _mediator.GetResourceFileName(culture);
			string text = FindResourceFile(culture, resourceFileName);
			if (text == null)
			{
				if (tryParents && culture.HasInvariantCultureName)
				{
					string value = ((_mediator.LocationInfo == null) ? "<null>" : _mediator.LocationInfo.FullName);
					throw new MissingManifestResourceException($"{SR.MissingManifestResource_NoNeutralDisk}{"\r\n"}baseName: {_mediator.BaseNameField}  locationInfo: {value}  fileName: {_mediator.GetResourceFileName(culture)}");
				}
			}
			else
			{
				result = CreateResourceSet(text);
			}
			return result;
		}

		private string FindResourceFile(CultureInfo culture, string fileName)
		{
			if (_mediator.ModuleDir != null)
			{
				string text = Path.Combine(_mediator.ModuleDir, fileName);
				if (File.Exists(text))
				{
					return text;
				}
			}
			if (File.Exists(fileName))
			{
				return fileName;
			}
			return null;
		}

		private ResourceSet CreateResourceSet(string file)
		{
			if (_mediator.UserResourceSet == null)
			{
				return new RuntimeResourceSet(file);
			}
			object[] args = new object[1] { file };
			try
			{
				return (ResourceSet)Activator.CreateInstance(_mediator.UserResourceSet, args);
			}
			catch (MissingMethodException innerException)
			{
				throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResMgrBadResSet_Type, _mediator.UserResourceSet.AssemblyQualifiedName), innerException);
			}
		}
	}
	internal interface IResourceGroveler
	{
		ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<string, ResourceSet> localResourceSets, bool tryParents, bool createIfNotExists);
	}
	public interface IResourceReader : System.Collections.IEnumerable, IDisposable
	{
		void Close();

		new IDictionaryEnumerator GetEnumerator();
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class MissingManifestResourceException : SystemException
	{
		public MissingManifestResourceException()
			: base(SR.Arg_MissingManifestResourceException)
		{
			base.HResult = -2146233038;
		}

		public MissingManifestResourceException(string? message)
			: base(message)
		{
			base.HResult = -2146233038;
		}

		public MissingManifestResourceException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233038;
		}

		protected MissingManifestResourceException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class MissingSatelliteAssemblyException : SystemException
	{
		private readonly string _cultureName;

		public string? CultureName => _cultureName;

		public MissingSatelliteAssemblyException()
			: base(SR.MissingSatelliteAssembly_Default)
		{
			base.HResult = -2146233034;
		}

		public MissingSatelliteAssemblyException(string? message)
			: base(message)
		{
			base.HResult = -2146233034;
		}

		public MissingSatelliteAssemblyException(string? message, string? cultureName)
			: base(message)
		{
			base.HResult = -2146233034;
			_cultureName = cultureName;
		}

		public MissingSatelliteAssemblyException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146233034;
		}

		protected MissingSatelliteAssemblyException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false)]
	public sealed class NeutralResourcesLanguageAttribute : Attribute
	{
		public string CultureName { get; }

		public UltimateResourceFallbackLocation Location { get; }

		public NeutralResourcesLanguageAttribute(string cultureName)
		{
			if (cultureName == null)
			{
				throw new ArgumentNullException("cultureName");
			}
			CultureName = cultureName;
			Location = UltimateResourceFallbackLocation.MainAssembly;
		}

		public NeutralResourcesLanguageAttribute(string cultureName, UltimateResourceFallbackLocation location)
		{
			if (cultureName == null)
			{
				throw new ArgumentNullException("cultureName");
			}
			if (!Enum.IsDefined(typeof(UltimateResourceFallbackLocation), location))
			{
				throw new ArgumentException(SR.Format(SR.Arg_InvalidNeutralResourcesLanguage_FallbackLoc, location));
			}
			CultureName = cultureName;
			Location = location;
		}
	}
	internal sealed class ResourceFallbackManager : IEnumerable<CultureInfo>, System.Collections.IEnumerable
	{
		private readonly CultureInfo m_startingCulture;

		private readonly CultureInfo m_neutralResourcesCulture;

		private readonly bool m_useParents;

		internal ResourceFallbackManager(CultureInfo startingCulture, CultureInfo neutralResourcesCulture, bool useParents)
		{
			if (startingCulture != null)
			{
				m_startingCulture = startingCulture;
			}
			else
			{
				m_startingCulture = CultureInfo.CurrentUICulture;
			}
			m_neutralResourcesCulture = neutralResourcesCulture;
			m_useParents = useParents;
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public IEnumerator<CultureInfo> GetEnumerator()
		{
			bool reachedNeutralResourcesCulture = false;
			CultureInfo currentCulture = m_startingCulture;
			do
			{
				if (m_neutralResourcesCulture != null && currentCulture.Name == m_neutralResourcesCulture.Name)
				{
					yield return CultureInfo.InvariantCulture;
					reachedNeutralResourcesCulture = true;
					break;
				}
				yield return currentCulture;
				currentCulture = currentCulture.Parent;
			}
			while (m_useParents && !currentCulture.HasInvariantCultureName);
			if (m_useParents && !m_startingCulture.HasInvariantCultureName && !reachedNeutralResourcesCulture)
			{
				yield return CultureInfo.InvariantCulture;
			}
		}
	}
	public class ResourceManager
	{
		internal sealed class CultureNameResourceSetPair
		{
			public string lastCultureName;

			public ResourceSet lastResourceSet;
		}

		internal sealed class ResourceManagerMediator
		{
			private readonly ResourceManager _rm;

			internal string ModuleDir => _rm._moduleDir;

			internal Type LocationInfo => _rm._locationInfo;

			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
			internal Type UserResourceSet => _rm._userResourceSet;

			internal string BaseNameField => _rm.BaseNameField;

			internal CultureInfo NeutralResourcesCulture => _rm._neutralResourcesCulture;

			internal bool LookedForSatelliteContractVersion
			{
				get
				{
					return _rm._lookedForSatelliteContractVersion;
				}
				set
				{
					_rm._lookedForSatelliteContractVersion = value;
				}
			}

			internal Version SatelliteContractVersion
			{
				get
				{
					return _rm._satelliteContractVersion;
				}
				set
				{
					_rm._satelliteContractVersion = value;
				}
			}

			internal UltimateResourceFallbackLocation FallbackLoc => _rm.FallbackLocation;

			internal Assembly MainAssembly => _rm.MainAssembly;

			internal string BaseName => _rm.BaseName;

			internal ResourceManagerMediator(ResourceManager rm)
			{
				if (rm == null)
				{
					throw new ArgumentNullException("rm");
				}
				_rm = rm;
			}

			internal string GetResourceFileName(CultureInfo culture)
			{
				return _rm.GetResourceFileName(culture);
			}

			internal static Version ObtainSatelliteContractVersion(Assembly a)
			{
				return GetSatelliteContractVersion(a);
			}
		}

		protected string BaseNameField;

		protected Assembly? MainAssembly;

		private Dictionary<string, ResourceSet> _resourceSets;

		private readonly string _moduleDir;

		private readonly Type _locationInfo;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		private readonly Type _userResourceSet;

		private CultureInfo _neutralResourcesCulture;

		private CultureNameResourceSetPair _lastUsedResourceCache;

		private bool _ignoreCase;

		private bool _useManifest;

		private UltimateResourceFallbackLocation _fallbackLoc;

		private Version _satelliteContractVersion;

		private bool _lookedForSatelliteContractVersion;

		private IResourceGroveler _resourceGroveler;

		public static readonly int MagicNumber = -1091581234;

		public static readonly int HeaderVersionNumber = 1;

		private static readonly Type s_minResourceSet = typeof(ResourceSet);

		public virtual string BaseName => BaseNameField;

		public virtual bool IgnoreCase
		{
			get
			{
				return _ignoreCase;
			}
			set
			{
				_ignoreCase = value;
			}
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public virtual Type ResourceSetType => _userResourceSet ?? typeof(RuntimeResourceSet);

		protected UltimateResourceFallbackLocation FallbackLocation
		{
			get
			{
				return _fallbackLoc;
			}
			set
			{
				_fallbackLoc = value;
			}
		}

		protected ResourceManager()
		{
			_lastUsedResourceCache = new CultureNameResourceSetPair();
			ResourceManagerMediator mediator = new ResourceManagerMediator(this);
			_resourceGroveler = new ManifestBasedResourceGroveler(mediator);
			BaseNameField = string.Empty;
		}

		private ResourceManager(string baseName, string resourceDir, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type userResourceSet)
		{
			if (baseName == null)
			{
				throw new ArgumentNullException("baseName");
			}
			if (resourceDir == null)
			{
				throw new ArgumentNullException("resourceDir");
			}
			BaseNameField = baseName;
			_moduleDir = resourceDir;
			_userResourceSet = userResourceSet;
			_resourceSets = new Dictionary<string, ResourceSet>();
			_lastUsedResourceCache = new CultureNameResourceSetPair();
			ResourceManagerMediator mediator = new ResourceManagerMediator(this);
			_resourceGroveler = new FileBasedResourceGroveler(mediator);
		}

		public ResourceManager(string baseName, Assembly assembly)
		{
			if (baseName == null)
			{
				throw new ArgumentNullException("baseName");
			}
			if (null == assembly)
			{
				throw new ArgumentNullException("assembly");
			}
			if (!assembly.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeAssembly);
			}
			MainAssembly = assembly;
			BaseNameField = baseName;
			CommonAssemblyInit();
		}

		public ResourceManager(string baseName, Assembly assembly, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type? usingResourceSet)
		{
			if (baseName == null)
			{
				throw new ArgumentNullException("baseName");
			}
			if (null == assembly)
			{
				throw new ArgumentNullException("assembly");
			}
			if (!assembly.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeAssembly);
			}
			MainAssembly = assembly;
			BaseNameField = baseName;
			if (usingResourceSet != null && usingResourceSet != s_minResourceSet && !usingResourceSet.IsSubclassOf(s_minResourceSet))
			{
				throw new ArgumentException(SR.Arg_ResMgrNotResSet, "usingResourceSet");
			}
			_userResourceSet = usingResourceSet;
			CommonAssemblyInit();
		}

		public ResourceManager(Type resourceSource)
		{
			if (null == resourceSource)
			{
				throw new ArgumentNullException("resourceSource");
			}
			if (!resourceSource.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType);
			}
			_locationInfo = resourceSource;
			MainAssembly = _locationInfo.Assembly;
			BaseNameField = resourceSource.Name;
			CommonAssemblyInit();
		}

		[MemberNotNull("_resourceGroveler")]
		private void CommonAssemblyInit()
		{
			_useManifest = true;
			_resourceSets = new Dictionary<string, ResourceSet>();
			_lastUsedResourceCache = new CultureNameResourceSetPair();
			ResourceManagerMediator mediator = new ResourceManagerMediator(this);
			_resourceGroveler = new ManifestBasedResourceGroveler(mediator);
			_neutralResourcesCulture = ManifestBasedResourceGroveler.GetNeutralResourcesLanguage(MainAssembly, out _fallbackLoc);
		}

		public virtual void ReleaseAllResources()
		{
			Dictionary<string, ResourceSet> resourceSets = _resourceSets;
			_resourceSets = new Dictionary<string, ResourceSet>();
			_lastUsedResourceCache = new CultureNameResourceSetPair();
			lock (resourceSets)
			{
				foreach (var (_, resourceSet2) in resourceSets)
				{
					resourceSet2.Close();
				}
			}
		}

		public static ResourceManager CreateFileBasedResourceManager(string baseName, string resourceDir, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type? usingResourceSet)
		{
			return new ResourceManager(baseName, resourceDir, usingResourceSet);
		}

		protected virtual string GetResourceFileName(CultureInfo culture)
		{
			if (culture.HasInvariantCultureName)
			{
				return BaseNameField + ".resources";
			}
			CultureInfo.VerifyCultureName(culture.Name, throwException: true);
			return BaseNameField + "." + culture.Name + ".resources";
		}

		internal ResourceSet GetFirstResourceSet(CultureInfo culture)
		{
			if (_neutralResourcesCulture != null && culture.Name == _neutralResourcesCulture.Name)
			{
				culture = CultureInfo.InvariantCulture;
			}
			if (_lastUsedResourceCache != null)
			{
				lock (_lastUsedResourceCache)
				{
					if (culture.Name == _lastUsedResourceCache.lastCultureName)
					{
						return _lastUsedResourceCache.lastResourceSet;
					}
				}
			}
			Dictionary<string, ResourceSet> resourceSets = _resourceSets;
			ResourceSet value = null;
			if (resourceSets != null)
			{
				lock (resourceSets)
				{
					resourceSets.TryGetValue(culture.Name, out value);
				}
			}
			if (value != null)
			{
				if (_lastUsedResourceCache != null)
				{
					lock (_lastUsedResourceCache)
					{
						_lastUsedResourceCache.lastCultureName = culture.Name;
						_lastUsedResourceCache.lastResourceSet = value;
					}
				}
				return value;
			}
			return null;
		}

		public virtual ResourceSet? GetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents)
		{
			if (culture == null)
			{
				throw new ArgumentNullException("culture");
			}
			Dictionary<string, ResourceSet> resourceSets = _resourceSets;
			if (resourceSets != null)
			{
				lock (resourceSets)
				{
					if (resourceSets.TryGetValue(culture.Name, out var value))
					{
						return value;
					}
				}
			}
			if (_useManifest && culture.HasInvariantCultureName)
			{
				string resourceFileName = GetResourceFileName(culture);
				Stream manifestResourceStream = MainAssembly.GetManifestResourceStream(_locationInfo, resourceFileName);
				if (createIfNotExists && manifestResourceStream != null)
				{
					ResourceSet value = ((ManifestBasedResourceGroveler)_resourceGroveler).CreateResourceSet(manifestResourceStream, MainAssembly);
					AddResourceSet(resourceSets, culture.Name, ref value);
					return value;
				}
			}
			return InternalGetResourceSet(culture, createIfNotExists, tryParents);
		}

		protected virtual ResourceSet? InternalGetResourceSet(CultureInfo culture, bool createIfNotExists, bool tryParents)
		{
			Dictionary<string, ResourceSet> resourceSets = _resourceSets;
			ResourceSet value = null;
			CultureInfo cultureInfo = null;
			lock (resourceSets)
			{
				if (resourceSets.TryGetValue(culture.Name, out value))
				{
					return value;
				}
			}
			ResourceFallbackManager resourceFallbackManager = new ResourceFallbackManager(culture, _neutralResourcesCulture, tryParents);
			foreach (CultureInfo item in resourceFallbackManager)
			{
				lock (resourceSets)
				{
					if (resourceSets.TryGetValue(item.Name, out value))
					{
						if (culture != item)
						{
							cultureInfo = item;
						}
						break;
					}
				}
				value = _resourceGroveler.GrovelForResourceSet(item, resourceSets, tryParents, createIfNotExists);
				if (value != null)
				{
					cultureInfo = item;
					break;
				}
			}
			if (value != null && cultureInfo != null)
			{
				foreach (CultureInfo item2 in resourceFallbackManager)
				{
					AddResourceSet(resourceSets, item2.Name, ref value);
					if (item2 == cultureInfo)
					{
						break;
					}
				}
			}
			return value;
		}

		private static void AddResourceSet(Dictionary<string, ResourceSet> localResourceSets, string cultureName, ref ResourceSet rs)
		{
			lock (localResourceSets)
			{
				if (localResourceSets.TryGetValue(cultureName, out var value))
				{
					if (value != rs)
					{
						if (!localResourceSets.ContainsValue(rs))
						{
							rs.Dispose();
						}
						rs = value;
					}
				}
				else
				{
					localResourceSets.Add(cultureName, rs);
				}
			}
		}

		protected static Version? GetSatelliteContractVersion(Assembly a)
		{
			if (a == null)
			{
				throw new ArgumentNullException("a", SR.ArgumentNull_Assembly);
			}
			string text = a.GetCustomAttribute<SatelliteContractVersionAttribute>()?.Version;
			if (text == null)
			{
				return null;
			}
			if (!Version.TryParse(text, out Version result))
			{
				throw new ArgumentException(SR.Format(SR.Arg_InvalidSatelliteContract_Asm_Ver, a, text));
			}
			return result;
		}

		protected static CultureInfo GetNeutralResourcesLanguage(Assembly a)
		{
			UltimateResourceFallbackLocation fallbackLocation;
			return ManifestBasedResourceGroveler.GetNeutralResourcesLanguage(a, out fallbackLocation);
		}

		internal static bool IsDefaultType(string asmTypeName, string typeName)
		{
			int num = asmTypeName.IndexOf(',');
			if (((num == -1) ? asmTypeName.Length : num) != typeName.Length)
			{
				return false;
			}
			if (string.Compare(asmTypeName, 0, typeName, 0, typeName.Length, StringComparison.Ordinal) != 0)
			{
				return false;
			}
			if (num == -1)
			{
				return true;
			}
			while (char.IsWhiteSpace(asmTypeName[++num]))
			{
			}
			AssemblyName assemblyName = new AssemblyName(asmTypeName.Substring(num));
			return string.Equals(assemblyName.Name, "mscorlib", StringComparison.OrdinalIgnoreCase);
		}

		public virtual string? GetString(string name)
		{
			return GetString(name, null);
		}

		public virtual string? GetString(string name, CultureInfo? culture)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (culture == null)
			{
				culture = CultureInfo.CurrentUICulture;
			}
			ResourceSet resourceSet = GetFirstResourceSet(culture);
			if (resourceSet != null)
			{
				string @string = resourceSet.GetString(name, _ignoreCase);
				if (@string != null)
				{
					return @string;
				}
			}
			ResourceFallbackManager resourceFallbackManager = new ResourceFallbackManager(culture, _neutralResourcesCulture, useParents: true);
			foreach (CultureInfo item in resourceFallbackManager)
			{
				ResourceSet resourceSet2 = InternalGetResourceSet(item, createIfNotExists: true, tryParents: true);
				if (resourceSet2 == null)
				{
					break;
				}
				if (resourceSet2 == resourceSet)
				{
					continue;
				}
				string string2 = resourceSet2.GetString(name, _ignoreCase);
				if (string2 != null)
				{
					if (_lastUsedResourceCache != null)
					{
						lock (_lastUsedResourceCache)
						{
							_lastUsedResourceCache.lastCultureName = item.Name;
							_lastUsedResourceCache.lastResourceSet = resourceSet2;
						}
					}
					return string2;
				}
				resourceSet = resourceSet2;
			}
			return null;
		}

		public virtual object? GetObject(string name)
		{
			return GetObject(name, null, wrapUnmanagedMemStream: true);
		}

		public virtual object? GetObject(string name, CultureInfo? culture)
		{
			return GetObject(name, culture, wrapUnmanagedMemStream: true);
		}

		private object GetObject(string name, CultureInfo culture, bool wrapUnmanagedMemStream)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (culture == null)
			{
				culture = CultureInfo.CurrentUICulture;
			}
			ResourceSet resourceSet = GetFirstResourceSet(culture);
			if (resourceSet != null)
			{
				object @object = resourceSet.GetObject(name, _ignoreCase);
				if (@object != null)
				{
					UnmanagedMemoryStream unmanagedMemoryStream = @object as UnmanagedMemoryStream;
					if (unmanagedMemoryStream != null && wrapUnmanagedMemStream)
					{
						return new UnmanagedMemoryStreamWrapper(unmanagedMemoryStream);
					}
					return @object;
				}
			}
			ResourceFallbackManager resourceFallbackManager = new ResourceFallbackManager(culture, _neutralResourcesCulture, useParents: true);
			foreach (CultureInfo item in resourceFallbackManager)
			{
				ResourceSet resourceSet2 = InternalGetResourceSet(item, createIfNotExists: true, tryParents: true);
				if (resourceSet2 == null)
				{
					break;
				}
				if (resourceSet2 == resourceSet)
				{
					continue;
				}
				object object2 = resourceSet2.GetObject(name, _ignoreCase);
				if (object2 != null)
				{
					if (_lastUsedResourceCache != null)
					{
						lock (_lastUsedResourceCache)
						{
							_lastUsedResourceCache.lastCultureName = item.Name;
							_lastUsedResourceCache.lastResourceSet = resourceSet2;
						}
					}
					UnmanagedMemoryStream unmanagedMemoryStream2 = object2 as UnmanagedMemoryStream;
					if (unmanagedMemoryStream2 != null && wrapUnmanagedMemStream)
					{
						return new UnmanagedMemoryStreamWrapper(unmanagedMemoryStream2);
					}
					return object2;
				}
				resourceSet = resourceSet2;
			}
			return null;
		}

		public UnmanagedMemoryStream? GetStream(string name)
		{
			return GetStream(name, null);
		}

		public UnmanagedMemoryStream? GetStream(string name, CultureInfo? culture)
		{
			object @object = GetObject(name, culture, wrapUnmanagedMemStream: false);
			UnmanagedMemoryStream unmanagedMemoryStream = @object as UnmanagedMemoryStream;
			if (unmanagedMemoryStream == null && @object != null)
			{
				throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotStream_Name, name));
			}
			return unmanagedMemoryStream;
		}
	}
	public sealed class ResourceReader : IResourceReader, System.Collections.IEnumerable, IDisposable
	{
		internal sealed class ResourceEnumerator : IDictionaryEnumerator, System.Collections.IEnumerator
		{
			private readonly ResourceReader _reader;

			private bool _currentIsValid;

			private int _currentName;

			private int _dataPosition;

			public object Key
			{
				get
				{
					if (_currentName == int.MinValue)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
					}
					if (!_currentIsValid)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
					}
					if (_reader._resCache == null)
					{
						throw new InvalidOperationException(SR.ResourceReaderIsClosed);
					}
					return _reader.AllocateStringForNameIndex(_currentName, out _dataPosition);
				}
			}

			public object Current => Entry;

			internal int DataPosition => _dataPosition;

			public DictionaryEntry Entry
			{
				get
				{
					if (_currentName == int.MinValue)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
					}
					if (!_currentIsValid)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
					}
					if (_reader._resCache == null)
					{
						throw new InvalidOperationException(SR.ResourceReaderIsClosed);
					}
					object obj = null;
					string key;
					lock (_reader)
					{
						lock (_reader._resCache)
						{
							key = _reader.AllocateStringForNameIndex(_currentName, out _dataPosition);
							if (_reader._resCache.TryGetValue(key, out var value))
							{
								obj = value.Value;
							}
							if (obj == null)
							{
								obj = ((_dataPosition != -1) ? _reader.LoadObject(_dataPosition) : _reader.GetValueForNameIndex(_currentName));
							}
						}
					}
					return new DictionaryEntry(key, obj);
				}
			}

			public object Value
			{
				get
				{
					if (_currentName == int.MinValue)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
					}
					if (!_currentIsValid)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
					}
					if (_reader._resCache == null)
					{
						throw new InvalidOperationException(SR.ResourceReaderIsClosed);
					}
					return _reader.GetValueForNameIndex(_currentName);
				}
			}

			internal ResourceEnumerator(ResourceReader reader)
			{
				_currentName = -1;
				_reader = reader;
				_dataPosition = -2;
			}

			public bool MoveNext()
			{
				if (_currentName == _reader._numResources - 1 || _currentName == int.MinValue)
				{
					_currentIsValid = false;
					_currentName = int.MinValue;
					return false;
				}
				_currentIsValid = true;
				_currentName++;
				return true;
			}

			public void Reset()
			{
				if (_reader._resCache == null)
				{
					throw new InvalidOperationException(SR.ResourceReaderIsClosed);
				}
				_currentIsValid = false;
				_currentName = -1;
			}
		}

		private readonly bool _permitDeserialization;

		private object _binaryFormatter;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
		private static Type s_binaryFormatterType;

		private static Func<object, Stream, object> s_deserializeMethod;

		private BinaryReader _store;

		internal Dictionary<string, ResourceLocator> _resCache;

		private long _nameSectionOffset;

		private long _dataSectionOffset;

		private int[] _nameHashes;

		private unsafe int* _nameHashesPtr;

		private int[] _namePositions;

		private unsafe int* _namePositionsPtr;

		private Type[] _typeTable;

		private int[] _typeNamePositions;

		private int _numResources;

		private UnmanagedMemoryStream _ums;

		private int _version;

		internal static bool AllowCustomResourceTypes { get; } = !AppContext.TryGetSwitch("System.Resources.ResourceManager.AllowCustomResourceTypes", out var isEnabled) || isEnabled;


		internal ResourceReader(Stream stream, Dictionary<string, ResourceLocator> resCache, bool permitDeserialization)
		{
			_resCache = resCache;
			_store = new BinaryReader(stream, Encoding.UTF8);
			_ums = stream as UnmanagedMemoryStream;
			_permitDeserialization = permitDeserialization;
			ReadResources();
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "InitializeBinaryFormatter will get trimmed out when AllowCustomResourceTypes is set to false. When set to true, we will already throw a warning for this feature switch, so we suppress this one in order forthe user to only get one error.")]
		private object DeserializeObject(int typeIndex)
		{
			if (!AllowCustomResourceTypes)
			{
				throw new NotSupportedException(SR.ResourceManager_ReflectionNotAllowed);
			}
			if (!_permitDeserialization)
			{
				throw new NotSupportedException(SR.NotSupported_ResourceObjectSerialization);
			}
			if (Volatile.Read(ref _binaryFormatter) == null && !InitializeBinaryFormatter())
			{
				throw new NotSupportedException(SR.BinaryFormatter_SerializationDisallowed);
			}
			Type type = FindType(typeIndex);
			object obj = s_deserializeMethod(_binaryFormatter, _store.BaseStream);
			if (obj.GetType() != type)
			{
				throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResType_SerBlobMismatch, type.FullName, obj.GetType().FullName));
			}
			return obj;
		}

		[RequiresUnreferencedCode("The CustomResourceTypesSupport feature switch has been enabled for this app which is being trimmed. Custom readers as well as custom objects on the resources file are not observable by the trimmer and so required assemblies, types and members may be removed.")]
		private bool InitializeBinaryFormatter()
		{
			if ((object)Volatile.Read(ref s_binaryFormatterType) == null || Volatile.Read(ref s_deserializeMethod) == null)
			{
				Type type = Type.GetType("System.Runtime.Serialization.Formatters.Binary.BinaryFormatter, System.Runtime.Serialization.Formatters", throwOnError: true);
				MethodInfo method = type.GetMethod("Deserialize", new Type[1] { typeof(Stream) });
				MethodInfo? method2 = typeof(ResourceReader).GetMethod("CreateUntypedDelegate", BindingFlags.Static | BindingFlags.NonPublic);
				object obj;
				if ((object)method2 == null)
				{
					obj = null;
				}
				else
				{
					MethodInfo methodInfo = method2.MakeGenericMethod(type);
					object[] parameters = new MethodInfo[1] { method };
					obj = methodInfo.Invoke(null, parameters);
				}
				Func<object, Stream, object> value = (Func<object, Stream, object>)obj;
				Interlocked.CompareExchange(ref s_binaryFormatterType, type, null);
				Interlocked.CompareExchange(ref s_deserializeMethod, value, null);
			}
			Volatile.Write(ref _binaryFormatter, Activator.CreateInstance(s_binaryFormatterType));
			return s_deserializeMethod != null;
		}

		private static Func<object, Stream, object> CreateUntypedDelegate<TInstance>(MethodInfo method)
		{
			Func<TInstance, Stream, object> typedDelegate = (Func<TInstance, Stream, object>)Delegate.CreateDelegate(typeof(Func<TInstance, Stream, object>), null, method);
			return (object obj, Stream stream) => typedDelegate((TInstance)obj, stream);
		}

		private static bool ValidateReaderType(string readerType)
		{
			return ResourceManager.IsDefaultType(readerType, "System.Resources.ResourceReader");
		}

		public void GetResourceData(string resourceName, out string resourceType, out byte[] resourceData)
		{
			if (resourceName == null)
			{
				throw new ArgumentNullException("resourceName");
			}
			if (_resCache == null)
			{
				throw new InvalidOperationException(SR.ResourceReaderIsClosed);
			}
			int[] array = new int[_numResources];
			int num = FindPosForResource(resourceName);
			if (num == -1)
			{
				throw new ArgumentException(SR.Format(SR.Arg_ResourceNameNotExist, resourceName));
			}
			lock (this)
			{
				for (int i = 0; i < _numResources; i++)
				{
					_store.BaseStream.Position = _nameSectionOffset + GetNamePosition(i);
					int num2 = _store.Read7BitEncodedInt();
					if (num2 < 0)
					{
						throw new FormatException(SR.Format(SR.BadImageFormat_ResourcesNameInvalidOffset, num2));
					}
					_store.BaseStream.Position += num2;
					int num3 = _store.ReadInt32();
					if (num3 < 0 || num3 >= _store.BaseStream.Length - _dataSectionOffset)
					{
						throw new FormatException(SR.Format(SR.BadImageFormat_ResourcesDataInvalidOffset, num3));
					}
					array[i] = num3;
				}
				Array.Sort(array);
				int num4 = Array.BinarySearch(array, num);
				long num5 = ((num4 < _numResources - 1) ? (array[num4 + 1] + _dataSectionOffset) : _store.BaseStream.Length);
				int num6 = (int)(num5 - (num + _dataSectionOffset));
				_store.BaseStream.Position = _dataSectionOffset + num;
				ResourceTypeCode resourceTypeCode = (ResourceTypeCode)_store.Read7BitEncodedInt();
				if (resourceTypeCode < ResourceTypeCode.Null || (int)resourceTypeCode >= 64 + _typeTable.Length)
				{
					throw new BadImageFormatException(SR.BadImageFormat_InvalidType);
				}
				resourceType = TypeNameFromTypeCode(resourceTypeCode);
				num6 -= (int)(_store.BaseStream.Position - (_dataSectionOffset + num));
				byte[] array2 = _store.ReadBytes(num6);
				if (array2.Length != num6)
				{
					throw new FormatException(SR.BadImageFormat_ResourceNameCorrupted);
				}
				resourceData = array2;
			}
		}

		public ResourceReader(string fileName)
		{
			_resCache = new Dictionary<string, ResourceLocator>(FastResourceComparer.Default);
			_store = new BinaryReader(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.RandomAccess), Encoding.UTF8);
			try
			{
				ReadResources();
			}
			catch
			{
				_store.Close();
				throw;
			}
		}

		public ResourceReader(Stream stream)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream");
			}
			if (!stream.CanRead)
			{
				throw new ArgumentException(SR.Argument_StreamNotReadable);
			}
			_resCache = new Dictionary<string, ResourceLocator>(FastResourceComparer.Default);
			_store = new BinaryReader(stream, Encoding.UTF8);
			_ums = stream as UnmanagedMemoryStream;
			ReadResources();
		}

		public void Close()
		{
			Dispose(disposing: true);
		}

		public void Dispose()
		{
			Close();
		}

		private unsafe void Dispose(bool disposing)
		{
			if (_store != null)
			{
				_resCache = null;
				if (disposing)
				{
					BinaryReader store = _store;
					_store = null;
					store?.Close();
				}
				_store = null;
				_namePositions = null;
				_nameHashes = null;
				_ums = null;
				_namePositionsPtr = null;
				_nameHashesPtr = null;
			}
		}

		internal unsafe static int ReadUnalignedI4(int* p)
		{
			return BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan<byte>(p, 4));
		}

		private void SkipString()
		{
			int num = _store.Read7BitEncodedInt();
			if (num < 0)
			{
				throw new BadImageFormatException(SR.BadImageFormat_NegativeStringLength);
			}
			_store.BaseStream.Seek(num, SeekOrigin.Current);
		}

		private unsafe int GetNameHash(int index)
		{
			if (_ums == null)
			{
				return _nameHashes[index];
			}
			return ReadUnalignedI4(_nameHashesPtr + index);
		}

		private unsafe int GetNamePosition(int index)
		{
			int num = ((_ums != null) ? ReadUnalignedI4(_namePositionsPtr + index) : _namePositions[index]);
			if (num < 0 || num > _dataSectionOffset - _nameSectionOffset)
			{
				throw new FormatException(SR.Format(SR.BadImageFormat_ResourcesNameInvalidOffset, num));
			}
			return num;
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			if (_resCache == null)
			{
				throw new InvalidOperationException(SR.ResourceReaderIsClosed);
			}
			return new ResourceEnumerator(this);
		}

		internal ResourceEnumerator GetEnumeratorInternal()
		{
			return new ResourceEnumerator(this);
		}

		internal int FindPosForResource(string name)
		{
			int num = FastResourceComparer.HashFunction(name);
			int num2 = 0;
			int i = _numResources - 1;
			int num3 = -1;
			bool flag = false;
			while (num2 <= i)
			{
				num3 = num2 + i >> 1;
				int nameHash = GetNameHash(num3);
				int num4 = ((nameHash != num) ? ((nameHash >= num) ? 1 : (-1)) : 0);
				if (num4 == 0)
				{
					flag = true;
					break;
				}
				if (num4 < 0)
				{
					num2 = num3 + 1;
				}
				else
				{
					i = num3 - 1;
				}
			}
			if (!flag)
			{
				return -1;
			}
			if (num2 != num3)
			{
				num2 = num3;
				while (num2 > 0 && GetNameHash(num2 - 1) == num)
				{
					num2--;
				}
			}
			if (i != num3)
			{
				for (i = num3; i < _numResources - 1 && GetNameHash(i + 1) == num; i++)
				{
				}
			}
			lock (this)
			{
				for (int j = num2; j <= i; j++)
				{
					_store.BaseStream.Seek(_nameSectionOffset + GetNamePosition(j), SeekOrigin.Begin);
					if (CompareStringEqualsName(name))
					{
						int num5 = _store.ReadInt32();
						if (num5 < 0 || num5 >= _store.BaseStream.Length - _dataSectionOffset)
						{
							throw new FormatException(SR.Format(SR.BadImageFormat_ResourcesDataInvalidOffset, num5));
						}
						return num5;
					}
				}
			}
			return -1;
		}

		private unsafe bool CompareStringEqualsName(string name)
		{
			int num = _store.Read7BitEncodedInt();
			if (num < 0)
			{
				throw new BadImageFormatException(SR.BadImageFormat_NegativeStringLength);
			}
			if (_ums != null)
			{
				byte* positionPointer = _ums.PositionPointer;
				_ums.Seek(num, SeekOrigin.Current);
				if (_ums.Position > _ums.Length)
				{
					throw new BadImageFormatException(SR.BadImageFormat_ResourcesNameTooLong);
				}
				return FastResourceComparer.CompareOrdinal(positionPointer, num, name) == 0;
			}
			byte[] array = new byte[num];
			int num2 = num;
			while (num2 > 0)
			{
				int num3 = _store.Read(array, num - num2, num2);
				if (num3 == 0)
				{
					throw new BadImageFormatException(SR.BadImageFormat_ResourceNameCorrupted);
				}
				num2 -= num3;
			}
			return FastResourceComparer.CompareOrdinal(array, num / 2, name) == 0;
		}

		private unsafe string AllocateStringForNameIndex(int index, out int dataOffset)
		{
			long num = GetNamePosition(index);
			int num2;
			byte[] array;
			lock (this)
			{
				_store.BaseStream.Seek(num + _nameSectionOffset, SeekOrigin.Begin);
				num2 = _store.Read7BitEncodedInt();
				if (num2 < 0)
				{
					throw new BadImageFormatException(SR.BadImageFormat_NegativeStringLength);
				}
				if (_ums != null)
				{
					if (_ums.Position > _ums.Length - num2)
					{
						throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourcesIndexTooLong, index));
					}
					string text = null;
					char* positionPointer = (char*)_ums.PositionPointer;
					_ = BitConverter.IsLittleEndian;
					text = new string(positionPointer, 0, num2 / 2);
					_ums.Position += num2;
					dataOffset = _store.ReadInt32();
					if (dataOffset < 0 || dataOffset >= _store.BaseStream.Length - _dataSectionOffset)
					{
						throw new FormatException(SR.Format(SR.BadImageFormat_ResourcesDataInvalidOffset, dataOffset));
					}
					return text;
				}
				array = new byte[num2];
				int num3 = num2;
				while (num3 > 0)
				{
					int num4 = _store.Read(array, num2 - num3, num3);
					if (num4 == 0)
					{
						throw new EndOfStreamException(SR.Format(SR.BadImageFormat_ResourceNameCorrupted_NameIndex, index));
					}
					num3 -= num4;
				}
				dataOffset = _store.ReadInt32();
				if (dataOffset < 0 || dataOffset >= _store.BaseStream.Length - _dataSectionOffset)
				{
					throw new FormatException(SR.Format(SR.BadImageFormat_ResourcesDataInvalidOffset, dataOffset));
				}
			}
			return Encoding.Unicode.GetString(array, 0, num2);
		}

		private object GetValueForNameIndex(int index)
		{
			long num = GetNamePosition(index);
			lock (this)
			{
				_store.BaseStream.Seek(num + _nameSectionOffset, SeekOrigin.Begin);
				SkipString();
				int num2 = _store.ReadInt32();
				if (num2 < 0 || num2 >= _store.BaseStream.Length - _dataSectionOffset)
				{
					throw new FormatException(SR.Format(SR.BadImageFormat_ResourcesDataInvalidOffset, num2));
				}
				if (_version == 1)
				{
					return LoadObjectV1(num2);
				}
				ResourceTypeCode typeCode;
				return LoadObjectV2(num2, out typeCode);
			}
		}

		internal string LoadString(int pos)
		{
			_store.BaseStream.Seek(_dataSectionOffset + pos, SeekOrigin.Begin);
			string result = null;
			int num = _store.Read7BitEncodedInt();
			if (_version == 1)
			{
				if (num == -1)
				{
					return null;
				}
				if (FindType(num) != typeof(string))
				{
					throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotString_Type, FindType(num).FullName));
				}
				result = _store.ReadString();
			}
			else
			{
				ResourceTypeCode resourceTypeCode = (ResourceTypeCode)num;
				if (resourceTypeCode != ResourceTypeCode.String && resourceTypeCode != 0)
				{
					throw new InvalidOperationException(SR.Format(p1: (resourceTypeCode >= ResourceTypeCode.StartOfUserTypes) ? FindType((int)(resourceTypeCode - 64)).FullName : resourceTypeCode.ToString(), resourceFormat: SR.InvalidOperation_ResourceNotString_Type));
				}
				if (resourceTypeCode == ResourceTypeCode.String)
				{
					result = _store.ReadString();
				}
			}
			return result;
		}

		internal object LoadObject(int pos)
		{
			if (_version == 1)
			{
				return LoadObjectV1(pos);
			}
			ResourceTypeCode typeCode;
			return LoadObjectV2(pos, out typeCode);
		}

		internal object LoadObject(int pos, out ResourceTypeCode typeCode)
		{
			if (_version == 1)
			{
				object obj = LoadObjectV1(pos);
				typeCode = ((obj is string) ? ResourceTypeCode.String : ResourceTypeCode.StartOfUserTypes);
				return obj;
			}
			return LoadObjectV2(pos, out typeCode);
		}

		internal object LoadObjectV1(int pos)
		{
			try
			{
				return _LoadObjectV1(pos);
			}
			catch (EndOfStreamException inner)
			{
				throw new BadImageFormatException(SR.BadImageFormat_TypeMismatch, inner);
			}
			catch (ArgumentOutOfRangeException inner2)
			{
				throw new BadImageFormatException(SR.BadImageFormat_TypeMismatch, inner2);
			}
		}

		private object _LoadObjectV1(int pos)
		{
			_store.BaseStream.Seek(_dataSectionOffset + pos, SeekOrigin.Begin);
			int num = _store.Read7BitEncodedInt();
			if (num == -1)
			{
				return null;
			}
			Type type = FindType(num);
			if (type == typeof(string))
			{
				return _store.ReadString();
			}
			if (type == typeof(int))
			{
				return _store.ReadInt32();
			}
			if (type == typeof(byte))
			{
				return _store.ReadByte();
			}
			if (type == typeof(sbyte))
			{
				return _store.ReadSByte();
			}
			if (type == typeof(short))
			{
				return _store.ReadInt16();
			}
			if (type == typeof(long))
			{
				return _store.ReadInt64();
			}
			if (type == typeof(ushort))
			{
				return _store.ReadUInt16();
			}
			if (type == typeof(uint))
			{
				return _store.ReadUInt32();
			}
			if (type == typeof(ulong))
			{
				return _store.ReadUInt64();
			}
			if (type == typeof(float))
			{
				return _store.ReadSingle();
			}
			if (type == typeof(double))
			{
				return _store.ReadDouble();
			}
			if (type == typeof(DateTime))
			{
				return new DateTime(_store.ReadInt64());
			}
			if (type == typeof(TimeSpan))
			{
				return new TimeSpan(_store.ReadInt64());
			}
			if (type == typeof(decimal))
			{
				int[] array = new int[4];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = _store.ReadInt32();
				}
				return new decimal(array);
			}
			return DeserializeObject(num);
		}

		internal object LoadObjectV2(int pos, out ResourceTypeCode typeCode)
		{
			try
			{
				return _LoadObjectV2(pos, out typeCode);
			}
			catch (EndOfStreamException inner)
			{
				throw new BadImageFormatException(SR.BadImageFormat_TypeMismatch, inner);
			}
			catch (ArgumentOutOfRangeException inner2)
			{
				throw new BadImageFormatException(SR.BadImageFormat_TypeMismatch, inner2);
			}
		}

		private unsafe object _LoadObjectV2(int pos, out ResourceTypeCode typeCode)
		{
			_store.BaseStream.Seek(_dataSectionOffset + pos, SeekOrigin.Begin);
			typeCode = (ResourceTypeCode)_store.Read7BitEncodedInt();
			switch (typeCode)
			{
			case ResourceTypeCode.Null:
				return null;
			case ResourceTypeCode.String:
				return _store.ReadString();
			case ResourceTypeCode.Boolean:
				return _store.ReadBoolean();
			case ResourceTypeCode.Char:
				return (char)_store.ReadUInt16();
			case ResourceTypeCode.Byte:
				return _store.ReadByte();
			case ResourceTypeCode.SByte:
				return _store.ReadSByte();
			case ResourceTypeCode.Int16:
				return _store.ReadInt16();
			case ResourceTypeCode.UInt16:
				return _store.ReadUInt16();
			case ResourceTypeCode.Int32:
				return _store.ReadInt32();
			case ResourceTypeCode.UInt32:
				return _store.ReadUInt32();
			case ResourceTypeCode.Int64:
				return _store.ReadInt64();
			case ResourceTypeCode.UInt64:
				return _store.ReadUInt64();
			case ResourceTypeCode.Single:
				return _store.ReadSingle();
			case ResourceTypeCode.Double:
				return _store.ReadDouble();
			case ResourceTypeCode.Decimal:
				return _store.ReadDecimal();
			case ResourceTypeCode.DateTime:
			{
				long dateData = _store.ReadInt64();
				return DateTime.FromBinary(dateData);
			}
			case ResourceTypeCode.TimeSpan:
			{
				long ticks = _store.ReadInt64();
				return new TimeSpan(ticks);
			}
			case ResourceTypeCode.ByteArray:
			{
				int num2 = _store.ReadInt32();
				if (num2 < 0)
				{
					throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, num2));
				}
				if (_ums == null)
				{
					if (num2 > _store.BaseStream.Length)
					{
						throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, num2));
					}
					return _store.ReadBytes(num2);
				}
				if (num2 > _ums.Length - _ums.Position)
				{
					throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, num2));
				}
				byte[] array2 = new byte[num2];
				int num3 = _ums.Read(array2, 0, num2);
				return array2;
			}
			case ResourceTypeCode.Stream:
			{
				int num = _store.ReadInt32();
				if (num < 0)
				{
					throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, num));
				}
				if (_ums == null)
				{
					byte[] array = _store.ReadBytes(num);
					return new PinnedBufferMemoryStream(array);
				}
				if (num > _ums.Length - _ums.Position)
				{
					throw new BadImageFormatException(SR.Format(SR.BadImageFormat_ResourceDataLengthInvalid, num));
				}
				return new UnmanagedMemoryStream(_ums.PositionPointer, num, num, FileAccess.Read);
			}
			default:
			{
				if (typeCode < ResourceTypeCode.StartOfUserTypes)
				{
					throw new BadImageFormatException(SR.BadImageFormat_TypeMismatch);
				}
				int typeIndex = (int)(typeCode - 64);
				return DeserializeObject(typeIndex);
			}
			}
		}

		[MemberNotNull("_typeTable")]
		[MemberNotNull("_typeNamePositions")]
		private void ReadResources()
		{
			try
			{
				_ReadResources();
			}
			catch (EndOfStreamException inner)
			{
				throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted, inner);
			}
			catch (IndexOutOfRangeException inner2)
			{
				throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted, inner2);
			}
		}

		[MemberNotNull("_typeTable")]
		[MemberNotNull("_typeNamePositions")]
		private unsafe void _ReadResources()
		{
			int num = _store.ReadInt32();
			if (num != ResourceManager.MagicNumber)
			{
				throw new ArgumentException(SR.Resources_StreamNotValid);
			}
			int num2 = _store.ReadInt32();
			int num3 = _store.ReadInt32();
			if (num3 < 0 || num2 < 0)
			{
				throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted);
			}
			if (num2 > 1)
			{
				_store.BaseStream.Seek(num3, SeekOrigin.Current);
			}
			else
			{
				string text = _store.ReadString();
				if (!ValidateReaderType(text))
				{
					throw new NotSupportedException(SR.Format(SR.NotSupported_WrongResourceReader_Type, text));
				}
				SkipString();
			}
			int num4 = _store.ReadInt32();
			if (num4 != 2 && num4 != 1)
			{
				throw new ArgumentException(SR.Format(SR.Arg_ResourceFileUnsupportedVersion, 2, num4));
			}
			_version = num4;
			_numResources = _store.ReadInt32();
			if (_numResources < 0)
			{
				throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted);
			}
			int num5 = _store.ReadInt32();
			if (num5 < 0)
			{
				throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted);
			}
			_typeTable = new Type[num5];
			_typeNamePositions = new int[num5];
			for (int i = 0; i < num5; i++)
			{
				_typeNamePositions[i] = (int)_store.BaseStream.Position;
				SkipString();
			}
			long position = _store.BaseStream.Position;
			int num6 = (int)position & 7;
			if (num6 != 0)
			{
				for (int j = 0; j < 8 - num6; j++)
				{
					_store.ReadByte();
				}
			}
			if (_ums == null)
			{
				_nameHashes = new int[_numResources];
				for (int k = 0; k < _numResources; k++)
				{
					_nameHashes[k] = _store.ReadInt32();
				}
			}
			else
			{
				int num7 = 4 * _numResources;
				if (num7 < 0)
				{
					throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted);
				}
				_nameHashesPtr = (int*)_ums.PositionPointer;
				_ums.Seek(num7, SeekOrigin.Current);
				_ = _ums.PositionPointer;
			}
			if (_ums == null)
			{
				_namePositions = new int[_numResources];
				for (int l = 0; l < _numResources; l++)
				{
					int num8 = _store.ReadInt32();
					if (num8 < 0)
					{
						throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted);
					}
					_namePositions[l] = num8;
				}
			}
			else
			{
				int num9 = 4 * _numResources;
				if (num9 < 0)
				{
					throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted);
				}
				_namePositionsPtr = (int*)_ums.PositionPointer;
				_ums.Seek(num9, SeekOrigin.Current);
				_ = _ums.PositionPointer;
			}
			_dataSectionOffset = _store.ReadInt32();
			if (_dataSectionOffset < 0)
			{
				throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted);
			}
			_nameSectionOffset = _store.BaseStream.Position;
			if (_dataSectionOffset < _nameSectionOffset)
			{
				throw new BadImageFormatException(SR.BadImageFormat_ResourcesHeaderCorrupted);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "UseReflectionToGetType will get trimmed out when AllowCustomResourceTypes is set to false. When set to true, we will already throw a warning for this feature switch, so we suppress this one in order forthe user to only get one error.")]
		private Type FindType(int typeIndex)
		{
			if (!AllowCustomResourceTypes)
			{
				throw new NotSupportedException(SR.ResourceManager_ReflectionNotAllowed);
			}
			if (typeIndex < 0 || typeIndex >= _typeTable.Length)
			{
				throw new BadImageFormatException(SR.BadImageFormat_InvalidType);
			}
			return _typeTable[typeIndex] ?? UseReflectionToGetType(typeIndex);
		}

		[RequiresUnreferencedCode("The CustomResourceTypesSupport feature switch has been enabled for this app which is being trimmed. Custom readers as well as custom objects on the resources file are not observable by the trimmer and so required assemblies, types and members may be removed.")]
		private Type UseReflectionToGetType(int typeIndex)
		{
			long position = _store.BaseStream.Position;
			try
			{
				_store.BaseStream.Position = _typeNamePositions[typeIndex];
				string typeName = _store.ReadString();
				_typeTable[typeIndex] = Type.GetType(typeName, throwOnError: true);
				return _typeTable[typeIndex];
			}
			catch (FileNotFoundException)
			{
				throw new NotSupportedException(SR.NotSupported_ResourceObjectSerialization);
			}
			finally
			{
				_store.BaseStream.Position = position;
			}
		}

		private string TypeNameFromTypeCode(ResourceTypeCode typeCode)
		{
			if (typeCode < ResourceTypeCode.StartOfUserTypes)
			{
				return "ResourceTypeCode." + typeCode;
			}
			int num = (int)(typeCode - 64);
			long position = _store.BaseStream.Position;
			try
			{
				_store.BaseStream.Position = _typeNamePositions[num];
				return _store.ReadString();
			}
			finally
			{
				_store.BaseStream.Position = position;
			}
		}
	}
	internal readonly struct ResourceLocator
	{
		internal int DataPosition { get; }

		internal object Value { get; }

		internal ResourceLocator(int dataPos, object value)
		{
			DataPosition = dataPos;
			Value = value;
		}

		internal static bool CanCache(ResourceTypeCode value)
		{
			return value <= ResourceTypeCode.TimeSpan;
		}
	}
	public class ResourceSet : IDisposable, System.Collections.IEnumerable
	{
		protected IResourceReader Reader;

		private Dictionary<object, object> _table;

		private Dictionary<string, object> _caseInsensitiveTable;

		protected ResourceSet()
		{
			_table = new Dictionary<object, object>();
		}

		internal ResourceSet(bool junk)
		{
		}

		public ResourceSet(string fileName)
			: this()
		{
			Reader = new ResourceReader(fileName);
			ReadResources();
		}

		public ResourceSet(Stream stream)
			: this()
		{
			Reader = new ResourceReader(stream);
			ReadResources();
		}

		public ResourceSet(IResourceReader reader)
			: this()
		{
			Reader = reader ?? throw new ArgumentNullException("reader");
			ReadResources();
		}

		public virtual void Close()
		{
			Dispose(disposing: true);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				IResourceReader reader = Reader;
				Reader = null;
				reader?.Close();
			}
			Reader = null;
			_caseInsensitiveTable = null;
			_table = null;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
		}

		public virtual Type GetDefaultReader()
		{
			return typeof(ResourceReader);
		}

		public virtual Type GetDefaultWriter()
		{
			return Type.GetType("System.Resources.ResourceWriter, System.Resources.Writer", throwOnError: true);
		}

		public virtual IDictionaryEnumerator GetEnumerator()
		{
			return GetEnumeratorHelper();
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumeratorHelper();
		}

		private IDictionaryEnumerator GetEnumeratorHelper()
		{
			IDictionary table = _table;
			if (table == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
			}
			return table.GetEnumerator();
		}

		public virtual string? GetString(string name)
		{
			object objectInternal = GetObjectInternal(name);
			if (objectInternal is string result)
			{
				return result;
			}
			if (objectInternal == null)
			{
				return null;
			}
			throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotString_Name, name));
		}

		public virtual string? GetString(string name, bool ignoreCase)
		{
			object objectInternal = GetObjectInternal(name);
			if (objectInternal is string result)
			{
				return result;
			}
			if (objectInternal != null)
			{
				throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotString_Name, name));
			}
			if (!ignoreCase)
			{
				return null;
			}
			objectInternal = GetCaseInsensitiveObjectInternal(name);
			if (objectInternal is string result2)
			{
				return result2;
			}
			if (objectInternal == null)
			{
				return null;
			}
			throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotString_Name, name));
		}

		public virtual object? GetObject(string name)
		{
			return GetObjectInternal(name);
		}

		public virtual object? GetObject(string name, bool ignoreCase)
		{
			object objectInternal = GetObjectInternal(name);
			if (objectInternal != null || !ignoreCase)
			{
				return objectInternal;
			}
			return GetCaseInsensitiveObjectInternal(name);
		}

		protected virtual void ReadResources()
		{
			IDictionaryEnumerator enumerator = Reader.GetEnumerator();
			while (enumerator.MoveNext())
			{
				_table.Add(enumerator.Key, enumerator.Value);
			}
		}

		private object GetObjectInternal(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			Dictionary<object, object> table = _table;
			if (table == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
			}
			table.TryGetValue(name, out var value);
			return value;
		}

		private object GetCaseInsensitiveObjectInternal(string name)
		{
			Dictionary<object, object> table = _table;
			if (table == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
			}
			Dictionary<string, object> dictionary = _caseInsensitiveTable;
			if (dictionary == null)
			{
				dictionary = new Dictionary<string, object>(table.Count, StringComparer.OrdinalIgnoreCase);
				foreach (KeyValuePair<object, object> item in table)
				{
					if (item.Key is string key)
					{
						dictionary.Add(key, item.Value);
					}
				}
				_caseInsensitiveTable = dictionary;
			}
			dictionary.TryGetValue(name, out var value);
			return value;
		}
	}
	internal enum ResourceTypeCode
	{
		Null = 0,
		String = 1,
		Boolean = 2,
		Char = 3,
		Byte = 4,
		SByte = 5,
		Int16 = 6,
		UInt16 = 7,
		Int32 = 8,
		UInt32 = 9,
		Int64 = 10,
		UInt64 = 11,
		Single = 12,
		Double = 13,
		Decimal = 14,
		DateTime = 15,
		TimeSpan = 16,
		LastPrimitive = 16,
		ByteArray = 32,
		Stream = 33,
		StartOfUserTypes = 64
	}
	internal sealed class RuntimeResourceSet : ResourceSet, System.Collections.IEnumerable
	{
		private Dictionary<string, ResourceLocator> _resCache;

		private ResourceReader _defaultReader;

		private Dictionary<string, ResourceLocator> _caseInsensitiveTable;

		internal RuntimeResourceSet(string fileName)
			: this(new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
		{
		}

		internal RuntimeResourceSet(Stream stream, bool permitDeserialization = false)
			: base(junk: false)
		{
			_resCache = new Dictionary<string, ResourceLocator>(FastResourceComparer.Default);
			_defaultReader = new ResourceReader(stream, _resCache, permitDeserialization);
		}

		protected override void Dispose(bool disposing)
		{
			if (_defaultReader != null)
			{
				if (disposing)
				{
					_defaultReader?.Close();
				}
				_defaultReader = null;
				_resCache = null;
				_caseInsensitiveTable = null;
				base.Dispose(disposing);
			}
		}

		public override IDictionaryEnumerator GetEnumerator()
		{
			return GetEnumeratorHelper();
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumeratorHelper();
		}

		private IDictionaryEnumerator GetEnumeratorHelper()
		{
			ResourceReader defaultReader = _defaultReader;
			if (defaultReader == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
			}
			return defaultReader.GetEnumerator();
		}

		public override string GetString(string key)
		{
			object @object = GetObject(key, ignoreCase: false, isString: true);
			return (string)@object;
		}

		public override string GetString(string key, bool ignoreCase)
		{
			object @object = GetObject(key, ignoreCase, isString: true);
			return (string)@object;
		}

		public override object GetObject(string key)
		{
			return GetObject(key, ignoreCase: false, isString: false);
		}

		public override object GetObject(string key, bool ignoreCase)
		{
			return GetObject(key, ignoreCase, isString: false);
		}

		private object GetObject(string key, bool ignoreCase, bool isString)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			ResourceReader defaultReader = _defaultReader;
			Dictionary<string, ResourceLocator> resCache = _resCache;
			if (defaultReader == null || resCache == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
			}
			ResourceLocator value;
			object obj;
			lock (resCache)
			{
				int dataPosition;
				if (resCache.TryGetValue(key, out value))
				{
					obj = value.Value;
					if (obj != null)
					{
						return obj;
					}
					dataPosition = value.DataPosition;
					ResourceTypeCode typeCode;
					return isString ? defaultReader.LoadString(dataPosition) : defaultReader.LoadObject(dataPosition, out typeCode);
				}
				dataPosition = defaultReader.FindPosForResource(key);
				if (dataPosition >= 0)
				{
					obj = ReadValue(defaultReader, dataPosition, isString, out value);
					resCache[key] = value;
					return obj;
				}
			}
			if (!ignoreCase)
			{
				return null;
			}
			bool flag = false;
			Dictionary<string, ResourceLocator> dictionary = _caseInsensitiveTable;
			if (dictionary == null)
			{
				dictionary = new Dictionary<string, ResourceLocator>(StringComparer.OrdinalIgnoreCase);
				flag = true;
			}
			lock (dictionary)
			{
				if (flag)
				{
					ResourceReader.ResourceEnumerator enumeratorInternal = defaultReader.GetEnumeratorInternal();
					while (enumeratorInternal.MoveNext())
					{
						string key2 = (string)enumeratorInternal.Key;
						ResourceLocator value2 = new ResourceLocator(enumeratorInternal.DataPosition, null);
						dictionary.Add(key2, value2);
					}
					_caseInsensitiveTable = dictionary;
				}
				if (!dictionary.TryGetValue(key, out value))
				{
					return null;
				}
				if (value.Value != null)
				{
					return value.Value;
				}
				obj = ReadValue(defaultReader, value.DataPosition, isString, out value);
				if (value.Value != null)
				{
					dictionary[key] = value;
				}
			}
			return obj;
		}

		private static object ReadValue(ResourceReader reader, int dataPos, bool isString, out ResourceLocator locator)
		{
			object obj;
			ResourceTypeCode typeCode;
			if (isString)
			{
				obj = reader.LoadString(dataPos);
				typeCode = ResourceTypeCode.String;
			}
			else
			{
				obj = reader.LoadObject(dataPos, out typeCode);
			}
			locator = new ResourceLocator(dataPos, ResourceLocator.CanCache(typeCode) ? obj : null);
			return obj;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false)]
	public sealed class SatelliteContractVersionAttribute : Attribute
	{
		public string Version { get; }

		public SatelliteContractVersionAttribute(string version)
		{
			if (version == null)
			{
				throw new ArgumentNullException("version");
			}
			Version = version;
		}
	}
	public enum UltimateResourceFallbackLocation
	{
		MainAssembly,
		Satellite
	}
}
namespace System.Reflection
{
	public abstract class Assembly : ICustomAttributeProvider, ISerializable
	{
		private static readonly Dictionary<string, Assembly> s_loadfile = new Dictionary<string, Assembly>();

		private static readonly List<string> s_loadFromAssemblyList = new List<string>();

		private static bool s_loadFromHandlerSet;

		private static int s_cachedSerializationSwitch;

		private static bool s_forceNullEntryPoint;

		public virtual IEnumerable<TypeInfo> DefinedTypes
		{
			[RequiresUnreferencedCode("Types might be removed")]
			get
			{
				Type[] types = GetTypes();
				TypeInfo[] array = new TypeInfo[types.Length];
				for (int i = 0; i < types.Length; i++)
				{
					TypeInfo typeInfo = types[i].GetTypeInfo();
					if (typeInfo == null)
					{
						throw new NotSupportedException(SR.Format(SR.NotSupported_NoTypeInfo, types[i].FullName));
					}
					array[i] = typeInfo;
				}
				return array;
			}
		}

		public virtual IEnumerable<Type> ExportedTypes
		{
			[RequiresUnreferencedCode("Types might be removed")]
			get
			{
				return GetExportedTypes();
			}
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public virtual string? CodeBase
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual MethodInfo? EntryPoint
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual string? FullName
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual string ImageRuntimeVersion
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool IsDynamic => false;

		public virtual string Location
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool ReflectionOnly
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool IsCollectible => true;

		public bool IsFullyTrusted => true;

		public virtual IEnumerable<CustomAttributeData> CustomAttributes => GetCustomAttributesData();

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public virtual string EscapedCodeBase => AssemblyName.EscapeCodeBase(CodeBase);

		public virtual Module ManifestModule
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual IEnumerable<Module> Modules => GetLoadedModules(getResourceModules: true);

		[Obsolete("The Global Assembly Cache is not supported.", DiagnosticId = "SYSLIB0005", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public virtual bool GlobalAssemblyCache
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual long HostContext
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual SecurityRuleSet SecurityRuleSet => SecurityRuleSet.None;

		public virtual event ModuleResolveEventHandler? ModuleResolve
		{
			add
			{
				throw NotImplemented.ByDesign;
			}
			remove
			{
				throw NotImplemented.ByDesign;
			}
		}

		public static Assembly Load(string assemblyString)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return RuntimeAssembly.InternalLoad(assemblyString, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext);
		}

		[Obsolete("Assembly.LoadWithPartialName has been deprecated. Use Assembly.Load() instead.")]
		public static Assembly? LoadWithPartialName(string partialName)
		{
			if (partialName == null)
			{
				throw new ArgumentNullException("partialName");
			}
			if (partialName.Length == 0 || partialName[0] == '\0')
			{
				throw new ArgumentException(SR.Format_StringZeroLength, "partialName");
			}
			try
			{
				StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
				return RuntimeAssembly.InternalLoad(partialName, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext);
			}
			catch (FileNotFoundException)
			{
				return null;
			}
		}

		public static Assembly Load(AssemblyName assemblyRef)
		{
			if (assemblyRef == null)
			{
				throw new ArgumentNullException("assemblyRef");
			}
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return RuntimeAssembly.InternalLoad(assemblyRef, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetExecutingAssemblyNative(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retAssembly);

		internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark)
		{
			RuntimeAssembly o = null;
			GetExecutingAssemblyNative(new StackCrawlMarkHandle(ref stackMark), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		public static Assembly GetExecutingAssembly()
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return GetExecutingAssembly(ref stackMark);
		}

		public static Assembly GetCallingAssembly()
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCallersCaller;
			return GetExecutingAssembly(ref stackMark);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetEntryAssemblyNative(ObjectHandleOnStack retAssembly);

		private static Assembly GetEntryAssemblyInternal()
		{
			RuntimeAssembly o = null;
			GetEntryAssemblyNative(ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool IsRuntimeImplemented()
		{
			return this is RuntimeAssembly;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern uint GetAssemblyCount();

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type[] GetTypes()
		{
			Module[] modules = GetModules(getResourceModules: false);
			if (modules.Length == 1)
			{
				return modules[0].GetTypes();
			}
			int num = 0;
			Type[][] array = new Type[modules.Length][];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = modules[i].GetTypes();
				num += array[i].Length;
			}
			int num2 = 0;
			Type[] array2 = new Type[num];
			for (int j = 0; j < array.Length; j++)
			{
				int num3 = array[j].Length;
				Array.Copy(array[j], 0, array2, num2, num3);
				num2 += num3;
			}
			return array2;
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type[] GetExportedTypes()
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type[] GetForwardedTypes()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual ManifestResourceInfo? GetManifestResourceInfo(string resourceName)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual string[] GetManifestResourceNames()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual Stream? GetManifestResourceStream(string name)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual Stream? GetManifestResourceStream(Type type, string name)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual AssemblyName GetName()
		{
			return GetName(copiedName: false);
		}

		public virtual AssemblyName GetName(bool copiedName)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type? GetType(string name)
		{
			return GetType(name, throwOnError: false, ignoreCase: false);
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type? GetType(string name, bool throwOnError)
		{
			return GetType(name, throwOnError, ignoreCase: false);
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type? GetType(string name, bool throwOnError, bool ignoreCase)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual bool IsDefined(Type attributeType, bool inherit)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual IList<CustomAttributeData> GetCustomAttributesData()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual object[] GetCustomAttributes(bool inherit)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Assembly.CreateInstance is not supported with trimming. Use Type.GetType instead.")]
		public object? CreateInstance(string typeName)
		{
			return CreateInstance(typeName, ignoreCase: false, BindingFlags.Instance | BindingFlags.Public, null, null, null, null);
		}

		[RequiresUnreferencedCode("Assembly.CreateInstance is not supported with trimming. Use Type.GetType instead.")]
		public object? CreateInstance(string typeName, bool ignoreCase)
		{
			return CreateInstance(typeName, ignoreCase, BindingFlags.Instance | BindingFlags.Public, null, null, null, null);
		}

		[RequiresUnreferencedCode("Assembly.CreateInstance is not supported with trimming. Use Type.GetType instead.")]
		public virtual object? CreateInstance(string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder? binder, object[]? args, CultureInfo? culture, object[]? activationAttributes)
		{
			Type type = GetType(typeName, throwOnError: false, ignoreCase);
			if (type == null)
			{
				return null;
			}
			return Activator.CreateInstance(type, bindingAttr, binder, args, culture, activationAttributes);
		}

		public virtual Module? GetModule(string name)
		{
			throw NotImplemented.ByDesign;
		}

		public Module[] GetModules()
		{
			return GetModules(getResourceModules: false);
		}

		public virtual Module[] GetModules(bool getResourceModules)
		{
			throw NotImplemented.ByDesign;
		}

		public Module[] GetLoadedModules()
		{
			return GetLoadedModules(getResourceModules: false);
		}

		public virtual Module[] GetLoadedModules(bool getResourceModules)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Assembly references might be removed")]
		public virtual AssemblyName[] GetReferencedAssemblies()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual Assembly GetSatelliteAssembly(CultureInfo culture)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual Assembly GetSatelliteAssembly(CultureInfo culture, Version? version)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public virtual FileStream? GetFile(string name)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public virtual FileStream[] GetFiles()
		{
			return GetFiles(getResourceModules: false);
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public virtual FileStream[] GetFiles(bool getResourceModules)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw NotImplemented.ByDesign;
		}

		public override string ToString()
		{
			return FullName ?? base.ToString();
		}

		public override bool Equals(object? o)
		{
			return base.Equals(o);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(Assembly? left, Assembly? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(Assembly? left, Assembly? right)
		{
			return !(left == right);
		}

		public static string CreateQualifiedName(string? assemblyName, string? typeName)
		{
			return typeName + ", " + assemblyName;
		}

		public static Assembly? GetAssembly(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			Module module = type.Module;
			if (module == null)
			{
				return null;
			}
			return module.Assembly;
		}

		public static Assembly? GetEntryAssembly()
		{
			if (s_forceNullEntryPoint)
			{
				return null;
			}
			return GetEntryAssemblyInternal();
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly Load(byte[] rawAssembly)
		{
			return Load(rawAssembly, null);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly Load(byte[] rawAssembly, byte[]? rawSymbolStore)
		{
			if (rawAssembly == null)
			{
				throw new ArgumentNullException("rawAssembly");
			}
			if (rawAssembly.Length == 0)
			{
				throw new BadImageFormatException(SR.BadImageFormat_BadILFormat);
			}
			SerializationInfo.ThrowIfDeserializationInProgress("AllowAssembliesFromByteArrays", ref s_cachedSerializationSwitch);
			AssemblyLoadContext assemblyLoadContext = new IndividualAssemblyLoadContext("Assembly.Load(byte[], ...)");
			return assemblyLoadContext.InternalLoad(rawAssembly, rawSymbolStore);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly LoadFile(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (PathInternal.IsPartiallyQualified(path))
			{
				throw new ArgumentException(SR.Format(SR.Argument_AbsolutePathRequired, path), "path");
			}
			string fullPath = Path.GetFullPath(path);
			lock (s_loadfile)
			{
				if (s_loadfile.TryGetValue(fullPath, out var value))
				{
					return value;
				}
				AssemblyLoadContext assemblyLoadContext = new IndividualAssemblyLoadContext("Assembly.LoadFile(" + fullPath + ")");
				value = assemblyLoadContext.LoadFromAssemblyPath(fullPath);
				s_loadfile.Add(fullPath, value);
				return value;
			}
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		[UnconditionalSuppressMessage("SingleFile", "IL3000:Avoid accessing Assembly file path when publishing as a single file", Justification = "The assembly is loaded by specifying a path outside of the single-file bundle, the location of the path will not be empty if the path exist, otherwise it will be handled as null")]
		private static Assembly LoadFromResolveHandler(object sender, ResolveEventArgs args)
		{
			Assembly requestingAssembly = args.RequestingAssembly;
			if (requestingAssembly == null)
			{
				return null;
			}
			if (AssemblyLoadContext.Default != AssemblyLoadContext.GetLoadContext(requestingAssembly))
			{
				return null;
			}
			string location = requestingAssembly.Location;
			if (string.IsNullOrEmpty(location))
			{
				return null;
			}
			location = Path.GetFullPath(location);
			lock (s_loadFromAssemblyList)
			{
				if (!s_loadFromAssemblyList.Contains(location))
				{
					if (AssemblyLoadContext.IsTracingEnabled())
					{
						AssemblyLoadContext.TraceAssemblyLoadFromResolveHandlerInvoked(args.Name, isTrackedAssembly: false, location, null);
					}
					return null;
				}
			}
			AssemblyName assemblyName = new AssemblyName(args.Name);
			string text = Path.Combine(Path.GetDirectoryName(location), assemblyName.Name + ".dll");
			if (AssemblyLoadContext.IsTracingEnabled())
			{
				AssemblyLoadContext.TraceAssemblyLoadFromResolveHandlerInvoked(args.Name, isTrackedAssembly: true, location, text);
			}
			try
			{
				return LoadFrom(text);
			}
			catch (FileNotFoundException)
			{
				return null;
			}
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly LoadFrom(string assemblyFile)
		{
			if (assemblyFile == null)
			{
				throw new ArgumentNullException("assemblyFile");
			}
			string fullPath = Path.GetFullPath(assemblyFile);
			if (!s_loadFromHandlerSet)
			{
				lock (s_loadFromAssemblyList)
				{
					if (!s_loadFromHandlerSet)
					{
						AssemblyLoadContext.AssemblyResolve += LoadFromResolveHandler;
						s_loadFromHandlerSet = true;
					}
				}
			}
			lock (s_loadFromAssemblyList)
			{
				if (!s_loadFromAssemblyList.Contains(fullPath))
				{
					s_loadFromAssemblyList.Add(fullPath);
				}
			}
			return AssemblyLoadContext.Default.LoadFromAssemblyPath(fullPath);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly LoadFrom(string assemblyFile, byte[]? hashValue, AssemblyHashAlgorithm hashAlgorithm)
		{
			throw new NotSupportedException(SR.NotSupported_AssemblyLoadFromHash);
		}

		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly UnsafeLoadFrom(string assemblyFile)
		{
			return LoadFrom(assemblyFile);
		}

		[RequiresUnreferencedCode("Types and members the loaded module depends on might be removed")]
		public Module LoadModule(string moduleName, byte[]? rawModule)
		{
			return LoadModule(moduleName, rawModule, null);
		}

		[RequiresUnreferencedCode("Types and members the loaded module depends on might be removed")]
		public virtual Module LoadModule(string moduleName, byte[]? rawModule, byte[]? rawSymbolStore)
		{
			throw NotImplemented.ByDesign;
		}

		[Obsolete("ReflectionOnly loading is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0018", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly ReflectionOnlyLoad(byte[] rawAssembly)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ReflectionOnly);
		}

		[Obsolete("ReflectionOnly loading is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0018", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly ReflectionOnlyLoad(string assemblyString)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ReflectionOnly);
		}

		[Obsolete("ReflectionOnly loading is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0018", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		[RequiresUnreferencedCode("Types and members the loaded assembly depends on might be removed")]
		public static Assembly ReflectionOnlyLoadFrom(string assemblyFile)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_ReflectionOnly);
		}
	}
	public sealed class AssemblyName : ICloneable, IDeserializationCallback, ISerializable
	{
		private string _name;

		private byte[] _publicKey;

		private byte[] _publicKeyToken;

		private CultureInfo _cultureInfo;

		private string _codeBase;

		private Version _version;

		private AssemblyHashAlgorithm _hashAlgorithm;

		private AssemblyVersionCompatibility _versionCompatibility;

		private AssemblyNameFlags _flags;

		internal const char c_DummyChar = '\uffff';

		private const short c_MaxAsciiCharsReallocate = 40;

		private const short c_MaxUnicodeCharsReallocate = 40;

		private const short c_MaxUTF_8BytesPerUnicodeChar = 4;

		private const short c_EncodedCharsPerByte = 3;

		private const string RFC3986ReservedMarks = ":/?#[]@!$&'()*+,;=";

		private const string RFC3986UnreservedMarks = "-._~";

		public string? Name
		{
			get
			{
				return _name;
			}
			set
			{
				_name = value;
			}
		}

		public Version? Version
		{
			get
			{
				return _version;
			}
			set
			{
				_version = value;
			}
		}

		public CultureInfo? CultureInfo
		{
			get
			{
				return _cultureInfo;
			}
			set
			{
				_cultureInfo = value;
			}
		}

		public string? CultureName
		{
			get
			{
				return _cultureInfo?.Name;
			}
			set
			{
				_cultureInfo = ((value == null) ? null : new CultureInfo(value));
			}
		}

		public string? CodeBase
		{
			[RequiresAssemblyFiles("The code will return an empty string for assemblies embedded in a single-file app")]
			get
			{
				return _codeBase;
			}
			set
			{
				_codeBase = value;
			}
		}

		[RequiresAssemblyFiles("The code will return an empty string for assemblies embedded in a single-file app")]
		public string? EscapedCodeBase
		{
			get
			{
				if (_codeBase == null)
				{
					return null;
				}
				return EscapeCodeBase(_codeBase);
			}
		}

		public ProcessorArchitecture ProcessorArchitecture
		{
			get
			{
				int num = (int)(_flags & (AssemblyNameFlags)112) >> 4;
				if (num > 5)
				{
					num = 0;
				}
				return (ProcessorArchitecture)num;
			}
			set
			{
				int num = (int)(value & (ProcessorArchitecture)7);
				if (num <= 5)
				{
					_flags = (AssemblyNameFlags)((long)_flags & 0xFFFFFF0FL);
					_flags |= (AssemblyNameFlags)(num << 4);
				}
			}
		}

		public AssemblyContentType ContentType
		{
			get
			{
				int num = (int)(_flags & (AssemblyNameFlags)3584) >> 9;
				if (num > 1)
				{
					num = 0;
				}
				return (AssemblyContentType)num;
			}
			set
			{
				int num = (int)(value & (AssemblyContentType)7);
				if (num <= 1)
				{
					_flags = (AssemblyNameFlags)((long)_flags & 0xFFFFF1FFL);
					_flags |= (AssemblyNameFlags)(num << 9);
				}
			}
		}

		public AssemblyNameFlags Flags
		{
			get
			{
				return _flags & (AssemblyNameFlags)(-3825);
			}
			set
			{
				_flags &= (AssemblyNameFlags)3824;
				_flags |= value & (AssemblyNameFlags)(-3825);
			}
		}

		public AssemblyHashAlgorithm HashAlgorithm
		{
			get
			{
				return _hashAlgorithm;
			}
			set
			{
				_hashAlgorithm = value;
			}
		}

		public AssemblyVersionCompatibility VersionCompatibility
		{
			get
			{
				return _versionCompatibility;
			}
			set
			{
				_versionCompatibility = value;
			}
		}

		[Obsolete("Strong name signing is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0017", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public StrongNameKeyPair? KeyPair
		{
			get
			{
				throw new PlatformNotSupportedException(SR.PlatformNotSupported_StrongNameSigning);
			}
			set
			{
				throw new PlatformNotSupportedException(SR.PlatformNotSupported_StrongNameSigning);
			}
		}

		public string FullName
		{
			get
			{
				if (string.IsNullOrEmpty(Name))
				{
					return string.Empty;
				}
				byte[] pkt = _publicKeyToken ?? ComputePublicKeyToken();
				return AssemblyNameFormatter.ComputeDisplayName(Name, Version, CultureName, pkt, Flags, ContentType);
			}
		}

		public AssemblyName(string assemblyName)
		{
			if (assemblyName == null)
			{
				throw new ArgumentNullException("assemblyName");
			}
			if (assemblyName.Length == 0 || assemblyName[0] == '\0')
			{
				throw new ArgumentException(SR.Format_StringZeroLength);
			}
			_name = assemblyName;
			nInit();
		}

		internal AssemblyName(string name, byte[] publicKey, byte[] publicKeyToken, Version version, CultureInfo cultureInfo, AssemblyHashAlgorithm hashAlgorithm, AssemblyVersionCompatibility versionCompatibility, string codeBase, AssemblyNameFlags flags)
		{
			_name = name;
			_publicKey = publicKey;
			_publicKeyToken = publicKeyToken;
			_version = version;
			_cultureInfo = cultureInfo;
			_hashAlgorithm = hashAlgorithm;
			_versionCompatibility = versionCompatibility;
			_codeBase = codeBase;
			_flags = flags;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal extern void nInit();

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern AssemblyName nGetFileInformation(string s);

		internal static AssemblyName GetFileInformationCore(string assemblyFile)
		{
			string fullPath = Path.GetFullPath(assemblyFile);
			return nGetFileInformation(fullPath);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern byte[] ComputePublicKeyToken();

		internal void SetProcArchIndex(PortableExecutableKinds pek, ImageFileMachine ifm)
		{
			ProcessorArchitecture = CalculateProcArchIndex(pek, ifm, _flags);
		}

		internal static ProcessorArchitecture CalculateProcArchIndex(PortableExecutableKinds pek, ImageFileMachine ifm, AssemblyNameFlags flags)
		{
			if ((flags & (AssemblyNameFlags)240) == (AssemblyNameFlags)112)
			{
				return ProcessorArchitecture.None;
			}
			if ((pek & PortableExecutableKinds.PE32Plus) == PortableExecutableKinds.PE32Plus)
			{
				switch (ifm)
				{
				case ImageFileMachine.IA64:
					return ProcessorArchitecture.IA64;
				case ImageFileMachine.AMD64:
					return ProcessorArchitecture.Amd64;
				case ImageFileMachine.I386:
					if ((pek & PortableExecutableKinds.ILOnly) == PortableExecutableKinds.ILOnly)
					{
						return ProcessorArchitecture.MSIL;
					}
					break;
				}
			}
			else
			{
				switch (ifm)
				{
				case ImageFileMachine.I386:
					if ((pek & PortableExecutableKinds.Required32Bit) == PortableExecutableKinds.Required32Bit)
					{
						return ProcessorArchitecture.X86;
					}
					if ((pek & PortableExecutableKinds.ILOnly) == PortableExecutableKinds.ILOnly)
					{
						return ProcessorArchitecture.MSIL;
					}
					return ProcessorArchitecture.X86;
				case ImageFileMachine.ARM:
					return ProcessorArchitecture.Arm;
				}
			}
			return ProcessorArchitecture.None;
		}

		public AssemblyName()
		{
			_versionCompatibility = AssemblyVersionCompatibility.SameMachine;
		}

		public object Clone()
		{
			return new AssemblyName
			{
				_name = _name,
				_publicKey = (byte[])_publicKey?.Clone(),
				_publicKeyToken = (byte[])_publicKeyToken?.Clone(),
				_cultureInfo = _cultureInfo,
				_version = _version,
				_flags = _flags,
				_codeBase = _codeBase,
				_hashAlgorithm = _hashAlgorithm,
				_versionCompatibility = _versionCompatibility
			};
		}

		public static AssemblyName GetAssemblyName(string assemblyFile)
		{
			if (assemblyFile == null)
			{
				throw new ArgumentNullException("assemblyFile");
			}
			return GetFileInformationCore(assemblyFile);
		}

		public byte[]? GetPublicKey()
		{
			return _publicKey;
		}

		public void SetPublicKey(byte[]? publicKey)
		{
			_publicKey = publicKey;
			if (publicKey == null)
			{
				_flags &= ~AssemblyNameFlags.PublicKey;
			}
			else
			{
				_flags |= AssemblyNameFlags.PublicKey;
			}
		}

		public byte[]? GetPublicKeyToken()
		{
			return _publicKeyToken ?? (_publicKeyToken = ComputePublicKeyToken());
		}

		public void SetPublicKeyToken(byte[]? publicKeyToken)
		{
			_publicKeyToken = publicKeyToken;
		}

		public override string ToString()
		{
			string fullName = FullName;
			if (fullName == null)
			{
				return base.ToString();
			}
			return fullName;
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public void OnDeserialization(object? sender)
		{
			throw new PlatformNotSupportedException();
		}

		public static bool ReferenceMatchesDefinition(AssemblyName? reference, AssemblyName? definition)
		{
			if (reference == definition)
			{
				return true;
			}
			if (reference == null)
			{
				throw new ArgumentNullException("reference");
			}
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			string text = reference.Name ?? string.Empty;
			string value = definition.Name ?? string.Empty;
			return text.Equals(value, StringComparison.OrdinalIgnoreCase);
		}

		[RequiresAssemblyFiles("The code will return an empty string for assemblies embedded in a single-file app")]
		internal static string EscapeCodeBase(string codebase)
		{
			if (codebase == null)
			{
				return string.Empty;
			}
			int destPos = 0;
			char[] array = EscapeString(codebase, 0, codebase.Length, null, ref destPos, isUriString: true, '\uffff', '\uffff', '\uffff');
			if (array == null)
			{
				return codebase;
			}
			return new string(array, 0, destPos);
		}

		internal unsafe static char[] EscapeString(string input, int start, int end, char[] dest, ref int destPos, bool isUriString, char force1, char force2, char rsvd)
		{
			int i = start;
			int num = start;
			byte* ptr = stackalloc byte[160];
			fixed (char* ptr2 = input)
			{
				for (; i < end; i++)
				{
					char c = ptr2[i];
					if (c > '\u007f')
					{
						short num2 = (short)Math.Min(end - i, 39);
						short num3 = 1;
						while (num3 < num2 && ptr2[i + num3] > '\u007f')
						{
							num3++;
						}
						if (ptr2[i + num3 - 1] >= '\ud800' && ptr2[i + num3 - 1] <= '\udbff')
						{
							if (num3 == 1 || num3 == end - i)
							{
								throw new FormatException(SR.Arg_FormatException);
							}
							num3++;
						}
						dest = EnsureDestinationSize(ptr2, dest, i, (short)(num3 * 4 * 3), 480, ref destPos, num);
						short num4 = (short)Encoding.UTF8.GetBytes(ptr2 + i, num3, ptr, 160);
						if (num4 == 0)
						{
							throw new FormatException(SR.Arg_FormatException);
						}
						i += num3 - 1;
						for (num3 = 0; num3 < num4; num3++)
						{
							EscapeAsciiChar((char)ptr[num3], dest, ref destPos);
						}
						num = i + 1;
					}
					else if (c == '%' && rsvd == '%')
					{
						dest = EnsureDestinationSize(ptr2, dest, i, 3, 120, ref destPos, num);
						if (i + 2 < end && HexConverter.IsHexChar(ptr2[i + 1]) && HexConverter.IsHexChar(ptr2[i + 2]))
						{
							dest[destPos++] = '%';
							dest[destPos++] = ptr2[i + 1];
							dest[destPos++] = ptr2[i + 2];
							i += 2;
						}
						else
						{
							EscapeAsciiChar('%', dest, ref destPos);
						}
						num = i + 1;
					}
					else if (c == force1 || c == force2 || (c != rsvd && (isUriString ? (!IsReservedUnreservedOrHash(c)) : (!IsUnreserved(c)))))
					{
						dest = EnsureDestinationSize(ptr2, dest, i, 3, 120, ref destPos, num);
						EscapeAsciiChar(c, dest, ref destPos);
						num = i + 1;
					}
				}
				if (num != i && (num != start || dest != null))
				{
					dest = EnsureDestinationSize(ptr2, dest, i, 0, 0, ref destPos, num);
				}
			}
			return dest;
		}

		private unsafe static char[] EnsureDestinationSize(char* pStr, char[] dest, int currentInputPos, short charsToAdd, short minReallocateChars, ref int destPos, int prevInputPos)
		{
			if (dest == null || dest.Length < destPos + (currentInputPos - prevInputPos) + charsToAdd)
			{
				char[] array = new char[destPos + (currentInputPos - prevInputPos) + minReallocateChars];
				if (dest != null && destPos != 0)
				{
					Buffer.BlockCopy(dest, 0, array, 0, destPos << 1);
				}
				dest = array;
			}
			while (prevInputPos != currentInputPos)
			{
				dest[destPos++] = pStr[prevInputPos++];
			}
			return dest;
		}

		internal static void EscapeAsciiChar(char ch, char[] to, ref int pos)
		{
			to[pos++] = '%';
			to[pos++] = HexConverter.ToCharUpper((int)ch >> 4);
			to[pos++] = HexConverter.ToCharUpper(ch);
		}

		private static bool IsReservedUnreservedOrHash(char c)
		{
			if (IsUnreserved(c))
			{
				return true;
			}
			return ":/?#[]@!$&'()*+,;=".Contains(c);
		}

		internal static bool IsUnreserved(char c)
		{
			if (IsAsciiLetterOrDigit(c))
			{
				return true;
			}
			return "-._~".Contains(c);
		}

		internal static bool IsAsciiLetter(char character)
		{
			if (character < 'a' || character > 'z')
			{
				if (character >= 'A')
				{
					return character <= 'Z';
				}
				return false;
			}
			return true;
		}

		internal static bool IsAsciiLetterOrDigit(char character)
		{
			if (!IsAsciiLetter(character))
			{
				if (character >= '0')
				{
					return character <= '9';
				}
				return false;
			}
			return true;
		}
	}
	internal static class Associates
	{
		[Flags]
		internal enum Attributes
		{
			ComposedOfAllVirtualMethods = 1,
			ComposedOfAllPrivateMethods = 2,
			ComposedOfNoPublicMembers = 4,
			ComposedOfNoStaticMembers = 8
		}

		internal static bool IncludeAccessor(MethodInfo associate, bool nonPublic)
		{
			if ((object)associate == null)
			{
				return false;
			}
			if (nonPublic)
			{
				return true;
			}
			if (associate.IsPublic)
			{
				return true;
			}
			return false;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Module.ResolveMethod is marked as RequiresUnreferencedCode because it relies on tokenswhich are not guaranteed to be stable across trimming. So if somebody hardcodes a token it could break.The usage here is not like that as all these tokens come from existing metadata loaded from some ILand so trimming has no effect (the tokens are read AFTER trimming occured).")]
		private static RuntimeMethodInfo AssignAssociates(int tkMethod, RuntimeType declaredType, RuntimeType reflectedType)
		{
			if (MetadataToken.IsNullToken(tkMethod))
			{
				return null;
			}
			bool flag = declaredType != reflectedType;
			IntPtr[] array = null;
			int typeInstCount = 0;
			RuntimeType[] instantiationInternal = declaredType.GetTypeHandleInternal().GetInstantiationInternal();
			if (instantiationInternal != null)
			{
				typeInstCount = instantiationInternal.Length;
				array = new IntPtr[instantiationInternal.Length];
				for (int i = 0; i < instantiationInternal.Length; i++)
				{
					array[i] = instantiationInternal[i].GetTypeHandleInternal().Value;
				}
			}
			RuntimeMethodHandleInternal runtimeMethodHandleInternal = ModuleHandle.ResolveMethodHandleInternal(RuntimeTypeHandle.GetModule(declaredType), tkMethod, array, typeInstCount, null, 0);
			if (flag)
			{
				MethodAttributes attributes = RuntimeMethodHandle.GetAttributes(runtimeMethodHandleInternal);
				if ((attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private)
				{
					return null;
				}
				if ((attributes & MethodAttributes.Virtual) != 0 && (RuntimeTypeHandle.GetAttributes(declaredType) & TypeAttributes.ClassSemanticsMask) == 0)
				{
					int slot = RuntimeMethodHandle.GetSlot(runtimeMethodHandleInternal);
					runtimeMethodHandleInternal = RuntimeTypeHandle.GetMethodAt(reflectedType, slot);
				}
			}
			RuntimeMethodInfo runtimeMethodInfo = RuntimeType.GetMethodBase(reflectedType, runtimeMethodHandleInternal) as RuntimeMethodInfo;
			return runtimeMethodInfo ?? (reflectedType.Module.ResolveMethod(tkMethod, null, null) as RuntimeMethodInfo);
		}

		internal static void AssignAssociates(MetadataImport scope, int mdPropEvent, RuntimeType declaringType, RuntimeType reflectedType, out RuntimeMethodInfo addOn, out RuntimeMethodInfo removeOn, out RuntimeMethodInfo fireOn, out RuntimeMethodInfo getter, out RuntimeMethodInfo setter, out MethodInfo[] other, out bool composedOfAllPrivateMethods, out BindingFlags bindingFlags)
		{
			addOn = (removeOn = (fireOn = (getter = (setter = null))));
			Attributes attributes = Attributes.ComposedOfAllVirtualMethods | Attributes.ComposedOfAllPrivateMethods | Attributes.ComposedOfNoPublicMembers | Attributes.ComposedOfNoStaticMembers;
			while (RuntimeTypeHandle.IsGenericVariable(reflectedType))
			{
				reflectedType = (RuntimeType)reflectedType.BaseType;
			}
			bool isInherited = declaringType != reflectedType;
			List<MethodInfo> list = null;
			scope.Enum(MetadataTokenType.MethodDef, mdPropEvent, out var result);
			int num = result.Length / 2;
			for (int i = 0; i < num; i++)
			{
				int tkMethod = result[i * 2];
				MethodSemanticsAttributes methodSemanticsAttributes = (MethodSemanticsAttributes)result[i * 2 + 1];
				RuntimeMethodInfo runtimeMethodInfo = AssignAssociates(tkMethod, declaringType, reflectedType);
				if (runtimeMethodInfo == null)
				{
					continue;
				}
				MethodAttributes attributes2 = runtimeMethodInfo.Attributes;
				bool flag = (attributes2 & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;
				bool flag2 = (attributes2 & MethodAttributes.Virtual) != 0;
				MethodAttributes methodAttributes = attributes2 & MethodAttributes.MemberAccessMask;
				bool flag3 = methodAttributes == MethodAttributes.Public;
				bool flag4 = (attributes2 & MethodAttributes.Static) != 0;
				if (flag3)
				{
					attributes &= ~Attributes.ComposedOfNoPublicMembers;
					attributes &= ~Attributes.ComposedOfAllPrivateMethods;
				}
				else if (!flag)
				{
					attributes &= ~Attributes.ComposedOfAllPrivateMethods;
				}
				if (flag4)
				{
					attributes &= ~Attributes.ComposedOfNoStaticMembers;
				}
				if (!flag2)
				{
					attributes &= ~Attributes.ComposedOfAllVirtualMethods;
				}
				switch (methodSemanticsAttributes)
				{
				case MethodSemanticsAttributes.Setter:
					setter = runtimeMethodInfo;
					continue;
				case MethodSemanticsAttributes.Getter:
					getter = runtimeMethodInfo;
					continue;
				case MethodSemanticsAttributes.Fire:
					fireOn = runtimeMethodInfo;
					continue;
				case MethodSemanticsAttributes.AddOn:
					addOn = runtimeMethodInfo;
					continue;
				case MethodSemanticsAttributes.RemoveOn:
					removeOn = runtimeMethodInfo;
					continue;
				}
				if (list == null)
				{
					list = new List<MethodInfo>(num);
				}
				list.Add(runtimeMethodInfo);
			}
			bool isPublic = (attributes & Attributes.ComposedOfNoPublicMembers) == 0;
			bool isStatic = (attributes & Attributes.ComposedOfNoStaticMembers) == 0;
			bindingFlags = RuntimeType.FilterPreCalculate(isPublic, isInherited, isStatic);
			composedOfAllPrivateMethods = (attributes & Attributes.ComposedOfAllPrivateMethods) != 0;
			other = list?.ToArray();
		}
	}
	public abstract class ConstructorInfo : MethodBase
	{
		public static readonly string ConstructorName = ".ctor";

		public static readonly string TypeConstructorName = ".cctor";

		public override MemberTypes MemberType => MemberTypes.Constructor;

		internal virtual Type GetReturnType()
		{
			throw new NotImplementedException();
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public object Invoke(object?[]? parameters)
		{
			return Invoke(BindingFlags.Default, null, parameters, null);
		}

		public abstract object Invoke(BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture);

		public override bool Equals(object? obj)
		{
			return base.Equals(obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(ConstructorInfo? left, ConstructorInfo? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(ConstructorInfo? left, ConstructorInfo? right)
		{
			return !(left == right);
		}
	}
	public abstract class FieldInfo : MemberInfo
	{
		public override MemberTypes MemberType => MemberTypes.Field;

		public abstract FieldAttributes Attributes { get; }

		public abstract Type FieldType { get; }

		public bool IsInitOnly => (Attributes & FieldAttributes.InitOnly) != 0;

		public bool IsLiteral => (Attributes & FieldAttributes.Literal) != 0;

		public bool IsNotSerialized => (Attributes & FieldAttributes.NotSerialized) != 0;

		public bool IsPinvokeImpl => (Attributes & FieldAttributes.PinvokeImpl) != 0;

		public bool IsSpecialName => (Attributes & FieldAttributes.SpecialName) != 0;

		public bool IsStatic => (Attributes & FieldAttributes.Static) != 0;

		public bool IsAssembly => (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Assembly;

		public bool IsFamily => (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Family;

		public bool IsFamilyAndAssembly => (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.FamANDAssem;

		public bool IsFamilyOrAssembly => (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.FamORAssem;

		public bool IsPrivate => (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Private;

		public bool IsPublic => (Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.Public;

		public virtual bool IsSecurityCritical => true;

		public virtual bool IsSecuritySafeCritical => false;

		public virtual bool IsSecurityTransparent => false;

		public abstract RuntimeFieldHandle FieldHandle { get; }

		public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle)
		{
			if (handle.IsNullHandle())
			{
				throw new ArgumentException(SR.Argument_InvalidHandle, "handle");
			}
			FieldInfo fieldInfo = RuntimeType.GetFieldInfo(handle.GetRuntimeFieldInfo());
			Type declaringType = fieldInfo.DeclaringType;
			if (declaringType != null && declaringType.IsGenericType)
			{
				throw new ArgumentException(SR.Format(SR.Argument_FieldDeclaringTypeGeneric, fieldInfo.Name, declaringType.GetGenericTypeDefinition()));
			}
			return fieldInfo;
		}

		public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType)
		{
			if (handle.IsNullHandle())
			{
				throw new ArgumentException(SR.Argument_InvalidHandle);
			}
			return RuntimeType.GetFieldInfo(declaringType.GetRuntimeType(), handle.GetRuntimeFieldInfo());
		}

		public override bool Equals(object? obj)
		{
			return base.Equals(obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(FieldInfo? left, FieldInfo? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(FieldInfo? left, FieldInfo? right)
		{
			return !(left == right);
		}

		public abstract object? GetValue(object? obj);

		[DebuggerHidden]
		[DebuggerStepThrough]
		public void SetValue(object? obj, object? value)
		{
			SetValue(obj, value, BindingFlags.Default, Type.DefaultBinder, null);
		}

		public abstract void SetValue(object? obj, object? value, BindingFlags invokeAttr, Binder? binder, CultureInfo? culture);

		[CLSCompliant(false)]
		public virtual void SetValueDirect(TypedReference obj, object value)
		{
			throw new NotSupportedException(SR.NotSupported_AbstractNonCLS);
		}

		[CLSCompliant(false)]
		public virtual object? GetValueDirect(TypedReference obj)
		{
			throw new NotSupportedException(SR.NotSupported_AbstractNonCLS);
		}

		public virtual object? GetRawConstantValue()
		{
			throw new NotSupportedException(SR.NotSupported_AbstractNonCLS);
		}

		public virtual Type[] GetOptionalCustomModifiers()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual Type[] GetRequiredCustomModifiers()
		{
			throw NotImplemented.ByDesign;
		}
	}
	[Flags]
	internal enum INVOCATION_FLAGS : uint
	{
		INVOCATION_FLAGS_UNKNOWN = 0u,
		INVOCATION_FLAGS_INITIALIZED = 1u,
		INVOCATION_FLAGS_NO_INVOKE = 2u,
		INVOCATION_FLAGS_RUN_CLASS_CONSTRUCTOR = 4u,
		INVOCATION_FLAGS_NO_CTOR_INVOKE = 8u,
		INVOCATION_FLAGS_IS_CTOR = 0x10u,
		INVOCATION_FLAGS_IS_DELEGATE_CTOR = 0x80u,
		INVOCATION_FLAGS_CONTAINS_STACK_POINTERS = 0x100u,
		INVOCATION_FLAGS_SPECIAL_FIELD = 0x10u,
		INVOCATION_FLAGS_FIELD_SPECIAL_CAST = 0x20u,
		INVOCATION_FLAGS_CONSTRUCTOR_INVOKE = 0x10000000u
	}
	internal sealed class LoaderAllocatorScout
	{
		internal IntPtr m_nativeLoaderAllocator;

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern bool Destroy(IntPtr nativeLoaderAllocator);

		~LoaderAllocatorScout()
		{
			if (!(m_nativeLoaderAllocator == IntPtr.Zero) && !Destroy(m_nativeLoaderAllocator))
			{
				GC.ReRegisterForFinalize(this);
			}
		}
	}
	internal sealed class LoaderAllocator
	{
		private LoaderAllocatorScout m_scout;

		private object[] m_slots;

		internal CerHashtable<RuntimeMethodInfo, RuntimeMethodInfo> m_methodInstantiations;

		private int m_slotsUsed;

		private LoaderAllocator()
		{
			m_slots = new object[5];
			m_scout = new LoaderAllocatorScout();
		}
	}
	internal static class MdConstant
	{
		public unsafe static object GetValue(MetadataImport scope, int token, RuntimeTypeHandle fieldTypeHandle, bool raw)
		{
			long value;
			int length;
			CorElementType corElementType;
			string defaultValue = scope.GetDefaultValue(token, out value, out length, out corElementType);
			RuntimeType runtimeType = fieldTypeHandle.GetRuntimeType();
			if (runtimeType.IsEnum && !raw)
			{
				long num = 0L;
				switch (corElementType)
				{
				case CorElementType.ELEMENT_TYPE_VOID:
					return DBNull.Value;
				case CorElementType.ELEMENT_TYPE_CHAR:
					num = *(ushort*)(&value);
					break;
				case CorElementType.ELEMENT_TYPE_I1:
					num = *(sbyte*)(&value);
					break;
				case CorElementType.ELEMENT_TYPE_U1:
					num = *(byte*)(&value);
					break;
				case CorElementType.ELEMENT_TYPE_I2:
					num = *(short*)(&value);
					break;
				case CorElementType.ELEMENT_TYPE_U2:
					num = *(ushort*)(&value);
					break;
				case CorElementType.ELEMENT_TYPE_I4:
					num = *(int*)(&value);
					break;
				case CorElementType.ELEMENT_TYPE_U4:
					num = (uint)(*(int*)(&value));
					break;
				case CorElementType.ELEMENT_TYPE_I8:
					num = value;
					break;
				case CorElementType.ELEMENT_TYPE_U8:
					num = value;
					break;
				case CorElementType.ELEMENT_TYPE_CLASS:
					return null;
				default:
					throw new FormatException(SR.Arg_BadLiteralFormat);
				}
				return RuntimeType.CreateEnum(runtimeType, num);
			}
			if (runtimeType == typeof(DateTime))
			{
				long num2 = 0L;
				switch (corElementType)
				{
				case CorElementType.ELEMENT_TYPE_VOID:
					return DBNull.Value;
				case CorElementType.ELEMENT_TYPE_I8:
					num2 = value;
					break;
				case CorElementType.ELEMENT_TYPE_U8:
					num2 = value;
					break;
				case CorElementType.ELEMENT_TYPE_CLASS:
					return null;
				default:
					throw new FormatException(SR.Arg_BadLiteralFormat);
				}
				return new DateTime(num2);
			}
			return corElementType switch
			{
				CorElementType.ELEMENT_TYPE_VOID => DBNull.Value, 
				CorElementType.ELEMENT_TYPE_CHAR => *(char*)(&value), 
				CorElementType.ELEMENT_TYPE_I1 => *(sbyte*)(&value), 
				CorElementType.ELEMENT_TYPE_U1 => *(byte*)(&value), 
				CorElementType.ELEMENT_TYPE_I2 => *(short*)(&value), 
				CorElementType.ELEMENT_TYPE_U2 => *(ushort*)(&value), 
				CorElementType.ELEMENT_TYPE_I4 => *(int*)(&value), 
				CorElementType.ELEMENT_TYPE_U4 => *(uint*)(&value), 
				CorElementType.ELEMENT_TYPE_I8 => value, 
				CorElementType.ELEMENT_TYPE_U8 => (ulong)value, 
				CorElementType.ELEMENT_TYPE_BOOLEAN => *(int*)(&value) != 0, 
				CorElementType.ELEMENT_TYPE_R4 => *(float*)(&value), 
				CorElementType.ELEMENT_TYPE_R8 => *(double*)(&value), 
				CorElementType.ELEMENT_TYPE_STRING => defaultValue ?? string.Empty, 
				CorElementType.ELEMENT_TYPE_CLASS => null, 
				_ => throw new FormatException(SR.Arg_BadLiteralFormat), 
			};
		}
	}
	internal sealed class MdFieldInfo : RuntimeFieldInfo
	{
		private int m_tkField;

		private string m_name;

		private RuntimeType m_fieldType;

		private FieldAttributes m_fieldAttributes;

		public override string Name => m_name ?? (m_name = GetRuntimeModule().MetadataImport.GetName(m_tkField).ToString());

		public override int MetadataToken => m_tkField;

		public override RuntimeFieldHandle FieldHandle
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override FieldAttributes Attributes => m_fieldAttributes;

		public override bool IsSecurityCritical => DeclaringType.IsSecurityCritical;

		public override bool IsSecuritySafeCritical => DeclaringType.IsSecuritySafeCritical;

		public override bool IsSecurityTransparent => DeclaringType.IsSecurityTransparent;

		public unsafe override Type FieldType
		{
			get
			{
				if (m_fieldType == null)
				{
					ConstArray sigOfFieldDef = GetRuntimeModule().MetadataImport.GetSigOfFieldDef(m_tkField);
					m_fieldType = new Signature(sigOfFieldDef.Signature.ToPointer(), sigOfFieldDef.Length, m_declaringType).FieldType;
				}
				return m_fieldType;
			}
		}

		internal MdFieldInfo(int tkField, FieldAttributes fieldAttributes, RuntimeTypeHandle declaringTypeHandle, RuntimeType.RuntimeTypeCache reflectedTypeCache, BindingFlags bindingFlags)
			: base(reflectedTypeCache, declaringTypeHandle.GetRuntimeType(), bindingFlags)
		{
			m_tkField = tkField;
			m_name = null;
			m_fieldAttributes = fieldAttributes;
		}

		internal override bool CacheEquals(object o)
		{
			if (o is MdFieldInfo mdFieldInfo && mdFieldInfo.m_tkField == m_tkField)
			{
				return m_declaringType.GetTypeHandleInternal().GetModuleHandle().Equals(mdFieldInfo.m_declaringType.GetTypeHandleInternal().GetModuleHandle());
			}
			return false;
		}

		internal override RuntimeModule GetRuntimeModule()
		{
			return m_declaringType.GetRuntimeModule();
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override object GetValueDirect(TypedReference obj)
		{
			return GetValue(null);
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override void SetValueDirect(TypedReference obj, object value)
		{
			throw new FieldAccessException(SR.Acc_ReadOnly);
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override object GetValue(object obj)
		{
			return GetValue(raw: false);
		}

		public override object GetRawConstantValue()
		{
			return GetValue(raw: true);
		}

		private object GetValue(bool raw)
		{
			object value = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_tkField, FieldType.GetTypeHandleInternal(), raw);
			if (value == DBNull.Value)
			{
				throw new NotSupportedException(SR.Arg_EnumLitValueNotFound);
			}
			return value;
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
		{
			throw new FieldAccessException(SR.Acc_ReadOnly);
		}

		public override Type[] GetRequiredCustomModifiers()
		{
			return Type.EmptyTypes;
		}

		public override Type[] GetOptionalCustomModifiers()
		{
			return Type.EmptyTypes;
		}
	}
	[Flags]
	internal enum MdSigCallingConvention : byte
	{
		CallConvMask = 0xF,
		Default = 0,
		C = 1,
		StdCall = 2,
		ThisCall = 3,
		FastCall = 4,
		Vararg = 5,
		Field = 6,
		LocalSig = 7,
		Property = 8,
		Unmanaged = 9,
		GenericInst = 0xA,
		Generic = 0x10,
		HasThis = 0x20,
		ExplicitThis = 0x40
	}
	[Flags]
	internal enum PInvokeAttributes
	{
		NoMangle = 1,
		CharSetMask = 6,
		CharSetNotSpec = 0,
		CharSetAnsi = 2,
		CharSetUnicode = 4,
		CharSetAuto = 6,
		BestFitUseAssem = 0,
		BestFitEnabled = 0x10,
		BestFitDisabled = 0x20,
		BestFitMask = 0x30,
		ThrowOnUnmappableCharUseAssem = 0,
		ThrowOnUnmappableCharEnabled = 0x1000,
		ThrowOnUnmappableCharDisabled = 0x2000,
		ThrowOnUnmappableCharMask = 0x3000,
		SupportsLastError = 0x40,
		CallConvMask = 0x700,
		CallConvWinapi = 0x100,
		CallConvCdecl = 0x200,
		CallConvStdcall = 0x300,
		CallConvThiscall = 0x400,
		CallConvFastcall = 0x500,
		MaxValue = 0xFFFF
	}
	[Flags]
	internal enum MethodSemanticsAttributes
	{
		Setter = 1,
		Getter = 2,
		Other = 4,
		AddOn = 8,
		RemoveOn = 0x10,
		Fire = 0x20
	}
	internal enum MetadataTokenType
	{
		Module = 0,
		TypeRef = 16777216,
		TypeDef = 33554432,
		FieldDef = 67108864,
		MethodDef = 100663296,
		ParamDef = 134217728,
		InterfaceImpl = 150994944,
		MemberRef = 167772160,
		CustomAttribute = 201326592,
		Permission = 234881024,
		Signature = 285212672,
		Event = 335544320,
		Property = 385875968,
		ModuleRef = 436207616,
		TypeSpec = 452984832,
		Assembly = 536870912,
		AssemblyRef = 587202560,
		File = 637534208,
		ExportedType = 654311424,
		ManifestResource = 671088640,
		GenericPar = 704643072,
		MethodSpec = 721420288,
		String = 1879048192,
		Name = 1895825408,
		BaseType = 1912602624,
		Invalid = int.MaxValue
	}
	internal readonly struct ConstArray
	{
		internal readonly int m_length;

		internal readonly IntPtr m_constArray;

		public IntPtr Signature => m_constArray;

		public int Length => m_length;

		public unsafe byte this[int index]
		{
			get
			{
				if (index < 0 || index >= m_length)
				{
					throw new IndexOutOfRangeException();
				}
				return ((byte*)m_constArray.ToPointer())[index];
			}
		}
	}
	internal struct MetadataToken
	{
		public int Value;

		public bool IsGlobalTypeDefToken => Value == 33554433;

		public MetadataTokenType TokenType => (MetadataTokenType)(Value & 0xFF000000u);

		public bool IsTypeRef => TokenType == MetadataTokenType.TypeRef;

		public bool IsTypeDef => TokenType == MetadataTokenType.TypeDef;

		public bool IsFieldDef => TokenType == MetadataTokenType.FieldDef;

		public bool IsMethodDef => TokenType == MetadataTokenType.MethodDef;

		public bool IsMemberRef => TokenType == MetadataTokenType.MemberRef;

		public bool IsEvent => TokenType == MetadataTokenType.Event;

		public bool IsProperty => TokenType == MetadataTokenType.Property;

		public bool IsParamDef => TokenType == MetadataTokenType.ParamDef;

		public bool IsTypeSpec => TokenType == MetadataTokenType.TypeSpec;

		public bool IsMethodSpec => TokenType == MetadataTokenType.MethodSpec;

		public bool IsString => TokenType == MetadataTokenType.String;

		public bool IsSignature => TokenType == MetadataTokenType.Signature;

		public bool IsGenericPar => TokenType == MetadataTokenType.GenericPar;

		public static implicit operator int(MetadataToken token)
		{
			return token.Value;
		}

		public static implicit operator MetadataToken(int token)
		{
			return new MetadataToken(token);
		}

		public static bool IsNullToken(int token)
		{
			return (token & 0xFFFFFF) == 0;
		}

		public MetadataToken(int token)
		{
			Value = token;
		}

		public override string ToString()
		{
			return string.Format(CultureInfo.InvariantCulture, "0x{0:x8}", Value);
		}
	}
	internal struct MetadataEnumResult
	{
		private int[] largeResult;

		private int length;

		private unsafe fixed int smallResult[16];

		public int Length => length;

		public unsafe int this[int index]
		{
			get
			{
				if (largeResult != null)
				{
					return largeResult[index];
				}
				fixed (int* ptr = smallResult)
				{
					return ptr[index];
				}
			}
		}
	}
	internal readonly struct MetadataImport
	{
		private readonly IntPtr m_metadataImport2;

		private readonly object m_keepalive;

		internal static readonly MetadataImport EmptyImport = new MetadataImport((IntPtr)0, null);

		public override int GetHashCode()
		{
			return ValueType.GetHashCodeOfPtr(m_metadataImport2);
		}

		public override bool Equals(object obj)
		{
			if (!(obj is MetadataImport))
			{
				return false;
			}
			return Equals((MetadataImport)obj);
		}

		private bool Equals(MetadataImport import)
		{
			return import.m_metadataImport2 == m_metadataImport2;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetMarshalAs(IntPtr pNativeType, int cNativeType, out int unmanagedType, out int safeArraySubType, out string safeArrayUserDefinedSubType, out int arraySubType, out int sizeParamIndex, out int sizeConst, out string marshalType, out string marshalCookie, out int iidParamIndex);

		internal static void GetMarshalAs(ConstArray nativeType, out UnmanagedType unmanagedType, out VarEnum safeArraySubType, out string safeArrayUserDefinedSubType, out UnmanagedType arraySubType, out int sizeParamIndex, out int sizeConst, out string marshalType, out string marshalCookie, out int iidParamIndex)
		{
			_GetMarshalAs(nativeType.Signature, nativeType.Length, out var unmanagedType2, out var safeArraySubType2, out safeArrayUserDefinedSubType, out var arraySubType2, out sizeParamIndex, out sizeConst, out marshalType, out marshalCookie, out iidParamIndex);
			unmanagedType = (UnmanagedType)unmanagedType2;
			safeArraySubType = (VarEnum)safeArraySubType2;
			arraySubType = (UnmanagedType)arraySubType2;
		}

		internal static void ThrowError(int hResult)
		{
			throw new MetadataException(hResult);
		}

		internal MetadataImport(IntPtr metadataImport2, object keepalive)
		{
			m_metadataImport2 = metadataImport2;
			m_keepalive = keepalive;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _Enum(IntPtr scope, int type, int parent, out MetadataEnumResult result);

		public void Enum(MetadataTokenType type, int parent, out MetadataEnumResult result)
		{
			_Enum(m_metadataImport2, (int)type, parent, out result);
		}

		public void EnumNestedTypes(int mdTypeDef, out MetadataEnumResult result)
		{
			Enum(MetadataTokenType.TypeDef, mdTypeDef, out result);
		}

		public void EnumCustomAttributes(int mdToken, out MetadataEnumResult result)
		{
			Enum(MetadataTokenType.CustomAttribute, mdToken, out result);
		}

		public void EnumParams(int mdMethodDef, out MetadataEnumResult result)
		{
			Enum(MetadataTokenType.ParamDef, mdMethodDef, out result);
		}

		public void EnumFields(int mdTypeDef, out MetadataEnumResult result)
		{
			Enum(MetadataTokenType.FieldDef, mdTypeDef, out result);
		}

		public void EnumProperties(int mdTypeDef, out MetadataEnumResult result)
		{
			Enum(MetadataTokenType.Property, mdTypeDef, out result);
		}

		public void EnumEvents(int mdTypeDef, out MetadataEnumResult result)
		{
			Enum(MetadataTokenType.Event, mdTypeDef, out result);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern string _GetDefaultValue(IntPtr scope, int mdToken, out long value, out int length, out int corElementType);

		public string GetDefaultValue(int mdToken, out long value, out int length, out CorElementType corElementType)
		{
			int corElementType2;
			string result = _GetDefaultValue(m_metadataImport2, mdToken, out value, out length, out corElementType2);
			corElementType = (CorElementType)corElementType2;
			return result;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void _GetUserString(IntPtr scope, int mdToken, void** name, out int length);

		public unsafe string GetUserString(int mdToken)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out void* ptr);
			_GetUserString(m_metadataImport2, mdToken, &ptr, out var length);
			if (ptr == null)
			{
				return null;
			}
			return new string((char*)ptr, 0, length);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void _GetName(IntPtr scope, int mdToken, void** name);

		public unsafe MdUtf8String GetName(int mdToken)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out void* pStringHeap);
			_GetName(m_metadataImport2, mdToken, &pStringHeap);
			return new MdUtf8String(pStringHeap);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void _GetNamespace(IntPtr scope, int mdToken, void** namesp);

		public unsafe MdUtf8String GetNamespace(int mdToken)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out void* pStringHeap);
			_GetNamespace(m_metadataImport2, mdToken, &pStringHeap);
			return new MdUtf8String(pStringHeap);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void _GetEventProps(IntPtr scope, int mdToken, void** name, out int eventAttributes);

		public unsafe void GetEventProps(int mdToken, out void* name, out EventAttributes eventAttributes)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out void* ptr);
			_GetEventProps(m_metadataImport2, mdToken, &ptr, out var eventAttributes2);
			name = ptr;
			eventAttributes = (EventAttributes)eventAttributes2;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetFieldDefProps(IntPtr scope, int mdToken, out int fieldAttributes);

		public void GetFieldDefProps(int mdToken, out FieldAttributes fieldAttributes)
		{
			_GetFieldDefProps(m_metadataImport2, mdToken, out var fieldAttributes2);
			fieldAttributes = (FieldAttributes)fieldAttributes2;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void _GetPropertyProps(IntPtr scope, int mdToken, void** name, out int propertyAttributes, out ConstArray signature);

		public unsafe void GetPropertyProps(int mdToken, out void* name, out PropertyAttributes propertyAttributes, out ConstArray signature)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out void* ptr);
			_GetPropertyProps(m_metadataImport2, mdToken, &ptr, out var propertyAttributes2, out signature);
			name = ptr;
			propertyAttributes = (PropertyAttributes)propertyAttributes2;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetParentToken(IntPtr scope, int mdToken, out int tkParent);

		public int GetParentToken(int tkToken)
		{
			_GetParentToken(m_metadataImport2, tkToken, out var tkParent);
			return tkParent;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetParamDefProps(IntPtr scope, int parameterToken, out int sequence, out int attributes);

		public void GetParamDefProps(int parameterToken, out int sequence, out ParameterAttributes attributes)
		{
			_GetParamDefProps(m_metadataImport2, parameterToken, out sequence, out var attributes2);
			attributes = (ParameterAttributes)attributes2;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetGenericParamProps(IntPtr scope, int genericParameter, out int flags);

		public void GetGenericParamProps(int genericParameter, out GenericParameterAttributes attributes)
		{
			_GetGenericParamProps(m_metadataImport2, genericParameter, out var flags);
			attributes = (GenericParameterAttributes)flags;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetScopeProps(IntPtr scope, out Guid mvid);

		public void GetScopeProps(out Guid mvid)
		{
			_GetScopeProps(m_metadataImport2, out mvid);
		}

		public ConstArray GetMethodSignature(MetadataToken token)
		{
			if (token.IsMemberRef)
			{
				return GetMemberRefProps(token);
			}
			return GetSigOfMethodDef(token);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetSigOfMethodDef(IntPtr scope, int methodToken, ref ConstArray signature);

		public ConstArray GetSigOfMethodDef(int methodToken)
		{
			ConstArray signature = default(ConstArray);
			_GetSigOfMethodDef(m_metadataImport2, methodToken, ref signature);
			return signature;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetSignatureFromToken(IntPtr scope, int methodToken, ref ConstArray signature);

		public ConstArray GetSignatureFromToken(int token)
		{
			ConstArray signature = default(ConstArray);
			_GetSignatureFromToken(m_metadataImport2, token, ref signature);
			return signature;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetMemberRefProps(IntPtr scope, int memberTokenRef, out ConstArray signature);

		public ConstArray GetMemberRefProps(int memberTokenRef)
		{
			_GetMemberRefProps(m_metadataImport2, memberTokenRef, out var signature);
			return signature;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetCustomAttributeProps(IntPtr scope, int customAttributeToken, out int constructorToken, out ConstArray signature);

		public void GetCustomAttributeProps(int customAttributeToken, out int constructorToken, out ConstArray signature)
		{
			_GetCustomAttributeProps(m_metadataImport2, customAttributeToken, out constructorToken, out signature);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetClassLayout(IntPtr scope, int typeTokenDef, out int packSize, out int classSize);

		public void GetClassLayout(int typeTokenDef, out int packSize, out int classSize)
		{
			_GetClassLayout(m_metadataImport2, typeTokenDef, out packSize, out classSize);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool _GetFieldOffset(IntPtr scope, int typeTokenDef, int fieldTokenDef, out int offset);

		public bool GetFieldOffset(int typeTokenDef, int fieldTokenDef, out int offset)
		{
			return _GetFieldOffset(m_metadataImport2, typeTokenDef, fieldTokenDef, out offset);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetSigOfFieldDef(IntPtr scope, int fieldToken, ref ConstArray fieldMarshal);

		public ConstArray GetSigOfFieldDef(int fieldToken)
		{
			ConstArray fieldMarshal = default(ConstArray);
			_GetSigOfFieldDef(m_metadataImport2, fieldToken, ref fieldMarshal);
			return fieldMarshal;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _GetFieldMarshal(IntPtr scope, int fieldToken, ref ConstArray fieldMarshal);

		public ConstArray GetFieldMarshal(int fieldToken)
		{
			ConstArray fieldMarshal = default(ConstArray);
			_GetFieldMarshal(m_metadataImport2, fieldToken, ref fieldMarshal);
			return fieldMarshal;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void _GetPInvokeMap(IntPtr scope, int token, out int attributes, void** importName, void** importDll);

		public unsafe void GetPInvokeMap(int token, out PInvokeAttributes attributes, out string importName, out string importDll)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out void* pStringHeap);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out void* pStringHeap2);
			_GetPInvokeMap(m_metadataImport2, token, out var attributes2, &pStringHeap, &pStringHeap2);
			importName = new MdUtf8String(pStringHeap).ToString();
			importDll = new MdUtf8String(pStringHeap2).ToString();
			attributes = (PInvokeAttributes)attributes2;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool _IsValidToken(IntPtr scope, int token);

		public bool IsValidToken(int token)
		{
			return _IsValidToken(m_metadataImport2, token);
		}
	}
	internal sealed class MetadataException : Exception
	{
		private int m_hr;

		internal MetadataException(int hr)
		{
			m_hr = hr;
		}

		public override string ToString()
		{
			return $"MetadataException HResult = {m_hr:x}.";
		}
	}
	public abstract class MemberInfo : ICustomAttributeProvider
	{
		public abstract MemberTypes MemberType { get; }

		public abstract string Name { get; }

		public abstract Type? DeclaringType { get; }

		public abstract Type? ReflectedType { get; }

		public virtual Module Module
		{
			get
			{
				if (this is Type type)
				{
					return type.Module;
				}
				throw NotImplemented.ByDesign;
			}
		}

		public virtual IEnumerable<CustomAttributeData> CustomAttributes => GetCustomAttributesData();

		public virtual bool IsCollectible => true;

		public virtual int MetadataToken
		{
			get
			{
				throw new InvalidOperationException();
			}
		}

		internal virtual bool CacheEquals(object o)
		{
			throw new NotImplementedException();
		}

		internal bool HasSameMetadataDefinitionAsCore<TOther>(MemberInfo other) where TOther : MemberInfo
		{
			if ((object)other == null)
			{
				throw new ArgumentNullException("other");
			}
			if (!(other is TOther))
			{
				return false;
			}
			if (MetadataToken != other.MetadataToken)
			{
				return false;
			}
			if (!Module.Equals(other.Module))
			{
				return false;
			}
			return true;
		}

		public virtual bool HasSameMetadataDefinitionAs(MemberInfo other)
		{
			throw NotImplemented.ByDesign;
		}

		public abstract bool IsDefined(Type attributeType, bool inherit);

		public abstract object[] GetCustomAttributes(bool inherit);

		public abstract object[] GetCustomAttributes(Type attributeType, bool inherit);

		public virtual IList<CustomAttributeData> GetCustomAttributesData()
		{
			throw NotImplemented.ByDesign;
		}

		public override bool Equals(object? obj)
		{
			return base.Equals(obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(MemberInfo? left, MemberInfo? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(MemberInfo? left, MemberInfo? right)
		{
			return !(left == right);
		}
	}
	public abstract class MethodBase : MemberInfo
	{
		private protected struct StackAllocedArguments
		{
			internal object _arg0;

			private object _arg1;

			private object _arg2;

			private object _arg3;
		}

		public abstract MethodAttributes Attributes { get; }

		public virtual MethodImplAttributes MethodImplementationFlags => GetMethodImplementationFlags();

		public virtual CallingConventions CallingConvention => CallingConventions.Standard;

		public bool IsAbstract => (Attributes & MethodAttributes.Abstract) != 0;

		public bool IsConstructor
		{
			get
			{
				if (this is ConstructorInfo && !IsStatic)
				{
					return (Attributes & MethodAttributes.RTSpecialName) == MethodAttributes.RTSpecialName;
				}
				return false;
			}
		}

		public bool IsFinal => (Attributes & MethodAttributes.Final) != 0;

		public bool IsHideBySig => (Attributes & MethodAttributes.HideBySig) != 0;

		public bool IsSpecialName => (Attributes & MethodAttributes.SpecialName) != 0;

		public bool IsStatic => (Attributes & MethodAttributes.Static) != 0;

		public bool IsVirtual => (Attributes & MethodAttributes.Virtual) != 0;

		public bool IsAssembly => (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Assembly;

		public bool IsFamily => (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Family;

		public bool IsFamilyAndAssembly => (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.FamANDAssem;

		public bool IsFamilyOrAssembly => (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.FamORAssem;

		public bool IsPrivate => (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;

		public bool IsPublic => (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;

		public virtual bool IsConstructedGenericMethod
		{
			get
			{
				if (IsGenericMethod)
				{
					return !IsGenericMethodDefinition;
				}
				return false;
			}
		}

		public virtual bool IsGenericMethod => false;

		public virtual bool IsGenericMethodDefinition => false;

		public virtual bool ContainsGenericParameters => false;

		public abstract RuntimeMethodHandle MethodHandle { get; }

		public virtual bool IsSecurityCritical
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool IsSecuritySafeCritical
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool IsSecurityTransparent
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public static MethodBase? GetMethodFromHandle(RuntimeMethodHandle handle)
		{
			if (handle.IsNullHandle())
			{
				throw new ArgumentException(SR.Argument_InvalidHandle);
			}
			MethodBase methodBase = RuntimeType.GetMethodBase(handle.GetMethodInfo());
			Type type = methodBase?.DeclaringType;
			if (type != null && type.IsGenericType)
			{
				throw new ArgumentException(SR.Format(SR.Argument_MethodDeclaringTypeGeneric, methodBase, type.GetGenericTypeDefinition()));
			}
			return methodBase;
		}

		public static MethodBase? GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
		{
			if (handle.IsNullHandle())
			{
				throw new ArgumentException(SR.Argument_InvalidHandle);
			}
			return RuntimeType.GetMethodBase(declaringType.GetRuntimeType(), handle.GetMethodInfo());
		}

		public static MethodBase? GetCurrentMethod()
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return RuntimeMethodInfo.InternalGetCurrentMethod(ref stackMark);
		}

		private IntPtr GetMethodDesc()
		{
			return MethodHandle.Value;
		}

		internal virtual ParameterInfo[] GetParametersNoCopy()
		{
			return GetParameters();
		}

		internal virtual Type[] GetParameterTypes()
		{
			ParameterInfo[] parametersNoCopy = GetParametersNoCopy();
			Type[] array = new Type[parametersNoCopy.Length];
			for (int i = 0; i < parametersNoCopy.Length; i++)
			{
				array[i] = parametersNoCopy[i].ParameterType;
			}
			return array;
		}

		private protected Span<object> CheckArguments(ref StackAllocedArguments stackArgs, ReadOnlySpan<object> parameters, Binder binder, BindingFlags invokeAttr, CultureInfo culture, Signature sig)
		{
			Span<object> result = ((parameters.Length <= 4) ? MemoryMarshal.CreateSpan(ref stackArgs._arg0, parameters.Length) : new Span<object>(new object[parameters.Length]));
			ParameterInfo[] array = null;
			for (int i = 0; i < parameters.Length; i++)
			{
				object obj = parameters[i];
				RuntimeType runtimeType = sig.Arguments[i];
				if (obj == Type.Missing)
				{
					if (array == null)
					{
						array = GetParametersNoCopy();
					}
					if (array[i].DefaultValue == DBNull.Value)
					{
						throw new ArgumentException(SR.Arg_VarMissNull, "parameters");
					}
					obj = array[i].DefaultValue;
				}
				result[i] = runtimeType.CheckValue(obj, binder, culture, invokeAttr);
			}
			return result;
		}

		public abstract ParameterInfo[] GetParameters();

		public abstract MethodImplAttributes GetMethodImplementationFlags();

		[RequiresUnreferencedCode("Trimming may change method bodies. For example it can change some instructions, remove branches or local variables.")]
		public virtual MethodBody? GetMethodBody()
		{
			throw new InvalidOperationException();
		}

		public virtual Type[] GetGenericArguments()
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public object? Invoke(object? obj, object?[]? parameters)
		{
			return Invoke(obj, BindingFlags.Default, null, parameters, null);
		}

		public abstract object? Invoke(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture);

		public override bool Equals(object? obj)
		{
			return base.Equals(obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(MethodBase? left, MethodBase? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(MethodBase? left, MethodBase? right)
		{
			return !(left == right);
		}

		internal static void AppendParameters(ref ValueStringBuilder sbParamList, Type[] parameterTypes, CallingConventions callingConvention)
		{
			string s = "";
			foreach (Type type in parameterTypes)
			{
				sbParamList.Append(s);
				string text = type.FormatTypeName();
				if (type.IsByRef)
				{
					sbParamList.Append(text.AsSpan().TrimEnd('&'));
					sbParamList.Append(" ByRef");
				}
				else
				{
					sbParamList.Append(text);
				}
				s = ", ";
			}
			if ((callingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
			{
				sbParamList.Append(s);
				sbParamList.Append("...");
			}
		}
	}
	internal sealed class RtFieldInfo : RuntimeFieldInfo, IRuntimeFieldInfo
	{
		private IntPtr m_fieldHandle;

		private FieldAttributes m_fieldAttributes;

		private string m_name;

		private RuntimeType m_fieldType;

		private INVOCATION_FLAGS m_invocationFlags;

		internal INVOCATION_FLAGS InvocationFlags
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if ((m_invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_INITIALIZED) == 0)
				{
					return InitializeInvocationFlags();
				}
				return m_invocationFlags;
			}
		}

		RuntimeFieldHandleInternal IRuntimeFieldInfo.Value => new RuntimeFieldHandleInternal(m_fieldHandle);

		public override string Name => m_name ?? (m_name = RuntimeFieldHandle.GetName(this));

		public override int MetadataToken => RuntimeFieldHandle.GetToken(this);

		public override RuntimeFieldHandle FieldHandle => new RuntimeFieldHandle(this);

		public override FieldAttributes Attributes => m_fieldAttributes;

		public override Type FieldType
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return m_fieldType ?? InitializeFieldType();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private INVOCATION_FLAGS InitializeInvocationFlags()
		{
			Type declaringType = DeclaringType;
			INVOCATION_FLAGS iNVOCATION_FLAGS = INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN;
			if (declaringType != null && declaringType.ContainsGenericParameters)
			{
				iNVOCATION_FLAGS |= INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE;
			}
			if (iNVOCATION_FLAGS == INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN)
			{
				if ((m_fieldAttributes & FieldAttributes.InitOnly) != 0)
				{
					iNVOCATION_FLAGS |= INVOCATION_FLAGS.INVOCATION_FLAGS_IS_CTOR;
				}
				if ((m_fieldAttributes & FieldAttributes.HasFieldRVA) != 0)
				{
					iNVOCATION_FLAGS |= INVOCATION_FLAGS.INVOCATION_FLAGS_IS_CTOR;
				}
				Type fieldType = FieldType;
				if (fieldType.IsPointer || fieldType.IsEnum || fieldType.IsPrimitive)
				{
					iNVOCATION_FLAGS |= INVOCATION_FLAGS.INVOCATION_FLAGS_FIELD_SPECIAL_CAST;
				}
			}
			return m_invocationFlags = iNVOCATION_FLAGS | INVOCATION_FLAGS.INVOCATION_FLAGS_INITIALIZED;
		}

		internal RtFieldInfo(RuntimeFieldHandleInternal handle, RuntimeType declaringType, RuntimeType.RuntimeTypeCache reflectedTypeCache, BindingFlags bindingFlags)
			: base(reflectedTypeCache, declaringType, bindingFlags)
		{
			m_fieldHandle = handle.Value;
			m_fieldAttributes = RuntimeFieldHandle.GetAttributes(handle);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void CheckConsistency(object target)
		{
			if ((m_fieldAttributes & FieldAttributes.Static) != FieldAttributes.Static && !m_declaringType.IsInstanceOfType(target))
			{
				if (target == null)
				{
					throw new TargetException(SR.RFLCT_Targ_StatFldReqTarg);
				}
				throw new ArgumentException(SR.Format(SR.Arg_FieldDeclTarget, Name, m_declaringType, target.GetType()));
			}
		}

		internal override bool CacheEquals(object o)
		{
			if (o is RtFieldInfo rtFieldInfo)
			{
				return rtFieldInfo.m_fieldHandle == m_fieldHandle;
			}
			return false;
		}

		internal override RuntimeModule GetRuntimeModule()
		{
			return RuntimeTypeHandle.GetModule(RuntimeFieldHandle.GetApproxDeclaringType(this));
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override object GetValue(object obj)
		{
			INVOCATION_FLAGS invocationFlags = InvocationFlags;
			RuntimeType runtimeType = DeclaringType as RuntimeType;
			if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != 0)
			{
				if (runtimeType != null && DeclaringType.ContainsGenericParameters)
				{
					throw new InvalidOperationException(SR.Arg_UnboundGenField);
				}
				throw new FieldAccessException();
			}
			CheckConsistency(obj);
			RuntimeType fieldType = (RuntimeType)FieldType;
			bool domainInitialized = false;
			if (runtimeType == null)
			{
				return RuntimeFieldHandle.GetValue(this, obj, fieldType, null, ref domainInitialized);
			}
			domainInitialized = runtimeType.DomainInitialized;
			object value = RuntimeFieldHandle.GetValue(this, obj, fieldType, runtimeType, ref domainInitialized);
			runtimeType.DomainInitialized = domainInitialized;
			return value;
		}

		public override object GetRawConstantValue()
		{
			throw new InvalidOperationException();
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public unsafe override object GetValueDirect(TypedReference obj)
		{
			if (obj.IsNull)
			{
				throw new ArgumentException(SR.Arg_TypedReference_Null);
			}
			return RuntimeFieldHandle.GetValueDirect(this, (RuntimeType)FieldType, &obj, (RuntimeType)DeclaringType);
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
		{
			INVOCATION_FLAGS invocationFlags = InvocationFlags;
			RuntimeType runtimeType = DeclaringType as RuntimeType;
			if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != 0)
			{
				if (runtimeType != null && runtimeType.ContainsGenericParameters)
				{
					throw new InvalidOperationException(SR.Arg_UnboundGenField);
				}
				throw new FieldAccessException();
			}
			CheckConsistency(obj);
			RuntimeType runtimeType2 = (RuntimeType)FieldType;
			value = runtimeType2.CheckValue(value, binder, culture, invokeAttr);
			bool domainInitialized = false;
			if (runtimeType == null)
			{
				RuntimeFieldHandle.SetValue(this, obj, value, runtimeType2, m_fieldAttributes, null, ref domainInitialized);
				return;
			}
			domainInitialized = runtimeType.DomainInitialized;
			RuntimeFieldHandle.SetValue(this, obj, value, runtimeType2, m_fieldAttributes, runtimeType, ref domainInitialized);
			runtimeType.DomainInitialized = domainInitialized;
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public unsafe override void SetValueDirect(TypedReference obj, object value)
		{
			if (obj.IsNull)
			{
				throw new ArgumentException(SR.Arg_TypedReference_Null);
			}
			RuntimeFieldHandle.SetValueDirect(this, (RuntimeType)FieldType, &obj, value, (RuntimeType)DeclaringType);
		}

		internal IntPtr GetFieldHandle()
		{
			return m_fieldHandle;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private RuntimeType InitializeFieldType()
		{
			return m_fieldType = new Signature(this, m_declaringType).FieldType;
		}

		public override Type[] GetRequiredCustomModifiers()
		{
			return new Signature(this, m_declaringType).GetCustomModifiers(1, required: true);
		}

		public override Type[] GetOptionalCustomModifiers()
		{
			return new Signature(this, m_declaringType).GetCustomModifiers(1, required: false);
		}
	}
	internal class RuntimeAssembly : Assembly
	{
		private sealed class ManifestResourceStream : UnmanagedMemoryStream
		{
			private RuntimeAssembly _manifestAssembly;

			internal unsafe ManifestResourceStream(RuntimeAssembly manifestAssembly, byte* pointer, long length, long capacity, FileAccess access)
				: base(pointer, length, capacity, access)
			{
				_manifestAssembly = manifestAssembly;
			}
		}

		private string m_fullname;

		private object m_syncRoot;

		private IntPtr m_assembly;

		internal object SyncRoot
		{
			get
			{
				if (m_syncRoot == null)
				{
					Interlocked.CompareExchange<object>(ref m_syncRoot, new object(), (object)null);
				}
				return m_syncRoot;
			}
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override string CodeBase
		{
			get
			{
				string codeBase = GetCodeBase();
				if (codeBase == null)
				{
					throw new NotSupportedException(SR.NotSupported_CodeBase);
				}
				return codeBase;
			}
		}

		public override string FullName
		{
			get
			{
				if (m_fullname == null)
				{
					string s = null;
					RuntimeAssembly assembly = this;
					GetFullName(new QCallAssembly(ref assembly), new StringHandleOnStack(ref s));
					Interlocked.CompareExchange(ref m_fullname, s, null);
				}
				return m_fullname;
			}
		}

		public override MethodInfo EntryPoint
		{
			get
			{
				IRuntimeMethodInfo o = null;
				RuntimeAssembly assembly = this;
				GetEntryPoint(new QCallAssembly(ref assembly), ObjectHandleOnStack.Create(ref o));
				if (o == null)
				{
					return null;
				}
				return (MethodInfo)RuntimeType.GetMethodBase(o);
			}
		}

		public override IEnumerable<TypeInfo> DefinedTypes
		{
			[RequiresUnreferencedCode("Types might be removed")]
			get
			{
				RuntimeModule[] modulesInternal = GetModulesInternal(loadIfNotFound: true, getResourceModules: false);
				if (modulesInternal.Length == 1)
				{
					return modulesInternal[0].GetDefinedTypes();
				}
				List<RuntimeType> list = new List<RuntimeType>();
				for (int i = 0; i < modulesInternal.Length; i++)
				{
					list.AddRange(modulesInternal[i].GetDefinedTypes());
				}
				return list.ToArray();
			}
		}

		public override bool IsCollectible
		{
			get
			{
				RuntimeAssembly assembly = this;
				return GetIsCollectible(new QCallAssembly(ref assembly)) != Interop.BOOL.FALSE;
			}
		}

		public override Module ManifestModule => GetManifestModule(GetNativeHandle());

		public override bool ReflectionOnly => false;

		public override string Location
		{
			get
			{
				string s = null;
				RuntimeAssembly assembly = this;
				GetLocation(new QCallAssembly(ref assembly), new StringHandleOnStack(ref s));
				return s;
			}
		}

		public override string ImageRuntimeVersion
		{
			get
			{
				string s = null;
				RuntimeAssembly assembly = this;
				GetImageRuntimeVersion(new QCallAssembly(ref assembly), new StringHandleOnStack(ref s));
				return s;
			}
		}

		[Obsolete("The Global Assembly Cache is not supported.", DiagnosticId = "SYSLIB0005", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
		public override bool GlobalAssemblyCache => false;

		public override long HostContext => 0L;

		public override bool IsDynamic => FCallIsDynamic(GetNativeHandle());

		private event ModuleResolveEventHandler _ModuleResolve;

		public override event ModuleResolveEventHandler ModuleResolve
		{
			add
			{
				_ModuleResolve += value;
			}
			remove
			{
				_ModuleResolve -= value;
			}
		}

		internal RuntimeAssembly()
		{
			throw new NotSupportedException();
		}

		internal IntPtr GetUnderlyingNativeHandle()
		{
			return m_assembly;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern bool GetCodeBase(QCallAssembly assembly, StringHandleOnStack retString);

		internal string GetCodeBase()
		{
			string s = null;
			RuntimeAssembly assembly = this;
			if (GetCodeBase(new QCallAssembly(ref assembly), new StringHandleOnStack(ref s)))
			{
				return s;
			}
			return null;
		}

		internal RuntimeAssembly GetNativeHandle()
		{
			return this;
		}

		public override AssemblyName GetName(bool copiedName)
		{
			string codeBase = GetCodeBase();
			AssemblyName assemblyName = new AssemblyName(GetSimpleName(), GetPublicKey(), null, GetVersion(), GetLocale(), GetHashAlgorithm(), AssemblyVersionCompatibility.SameMachine, codeBase, GetFlags() | AssemblyNameFlags.PublicKey);
			Module manifestModule = ManifestModule;
			if (manifestModule.MDStreamVersion > 65536)
			{
				manifestModule.GetPEKind(out var peKind, out var machine);
				assemblyName.SetProcArchIndex(peKind, machine);
			}
			return assemblyName;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetFullName(QCallAssembly assembly, StringHandleOnStack retString);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetType(QCallAssembly assembly, string name, bool throwOnError, bool ignoreCase, ObjectHandleOnStack type, ObjectHandleOnStack keepAlive, ObjectHandleOnStack assemblyLoadContext);

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type GetType(string name, bool throwOnError, bool ignoreCase)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			RuntimeType o = null;
			object o2 = null;
			AssemblyLoadContext o3 = AssemblyLoadContext.CurrentContextualReflectionContext;
			RuntimeAssembly assembly = this;
			GetType(new QCallAssembly(ref assembly), name, throwOnError, ignoreCase, ObjectHandleOnStack.Create(ref o), ObjectHandleOnStack.Create(ref o2), ObjectHandleOnStack.Create(ref o3));
			GC.KeepAlive(o2);
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes);

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type[] GetExportedTypes()
		{
			Type[] o = null;
			RuntimeAssembly assembly = this;
			GetExportedTypes(new QCallAssembly(ref assembly), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern Interop.BOOL GetIsCollectible(QCallAssembly assembly);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern byte* GetResource(QCallAssembly assembly, string resourceName, out uint length);

		public override Stream GetManifestResourceStream(Type type, string name)
		{
			if (type == null && name == null)
			{
				throw new ArgumentNullException("type");
			}
			string text = type?.Namespace;
			char ptr = Type.Delimiter;
			string name2 = ((text != null && name != null) ? string.Concat(text, new ReadOnlySpan<char>(ref ptr, 1), name) : (text + name));
			return GetManifestResourceStream(name2);
		}

		public unsafe override Stream GetManifestResourceStream(string name)
		{
			RuntimeAssembly assembly = this;
			uint length;
			byte* resource = GetResource(new QCallAssembly(ref assembly), name, out length);
			if (resource != null)
			{
				return new ManifestResourceStream(this, resource, length, length, FileAccess.Read);
			}
			return null;
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}

		internal static RuntimeAssembly InternalLoad(string assemblyName, ref StackCrawlMark stackMark, AssemblyLoadContext assemblyLoadContext = null)
		{
			return InternalLoad(new AssemblyName(assemblyName), ref stackMark, assemblyLoadContext);
		}

		internal static RuntimeAssembly InternalLoad(AssemblyName assemblyName, ref StackCrawlMark stackMark, AssemblyLoadContext assemblyLoadContext = null)
		{
			return InternalLoad(assemblyName, null, ref stackMark, throwOnFileNotFound: true, assemblyLoadContext);
		}

		internal static RuntimeAssembly InternalLoad(AssemblyName assemblyName, RuntimeAssembly requestingAssembly, ref StackCrawlMark stackMark, bool throwOnFileNotFound, AssemblyLoadContext assemblyLoadContext = null)
		{
			RuntimeAssembly o = null;
			InternalLoad(ObjectHandleOnStack.Create(ref assemblyName), ObjectHandleOnStack.Create(ref requestingAssembly), new StackCrawlMarkHandle(ref stackMark), throwOnFileNotFound, ObjectHandleOnStack.Create(ref assemblyLoadContext), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void InternalLoad(ObjectHandleOnStack assemblyName, ObjectHandleOnStack requestingAssembly, StackCrawlMarkHandle stackMark, bool throwOnFileNotFound, ObjectHandleOnStack assemblyLoadContext, ObjectHandleOnStack retAssembly);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule);

		public override Module GetModule(string name)
		{
			Module o = null;
			RuntimeAssembly assembly = this;
			GetModule(new QCallAssembly(ref assembly), name, ObjectHandleOnStack.Create(ref o));
			return o;
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override FileStream GetFile(string name)
		{
			if (Location.Length == 0)
			{
				throw new FileNotFoundException(SR.IO_NoFileTableInInMemoryAssemblies);
			}
			RuntimeModule runtimeModule = (RuntimeModule)GetModule(name);
			if (runtimeModule == null)
			{
				return null;
			}
			return new FileStream(runtimeModule.GetFullyQualifiedName(), FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync: false);
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override FileStream[] GetFiles(bool getResourceModules)
		{
			if (Location.Length == 0)
			{
				throw new FileNotFoundException(SR.IO_NoFileTableInInMemoryAssemblies);
			}
			Module[] modules = GetModules(getResourceModules);
			FileStream[] array = new FileStream[modules.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new FileStream(((RuntimeModule)modules[i]).GetFullyQualifiedName(), FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync: false);
			}
			return array;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern string[] GetManifestResourceNames(RuntimeAssembly assembly);

		public override string[] GetManifestResourceNames()
		{
			return GetManifestResourceNames(GetNativeHandle());
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern AssemblyName[] GetReferencedAssemblies(RuntimeAssembly assembly);

		[RequiresUnreferencedCode("Assembly references might be removed")]
		public override AssemblyName[] GetReferencedAssemblies()
		{
			return GetReferencedAssemblies(GetNativeHandle());
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetManifestResourceInfo(QCallAssembly assembly, string resourceName, ObjectHandleOnStack assemblyRef, StringHandleOnStack retFileName);

		public override ManifestResourceInfo GetManifestResourceInfo(string resourceName)
		{
			RuntimeAssembly o = null;
			string s = null;
			RuntimeAssembly assembly = this;
			int manifestResourceInfo = GetManifestResourceInfo(new QCallAssembly(ref assembly), resourceName, ObjectHandleOnStack.Create(ref o), new StringHandleOnStack(ref s));
			if (manifestResourceInfo == -1)
			{
				return null;
			}
			return new ManifestResourceInfo(o, s, (ResourceLocation)manifestResourceInfo);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetLocation(QCallAssembly assembly, StringHandleOnStack retString);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetVersion(QCallAssembly assembly, out int majVer, out int minVer, out int buildNum, out int revNum);

		internal Version GetVersion()
		{
			RuntimeAssembly assembly = this;
			GetVersion(new QCallAssembly(ref assembly), out var majVer, out var minVer, out var buildNum, out var revNum);
			return new Version(majVer, minVer, buildNum, revNum);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetLocale(QCallAssembly assembly, StringHandleOnStack retString);

		internal CultureInfo GetLocale()
		{
			string s = null;
			RuntimeAssembly assembly = this;
			GetLocale(new QCallAssembly(ref assembly), new StringHandleOnStack(ref s));
			if (s == null)
			{
				return CultureInfo.InvariantCulture;
			}
			return CultureInfo.GetCultureInfo(s);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool FCallIsDynamic(RuntimeAssembly assembly);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName);

		internal string GetSimpleName()
		{
			RuntimeAssembly assembly = this;
			string s = null;
			GetSimpleName(new QCallAssembly(ref assembly), new StringHandleOnStack(ref s));
			return s;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly);

		private AssemblyHashAlgorithm GetHashAlgorithm()
		{
			RuntimeAssembly assembly = this;
			return GetHashAlgorithm(new QCallAssembly(ref assembly));
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern AssemblyNameFlags GetFlags(QCallAssembly assembly);

		private AssemblyNameFlags GetFlags()
		{
			RuntimeAssembly assembly = this;
			return GetFlags(new QCallAssembly(ref assembly));
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey);

		internal byte[] GetPublicKey()
		{
			byte[] o = null;
			RuntimeAssembly assembly = this;
			GetPublicKey(new QCallAssembly(ref assembly), ObjectHandleOnStack.Create(ref o));
			return o;
		}

		public override Assembly GetSatelliteAssembly(CultureInfo culture)
		{
			return GetSatelliteAssembly(culture, null);
		}

		public override Assembly GetSatelliteAssembly(CultureInfo culture, Version version)
		{
			if (culture == null)
			{
				throw new ArgumentNullException("culture");
			}
			return InternalGetSatelliteAssembly(culture, version, throwOnFileNotFound: true);
		}

		internal Assembly InternalGetSatelliteAssembly(CultureInfo culture, Version version, bool throwOnFileNotFound)
		{
			AssemblyName assemblyName = new AssemblyName();
			assemblyName.SetPublicKey(GetPublicKey());
			assemblyName.Flags = GetFlags() | AssemblyNameFlags.PublicKey;
			assemblyName.Version = version ?? GetVersion();
			assemblyName.CultureInfo = culture;
			assemblyName.Name = GetSimpleName() + ".resources";
			StackCrawlMark stackMark = StackCrawlMark.LookForMe;
			RuntimeAssembly runtimeAssembly = InternalLoad(assemblyName, this, ref stackMark, throwOnFileNotFound);
			if (runtimeAssembly == this)
			{
				runtimeAssembly = null;
			}
			if (runtimeAssembly == null && throwOnFileNotFound)
			{
				throw new FileNotFoundException(SR.Format(culture, SR.IO_FileNotFound_FileName, assemblyName.Name));
			}
			return runtimeAssembly;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetModules(QCallAssembly assembly, bool loadIfNotFound, bool getResourceModules, ObjectHandleOnStack retModuleHandles);

		private RuntimeModule[] GetModulesInternal(bool loadIfNotFound, bool getResourceModules)
		{
			RuntimeModule[] o = null;
			RuntimeAssembly assembly = this;
			GetModules(new QCallAssembly(ref assembly), loadIfNotFound, getResourceModules, ObjectHandleOnStack.Create(ref o));
			return o;
		}

		public override Module[] GetModules(bool getResourceModules)
		{
			return GetModulesInternal(loadIfNotFound: true, getResourceModules);
		}

		public override Module[] GetLoadedModules(bool getResourceModules)
		{
			return GetModulesInternal(loadIfNotFound: false, getResourceModules);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern RuntimeModule GetManifestModule(RuntimeAssembly assembly);

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern int GetToken(RuntimeAssembly assembly);

		[RequiresUnreferencedCode("Types might be removed")]
		public sealed override Type[] GetForwardedTypes()
		{
			List<Type> list = new List<Type>();
			List<Exception> list2 = new List<Exception>();
			GetManifestModule(GetNativeHandle()).MetadataImport.Enum(MetadataTokenType.ExportedType, 0, out var result);
			RuntimeAssembly assembly = this;
			QCallAssembly assembly2 = new QCallAssembly(ref assembly);
			for (int i = 0; i < result.Length; i++)
			{
				MetadataToken mdtExternalType = result[i];
				Type o = null;
				Exception item = null;
				ObjectHandleOnStack type = ObjectHandleOnStack.Create(ref o);
				try
				{
					GetForwardedType(assembly2, mdtExternalType, type);
					if (o == null)
					{
						continue;
					}
				}
				catch (Exception ex)
				{
					o = null;
					item = ex;
				}
				if (o != null)
				{
					list.Add(o);
					AddPublicNestedTypes(o, list, list2);
				}
				else
				{
					list2.Add(item);
				}
			}
			if (list2.Count != 0)
			{
				int count = list.Count;
				int count2 = list2.Count;
				list.AddRange(new Type[count2]);
				list2.InsertRange(0, new Exception[count]);
				throw new ReflectionTypeLoadException(list.ToArray(), list2.ToArray());
			}
			return list.ToArray();
		}

		[RequiresUnreferencedCode("Types might be removed because recursive nested types can't currently be annotated for dynamic access.")]
		private static void AddPublicNestedTypes(Type type, List<Type> types, List<Exception> exceptions)
		{
			Type[] nestedTypes;
			try
			{
				nestedTypes = type.GetNestedTypes(BindingFlags.Public);
			}
			catch (Exception item)
			{
				exceptions.Add(item);
				return;
			}
			Type[] array = nestedTypes;
			foreach (Type type2 in array)
			{
				types.Add(type2);
				AddPublicNestedTypes(type2, types, exceptions);
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetForwardedType(QCallAssembly assembly, MetadataToken mdtExternalType, ObjectHandleOnStack type);
	}
	internal sealed class RuntimeConstructorInfo : ConstructorInfo, IRuntimeMethodInfo
	{
		private volatile RuntimeType m_declaringType;

		private RuntimeType.RuntimeTypeCache m_reflectedTypeCache;

		private string m_toString;

		private ParameterInfo[] m_parameters;

		private object _empty1;

		private object _empty2;

		private object _empty3;

		private IntPtr m_handle;

		private MethodAttributes m_methodAttributes;

		private BindingFlags m_bindingFlags;

		private Signature m_signature;

		private INVOCATION_FLAGS m_invocationFlags;

		internal INVOCATION_FLAGS InvocationFlags
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				INVOCATION_FLAGS iNVOCATION_FLAGS = m_invocationFlags;
				if ((iNVOCATION_FLAGS & INVOCATION_FLAGS.INVOCATION_FLAGS_INITIALIZED) == 0)
				{
					iNVOCATION_FLAGS = LazyCreateInvocationFlags();
				}
				return iNVOCATION_FLAGS;
				[MethodImpl(MethodImplOptions.NoInlining)]
				INVOCATION_FLAGS LazyCreateInvocationFlags()
				{
					INVOCATION_FLAGS iNVOCATION_FLAGS2 = INVOCATION_FLAGS.INVOCATION_FLAGS_IS_CTOR;
					Type declaringType = DeclaringType;
					if (declaringType == typeof(void) || (declaringType != null && declaringType.ContainsGenericParameters) || (CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
					{
						iNVOCATION_FLAGS2 |= INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE;
					}
					else if (base.IsStatic)
					{
						iNVOCATION_FLAGS2 |= INVOCATION_FLAGS.INVOCATION_FLAGS_RUN_CLASS_CONSTRUCTOR | INVOCATION_FLAGS.INVOCATION_FLAGS_NO_CTOR_INVOKE;
					}
					else if (declaringType != null && declaringType.IsAbstract)
					{
						iNVOCATION_FLAGS2 |= INVOCATION_FLAGS.INVOCATION_FLAGS_NO_CTOR_INVOKE;
					}
					else
					{
						if (declaringType != null && declaringType.IsByRefLike)
						{
							iNVOCATION_FLAGS2 |= INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS;
						}
						if (typeof(Delegate).IsAssignableFrom(DeclaringType))
						{
							iNVOCATION_FLAGS2 |= INVOCATION_FLAGS.INVOCATION_FLAGS_IS_DELEGATE_CTOR;
						}
					}
					return m_invocationFlags = iNVOCATION_FLAGS2 | INVOCATION_FLAGS.INVOCATION_FLAGS_INITIALIZED;
				}
			}
		}

		RuntimeMethodHandleInternal IRuntimeMethodInfo.Value => new RuntimeMethodHandleInternal(m_handle);

		private Signature Signature
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return m_signature ?? LazyCreateSignature();
				[MethodImpl(MethodImplOptions.NoInlining)]
				Signature LazyCreateSignature()
				{
					Signature signature = new Signature(this, m_declaringType);
					Volatile.Write(ref m_signature, signature);
					return signature;
				}
			}
		}

		private RuntimeType ReflectedTypeInternal => m_reflectedTypeCache.GetRuntimeType();

		internal BindingFlags BindingFlags => m_bindingFlags;

		public override string Name => RuntimeMethodHandle.GetName(this);

		public override MemberTypes MemberType => MemberTypes.Constructor;

		public override Type DeclaringType
		{
			get
			{
				if (!m_reflectedTypeCache.IsGlobal)
				{
					return m_declaringType;
				}
				return null;
			}
		}

		public override Type ReflectedType
		{
			get
			{
				if (!m_reflectedTypeCache.IsGlobal)
				{
					return ReflectedTypeInternal;
				}
				return null;
			}
		}

		public override int MetadataToken => RuntimeMethodHandle.GetMethodDef(this);

		public override Module Module => GetRuntimeModule();

		public override RuntimeMethodHandle MethodHandle => new RuntimeMethodHandle(this);

		public override MethodAttributes Attributes => m_methodAttributes;

		public override CallingConventions CallingConvention => Signature.CallingConvention;

		public override bool IsSecurityCritical => true;

		public override bool IsSecuritySafeCritical => false;

		public override bool IsSecurityTransparent => false;

		public override bool ContainsGenericParameters
		{
			get
			{
				if (DeclaringType != null)
				{
					return DeclaringType.ContainsGenericParameters;
				}
				return false;
			}
		}

		internal RuntimeConstructorInfo(RuntimeMethodHandleInternal handle, RuntimeType declaringType, RuntimeType.RuntimeTypeCache reflectedTypeCache, MethodAttributes methodAttributes, BindingFlags bindingFlags)
		{
			m_bindingFlags = bindingFlags;
			m_reflectedTypeCache = reflectedTypeCache;
			m_declaringType = declaringType;
			m_handle = handle.Value;
			m_methodAttributes = methodAttributes;
		}

		internal override bool CacheEquals(object o)
		{
			if (o is RuntimeConstructorInfo runtimeConstructorInfo)
			{
				return runtimeConstructorInfo.m_handle == m_handle;
			}
			return false;
		}

		private void CheckConsistency(object target)
		{
			if ((target != null || !base.IsStatic) && !m_declaringType.IsInstanceOfType(target))
			{
				if (target == null)
				{
					throw new TargetException(SR.RFLCT_Targ_StatMethReqTarg);
				}
				throw new TargetException(SR.RFLCT_Targ_ITargMismatch);
			}
		}

		public override string ToString()
		{
			if (m_toString == null)
			{
				ValueStringBuilder sbParamList = new ValueStringBuilder(100);
				sbParamList.Append("Void ");
				sbParamList.Append(Name);
				sbParamList.Append('(');
				MethodBase.AppendParameters(ref sbParamList, GetParameterTypes(), CallingConvention);
				sbParamList.Append(')');
				m_toString = sbParamList.ToString();
			}
			return m_toString;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}

		public sealed override bool HasSameMetadataDefinitionAs(MemberInfo other)
		{
			return HasSameMetadataDefinitionAsCore<RuntimeConstructorInfo>(other);
		}

		internal RuntimeType GetRuntimeType()
		{
			return m_declaringType;
		}

		internal RuntimeModule GetRuntimeModule()
		{
			return RuntimeTypeHandle.GetModule(m_declaringType);
		}

		internal override Type GetReturnType()
		{
			return Signature.ReturnType;
		}

		internal override ParameterInfo[] GetParametersNoCopy()
		{
			return m_parameters ?? (m_parameters = RuntimeParameterInfo.GetParameters(this, this, Signature));
		}

		public override ParameterInfo[] GetParameters()
		{
			ParameterInfo[] parametersNoCopy = GetParametersNoCopy();
			if (parametersNoCopy.Length == 0)
			{
				return parametersNoCopy;
			}
			ParameterInfo[] array = new ParameterInfo[parametersNoCopy.Length];
			Array.Copy(parametersNoCopy, array, parametersNoCopy.Length);
			return array;
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			return RuntimeMethodHandle.GetImplAttributes(this);
		}

		internal static void CheckCanCreateInstance(Type declaringType, bool isVarArg)
		{
			if (declaringType == null)
			{
				throw new ArgumentNullException("declaringType");
			}
			if (declaringType.IsInterface)
			{
				throw new MemberAccessException(SR.Format(SR.Acc_CreateInterfaceEx, declaringType));
			}
			if (declaringType.IsAbstract)
			{
				throw new MemberAccessException(SR.Format(SR.Acc_CreateAbstEx, declaringType));
			}
			if (declaringType.GetRootElementType() == typeof(ArgIterator))
			{
				throw new NotSupportedException();
			}
			if (isVarArg)
			{
				throw new NotSupportedException();
			}
			if (declaringType.ContainsGenericParameters)
			{
				throw new MemberAccessException(SR.Format(SR.Acc_CreateGenericEx, declaringType));
			}
			if (declaringType == typeof(void))
			{
				throw new MemberAccessException(SR.Access_Void);
			}
		}

		[DoesNotReturn]
		internal void ThrowNoInvokeException()
		{
			CheckCanCreateInstance(DeclaringType, (CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs);
			if ((Attributes & MethodAttributes.Static) == MethodAttributes.Static)
			{
				throw new MemberAccessException(SR.Acc_NotClassInit);
			}
			throw new TargetException();
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2059:RunClassConstructor", Justification = "This ConstructorInfo instance represents the static constructor itself, so if this object was created, the static constructor exists.")]
		public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			INVOCATION_FLAGS invocationFlags = InvocationFlags;
			if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE) != 0)
			{
				ThrowNoInvokeException();
			}
			CheckConsistency(obj);
			if ((invocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_RUN_CLASS_CONSTRUCTOR) != 0)
			{
				Type declaringType = DeclaringType;
				if (declaringType != null)
				{
					RuntimeHelpers.RunClassConstructor(declaringType.TypeHandle);
				}
				else
				{
					RuntimeHelpers.RunModuleConstructor(Module.ModuleHandle);
				}
				return null;
			}
			Signature signature = Signature;
			int num = signature.Arguments.Length;
			int num2 = ((parameters != null) ? parameters.Length : 0);
			if (num != num2)
			{
				throw new TargetParameterCountException(SR.Arg_ParmCnt);
			}
			bool wrapExceptions = (invokeAttr & BindingFlags.DoNotWrapExceptions) == 0;
			StackAllocedArguments stackArgs = default(StackAllocedArguments);
			Span<object> arguments = default(Span<object>);
			if (num2 != 0)
			{
				arguments = CheckArguments(ref stackArgs, parameters, binder, invokeAttr, culture, signature);
			}
			object result = RuntimeMethodHandle.InvokeMethod(obj, in arguments, signature, constructor: false, wrapExceptions);
			for (int i = 0; i < arguments.Length; i++)
			{
				parameters[i] = arguments[i];
			}
			return result;
		}

		[RequiresUnreferencedCode("Trimming may change method bodies. For example it can change some instructions, remove branches or local variables.")]
		public override MethodBody GetMethodBody()
		{
			RuntimeMethodBody methodBody = RuntimeMethodHandle.GetMethodBody(this, ReflectedTypeInternal);
			if (methodBody != null)
			{
				methodBody._methodBase = this;
			}
			return methodBody;
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			INVOCATION_FLAGS invocationFlags = InvocationFlags;
			if ((invocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE | INVOCATION_FLAGS.INVOCATION_FLAGS_NO_CTOR_INVOKE | INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS)) != 0)
			{
				ThrowNoInvokeException();
			}
			Signature signature = Signature;
			int num = signature.Arguments.Length;
			int num2 = ((parameters != null) ? parameters.Length : 0);
			if (num != num2)
			{
				throw new TargetParameterCountException(SR.Arg_ParmCnt);
			}
			bool wrapExceptions = (invokeAttr & BindingFlags.DoNotWrapExceptions) == 0;
			StackAllocedArguments stackArgs = default(StackAllocedArguments);
			Span<object> arguments = default(Span<object>);
			if (num2 != 0)
			{
				arguments = CheckArguments(ref stackArgs, parameters, binder, invokeAttr, culture, signature);
			}
			object result = RuntimeMethodHandle.InvokeMethod(null, in arguments, signature, constructor: true, wrapExceptions);
			for (int i = 0; i < arguments.Length; i++)
			{
				parameters[i] = arguments[i];
			}
			return result;
		}
	}
	internal sealed class RuntimeCustomAttributeData : CustomAttributeData
	{
		private ConstructorInfo m_ctor;

		private readonly RuntimeModule m_scope;

		private readonly MemberInfo[] m_members;

		private readonly CustomAttributeCtorParameter[] m_ctorParams;

		private readonly CustomAttributeNamedParameter[] m_namedParams;

		private IList<CustomAttributeTypedArgument> m_typedCtorArgs;

		private IList<CustomAttributeNamedArgument> m_namedArgs;

		public override ConstructorInfo Constructor => m_ctor;

		public override IList<CustomAttributeTypedArgument> ConstructorArguments
		{
			get
			{
				if (m_typedCtorArgs == null)
				{
					CustomAttributeTypedArgument[] array = new CustomAttributeTypedArgument[m_ctorParams.Length];
					for (int i = 0; i < array.Length; i++)
					{
						CustomAttributeEncodedArgument customAttributeEncodedArgument = m_ctorParams[i].CustomAttributeEncodedArgument;
						array[i] = new CustomAttributeTypedArgument(m_scope, customAttributeEncodedArgument);
					}
					m_typedCtorArgs = Array.AsReadOnly(array);
				}
				return m_typedCtorArgs;
			}
		}

		public override IList<CustomAttributeNamedArgument> NamedArguments
		{
			get
			{
				if (m_namedArgs == null)
				{
					if (m_namedParams == null)
					{
						return null;
					}
					int num = 0;
					for (int i = 0; i < m_namedParams.Length; i++)
					{
						if (m_namedParams[i].EncodedArgument.CustomAttributeType.EncodedType != 0)
						{
							num++;
						}
					}
					CustomAttributeNamedArgument[] array = new CustomAttributeNamedArgument[num];
					int j = 0;
					int num2 = 0;
					for (; j < m_namedParams.Length; j++)
					{
						if (m_namedParams[j].EncodedArgument.CustomAttributeType.EncodedType != 0)
						{
							array[num2++] = new CustomAttributeNamedArgument(m_members[j], new CustomAttributeTypedArgument(m_scope, m_namedParams[j].EncodedArgument));
						}
					}
					m_namedArgs = Array.AsReadOnly(array);
				}
				return m_namedArgs;
			}
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeType target)
		{
			IList<CustomAttributeData> customAttributes = GetCustomAttributes(target.GetRuntimeModule(), target.MetadataToken);
			RuntimeType.ListBuilder<Attribute> pcas = default(RuntimeType.ListBuilder<Attribute>);
			PseudoCustomAttribute.GetCustomAttributes(target, (RuntimeType)typeof(object), ref pcas);
			if (pcas.Count <= 0)
			{
				return customAttributes;
			}
			return GetCombinedList(customAttributes, ref pcas);
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeFieldInfo target)
		{
			IList<CustomAttributeData> customAttributes = GetCustomAttributes(target.GetRuntimeModule(), target.MetadataToken);
			RuntimeType.ListBuilder<Attribute> pcas = default(RuntimeType.ListBuilder<Attribute>);
			PseudoCustomAttribute.GetCustomAttributes(target, (RuntimeType)typeof(object), ref pcas);
			if (pcas.Count <= 0)
			{
				return customAttributes;
			}
			return GetCombinedList(customAttributes, ref pcas);
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeMethodInfo target)
		{
			IList<CustomAttributeData> customAttributes = GetCustomAttributes(target.GetRuntimeModule(), target.MetadataToken);
			RuntimeType.ListBuilder<Attribute> pcas = default(RuntimeType.ListBuilder<Attribute>);
			PseudoCustomAttribute.GetCustomAttributes(target, (RuntimeType)typeof(object), ref pcas);
			if (pcas.Count <= 0)
			{
				return customAttributes;
			}
			return GetCombinedList(customAttributes, ref pcas);
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeConstructorInfo target)
		{
			return GetCustomAttributes(target.GetRuntimeModule(), target.MetadataToken);
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeEventInfo target)
		{
			return GetCustomAttributes(target.GetRuntimeModule(), target.MetadataToken);
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimePropertyInfo target)
		{
			return GetCustomAttributes(target.GetRuntimeModule(), target.MetadataToken);
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeModule target)
		{
			if (target.IsResource())
			{
				return new List<CustomAttributeData>();
			}
			return GetCustomAttributes(target, target.MetadataToken);
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeAssembly target)
		{
			return GetCustomAttributes((RuntimeModule)target.ManifestModule, RuntimeAssembly.GetToken(target.GetNativeHandle()));
		}

		internal static IList<CustomAttributeData> GetCustomAttributesInternal(RuntimeParameterInfo target)
		{
			RuntimeType.ListBuilder<Attribute> pcas = default(RuntimeType.ListBuilder<Attribute>);
			IList<CustomAttributeData> customAttributes = GetCustomAttributes(target.GetRuntimeModule(), target.MetadataToken);
			PseudoCustomAttribute.GetCustomAttributes(target, (RuntimeType)typeof(object), ref pcas);
			if (pcas.Count <= 0)
			{
				return customAttributes;
			}
			return GetCombinedList(customAttributes, ref pcas);
		}

		private static IList<CustomAttributeData> GetCombinedList(IList<CustomAttributeData> customAttributes, ref RuntimeType.ListBuilder<Attribute> pseudoAttributes)
		{
			CustomAttributeData[] array = new CustomAttributeData[customAttributes.Count + pseudoAttributes.Count];
			customAttributes.CopyTo(array, pseudoAttributes.Count);
			for (int i = 0; i < pseudoAttributes.Count; i++)
			{
				array[i] = new RuntimeCustomAttributeData(pseudoAttributes[i]);
			}
			return Array.AsReadOnly(array);
		}

		private static CustomAttributeEncoding TypeToCustomAttributeEncoding(RuntimeType type)
		{
			if (type == typeof(int))
			{
				return CustomAttributeEncoding.Int32;
			}
			if (type.IsEnum)
			{
				return CustomAttributeEncoding.Enum;
			}
			if (type == typeof(string))
			{
				return CustomAttributeEncoding.String;
			}
			if (type == typeof(Type))
			{
				return CustomAttributeEncoding.Type;
			}
			if (type == typeof(object))
			{
				return CustomAttributeEncoding.Object;
			}
			if (type.IsArray)
			{
				return CustomAttributeEncoding.Array;
			}
			if (type == typeof(char))
			{
				return CustomAttributeEncoding.Char;
			}
			if (type == typeof(bool))
			{
				return CustomAttributeEncoding.Boolean;
			}
			if (type == typeof(byte))
			{
				return CustomAttributeEncoding.Byte;
			}
			if (type == typeof(sbyte))
			{
				return CustomAttributeEncoding.SByte;
			}
			if (type == typeof(short))
			{
				return CustomAttributeEncoding.Int16;
			}
			if (type == typeof(ushort))
			{
				return CustomAttributeEncoding.UInt16;
			}
			if (type == typeof(uint))
			{
				return CustomAttributeEncoding.UInt32;
			}
			if (type == typeof(long))
			{
				return CustomAttributeEncoding.Int64;
			}
			if (type == typeof(ulong))
			{
				return CustomAttributeEncoding.UInt64;
			}
			if (type == typeof(float))
			{
				return CustomAttributeEncoding.Float;
			}
			if (type == typeof(double))
			{
				return CustomAttributeEncoding.Double;
			}
			if (type == typeof(Enum))
			{
				return CustomAttributeEncoding.Object;
			}
			if (type.IsClass)
			{
				return CustomAttributeEncoding.Object;
			}
			if (type.IsInterface)
			{
				return CustomAttributeEncoding.Object;
			}
			if (type.IsValueType)
			{
				return CustomAttributeEncoding.Undefined;
			}
			throw new ArgumentException(SR.Argument_InvalidKindOfTypeForCA, "type");
		}

		private static CustomAttributeType InitCustomAttributeType(RuntimeType parameterType)
		{
			CustomAttributeEncoding customAttributeEncoding = TypeToCustomAttributeEncoding(parameterType);
			CustomAttributeEncoding customAttributeEncoding2 = CustomAttributeEncoding.Undefined;
			CustomAttributeEncoding encodedEnumType = CustomAttributeEncoding.Undefined;
			string enumName = null;
			if (customAttributeEncoding == CustomAttributeEncoding.Array)
			{
				parameterType = (RuntimeType)parameterType.GetElementType();
				customAttributeEncoding2 = TypeToCustomAttributeEncoding(parameterType);
			}
			if (customAttributeEncoding == CustomAttributeEncoding.Enum || customAttributeEncoding2 == CustomAttributeEncoding.Enum)
			{
				encodedEnumType = TypeToCustomAttributeEncoding((RuntimeType)Enum.GetUnderlyingType(parameterType));
				enumName = parameterType.AssemblyQualifiedName;
			}
			return new CustomAttributeType(customAttributeEncoding, customAttributeEncoding2, encodedEnumType, enumName);
		}

		private static IList<CustomAttributeData> GetCustomAttributes(RuntimeModule module, int tkTarget)
		{
			CustomAttributeRecord[] customAttributeRecords = GetCustomAttributeRecords(module, tkTarget);
			if (customAttributeRecords.Length == 0)
			{
				return Array.Empty<CustomAttributeData>();
			}
			CustomAttributeData[] array = new CustomAttributeData[customAttributeRecords.Length];
			for (int i = 0; i < customAttributeRecords.Length; i++)
			{
				array[i] = new RuntimeCustomAttributeData(module, customAttributeRecords[i].tkCtor, in customAttributeRecords[i].blob);
			}
			return Array.AsReadOnly(array);
		}

		internal static CustomAttributeRecord[] GetCustomAttributeRecords(RuntimeModule module, int targetToken)
		{
			MetadataImport metadataImport = module.MetadataImport;
			metadataImport.EnumCustomAttributes(targetToken, out var result);
			if (result.Length == 0)
			{
				return Array.Empty<CustomAttributeRecord>();
			}
			CustomAttributeRecord[] array = new CustomAttributeRecord[result.Length];
			for (int i = 0; i < array.Length; i++)
			{
				metadataImport.GetCustomAttributeProps(result[i], out array[i].tkCtor.Value, out array[i].blob);
			}
			return array;
		}

		internal static CustomAttributeTypedArgument Filter(IList<CustomAttributeData> attrs, Type caType, int parameter)
		{
			for (int i = 0; i < attrs.Count; i++)
			{
				if (attrs[i].Constructor.DeclaringType == caType)
				{
					return attrs[i].ConstructorArguments[parameter];
				}
			}
			return default(CustomAttributeTypedArgument);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "Property setters and fields which are accessed by any attribute instantiation which is present in the code linker has analyzed.As such enumerating all fields and properties may return different results after trimmingbut all those which are needed to actually have data will be there.")]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "We're getting a MethodBase of a constructor that we found in the metadata. The attribute constructor won't be trimmed.")]
		private RuntimeCustomAttributeData(RuntimeModule scope, MetadataToken caCtorToken, in ConstArray blob)
		{
			m_scope = scope;
			m_ctor = (RuntimeConstructorInfo)RuntimeType.GetMethodBase(scope, caCtorToken);
			if (m_ctor.DeclaringType.IsGenericType)
			{
				Type type = scope.ResolveType(scope.MetadataImport.GetParentToken(caCtorToken), null, null);
				m_ctor = (RuntimeConstructorInfo)scope.ResolveMethod(caCtorToken, type.GenericTypeArguments, null).MethodHandle.GetMethodInfo();
			}
			ParameterInfo[] parametersNoCopy = m_ctor.GetParametersNoCopy();
			m_ctorParams = new CustomAttributeCtorParameter[parametersNoCopy.Length];
			for (int i = 0; i < parametersNoCopy.Length; i++)
			{
				m_ctorParams[i] = new CustomAttributeCtorParameter(InitCustomAttributeType((RuntimeType)parametersNoCopy[i].ParameterType));
			}
			FieldInfo[] fields = m_ctor.DeclaringType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			PropertyInfo[] properties = m_ctor.DeclaringType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			m_namedParams = new CustomAttributeNamedParameter[properties.Length + fields.Length];
			for (int j = 0; j < fields.Length; j++)
			{
				m_namedParams[j] = new CustomAttributeNamedParameter(fields[j].Name, CustomAttributeEncoding.Field, InitCustomAttributeType((RuntimeType)fields[j].FieldType));
			}
			for (int k = 0; k < properties.Length; k++)
			{
				m_namedParams[k + fields.Length] = new CustomAttributeNamedParameter(properties[k].Name, CustomAttributeEncoding.Property, InitCustomAttributeType((RuntimeType)properties[k].PropertyType));
			}
			m_members = new MemberInfo[fields.Length + properties.Length];
			fields.CopyTo(m_members, 0);
			properties.CopyTo(m_members, fields.Length);
			CustomAttributeEncodedArgument.ParseAttributeArguments(blob, ref m_ctorParams, ref m_namedParams, m_scope);
		}

		internal RuntimeCustomAttributeData(Attribute attribute)
		{
			if (attribute is DllImportAttribute dllImport)
			{
				Init(dllImport);
			}
			else if (attribute is FieldOffsetAttribute fieldOffset)
			{
				Init(fieldOffset);
			}
			else if (attribute is MarshalAsAttribute marshalAs)
			{
				Init(marshalAs);
			}
			else if (attribute is TypeForwardedToAttribute forwardedTo)
			{
				Init(forwardedTo);
			}
			else
			{
				Init(attribute);
			}
		}

		private void Init(DllImportAttribute dllImport)
		{
			Type typeFromHandle = typeof(DllImportAttribute);
			m_ctor = typeFromHandle.GetConstructors(BindingFlags.Instance | BindingFlags.Public)[0];
			m_typedCtorArgs = Array.AsReadOnly(new CustomAttributeTypedArgument[1]
			{
				new CustomAttributeTypedArgument(dllImport.Value)
			});
			m_namedArgs = Array.AsReadOnly(new CustomAttributeNamedArgument[8]
			{
				new CustomAttributeNamedArgument(typeFromHandle.GetField("EntryPoint"), dllImport.EntryPoint),
				new CustomAttributeNamedArgument(typeFromHandle.GetField("CharSet"), dllImport.CharSet),
				new CustomAttributeNamedArgument(typeFromHandle.GetField("ExactSpelling"), dllImport.ExactSpelling),
				new CustomAttributeNamedArgument(typeFromHandle.GetField("SetLastError"), dllImport.SetLastError),
				new CustomAttributeNamedArgument(typeFromHandle.GetField("PreserveSig"), dllImport.PreserveSig),
				new CustomAttributeNamedArgument(typeFromHandle.GetField("CallingConvention"), dllImport.CallingConvention),
				new CustomAttributeNamedArgument(typeFromHandle.GetField("BestFitMapping"), dllImport.BestFitMapping),
				new CustomAttributeNamedArgument(typeFromHandle.GetField("ThrowOnUnmappableChar"), dllImport.ThrowOnUnmappableChar)
			});
		}

		private void Init(FieldOffsetAttribute fieldOffset)
		{
			m_ctor = typeof(FieldOffsetAttribute).GetConstructors(BindingFlags.Instance | BindingFlags.Public)[0];
			m_typedCtorArgs = Array.AsReadOnly(new CustomAttributeTypedArgument[1]
			{
				new CustomAttributeTypedArgument(fieldOffset.Value)
			});
			m_namedArgs = Array.AsReadOnly(Array.Empty<CustomAttributeNamedArgument>());
		}

		private void Init(MarshalAsAttribute marshalAs)
		{
			Type typeFromHandle = typeof(MarshalAsAttribute);
			m_ctor = typeFromHandle.GetConstructors(BindingFlags.Instance | BindingFlags.Public)[0];
			m_typedCtorArgs = Array.AsReadOnly(new CustomAttributeTypedArgument[1]
			{
				new CustomAttributeTypedArgument(marshalAs.Value)
			});
			int num = 3;
			if (marshalAs.MarshalType != null)
			{
				num++;
			}
			if ((object)marshalAs.MarshalTypeRef != null)
			{
				num++;
			}
			if (marshalAs.MarshalCookie != null)
			{
				num++;
			}
			num++;
			num++;
			if ((object)marshalAs.SafeArrayUserDefinedSubType != null)
			{
				num++;
			}
			CustomAttributeNamedArgument[] array = new CustomAttributeNamedArgument[num];
			num = 0;
			array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("ArraySubType"), marshalAs.ArraySubType);
			array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("SizeParamIndex"), marshalAs.SizeParamIndex);
			array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("SizeConst"), marshalAs.SizeConst);
			array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("IidParameterIndex"), marshalAs.IidParameterIndex);
			array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("SafeArraySubType"), marshalAs.SafeArraySubType);
			if (marshalAs.MarshalType != null)
			{
				array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("MarshalType"), marshalAs.MarshalType);
			}
			if ((object)marshalAs.MarshalTypeRef != null)
			{
				array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("MarshalTypeRef"), marshalAs.MarshalTypeRef);
			}
			if (marshalAs.MarshalCookie != null)
			{
				array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("MarshalCookie"), marshalAs.MarshalCookie);
			}
			if ((object)marshalAs.SafeArrayUserDefinedSubType != null)
			{
				array[num++] = new CustomAttributeNamedArgument(typeFromHandle.GetField("SafeArrayUserDefinedSubType"), marshalAs.SafeArrayUserDefinedSubType);
			}
			m_namedArgs = Array.AsReadOnly(array);
		}

		private void Init(TypeForwardedToAttribute forwardedTo)
		{
			Type typeFromHandle = typeof(TypeForwardedToAttribute);
			Type[] types = new Type[1] { typeof(Type) };
			m_ctor = typeFromHandle.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, types, null);
			m_typedCtorArgs = Array.AsReadOnly(new CustomAttributeTypedArgument[1]
			{
				new CustomAttributeTypedArgument(typeof(Type), forwardedTo.Destination)
			});
			CustomAttributeNamedArgument[] array = Array.Empty<CustomAttributeNamedArgument>();
			m_namedArgs = Array.AsReadOnly(array);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "The pca object had to be created by the single ctor on the Type. So the ctor couldn't have been trimmed.")]
		private void Init(object pca)
		{
			Type type = pca.GetType();
			m_ctor = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public)[0];
			m_typedCtorArgs = Array.AsReadOnly(Array.Empty<CustomAttributeTypedArgument>());
			m_namedArgs = Array.AsReadOnly(Array.Empty<CustomAttributeNamedArgument>());
		}
	}
	public readonly struct CustomAttributeTypedArgument
	{
		private readonly object _value;

		private readonly Type _argumentType;

		public Type ArgumentType => _argumentType;

		public object? Value => _value;

		private static Type CustomAttributeEncodingToType(CustomAttributeEncoding encodedType)
		{
			return encodedType switch
			{
				CustomAttributeEncoding.Enum => typeof(Enum), 
				CustomAttributeEncoding.Int32 => typeof(int), 
				CustomAttributeEncoding.String => typeof(string), 
				CustomAttributeEncoding.Type => typeof(Type), 
				CustomAttributeEncoding.Array => typeof(Array), 
				CustomAttributeEncoding.Char => typeof(char), 
				CustomAttributeEncoding.Boolean => typeof(bool), 
				CustomAttributeEncoding.SByte => typeof(sbyte), 
				CustomAttributeEncoding.Byte => typeof(byte), 
				CustomAttributeEncoding.Int16 => typeof(short), 
				CustomAttributeEncoding.UInt16 => typeof(ushort), 
				CustomAttributeEncoding.UInt32 => typeof(uint), 
				CustomAttributeEncoding.Int64 => typeof(long), 
				CustomAttributeEncoding.UInt64 => typeof(ulong), 
				CustomAttributeEncoding.Float => typeof(float), 
				CustomAttributeEncoding.Double => typeof(double), 
				CustomAttributeEncoding.Object => typeof(object), 
				_ => throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)encodedType), "encodedType"), 
			};
		}

		private unsafe static object EncodedValueToRawValue(long val, CustomAttributeEncoding encodedType)
		{
			return encodedType switch
			{
				CustomAttributeEncoding.Boolean => (byte)val != 0, 
				CustomAttributeEncoding.Char => (char)val, 
				CustomAttributeEncoding.Byte => (byte)val, 
				CustomAttributeEncoding.SByte => (sbyte)val, 
				CustomAttributeEncoding.Int16 => (short)val, 
				CustomAttributeEncoding.UInt16 => (ushort)val, 
				CustomAttributeEncoding.Int32 => (int)val, 
				CustomAttributeEncoding.UInt32 => (uint)val, 
				CustomAttributeEncoding.Int64 => val, 
				CustomAttributeEncoding.UInt64 => (ulong)val, 
				CustomAttributeEncoding.Float => *(float*)(&val), 
				CustomAttributeEncoding.Double => *(double*)(&val), 
				_ => throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)val), "val"), 
			};
		}

		private static RuntimeType ResolveType(RuntimeModule scope, string typeName)
		{
			RuntimeType typeByNameUsingCARules = RuntimeTypeHandle.GetTypeByNameUsingCARules(typeName, scope);
			if ((object)typeByNameUsingCARules == null)
			{
				throw new InvalidOperationException(SR.Format(SR.Arg_CATypeResolutionFailed, typeName));
			}
			return typeByNameUsingCARules;
		}

		internal CustomAttributeTypedArgument(RuntimeModule scope, CustomAttributeEncodedArgument encodedArg)
		{
			CustomAttributeEncoding encodedType = encodedArg.CustomAttributeType.EncodedType;
			switch (encodedType)
			{
			case CustomAttributeEncoding.Undefined:
				throw new ArgumentException(null, "encodedArg");
			case CustomAttributeEncoding.Enum:
				_argumentType = ResolveType(scope, encodedArg.CustomAttributeType.EnumName);
				_value = EncodedValueToRawValue(encodedArg.PrimitiveValue, encodedArg.CustomAttributeType.EncodedEnumType);
				break;
			case CustomAttributeEncoding.String:
				_argumentType = typeof(string);
				_value = encodedArg.StringValue;
				break;
			case CustomAttributeEncoding.Type:
				_argumentType = typeof(Type);
				_value = null;
				if (encodedArg.StringValue != null)
				{
					_value = ResolveType(scope, encodedArg.StringValue);
				}
				break;
			case CustomAttributeEncoding.Array:
			{
				encodedType = encodedArg.CustomAttributeType.EncodedArrayType;
				Type type = ((encodedType != CustomAttributeEncoding.Enum) ? CustomAttributeEncodingToType(encodedType) : ResolveType(scope, encodedArg.CustomAttributeType.EnumName));
				_argumentType = type.MakeArrayType();
				if (encodedArg.ArrayValue == null)
				{
					_value = null;
					break;
				}
				CustomAttributeTypedArgument[] array = new CustomAttributeTypedArgument[encodedArg.ArrayValue.Length];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = new CustomAttributeTypedArgument(scope, encodedArg.ArrayValue[i]);
				}
				_value = Array.AsReadOnly(array);
				break;
			}
			default:
				_argumentType = CustomAttributeEncodingToType(encodedType);
				_value = EncodedValueToRawValue(encodedArg.PrimitiveValue, encodedType);
				break;
			}
		}

		public static bool operator ==(CustomAttributeTypedArgument left, CustomAttributeTypedArgument right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(CustomAttributeTypedArgument left, CustomAttributeTypedArgument right)
		{
			return !left.Equals(right);
		}

		public CustomAttributeTypedArgument(Type argumentType, object? value)
		{
			if ((object)argumentType == null)
			{
				throw new ArgumentNullException("argumentType");
			}
			_value = CanonicalizeValue(value);
			_argumentType = argumentType;
		}

		public CustomAttributeTypedArgument(object value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			_value = CanonicalizeValue(value);
			_argumentType = value.GetType();
		}

		public override string ToString()
		{
			return ToString(typed: false);
		}

		internal string ToString(bool typed)
		{
			if ((object)_argumentType == null)
			{
				return base.ToString();
			}
			if (ArgumentType.IsEnum)
			{
				if (typed)
				{
					return $"{Value}";
				}
				return $"({ArgumentType.FullName}){Value}";
			}
			if (Value == null)
			{
				if (!typed)
				{
					return "(" + ArgumentType.Name + ")null";
				}
				return "null";
			}
			if (ArgumentType == typeof(string))
			{
				return $"\"{Value}\"";
			}
			if (ArgumentType == typeof(char))
			{
				return $"'{Value}'";
			}
			if (ArgumentType == typeof(Type))
			{
				return "typeof(" + ((Type)Value).FullName + ")";
			}
			if (ArgumentType.IsArray)
			{
				IList<CustomAttributeTypedArgument> list = (IList<CustomAttributeTypedArgument>)Value;
				Type elementType = ArgumentType.GetElementType();
				Span<char> initialBuffer = stackalloc char[256];
				ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
				valueStringBuilder.Append("new ");
				valueStringBuilder.Append(elementType.IsEnum ? elementType.FullName : elementType.Name);
				valueStringBuilder.Append('[');
				int count = list.Count;
				valueStringBuilder.Append(count.ToString());
				valueStringBuilder.Append("] { ");
				for (int i = 0; i < count; i++)
				{
					if (i != 0)
					{
						valueStringBuilder.Append(", ");
					}
					valueStringBuilder.Append(list[i].ToString(elementType != typeof(object)));
				}
				valueStringBuilder.Append(" }");
				return valueStringBuilder.ToString();
			}
			if (typed)
			{
				return $"{Value}";
			}
			return $"({ArgumentType.Name}){Value}";
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		public override bool Equals(object? obj)
		{
			return obj == (object)this;
		}

		private static object CanonicalizeValue(object value)
		{
			if (!(value is Enum @enum))
			{
				return value;
			}
			return @enum.GetValue();
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal struct CustomAttributeRecord
	{
		internal ConstArray blob;

		internal MetadataToken tkCtor;
	}
	internal enum CustomAttributeEncoding
	{
		Undefined = 0,
		Boolean = 2,
		Char = 3,
		SByte = 4,
		Byte = 5,
		Int16 = 6,
		UInt16 = 7,
		Int32 = 8,
		UInt32 = 9,
		Int64 = 10,
		UInt64 = 11,
		Float = 12,
		Double = 13,
		String = 14,
		Array = 29,
		Type = 80,
		Object = 81,
		Field = 83,
		Property = 84,
		Enum = 85
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct CustomAttributeEncodedArgument
	{
		private readonly long m_primitiveValue;

		private readonly CustomAttributeEncodedArgument[] m_arrayValue;

		private readonly string m_stringValue;

		private readonly CustomAttributeType m_type;

		public CustomAttributeType CustomAttributeType => m_type;

		public long PrimitiveValue => m_primitiveValue;

		public CustomAttributeEncodedArgument[] ArrayValue => m_arrayValue;

		public string StringValue => m_stringValue;

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void ParseAttributeArguments(IntPtr pCa, int cCa, ref CustomAttributeCtorParameter[] CustomAttributeCtorParameters, ref CustomAttributeNamedParameter[] CustomAttributeTypedArgument, RuntimeAssembly assembly);

		internal static void ParseAttributeArguments(ConstArray attributeBlob, ref CustomAttributeCtorParameter[] customAttributeCtorParameters, ref CustomAttributeNamedParameter[] customAttributeNamedParameters, RuntimeModule customAttributeModule)
		{
			if ((object)customAttributeModule == null)
			{
				throw new ArgumentNullException("customAttributeModule");
			}
			if (customAttributeCtorParameters.Length != 0 || customAttributeNamedParameters.Length != 0)
			{
				ParseAttributeArguments(attributeBlob.Signature, attributeBlob.Length, ref customAttributeCtorParameters, ref customAttributeNamedParameters, (RuntimeAssembly)customAttributeModule.Assembly);
			}
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct CustomAttributeNamedParameter
	{
		private readonly string m_argumentName;

		private readonly CustomAttributeEncoding m_fieldOrProperty;

		private readonly CustomAttributeEncoding m_padding;

		private readonly CustomAttributeType m_type;

		private readonly CustomAttributeEncodedArgument m_encodedArgument;

		public CustomAttributeEncodedArgument EncodedArgument => m_encodedArgument;

		public CustomAttributeNamedParameter(string argumentName, CustomAttributeEncoding fieldOrProperty, CustomAttributeType type)
		{
			if (argumentName == null)
			{
				throw new ArgumentNullException("argumentName");
			}
			m_argumentName = argumentName;
			m_fieldOrProperty = fieldOrProperty;
			m_padding = fieldOrProperty;
			m_type = type;
			m_encodedArgument = default(CustomAttributeEncodedArgument);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct CustomAttributeCtorParameter
	{
		private readonly CustomAttributeType m_type;

		private readonly CustomAttributeEncodedArgument m_encodedArgument;

		public CustomAttributeEncodedArgument CustomAttributeEncodedArgument => m_encodedArgument;

		public CustomAttributeCtorParameter(CustomAttributeType type)
		{
			m_type = type;
			m_encodedArgument = default(CustomAttributeEncodedArgument);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct CustomAttributeType
	{
		private readonly string m_enumName;

		private readonly CustomAttributeEncoding m_encodedType;

		private readonly CustomAttributeEncoding m_encodedEnumType;

		private readonly CustomAttributeEncoding m_encodedArrayType;

		private readonly CustomAttributeEncoding m_padding;

		public CustomAttributeEncoding EncodedType => m_encodedType;

		public CustomAttributeEncoding EncodedEnumType => m_encodedEnumType;

		public CustomAttributeEncoding EncodedArrayType => m_encodedArrayType;

		public string EnumName => m_enumName;

		public CustomAttributeType(CustomAttributeEncoding encodedType, CustomAttributeEncoding encodedArrayType, CustomAttributeEncoding encodedEnumType, string enumName)
		{
			m_encodedType = encodedType;
			m_encodedArrayType = encodedArrayType;
			m_encodedEnumType = encodedEnumType;
			m_enumName = enumName;
			m_padding = m_encodedType;
		}
	}
	internal static class CustomAttribute
	{
		private static readonly RuntimeType Type_RuntimeType = (RuntimeType)typeof(RuntimeType);

		private static readonly RuntimeType Type_Type = (RuntimeType)typeof(Type);

		internal static bool IsDefined(RuntimeType type, RuntimeType caType, bool inherit)
		{
			if ((object)type.GetElementType() != null)
			{
				return false;
			}
			if (PseudoCustomAttribute.IsDefined(type, caType))
			{
				return true;
			}
			if (IsCustomAttributeDefined(type.GetRuntimeModule(), type.MetadataToken, caType))
			{
				return true;
			}
			if (!inherit)
			{
				return false;
			}
			type = type.BaseType as RuntimeType;
			while ((object)type != null)
			{
				if (IsCustomAttributeDefined(type.GetRuntimeModule(), type.MetadataToken, caType, 0, inherit))
				{
					return true;
				}
				type = type.BaseType as RuntimeType;
			}
			return false;
		}

		internal static bool IsDefined(RuntimeMethodInfo method, RuntimeType caType, bool inherit)
		{
			if (PseudoCustomAttribute.IsDefined(method, caType))
			{
				return true;
			}
			if (IsCustomAttributeDefined(method.GetRuntimeModule(), method.MetadataToken, caType))
			{
				return true;
			}
			if (!inherit)
			{
				return false;
			}
			method = method.GetParentDefinition();
			while ((object)method != null)
			{
				if (IsCustomAttributeDefined(method.GetRuntimeModule(), method.MetadataToken, caType, 0, inherit))
				{
					return true;
				}
				method = method.GetParentDefinition();
			}
			return false;
		}

		internal static bool IsDefined(RuntimeConstructorInfo ctor, RuntimeType caType)
		{
			return IsCustomAttributeDefined(ctor.GetRuntimeModule(), ctor.MetadataToken, caType);
		}

		internal static bool IsDefined(RuntimePropertyInfo property, RuntimeType caType)
		{
			return IsCustomAttributeDefined(property.GetRuntimeModule(), property.MetadataToken, caType);
		}

		internal static bool IsDefined(RuntimeEventInfo e, RuntimeType caType)
		{
			return IsCustomAttributeDefined(e.GetRuntimeModule(), e.MetadataToken, caType);
		}

		internal static bool IsDefined(RuntimeFieldInfo field, RuntimeType caType)
		{
			if (PseudoCustomAttribute.IsDefined(field, caType))
			{
				return true;
			}
			return IsCustomAttributeDefined(field.GetRuntimeModule(), field.MetadataToken, caType);
		}

		internal static bool IsDefined(RuntimeParameterInfo parameter, RuntimeType caType)
		{
			if (PseudoCustomAttribute.IsDefined(parameter, caType))
			{
				return true;
			}
			return IsCustomAttributeDefined(parameter.GetRuntimeModule(), parameter.MetadataToken, caType);
		}

		internal static bool IsDefined(RuntimeAssembly assembly, RuntimeType caType)
		{
			return IsCustomAttributeDefined(assembly.ManifestModule as RuntimeModule, RuntimeAssembly.GetToken(assembly.GetNativeHandle()), caType);
		}

		internal static bool IsDefined(RuntimeModule module, RuntimeType caType)
		{
			return IsCustomAttributeDefined(module, module.MetadataToken, caType);
		}

		internal static object[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool inherit)
		{
			if ((object)type.GetElementType() != null)
			{
				if (!caType.IsValueType)
				{
					return CreateAttributeArrayHelper(caType, 0);
				}
				return Array.Empty<object>();
			}
			if (type.IsGenericType && !type.IsGenericTypeDefinition)
			{
				type = type.GetGenericTypeDefinition() as RuntimeType;
			}
			RuntimeType.ListBuilder<Attribute> pcas = default(RuntimeType.ListBuilder<Attribute>);
			PseudoCustomAttribute.GetCustomAttributes(type, caType, ref pcas);
			if (!inherit || (caType.IsSealed && !GetAttributeUsage(caType).Inherited))
			{
				object[] customAttributes = GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, pcas.Count, caType);
				if (pcas.Count > 0)
				{
					pcas.CopyTo(customAttributes, customAttributes.Length - pcas.Count);
				}
				return customAttributes;
			}
			RuntimeType.ListBuilder<object> attributes = default(RuntimeType.ListBuilder<object>);
			bool mustBeInheritable = false;
			RuntimeType elementType = ((caType.IsValueType || caType.ContainsGenericParameters) ? ((RuntimeType)typeof(object)) : caType);
			for (int i = 0; i < pcas.Count; i++)
			{
				attributes.Add(pcas[i]);
			}
			while (type != (RuntimeType)typeof(object) && type != null)
			{
				AddCustomAttributes(ref attributes, type.GetRuntimeModule(), type.MetadataToken, caType, mustBeInheritable, attributes);
				mustBeInheritable = true;
				type = type.BaseType as RuntimeType;
			}
			object[] array = CreateAttributeArrayHelper(elementType, attributes.Count);
			for (int j = 0; j < attributes.Count; j++)
			{
				array[j] = attributes[j];
			}
			return array;
		}

		internal static object[] GetCustomAttributes(RuntimeMethodInfo method, RuntimeType caType, bool inherit)
		{
			if (method.IsGenericMethod && !method.IsGenericMethodDefinition)
			{
				method = method.GetGenericMethodDefinition() as RuntimeMethodInfo;
			}
			RuntimeType.ListBuilder<Attribute> pcas = default(RuntimeType.ListBuilder<Attribute>);
			PseudoCustomAttribute.GetCustomAttributes(method, caType, ref pcas);
			if (!inherit || (caType.IsSealed && !GetAttributeUsage(caType).Inherited))
			{
				object[] customAttributes = GetCustomAttributes(method.GetRuntimeModule(), method.MetadataToken, pcas.Count, caType);
				if (pcas.Count > 0)
				{
					pcas.CopyTo(customAttributes, customAttributes.Length - pcas.Count);
				}
				return customAttributes;
			}
			RuntimeType.ListBuilder<object> attributes = default(RuntimeType.ListBuilder<object>);
			bool mustBeInheritable = false;
			RuntimeType elementType = ((caType.IsValueType || caType.ContainsGenericParameters) ? ((RuntimeType)typeof(object)) : caType);
			for (int i = 0; i < pcas.Count; i++)
			{
				attributes.Add(pcas[i]);
			}
			while (method != null)
			{
				AddCustomAttributes(ref attributes, method.GetRuntimeModule(), method.MetadataToken, caType, mustBeInheritable, attributes);
				mustBeInheritable = true;
				method = method.GetParentDefinition();
			}
			object[] array = CreateAttributeArrayHelper(elementType, attributes.Count);
			for (int j = 0; j < attributes.Count; j++)
			{
				array[j] = attributes[j];
			}
			return array;
		}

		internal static object[] GetCustomAttributes(RuntimeConstructorInfo ctor, RuntimeType caType)
		{
			return GetCustomAttributes(ctor.GetRuntimeModule(), ctor.MetadataToken, 0, caType);
		}

		internal static object[] GetCustomAttributes(RuntimePropertyInfo property, RuntimeType caType)
		{
			return GetCustomAttributes(property.GetRuntimeModule(), property.MetadataToken, 0, caType);
		}

		internal static object[] GetCustomAttributes(RuntimeEventInfo e, RuntimeType caType)
		{
			return GetCustomAttributes(e.GetRuntimeModule(), e.MetadataToken, 0, caType);
		}

		internal static object[] GetCustomAttributes(RuntimeFieldInfo field, RuntimeType caType)
		{
			RuntimeType.ListBuilder<Attribute> pcas = default(RuntimeType.ListBuilder<Attribute>);
			PseudoCustomAttribute.GetCustomAttributes(field, caType, ref pcas);
			object[] customAttributes = GetCustomAttributes(field.GetRuntimeModule(), field.MetadataToken, pcas.Count, caType);
			if (pcas.Count > 0)
			{
				pcas.CopyTo(customAttributes, customAttributes.Length - pcas.Count);
			}
			return customAttributes;
		}

		internal static object[] GetCustomAttributes(RuntimeParameterInfo parameter, RuntimeType caType)
		{
			RuntimeType.ListBuilder<Attribute> pcas = default(RuntimeType.ListBuilder<Attribute>);
			PseudoCustomAttribute.GetCustomAttributes(parameter, caType, ref pcas);
			object[] customAttributes = GetCustomAttributes(parameter.GetRuntimeModule(), parameter.MetadataToken, pcas.Count, caType);
			if (pcas.Count > 0)
			{
				pcas.CopyTo(customAttributes, customAttributes.Length - pcas.Count);
			}
			return customAttributes;
		}

		internal static object[] GetCustomAttributes(RuntimeAssembly assembly, RuntimeType caType)
		{
			int token = RuntimeAssembly.GetToken(assembly.GetNativeHandle());
			return GetCustomAttributes(assembly.ManifestModule as RuntimeModule, token, 0, caType);
		}

		internal static object[] GetCustomAttributes(RuntimeModule module, RuntimeType caType)
		{
			return GetCustomAttributes(module, module.MetadataToken, 0, caType);
		}

		private static bool IsCustomAttributeDefined(RuntimeModule decoratedModule, int decoratedMetadataToken, RuntimeType attributeFilterType)
		{
			return IsCustomAttributeDefined(decoratedModule, decoratedMetadataToken, attributeFilterType, 0, mustBeInheritable: false);
		}

		private static bool IsCustomAttributeDefined(RuntimeModule decoratedModule, int decoratedMetadataToken, RuntimeType attributeFilterType, int attributeCtorToken, bool mustBeInheritable)
		{
			MetadataImport scope = decoratedModule.MetadataImport;
			scope.EnumCustomAttributes(decoratedMetadataToken, out var result);
			if (result.Length == 0)
			{
				return false;
			}
			CustomAttributeRecord customAttributeRecord = default(CustomAttributeRecord);
			if ((object)attributeFilterType != null)
			{
				RuntimeType.ListBuilder<object> derivedAttributes = default(RuntimeType.ListBuilder<object>);
				for (int i = 0; i < result.Length; i++)
				{
					scope.GetCustomAttributeProps(result[i], out customAttributeRecord.tkCtor.Value, out customAttributeRecord.blob);
					if (FilterCustomAttributeRecord(customAttributeRecord.tkCtor, in scope, decoratedModule, decoratedMetadataToken, attributeFilterType, mustBeInheritable, ref derivedAttributes, out var _, out var _, out var _))
					{
						return true;
					}
				}
			}
			else
			{
				for (int j = 0; j < result.Length; j++)
				{
					scope.GetCustomAttributeProps(result[j], out customAttributeRecord.tkCtor.Value, out customAttributeRecord.blob);
					if ((int)customAttributeRecord.tkCtor == attributeCtorToken)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static object[] GetCustomAttributes(RuntimeModule decoratedModule, int decoratedMetadataToken, int pcaCount, RuntimeType attributeFilterType)
		{
			RuntimeType.ListBuilder<object> attributes = default(RuntimeType.ListBuilder<object>);
			AddCustomAttributes(ref attributes, decoratedModule, decoratedMetadataToken, attributeFilterType, mustBeInheritable: false, default(RuntimeType.ListBuilder<object>));
			RuntimeType elementType = (((object)attributeFilterType == null || attributeFilterType.IsValueType || attributeFilterType.ContainsGenericParameters) ? ((RuntimeType)typeof(object)) : attributeFilterType);
			object[] array = CreateAttributeArrayHelper(elementType, attributes.Count + pcaCount);
			for (int i = 0; i < attributes.Count; i++)
			{
				array[i] = attributes[i];
			}
			return array;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2065:UnrecognizedReflectionPattern", Justification = "Linker guarantees presence of all the constructor parameters, property setters and fields which are accessed by any attribute instantiation which is present in the code linker has analyzed.As such the reflection usage in this method will never fail as those methods/fields will be present.")]
		private unsafe static void AddCustomAttributes(ref RuntimeType.ListBuilder<object> attributes, RuntimeModule decoratedModule, int decoratedMetadataToken, RuntimeType attributeFilterType, bool mustBeInheritable, RuntimeType.ListBuilder<object> derivedAttributes)
		{
			CustomAttributeRecord[] customAttributeRecords = RuntimeCustomAttributeData.GetCustomAttributeRecords(decoratedModule, decoratedMetadataToken);
			if ((object)attributeFilterType == null && customAttributeRecords.Length == 0)
			{
				return;
			}
			MetadataImport scope = decoratedModule.MetadataImport;
			for (int i = 0; i < customAttributeRecords.Length; i++)
			{
				ref CustomAttributeRecord reference = ref customAttributeRecords[i];
				IntPtr blob = reference.blob.Signature;
				IntPtr intPtr = (IntPtr)((byte*)(void*)blob + reference.blob.Length);
				if (!FilterCustomAttributeRecord(reference.tkCtor, in scope, decoratedModule, decoratedMetadataToken, attributeFilterType, mustBeInheritable, ref derivedAttributes, out var attributeType, out var ctorWithParameters, out var isVarArg))
				{
					continue;
				}
				RuntimeConstructorInfo.CheckCanCreateInstance(attributeType, isVarArg);
				object obj;
				int namedArgs;
				if (ctorWithParameters != null)
				{
					obj = CreateCaObject(decoratedModule, attributeType, ctorWithParameters, ref blob, intPtr, out namedArgs);
				}
				else
				{
					obj = attributeType.CreateInstanceDefaultCtor(publicOnly: false, wrapExceptions: false);
					if ((int)((byte*)(void*)intPtr - (byte*)(void*)blob) == 0)
					{
						namedArgs = 0;
					}
					else
					{
						int num = Unsafe.ReadUnaligned<int>((void*)blob);
						if ((num & 0xFFFF) != 1)
						{
							throw new CustomAttributeFormatException();
						}
						namedArgs = num >> 16;
						blob = (IntPtr)((byte*)(void*)blob + 4);
					}
				}
				for (int j = 0; j < namedArgs; j++)
				{
					GetPropertyOrFieldData(decoratedModule, ref blob, intPtr, out var name, out var isProperty, out var type, out var value);
					try
					{
						if (isProperty)
						{
							if ((object)type == null && value != null)
							{
								type = (RuntimeType)value.GetType();
								if (type == Type_RuntimeType)
								{
									type = Type_Type;
								}
							}
							PropertyInfo propertyInfo = (((object)type == null) ? attributeType.GetProperty(name) : attributeType.GetProperty(name, type, Type.EmptyTypes));
							if ((object)propertyInfo == null)
							{
								throw new CustomAttributeFormatException(SR.Format(SR.RFLCT_InvalidPropFail, name));
							}
							MethodInfo setMethod = propertyInfo.GetSetMethod(nonPublic: true);
							if (setMethod.IsPublic)
							{
								setMethod.Invoke(obj, BindingFlags.Default, null, new object[1] { value }, null);
							}
						}
						else
						{
							FieldInfo field = attributeType.GetField(name);
							field.SetValue(obj, value, BindingFlags.Default, Type.DefaultBinder, null);
						}
					}
					catch (Exception inner)
					{
						throw new CustomAttributeFormatException(SR.Format(isProperty ? SR.RFLCT_InvalidPropFail : SR.RFLCT_InvalidFieldFail, name), inner);
					}
				}
				if (blob != intPtr)
				{
					throw new CustomAttributeFormatException();
				}
				attributes.Add(obj);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Module.ResolveMethod and Module.ResolveType are marked as RequiresUnreferencedCode because they rely on tokenswhich are not guaranteed to be stable across trimming. So if somebody hardcodes a token it could break.The usage here is not like that as all these tokens come from existing metadata loaded from some ILand so trimming has no effect (the tokens are read AFTER trimming occured).")]
		private static bool FilterCustomAttributeRecord(MetadataToken caCtorToken, in MetadataImport scope, RuntimeModule decoratedModule, MetadataToken decoratedToken, RuntimeType attributeFilterType, bool mustBeInheritable, ref RuntimeType.ListBuilder<object> derivedAttributes, out RuntimeType attributeType, out IRuntimeMethodInfo ctorWithParameters, out bool isVarArg)
		{
			ctorWithParameters = null;
			isVarArg = false;
			attributeType = decoratedModule.ResolveType(scope.GetParentToken(caCtorToken), null, null) as RuntimeType;
			if (!attributeFilterType.IsAssignableFrom(attributeType))
			{
				return false;
			}
			if (!AttributeUsageCheck(attributeType, mustBeInheritable, ref derivedAttributes))
			{
				return false;
			}
			if ((attributeType.Attributes & TypeAttributes.WindowsRuntime) == TypeAttributes.WindowsRuntime)
			{
				return false;
			}
			ConstArray methodSignature = scope.GetMethodSignature(caCtorToken);
			isVarArg = (methodSignature[0] & 5) != 0;
			if (methodSignature[1] != 0)
			{
				if (attributeType.IsGenericType)
				{
					ctorWithParameters = decoratedModule.ResolveMethod(caCtorToken, attributeType.GenericTypeArguments, null).MethodHandle.GetMethodInfo();
				}
				else
				{
					ctorWithParameters = new ModuleHandle(decoratedModule).ResolveMethodHandle(caCtorToken).GetMethodInfo();
				}
			}
			MetadataToken metadataToken = default(MetadataToken);
			if (decoratedToken.IsParamDef)
			{
				metadataToken = new MetadataToken(scope.GetParentToken(decoratedToken));
				metadataToken = new MetadataToken(scope.GetParentToken(metadataToken));
			}
			else if (decoratedToken.IsMethodDef || decoratedToken.IsProperty || decoratedToken.IsEvent || decoratedToken.IsFieldDef)
			{
				metadataToken = new MetadataToken(scope.GetParentToken(decoratedToken));
			}
			else if (decoratedToken.IsTypeDef)
			{
				metadataToken = decoratedToken;
			}
			else if (decoratedToken.IsGenericPar)
			{
				metadataToken = new MetadataToken(scope.GetParentToken(decoratedToken));
				if (metadataToken.IsMethodDef)
				{
					metadataToken = new MetadataToken(scope.GetParentToken(metadataToken));
				}
			}
			RuntimeTypeHandle rth = (metadataToken.IsTypeDef ? decoratedModule.ModuleHandle.ResolveTypeHandle(metadataToken) : default(RuntimeTypeHandle));
			RuntimeTypeHandle rth2 = attributeType.TypeHandle;
			bool result = RuntimeMethodHandle.IsCAVisibleFromDecoratedType(new QCallTypeHandle(ref rth2), (ctorWithParameters != null) ? ctorWithParameters.Value : RuntimeMethodHandleInternal.EmptyHandle, new QCallTypeHandle(ref rth), new QCallModule(ref decoratedModule)) != Interop.BOOL.FALSE;
			GC.KeepAlive(ctorWithParameters);
			return result;
		}

		private static bool AttributeUsageCheck(RuntimeType attributeType, bool mustBeInheritable, ref RuntimeType.ListBuilder<object> derivedAttributes)
		{
			AttributeUsageAttribute attributeUsageAttribute = null;
			if (mustBeInheritable)
			{
				attributeUsageAttribute = GetAttributeUsage(attributeType);
				if (!attributeUsageAttribute.Inherited)
				{
					return false;
				}
			}
			if (derivedAttributes.Count == 0)
			{
				return true;
			}
			for (int i = 0; i < derivedAttributes.Count; i++)
			{
				if (derivedAttributes[i].GetType() == attributeType)
				{
					if (attributeUsageAttribute == null)
					{
						attributeUsageAttribute = GetAttributeUsage(attributeType);
					}
					return attributeUsageAttribute.AllowMultiple;
				}
			}
			return true;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Module.ResolveType is marked as RequiresUnreferencedCode because it relies on tokenswhich are not guaranteed to be stable across trimming. So if somebody hardcodes a token it could break.The usage here is not like that as all these tokens come from existing metadata loaded from some ILand so trimming has no effect (the tokens are read AFTER trimming occured).")]
		internal static AttributeUsageAttribute GetAttributeUsage(RuntimeType decoratedAttribute)
		{
			RuntimeModule runtimeModule = decoratedAttribute.GetRuntimeModule();
			MetadataImport metadataImport = runtimeModule.MetadataImport;
			CustomAttributeRecord[] customAttributeRecords = RuntimeCustomAttributeData.GetCustomAttributeRecords(runtimeModule, decoratedAttribute.MetadataToken);
			AttributeUsageAttribute attributeUsageAttribute = null;
			for (int i = 0; i < customAttributeRecords.Length; i++)
			{
				ref CustomAttributeRecord reference = ref customAttributeRecords[i];
				RuntimeType runtimeType = runtimeModule.ResolveType(metadataImport.GetParentToken(reference.tkCtor), null, null) as RuntimeType;
				if (!(runtimeType != (RuntimeType)typeof(AttributeUsageAttribute)))
				{
					if (attributeUsageAttribute != null)
					{
						throw new FormatException(SR.Format(SR.Format_AttributeUsage, runtimeType));
					}
					ParseAttributeUsageAttribute(reference.blob, out var targets, out var inherited, out var allowMultiple);
					attributeUsageAttribute = new AttributeUsageAttribute(targets, allowMultiple, inherited);
				}
			}
			return attributeUsageAttribute ?? AttributeUsageAttribute.Default;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void _ParseAttributeUsageAttribute(IntPtr pCa, int cCa, out int targets, out bool inherited, out bool allowMultiple);

		private static void ParseAttributeUsageAttribute(ConstArray ca, out AttributeTargets targets, out bool inherited, out bool allowMultiple)
		{
			_ParseAttributeUsageAttribute(ca.Signature, ca.Length, out var targets2, out inherited, out allowMultiple);
			targets = (AttributeTargets)targets2;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern object _CreateCaObject(RuntimeModule pModule, RuntimeType type, IRuntimeMethodInfo pCtor, byte** ppBlob, byte* pEndBlob, int* pcNamedArgs);

		private unsafe static object CreateCaObject(RuntimeModule module, RuntimeType type, IRuntimeMethodInfo ctor, ref IntPtr blob, IntPtr blobEnd, out int namedArgs)
		{
			byte* ptr = (byte*)(void*)blob;
			byte* pEndBlob = (byte*)(void*)blobEnd;
			System.Runtime.CompilerServices.Unsafe.SkipInit(out int num);
			object result = _CreateCaObject(module, type, ctor, &ptr, pEndBlob, &num);
			blob = (IntPtr)ptr;
			namedArgs = num;
			return result;
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private unsafe static extern void _GetPropertyOrFieldData(RuntimeModule pModule, byte** ppBlobStart, byte* pBlobEnd, out string name, out bool bIsProperty, out RuntimeType type, out object value);

		private unsafe static void GetPropertyOrFieldData(RuntimeModule module, ref IntPtr blobStart, IntPtr blobEnd, out string name, out bool isProperty, out RuntimeType type, out object value)
		{
			byte* ptr = (byte*)(void*)blobStart;
			_GetPropertyOrFieldData(module, &ptr, (byte*)(void*)blobEnd, out name, out isProperty, out type, out value);
			blobStart = (IntPtr)ptr;
		}

		private static object[] CreateAttributeArrayHelper(RuntimeType elementType, int elementCount)
		{
			if (elementCount == 0)
			{
				return elementType.GetEmptyArray();
			}
			return (object[])Array.CreateInstance(elementType, elementCount);
		}
	}
	internal static class PseudoCustomAttribute
	{
		private static readonly HashSet<RuntimeType> s_pca = CreatePseudoCustomAttributeHashSet();

		private static HashSet<RuntimeType> CreatePseudoCustomAttributeHashSet()
		{
			Type[] array = new Type[11]
			{
				typeof(FieldOffsetAttribute),
				typeof(SerializableAttribute),
				typeof(MarshalAsAttribute),
				typeof(ComImportAttribute),
				typeof(NonSerializedAttribute),
				typeof(InAttribute),
				typeof(OutAttribute),
				typeof(OptionalAttribute),
				typeof(DllImportAttribute),
				typeof(PreserveSigAttribute),
				typeof(TypeForwardedToAttribute)
			};
			HashSet<RuntimeType> hashSet = new HashSet<RuntimeType>(array.Length);
			Type[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RuntimeType item = (RuntimeType)array2[i];
				hashSet.Add(item);
			}
			return hashSet;
		}

		internal static void GetCustomAttributes(RuntimeType type, RuntimeType caType, ref RuntimeType.ListBuilder<Attribute> pcas)
		{
			bool flag = caType == typeof(object) || caType == typeof(Attribute);
			if (flag || s_pca.Contains(caType))
			{
				if ((flag || caType == typeof(SerializableAttribute)) && (type.Attributes & TypeAttributes.Serializable) != 0)
				{
					pcas.Add(new SerializableAttribute());
				}
				if ((flag || caType == typeof(ComImportAttribute)) && (type.Attributes & TypeAttributes.Import) != 0)
				{
					pcas.Add(new ComImportAttribute());
				}
			}
		}

		internal static bool IsDefined(RuntimeType type, RuntimeType caType)
		{
			bool flag = caType == typeof(object) || caType == typeof(Attribute);
			if (!flag && !s_pca.Contains(caType))
			{
				return false;
			}
			if ((flag || caType == typeof(SerializableAttribute)) && (type.Attributes & TypeAttributes.Serializable) != 0)
			{
				return true;
			}
			if ((flag || caType == typeof(ComImportAttribute)) && (type.Attributes & TypeAttributes.Import) != 0)
			{
				return true;
			}
			return false;
		}

		internal static void GetCustomAttributes(RuntimeMethodInfo method, RuntimeType caType, ref RuntimeType.ListBuilder<Attribute> pcas)
		{
			bool flag = caType == typeof(object) || caType == typeof(Attribute);
			if (!flag && !s_pca.Contains(caType))
			{
				return;
			}
			if (flag || caType == typeof(DllImportAttribute))
			{
				Attribute dllImportCustomAttribute = GetDllImportCustomAttribute(method);
				if (dllImportCustomAttribute != null)
				{
					pcas.Add(dllImportCustomAttribute);
				}
			}
			if ((flag || caType == typeof(PreserveSigAttribute)) && (method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) != 0)
			{
				pcas.Add(new PreserveSigAttribute());
			}
		}

		internal static bool IsDefined(RuntimeMethodInfo method, RuntimeType caType)
		{
			bool flag = caType == typeof(object) || caType == typeof(Attribute);
			if (!flag && !s_pca.Contains(caType))
			{
				return false;
			}
			if ((flag || caType == typeof(DllImportAttribute)) && (method.Attributes & MethodAttributes.PinvokeImpl) != 0)
			{
				return true;
			}
			if ((flag || caType == typeof(PreserveSigAttribute)) && (method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) != 0)
			{
				return true;
			}
			return false;
		}

		internal static void GetCustomAttributes(RuntimeParameterInfo parameter, RuntimeType caType, ref RuntimeType.ListBuilder<Attribute> pcas)
		{
			bool flag = caType == typeof(object) || caType == typeof(Attribute);
			if (!flag && !s_pca.Contains(caType))
			{
				return;
			}
			if ((flag || caType == typeof(InAttribute)) && parameter.IsIn)
			{
				pcas.Add(new InAttribute());
			}
			if ((flag || caType == typeof(OutAttribute)) && parameter.IsOut)
			{
				pcas.Add(new OutAttribute());
			}
			if ((flag || caType == typeof(OptionalAttribute)) && parameter.IsOptional)
			{
				pcas.Add(new OptionalAttribute());
			}
			if (flag || caType == typeof(MarshalAsAttribute))
			{
				Attribute marshalAsCustomAttribute = GetMarshalAsCustomAttribute(parameter);
				if (marshalAsCustomAttribute != null)
				{
					pcas.Add(marshalAsCustomAttribute);
				}
			}
		}

		internal static bool IsDefined(RuntimeParameterInfo parameter, RuntimeType caType)
		{
			bool flag = caType == typeof(object) || caType == typeof(Attribute);
			if (!flag && !s_pca.Contains(caType))
			{
				return false;
			}
			if ((flag || caType == typeof(InAttribute)) && parameter.IsIn)
			{
				return true;
			}
			if ((flag || caType == typeof(OutAttribute)) && parameter.IsOut)
			{
				return true;
			}
			if ((flag || caType == typeof(OptionalAttribute)) && parameter.IsOptional)
			{
				return true;
			}
			if ((flag || caType == typeof(MarshalAsAttribute)) && GetMarshalAsCustomAttribute(parameter) != null)
			{
				return true;
			}
			return false;
		}

		internal static void GetCustomAttributes(RuntimeFieldInfo field, RuntimeType caType, ref RuntimeType.ListBuilder<Attribute> pcas)
		{
			bool flag = caType == typeof(object) || caType == typeof(Attribute);
			if (!flag && !s_pca.Contains(caType))
			{
				return;
			}
			if (flag || caType == typeof(MarshalAsAttribute))
			{
				Attribute marshalAsCustomAttribute = GetMarshalAsCustomAttribute(field);
				if (marshalAsCustomAttribute != null)
				{
					pcas.Add(marshalAsCustomAttribute);
				}
			}
			if (flag || caType == typeof(FieldOffsetAttribute))
			{
				Attribute marshalAsCustomAttribute = GetFieldOffsetCustomAttribute(field);
				if (marshalAsCustomAttribute != null)
				{
					pcas.Add(marshalAsCustomAttribute);
				}
			}
			if ((flag || caType == typeof(NonSerializedAttribute)) && (field.Attributes & FieldAttributes.NotSerialized) != 0)
			{
				pcas.Add(new NonSerializedAttribute());
			}
		}

		internal static bool IsDefined(RuntimeFieldInfo field, RuntimeType caType)
		{
			bool flag = caType == typeof(object) || caType == typeof(Attribute);
			if (!flag && !s_pca.Contains(caType))
			{
				return false;
			}
			if ((flag || caType == typeof(MarshalAsAttribute)) && GetMarshalAsCustomAttribute(field) != null)
			{
				return true;
			}
			if ((flag || caType == typeof(FieldOffsetAttribute)) && GetFieldOffsetCustomAttribute(field) != null)
			{
				return true;
			}
			if ((flag || caType == typeof(NonSerializedAttribute)) && (field.Attributes & FieldAttributes.NotSerialized) != 0)
			{
				return true;
			}
			return false;
		}

		private static DllImportAttribute GetDllImportCustomAttribute(RuntimeMethodInfo method)
		{
			if ((method.Attributes & MethodAttributes.PinvokeImpl) == 0)
			{
				return null;
			}
			MetadataImport metadataImport = ModuleHandle.GetMetadataImport(method.Module.ModuleHandle.GetRuntimeModule());
			int metadataToken = method.MetadataToken;
			metadataImport.GetPInvokeMap(metadataToken, out var attributes, out var importName, out var importDll);
			CharSet charSet = CharSet.None;
			switch (attributes & PInvokeAttributes.CharSetMask)
			{
			case PInvokeAttributes.CharSetNotSpec:
				charSet = CharSet.None;
				break;
			case PInvokeAttributes.CharSetAnsi:
				charSet = CharSet.Ansi;
				break;
			case PInvokeAttributes.CharSetUnicode:
				charSet = CharSet.Unicode;
				break;
			case PInvokeAttributes.CharSetMask:
				charSet = CharSet.Auto;
				break;
			}
			CallingConvention callingConvention = CallingConvention.Cdecl;
			switch (attributes & PInvokeAttributes.CallConvMask)
			{
			case PInvokeAttributes.CallConvWinapi:
				callingConvention = CallingConvention.Winapi;
				break;
			case PInvokeAttributes.CallConvCdecl:
				callingConvention = CallingConvention.Cdecl;
				break;
			case PInvokeAttributes.CallConvStdcall:
				callingConvention = CallingConvention.StdCall;
				break;
			case PInvokeAttributes.CallConvThiscall:
				callingConvention = CallingConvention.ThisCall;
				break;
			case PInvokeAttributes.CallConvFastcall:
				callingConvention = CallingConvention.FastCall;
				break;
			}
			DllImportAttribute dllImportAttribute = new DllImportAttribute(importDll);
			dllImportAttribute.EntryPoint = importName;
			dllImportAttribute.CharSet = charSet;
			dllImportAttribute.SetLastError = (attributes & PInvokeAttributes.SupportsLastError) != 0;
			dllImportAttribute.ExactSpelling = (attributes & PInvokeAttributes.NoMangle) != 0;
			dllImportAttribute.PreserveSig = (method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) != 0;
			dllImportAttribute.CallingConvention = callingConvention;
			dllImportAttribute.BestFitMapping = (attributes & PInvokeAttributes.BestFitMask) == PInvokeAttributes.BestFitEnabled;
			dllImportAttribute.ThrowOnUnmappableChar = (attributes & PInvokeAttributes.ThrowOnUnmappableCharMask) == PInvokeAttributes.ThrowOnUnmappableCharEnabled;
			return dllImportAttribute;
		}

		private static MarshalAsAttribute GetMarshalAsCustomAttribute(RuntimeParameterInfo parameter)
		{
			return GetMarshalAsCustomAttribute(parameter.MetadataToken, parameter.GetRuntimeModule());
		}

		private static MarshalAsAttribute GetMarshalAsCustomAttribute(RuntimeFieldInfo field)
		{
			return GetMarshalAsCustomAttribute(field.MetadataToken, field.GetRuntimeModule());
		}

		private static MarshalAsAttribute GetMarshalAsCustomAttribute(int token, RuntimeModule scope)
		{
			ConstArray fieldMarshal = ModuleHandle.GetMetadataImport(scope).GetFieldMarshal(token);
			if (fieldMarshal.Length == 0)
			{
				return null;
			}
			MetadataImport.GetMarshalAs(fieldMarshal, out var unmanagedType, out var safeArraySubType, out var safeArrayUserDefinedSubType, out var arraySubType, out var sizeParamIndex, out var sizeConst, out var marshalType, out var marshalCookie, out var iidParamIndex);
			RuntimeType safeArrayUserDefinedSubType2 = (string.IsNullOrEmpty(safeArrayUserDefinedSubType) ? null : RuntimeTypeHandle.GetTypeByNameUsingCARules(safeArrayUserDefinedSubType, scope));
			RuntimeType marshalTypeRef = null;
			try
			{
				marshalTypeRef = ((marshalType == null) ? null : RuntimeTypeHandle.GetTypeByNameUsingCARules(marshalType, scope));
			}
			catch (TypeLoadException)
			{
			}
			MarshalAsAttribute marshalAsAttribute = new MarshalAsAttribute(unmanagedType);
			marshalAsAttribute.SafeArraySubType = safeArraySubType;
			marshalAsAttribute.SafeArrayUserDefinedSubType = safeArrayUserDefinedSubType2;
			marshalAsAttribute.IidParameterIndex = iidParamIndex;
			marshalAsAttribute.ArraySubType = arraySubType;
			marshalAsAttribute.SizeParamIndex = (short)sizeParamIndex;
			marshalAsAttribute.SizeConst = sizeConst;
			marshalAsAttribute.MarshalType = marshalType;
			marshalAsAttribute.MarshalTypeRef = marshalTypeRef;
			marshalAsAttribute.MarshalCookie = marshalCookie;
			return marshalAsAttribute;
		}

		private static FieldOffsetAttribute GetFieldOffsetCustomAttribute(RuntimeFieldInfo field)
		{
			if ((object)field.DeclaringType != null && field.GetRuntimeModule().MetadataImport.GetFieldOffset(field.DeclaringType.MetadataToken, field.MetadataToken, out var offset))
			{
				return new FieldOffsetAttribute(offset);
			}
			return null;
		}

		internal static StructLayoutAttribute GetStructLayoutCustomAttribute(RuntimeType type)
		{
			if (type.IsInterface || type.HasElementType || type.IsGenericParameter)
			{
				return null;
			}
			LayoutKind layoutKind = LayoutKind.Auto;
			switch (type.Attributes & TypeAttributes.LayoutMask)
			{
			case TypeAttributes.ExplicitLayout:
				layoutKind = LayoutKind.Explicit;
				break;
			case TypeAttributes.NotPublic:
				layoutKind = LayoutKind.Auto;
				break;
			case TypeAttributes.SequentialLayout:
				layoutKind = LayoutKind.Sequential;
				break;
			}
			CharSet charSet = CharSet.None;
			switch (type.Attributes & TypeAttributes.StringFormatMask)
			{
			case TypeAttributes.NotPublic:
				charSet = CharSet.Ansi;
				break;
			case TypeAttributes.AutoClass:
				charSet = CharSet.Auto;
				break;
			case TypeAttributes.UnicodeClass:
				charSet = CharSet.Unicode;
				break;
			}
			type.GetRuntimeModule().MetadataImport.GetClassLayout(type.MetadataToken, out var packSize, out var classSize);
			if (packSize == 0)
			{
				packSize = 8;
			}
			StructLayoutAttribute structLayoutAttribute = new StructLayoutAttribute(layoutKind);
			structLayoutAttribute.Pack = packSize;
			structLayoutAttribute.Size = classSize;
			structLayoutAttribute.CharSet = charSet;
			return structLayoutAttribute;
		}
	}
	internal sealed class RuntimeEventInfo : EventInfo
	{
		private int m_token;

		private EventAttributes m_flags;

		private string m_name;

		private unsafe void* m_utf8name;

		private RuntimeType.RuntimeTypeCache m_reflectedTypeCache;

		private RuntimeMethodInfo m_addMethod;

		private RuntimeMethodInfo m_removeMethod;

		private RuntimeMethodInfo m_raiseMethod;

		private MethodInfo[] m_otherMethod;

		private RuntimeType m_declaringType;

		private BindingFlags m_bindingFlags;

		internal BindingFlags BindingFlags => m_bindingFlags;

		public override MemberTypes MemberType => MemberTypes.Event;

		public unsafe override string Name => m_name ?? (m_name = new MdUtf8String(m_utf8name).ToString());

		public override Type DeclaringType => m_declaringType;

		public override Type ReflectedType => ReflectedTypeInternal;

		private RuntimeType ReflectedTypeInternal => m_reflectedTypeCache.GetRuntimeType();

		public override int MetadataToken => m_token;

		public override Module Module => GetRuntimeModule();

		public override EventAttributes Attributes => m_flags;

		internal unsafe RuntimeEventInfo(int tkEvent, RuntimeType declaredType, RuntimeType.RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
		{
			MetadataImport metadataImport = declaredType.GetRuntimeModule().MetadataImport;
			m_token = tkEvent;
			m_reflectedTypeCache = reflectedTypeCache;
			m_declaringType = declaredType;
			RuntimeType runtimeType = reflectedTypeCache.GetRuntimeType();
			metadataImport.GetEventProps(tkEvent, out m_utf8name, out m_flags);
			Associates.AssignAssociates(metadataImport, tkEvent, declaredType, runtimeType, out m_addMethod, out m_removeMethod, out m_raiseMethod, out var _, out var _, out m_otherMethod, out isPrivate, out m_bindingFlags);
		}

		internal override bool CacheEquals(object o)
		{
			if (o is RuntimeEventInfo runtimeEventInfo && runtimeEventInfo.m_token == m_token)
			{
				return RuntimeTypeHandle.GetModule(m_declaringType).Equals(RuntimeTypeHandle.GetModule(runtimeEventInfo.m_declaringType));
			}
			return false;
		}

		public override string ToString()
		{
			if (m_addMethod == null || m_addMethod.GetParametersNoCopy().Length == 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NoPublicAddMethod);
			}
			return m_addMethod.GetParametersNoCopy()[0].ParameterType.FormatTypeName() + " " + Name;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}

		public sealed override bool HasSameMetadataDefinitionAs(MemberInfo other)
		{
			return HasSameMetadataDefinitionAsCore<RuntimeEventInfo>(other);
		}

		internal RuntimeModule GetRuntimeModule()
		{
			return m_declaringType.GetRuntimeModule();
		}

		public override MethodInfo[] GetOtherMethods(bool nonPublic)
		{
			List<MethodInfo> list = new List<MethodInfo>();
			if (m_otherMethod == null)
			{
				return Array.Empty<MethodInfo>();
			}
			for (int i = 0; i < m_otherMethod.Length; i++)
			{
				if (Associates.IncludeAccessor(m_otherMethod[i], nonPublic))
				{
					list.Add(m_otherMethod[i]);
				}
			}
			return list.ToArray();
		}

		public override MethodInfo GetAddMethod(bool nonPublic)
		{
			if (!Associates.IncludeAccessor(m_addMethod, nonPublic))
			{
				return null;
			}
			return m_addMethod;
		}

		public override MethodInfo GetRemoveMethod(bool nonPublic)
		{
			if (!Associates.IncludeAccessor(m_removeMethod, nonPublic))
			{
				return null;
			}
			return m_removeMethod;
		}

		public override MethodInfo GetRaiseMethod(bool nonPublic)
		{
			if (!Associates.IncludeAccessor(m_raiseMethod, nonPublic))
			{
				return null;
			}
			return m_raiseMethod;
		}
	}
	internal sealed class RuntimeExceptionHandlingClause : ExceptionHandlingClause
	{
		private RuntimeMethodBody _methodBody;

		private ExceptionHandlingClauseOptions _flags;

		private int _tryOffset;

		private int _tryLength;

		private int _handlerOffset;

		private int _handlerLength;

		private int _catchMetadataToken;

		private int _filterOffset;

		public override ExceptionHandlingClauseOptions Flags => _flags;

		public override int TryOffset => _tryOffset;

		public override int TryLength => _tryLength;

		public override int HandlerOffset => _handlerOffset;

		public override int HandlerLength => _handlerLength;

		public override int FilterOffset
		{
			get
			{
				if (_flags != ExceptionHandlingClauseOptions.Filter)
				{
					throw new InvalidOperationException(SR.Arg_EHClauseNotFilter);
				}
				return _filterOffset;
			}
		}

		public override Type CatchType
		{
			[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Module.ResolveType is marked as RequiresUnreferencedCode because it relies on tokenswhich are not guaranteed to be stable across trimming. So if somebody hardcodes a token it could break.The usage here is not like that as all these tokens come from existing metadata loaded from some ILand so trimming has no effect (the tokens are read AFTER trimming occured).")]
			get
			{
				if (_flags != 0)
				{
					throw new InvalidOperationException(SR.Arg_EHClauseNotClause);
				}
				Type result = null;
				if (!MetadataToken.IsNullToken(_catchMetadataToken))
				{
					Type declaringType = _methodBody._methodBase.DeclaringType;
					Module module = ((declaringType == null) ? _methodBody._methodBase.Module : declaringType.Module);
					result = module.ResolveType(_catchMetadataToken, declaringType?.GetGenericArguments(), (_methodBody._methodBase is MethodInfo) ? _methodBody._methodBase.GetGenericArguments() : null);
				}
				return result;
			}
		}

		private RuntimeExceptionHandlingClause()
		{
		}

		public override string ToString()
		{
			if (Flags == ExceptionHandlingClauseOptions.Clause)
			{
				return string.Format(CultureInfo.CurrentUICulture, "Flags={0}, TryOffset={1}, TryLength={2}, HandlerOffset={3}, HandlerLength={4}, CatchType={5}", Flags, TryOffset, TryLength, HandlerOffset, HandlerLength, CatchType);
			}
			if (Flags == ExceptionHandlingClauseOptions.Filter)
			{
				return string.Format(CultureInfo.CurrentUICulture, "Flags={0}, TryOffset={1}, TryLength={2}, HandlerOffset={3}, HandlerLength={4}, FilterOffset={5}", Flags, TryOffset, TryLength, HandlerOffset, HandlerLength, FilterOffset);
			}
			return string.Format(CultureInfo.CurrentUICulture, "Flags={0}, TryOffset={1}, TryLength={2}, HandlerOffset={3}, HandlerLength={4}", Flags, TryOffset, TryLength, HandlerOffset, HandlerLength);
		}
	}
	internal abstract class RuntimeFieldInfo : FieldInfo
	{
		private BindingFlags m_bindingFlags;

		protected RuntimeType.RuntimeTypeCache m_reflectedTypeCache;

		protected RuntimeType m_declaringType;

		internal BindingFlags BindingFlags => m_bindingFlags;

		private RuntimeType ReflectedTypeInternal => m_reflectedTypeCache.GetRuntimeType();

		public override MemberTypes MemberType => MemberTypes.Field;

		public override Type ReflectedType
		{
			get
			{
				if (!m_reflectedTypeCache.IsGlobal)
				{
					return ReflectedTypeInternal;
				}
				return null;
			}
		}

		public override Type DeclaringType
		{
			get
			{
				if (!m_reflectedTypeCache.IsGlobal)
				{
					return m_declaringType;
				}
				return null;
			}
		}

		public override Module Module => GetRuntimeModule();

		public override bool IsCollectible => m_declaringType.IsCollectible;

		protected RuntimeFieldInfo(RuntimeType.RuntimeTypeCache reflectedTypeCache, RuntimeType declaringType, BindingFlags bindingFlags)
		{
			m_bindingFlags = bindingFlags;
			m_declaringType = declaringType;
			m_reflectedTypeCache = reflectedTypeCache;
		}

		internal RuntimeType GetDeclaringTypeInternal()
		{
			return m_declaringType;
		}

		internal RuntimeType GetRuntimeType()
		{
			return m_declaringType;
		}

		internal abstract RuntimeModule GetRuntimeModule();

		public sealed override bool HasSameMetadataDefinitionAs(MemberInfo other)
		{
			return HasSameMetadataDefinitionAsCore<RuntimeFieldInfo>(other);
		}

		public override string ToString()
		{
			return FieldType.FormatTypeName() + " " + Name;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}
	}
	internal sealed class RuntimeLocalVariableInfo : LocalVariableInfo
	{
		private RuntimeType _type;

		private int _localIndex;

		private bool _isPinned;

		public override Type LocalType => _type;

		public override int LocalIndex => _localIndex;

		public override bool IsPinned => _isPinned;

		private RuntimeLocalVariableInfo()
		{
		}
	}
	internal sealed class RuntimeMethodBody : MethodBody
	{
		private byte[] _IL;

		private ExceptionHandlingClause[] _exceptionHandlingClauses;

		private LocalVariableInfo[] _localVariables;

		internal MethodBase _methodBase;

		private int _localSignatureMetadataToken;

		private int _maxStackSize;

		private bool _initLocals;

		public override int LocalSignatureMetadataToken => _localSignatureMetadataToken;

		public override IList<LocalVariableInfo> LocalVariables => Array.AsReadOnly(_localVariables);

		public override int MaxStackSize => _maxStackSize;

		public override bool InitLocals => _initLocals;

		public override IList<ExceptionHandlingClause> ExceptionHandlingClauses => Array.AsReadOnly(_exceptionHandlingClauses);

		private RuntimeMethodBody()
		{
			_IL = null;
			_exceptionHandlingClauses = null;
			_localVariables = null;
			_methodBase = null;
		}

		public override byte[] GetILAsByteArray()
		{
			return _IL;
		}
	}
	internal sealed class RuntimeMethodInfo : MethodInfo, IRuntimeMethodInfo
	{
		private IntPtr m_handle;

		private RuntimeType.RuntimeTypeCache m_reflectedTypeCache;

		private string m_name;

		private string m_toString;

		private ParameterInfo[] m_parameters;

		private ParameterInfo m_returnParameter;

		private BindingFlags m_bindingFlags;

		private MethodAttributes m_methodAttributes;

		private Signature m_signature;

		private RuntimeType m_declaringType;

		private object m_keepalive;

		private INVOCATION_FLAGS m_invocationFlags;

		internal INVOCATION_FLAGS InvocationFlags
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				INVOCATION_FLAGS iNVOCATION_FLAGS = m_invocationFlags;
				if ((iNVOCATION_FLAGS & INVOCATION_FLAGS.INVOCATION_FLAGS_INITIALIZED) == 0)
				{
					iNVOCATION_FLAGS = LazyCreateInvocationFlags();
				}
				return iNVOCATION_FLAGS;
				[MethodImpl(MethodImplOptions.NoInlining)]
				INVOCATION_FLAGS LazyCreateInvocationFlags()
				{
					INVOCATION_FLAGS iNVOCATION_FLAGS2 = INVOCATION_FLAGS.INVOCATION_FLAGS_UNKNOWN;
					Type declaringType = DeclaringType;
					if (ContainsGenericParameters || IsDisallowedByRefType(ReturnType) || (declaringType != null && declaringType.ContainsGenericParameters) || (CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
					{
						iNVOCATION_FLAGS2 = INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE;
					}
					else if ((declaringType != null && declaringType.IsByRefLike) || ReturnType.IsByRefLike)
					{
						iNVOCATION_FLAGS2 |= INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS;
					}
					return m_invocationFlags = iNVOCATION_FLAGS2 | INVOCATION_FLAGS.INVOCATION_FLAGS_INITIALIZED;
				}
			}
		}

		RuntimeMethodHandleInternal IRuntimeMethodInfo.Value => new RuntimeMethodHandleInternal(m_handle);

		private RuntimeType ReflectedTypeInternal => m_reflectedTypeCache.GetRuntimeType();

		internal Signature Signature
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return m_signature ?? LazyCreateSignature();
				[MethodImpl(MethodImplOptions.NoInlining)]
				Signature LazyCreateSignature()
				{
					Signature signature = new Signature(this, m_declaringType);
					Volatile.Write(ref m_signature, signature);
					return signature;
				}
			}
		}

		internal BindingFlags BindingFlags => m_bindingFlags;

		internal sealed override int GenericParameterCount => RuntimeMethodHandle.GetGenericParameterCount(this);

		public override string Name => m_name ?? (m_name = RuntimeMethodHandle.GetName(this));

		public override Type DeclaringType
		{
			get
			{
				if (m_reflectedTypeCache.IsGlobal)
				{
					return null;
				}
				return m_declaringType;
			}
		}

		public override Type ReflectedType
		{
			get
			{
				if (m_reflectedTypeCache.IsGlobal)
				{
					return null;
				}
				return m_reflectedTypeCache.GetRuntimeType();
			}
		}

		public override MemberTypes MemberType => MemberTypes.Method;

		public override int MetadataToken => RuntimeMethodHandle.GetMethodDef(this);

		public override Module Module => GetRuntimeModule();

		public override bool IsSecurityCritical => true;

		public override bool IsSecuritySafeCritical => false;

		public override bool IsSecurityTransparent => false;

		public override RuntimeMethodHandle MethodHandle => new RuntimeMethodHandle(this);

		public override MethodAttributes Attributes => m_methodAttributes;

		public override CallingConventions CallingConvention => Signature.CallingConvention;

		public override Type ReturnType => Signature.ReturnType;

		public override ICustomAttributeProvider ReturnTypeCustomAttributes => ReturnParameter;

		public override ParameterInfo ReturnParameter => FetchReturnParameter();

		public override bool IsCollectible => RuntimeMethodHandle.GetIsCollectible(new RuntimeMethodHandleInternal(m_handle)) != Interop.BOOL.FALSE;

		public override bool IsGenericMethod => RuntimeMethodHandle.HasMethodInstantiation(this);

		public override bool IsGenericMethodDefinition => RuntimeMethodHandle.IsGenericMethodDefinition(this);

		public override bool ContainsGenericParameters
		{
			get
			{
				if (DeclaringType != null && DeclaringType.ContainsGenericParameters)
				{
					return true;
				}
				if (!IsGenericMethod)
				{
					return false;
				}
				Type[] genericArguments = GetGenericArguments();
				for (int i = 0; i < genericArguments.Length; i++)
				{
					if (genericArguments[i].ContainsGenericParameters)
					{
						return true;
					}
				}
				return false;
			}
		}

		private static bool IsDisallowedByRefType(Type type)
		{
			if (!type.IsByRef)
			{
				return false;
			}
			Type elementType = type.GetElementType();
			if (!elementType.IsByRefLike)
			{
				return elementType == typeof(void);
			}
			return true;
		}

		internal RuntimeMethodInfo(RuntimeMethodHandleInternal handle, RuntimeType declaringType, RuntimeType.RuntimeTypeCache reflectedTypeCache, MethodAttributes methodAttributes, BindingFlags bindingFlags, object keepalive)
		{
			m_bindingFlags = bindingFlags;
			m_declaringType = declaringType;
			m_keepalive = keepalive;
			m_handle = handle.Value;
			m_reflectedTypeCache = reflectedTypeCache;
			m_methodAttributes = methodAttributes;
		}

		private ParameterInfo[] FetchNonReturnParameters()
		{
			return m_parameters ?? (m_parameters = RuntimeParameterInfo.GetParameters(this, this, Signature));
		}

		private ParameterInfo FetchReturnParameter()
		{
			return m_returnParameter ?? (m_returnParameter = RuntimeParameterInfo.GetReturnParameter(this, this, Signature));
		}

		internal override bool CacheEquals(object o)
		{
			if (o is RuntimeMethodInfo runtimeMethodInfo)
			{
				return runtimeMethodInfo.m_handle == m_handle;
			}
			return false;
		}

		internal RuntimeMethodInfo GetParentDefinition()
		{
			if (!base.IsVirtual || m_declaringType.IsInterface)
			{
				return null;
			}
			RuntimeType runtimeType = (RuntimeType)m_declaringType.BaseType;
			if (runtimeType == null)
			{
				return null;
			}
			int slot = RuntimeMethodHandle.GetSlot(this);
			if (RuntimeTypeHandle.GetNumVirtuals(runtimeType) <= slot)
			{
				return null;
			}
			return (RuntimeMethodInfo)RuntimeType.GetMethodBase(runtimeType, RuntimeTypeHandle.GetMethodAt(runtimeType, slot));
		}

		internal RuntimeType GetDeclaringTypeInternal()
		{
			return m_declaringType;
		}

		public override string ToString()
		{
			if (m_toString == null)
			{
				ValueStringBuilder sbParamList = new ValueStringBuilder(100);
				sbParamList.Append(ReturnType.FormatTypeName());
				sbParamList.Append(' ');
				sbParamList.Append(Name);
				if (IsGenericMethod)
				{
					sbParamList.Append(RuntimeMethodHandle.ConstructInstantiation(this, TypeNameFormatFlags.FormatBasic));
				}
				sbParamList.Append('(');
				MethodBase.AppendParameters(ref sbParamList, GetParameterTypes(), CallingConvention);
				sbParamList.Append(')');
				m_toString = sbParamList.ToString();
			}
			return m_toString;
		}

		public override int GetHashCode()
		{
			if (IsGenericMethod)
			{
				return ValueType.GetHashCodeOfPtr(m_handle);
			}
			return base.GetHashCode();
		}

		public override bool Equals(object obj)
		{
			if (!IsGenericMethod)
			{
				return obj == this;
			}
			RuntimeMethodInfo runtimeMethodInfo = obj as RuntimeMethodInfo;
			if (runtimeMethodInfo == null || !runtimeMethodInfo.IsGenericMethod)
			{
				return false;
			}
			IRuntimeMethodInfo runtimeMethodInfo2 = RuntimeMethodHandle.StripMethodInstantiation(this);
			IRuntimeMethodInfo runtimeMethodInfo3 = RuntimeMethodHandle.StripMethodInstantiation(runtimeMethodInfo);
			if (runtimeMethodInfo2.Value.Value != runtimeMethodInfo3.Value.Value)
			{
				return false;
			}
			Type[] genericArguments = GetGenericArguments();
			Type[] genericArguments2 = runtimeMethodInfo.GetGenericArguments();
			if (genericArguments.Length != genericArguments2.Length)
			{
				return false;
			}
			for (int i = 0; i < genericArguments.Length; i++)
			{
				if (genericArguments[i] != genericArguments2[i])
				{
					return false;
				}
			}
			if (DeclaringType != runtimeMethodInfo.DeclaringType)
			{
				return false;
			}
			if (ReflectedType != runtimeMethodInfo.ReflectedType)
			{
				return false;
			}
			return true;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType, inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType, inherit);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}

		public sealed override bool HasSameMetadataDefinitionAs(MemberInfo other)
		{
			return HasSameMetadataDefinitionAsCore<RuntimeMethodInfo>(other);
		}

		internal RuntimeType GetRuntimeType()
		{
			return m_declaringType;
		}

		internal RuntimeModule GetRuntimeModule()
		{
			return m_declaringType.GetRuntimeModule();
		}

		internal override ParameterInfo[] GetParametersNoCopy()
		{
			return FetchNonReturnParameters();
		}

		public override ParameterInfo[] GetParameters()
		{
			ParameterInfo[] array = FetchNonReturnParameters();
			if (array.Length == 0)
			{
				return array;
			}
			ParameterInfo[] array2 = new ParameterInfo[array.Length];
			Array.Copy(array, array2, array.Length);
			return array2;
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			return RuntimeMethodHandle.GetImplAttributes(this);
		}

		[RequiresUnreferencedCode("Trimming may change method bodies. For example it can change some instructions, remove branches or local variables.")]
		public override MethodBody GetMethodBody()
		{
			RuntimeMethodBody methodBody = RuntimeMethodHandle.GetMethodBody(this, ReflectedTypeInternal);
			if (methodBody != null)
			{
				methodBody._methodBase = this;
			}
			return methodBody;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void CheckConsistency(object target)
		{
			if ((m_methodAttributes & MethodAttributes.Static) == 0 && !m_declaringType.IsInstanceOfType(target))
			{
				if (target == null)
				{
					throw new TargetException(SR.RFLCT_Targ_StatMethReqTarg);
				}
				throw new TargetException(SR.RFLCT_Targ_ITargMismatch);
			}
		}

		[DoesNotReturn]
		private void ThrowNoInvokeException()
		{
			if ((InvocationFlags & INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS) != 0)
			{
				throw new NotSupportedException();
			}
			if ((CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
			{
				throw new NotSupportedException();
			}
			if (DeclaringType.ContainsGenericParameters || ContainsGenericParameters)
			{
				throw new InvalidOperationException(SR.Arg_UnboundGenParam);
			}
			if (base.IsAbstract)
			{
				throw new MemberAccessException();
			}
			if (ReturnType.IsByRef)
			{
				Type elementType = ReturnType.GetElementType();
				if (elementType.IsByRefLike)
				{
					throw new NotSupportedException(SR.NotSupported_ByRefToByRefLikeReturn);
				}
				if (elementType == typeof(void))
				{
					throw new NotSupportedException(SR.NotSupported_ByRefToVoidReturn);
				}
			}
			throw new TargetException();
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			if ((InvocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE | INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS)) != 0)
			{
				ThrowNoInvokeException();
			}
			CheckConsistency(obj);
			Signature signature = Signature;
			int num = ((parameters != null) ? parameters.Length : 0);
			if (signature.Arguments.Length != num)
			{
				throw new TargetParameterCountException(SR.Arg_ParmCnt);
			}
			StackAllocedArguments stackArgs = default(StackAllocedArguments);
			Span<object> arguments = default(Span<object>);
			if (num != 0)
			{
				arguments = CheckArguments(ref stackArgs, parameters, binder, invokeAttr, culture, signature);
			}
			bool wrapExceptions = (invokeAttr & BindingFlags.DoNotWrapExceptions) == 0;
			object result = RuntimeMethodHandle.InvokeMethod(obj, in arguments, Signature, constructor: false, wrapExceptions);
			for (int i = 0; i < arguments.Length; i++)
			{
				parameters[i] = arguments[i];
			}
			return result;
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		internal object InvokeOneParameter(object obj, BindingFlags invokeAttr, Binder binder, object parameter, CultureInfo culture)
		{
			if ((InvocationFlags & (INVOCATION_FLAGS.INVOCATION_FLAGS_NO_INVOKE | INVOCATION_FLAGS.INVOCATION_FLAGS_CONTAINS_STACK_POINTERS)) != 0)
			{
				ThrowNoInvokeException();
			}
			CheckConsistency(obj);
			Signature signature = Signature;
			if (signature.Arguments.Length != 1)
			{
				throw new TargetParameterCountException(SR.Arg_ParmCnt);
			}
			StackAllocedArguments stackArgs = default(StackAllocedArguments);
			Span<object> arguments = CheckArguments(ref stackArgs, new ReadOnlySpan<object>(ref parameter, 1), binder, invokeAttr, culture, signature);
			bool wrapExceptions = (invokeAttr & BindingFlags.DoNotWrapExceptions) == 0;
			return RuntimeMethodHandle.InvokeMethod(obj, in arguments, Signature, constructor: false, wrapExceptions);
		}

		public override MethodInfo GetBaseDefinition()
		{
			if (!base.IsVirtual || base.IsStatic || m_declaringType == null || m_declaringType.IsInterface)
			{
				return this;
			}
			int slot = RuntimeMethodHandle.GetSlot(this);
			RuntimeType runtimeType = (RuntimeType)DeclaringType;
			RuntimeType reflectedType = runtimeType;
			RuntimeMethodHandleInternal methodHandle = default(RuntimeMethodHandleInternal);
			do
			{
				int numVirtuals = RuntimeTypeHandle.GetNumVirtuals(runtimeType);
				if (numVirtuals <= slot)
				{
					break;
				}
				methodHandle = RuntimeTypeHandle.GetMethodAt(runtimeType, slot);
				reflectedType = runtimeType;
				runtimeType = (RuntimeType)runtimeType.BaseType;
			}
			while (runtimeType != null);
			return (MethodInfo)RuntimeType.GetMethodBase(reflectedType, methodHandle);
		}

		public override Delegate CreateDelegate(Type delegateType)
		{
			return CreateDelegateInternal(delegateType, null, (DelegateBindingFlags)68);
		}

		public override Delegate CreateDelegate(Type delegateType, object target)
		{
			return CreateDelegateInternal(delegateType, target, DelegateBindingFlags.RelaxedSignature);
		}

		private Delegate CreateDelegateInternal(Type delegateType, object firstArgument, DelegateBindingFlags bindingFlags)
		{
			if (delegateType == null)
			{
				throw new ArgumentNullException("delegateType");
			}
			RuntimeType runtimeType = delegateType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType, "delegateType");
			}
			if (!runtimeType.IsDelegate())
			{
				throw new ArgumentException(SR.Arg_MustBeDelegate, "delegateType");
			}
			Delegate @delegate = Delegate.CreateDelegateInternal(runtimeType, this, firstArgument, bindingFlags);
			if ((object)@delegate == null)
			{
				throw new ArgumentException(SR.Arg_DlgtTargMeth);
			}
			return @delegate;
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public override MethodInfo MakeGenericMethod(params Type[] methodInstantiation)
		{
			if (methodInstantiation == null)
			{
				throw new ArgumentNullException("methodInstantiation");
			}
			RuntimeType[] array = new RuntimeType[methodInstantiation.Length];
			if (!IsGenericMethodDefinition)
			{
				throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericMethodDefinition, this));
			}
			for (int i = 0; i < methodInstantiation.Length; i++)
			{
				Type type = methodInstantiation[i];
				if (type == null)
				{
					throw new ArgumentNullException();
				}
				RuntimeType runtimeType = type as RuntimeType;
				if (runtimeType == null)
				{
					Type[] array2 = new Type[methodInstantiation.Length];
					for (int j = 0; j < methodInstantiation.Length; j++)
					{
						array2[j] = methodInstantiation[j];
					}
					methodInstantiation = array2;
					return MethodBuilderInstantiation.MakeGenericMethod(this, methodInstantiation);
				}
				array[i] = runtimeType;
			}
			RuntimeType[] genericArgumentsInternal = GetGenericArgumentsInternal();
			RuntimeType.SanityCheckGenericArguments(array, genericArgumentsInternal);
			MethodInfo methodInfo = null;
			try
			{
				return RuntimeType.GetMethodBase(ReflectedTypeInternal, RuntimeMethodHandle.GetStubIfNeeded(new RuntimeMethodHandleInternal(m_handle), m_declaringType, array)) as MethodInfo;
			}
			catch (VerificationException e)
			{
				RuntimeType.ValidateGenericArguments(this, array, e);
				throw;
			}
		}

		internal RuntimeType[] GetGenericArgumentsInternal()
		{
			return RuntimeMethodHandle.GetMethodInstantiationInternal(this);
		}

		public override Type[] GetGenericArguments()
		{
			return RuntimeMethodHandle.GetMethodInstantiationPublic(this) ?? Type.EmptyTypes;
		}

		public override MethodInfo GetGenericMethodDefinition()
		{
			if (!IsGenericMethod)
			{
				throw new InvalidOperationException();
			}
			return RuntimeType.GetMethodBase(m_declaringType, RuntimeMethodHandle.StripMethodInstantiation(this)) as MethodInfo;
		}

		internal static MethodBase InternalGetCurrentMethod(ref StackCrawlMark stackMark)
		{
			IRuntimeMethodInfo currentMethod = RuntimeMethodHandle.GetCurrentMethod(ref stackMark);
			if (currentMethod == null)
			{
				return null;
			}
			return RuntimeType.GetMethodBase(currentMethod);
		}
	}
	internal class RuntimeModule : Module
	{
		private RuntimeType m_runtimeType;

		private RuntimeAssembly m_runtimeAssembly;

		private IntPtr m_pRefClass;

		private IntPtr m_pData;

		private IntPtr m_pGlobals;

		private IntPtr m_pFields;

		public override int MDStreamVersion => ModuleHandle.GetMDStreamVersion(this);

		internal RuntimeType RuntimeType => m_runtimeType ?? (m_runtimeType = ModuleHandle.GetModuleType(this));

		internal MetadataImport MetadataImport => ModuleHandle.GetMetadataImport(this);

		[RequiresAssemblyFiles("Returns <Unknown> for modules with no file path")]
		public override string FullyQualifiedName => GetFullyQualifiedName();

		public override Guid ModuleVersionId
		{
			get
			{
				MetadataImport.GetScopeProps(out var mvid);
				return mvid;
			}
		}

		public override int MetadataToken => ModuleHandle.GetToken(this);

		public override string ScopeName
		{
			get
			{
				string s = null;
				RuntimeModule module = this;
				GetScopeName(new QCallModule(ref module), new StringHandleOnStack(ref s));
				return s;
			}
		}

		[RequiresAssemblyFiles("Returns <Unknown> for modules with no file path")]
		public override string Name
		{
			get
			{
				string fullyQualifiedName = GetFullyQualifiedName();
				int num = fullyQualifiedName.LastIndexOf(Path.DirectorySeparatorChar);
				if (num == -1)
				{
					return fullyQualifiedName;
				}
				return fullyQualifiedName.Substring(num + 1);
			}
		}

		public override Assembly Assembly => GetRuntimeAssembly();

		internal RuntimeModule()
		{
			throw new NotSupportedException();
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetType(QCallModule module, string className, bool throwOnError, bool ignoreCase, ObjectHandleOnStack type, ObjectHandleOnStack keepAlive);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetScopeName(QCallModule module, StringHandleOnStack retString);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetFullyQualifiedName(QCallModule module, StringHandleOnStack retString);

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern RuntimeType[] GetTypes(RuntimeModule module);

		internal RuntimeType[] GetDefinedTypes()
		{
			return GetTypes(this);
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool IsResource(RuntimeModule module);

		private static RuntimeTypeHandle[] ConvertToTypeHandleArray(Type[] genericArguments)
		{
			if (genericArguments == null)
			{
				return null;
			}
			int num = genericArguments.Length;
			RuntimeTypeHandle[] array = new RuntimeTypeHandle[num];
			for (int i = 0; i < num; i++)
			{
				Type type = genericArguments[i];
				if (type == null)
				{
					throw new ArgumentException(SR.Argument_InvalidGenericInstArray);
				}
				type = type.UnderlyingSystemType;
				if (type == null)
				{
					throw new ArgumentException(SR.Argument_InvalidGenericInstArray);
				}
				if (!(type is RuntimeType))
				{
					throw new ArgumentException(SR.Argument_InvalidGenericInstArray);
				}
				array[i] = type.GetTypeHandleInternal();
			}
			return array;
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override byte[] ResolveSignature(int metadataToken)
		{
			MetadataToken metadataToken2 = new MetadataToken(metadataToken);
			if (!MetadataImport.IsValidToken(metadataToken2))
			{
				throw new ArgumentOutOfRangeException("metadataToken", SR.Format(SR.Argument_InvalidToken, metadataToken2, this));
			}
			if (!metadataToken2.IsMemberRef && !metadataToken2.IsMethodDef && !metadataToken2.IsTypeSpec && !metadataToken2.IsSignature && !metadataToken2.IsFieldDef)
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidToken, metadataToken2, this), "metadataToken");
			}
			ConstArray constArray = ((!metadataToken2.IsMemberRef) ? MetadataImport.GetSignatureFromToken(metadataToken) : MetadataImport.GetMemberRefProps(metadataToken));
			byte[] array = new byte[constArray.Length];
			for (int i = 0; i < constArray.Length; i++)
			{
				array[i] = constArray[i];
			}
			return array;
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public unsafe override MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
		{
			try
			{
				MetadataToken metadataToken2 = new MetadataToken(metadataToken);
				if (!metadataToken2.IsMethodDef && !metadataToken2.IsMethodSpec)
				{
					if (!metadataToken2.IsMemberRef)
					{
						throw new ArgumentException(SR.Format(SR.Argument_ResolveMethod, metadataToken2, this), "metadataToken");
					}
					if (*(byte*)(void*)MetadataImport.GetMemberRefProps(metadataToken2).Signature == 6)
					{
						throw new ArgumentException(SR.Format(SR.Argument_ResolveMethod, metadataToken2, this), "metadataToken");
					}
				}
				RuntimeTypeHandle[] typeInstantiationContext = null;
				RuntimeTypeHandle[] methodInstantiationContext = null;
				if (genericTypeArguments != null && genericTypeArguments.Length != 0)
				{
					typeInstantiationContext = ConvertToTypeHandleArray(genericTypeArguments);
				}
				if (genericMethodArguments != null && genericMethodArguments.Length != 0)
				{
					methodInstantiationContext = ConvertToTypeHandleArray(genericMethodArguments);
				}
				IRuntimeMethodInfo methodInfo = new ModuleHandle(this).ResolveMethodHandle(metadataToken2, typeInstantiationContext, methodInstantiationContext).GetMethodInfo();
				Type type = RuntimeMethodHandle.GetDeclaringType(methodInfo);
				if (type.IsGenericType || type.IsArray)
				{
					MetadataToken metadataToken3 = new MetadataToken(MetadataImport.GetParentToken(metadataToken2));
					if (metadataToken2.IsMethodSpec)
					{
						metadataToken3 = new MetadataToken(MetadataImport.GetParentToken(metadataToken3));
					}
					type = ResolveType(metadataToken3, genericTypeArguments, genericMethodArguments);
				}
				return RuntimeType.GetMethodBase(type as RuntimeType, methodInfo);
			}
			catch (BadImageFormatException innerException)
			{
				throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, innerException);
			}
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		private FieldInfo ResolveLiteralField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
		{
			MetadataToken metadataToken2 = new MetadataToken(metadataToken);
			if (!MetadataImport.IsValidToken(metadataToken2) || !metadataToken2.IsFieldDef)
			{
				throw new ArgumentOutOfRangeException("metadataToken", SR.Format(SR.Argument_InvalidToken, metadataToken2, this));
			}
			string name = MetadataImport.GetName(metadataToken2).ToString();
			int parentToken = MetadataImport.GetParentToken(metadataToken2);
			Type type = ResolveType(parentToken, genericTypeArguments, genericMethodArguments);
			type.GetFields();
			try
			{
				return type.GetField(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
			catch
			{
				throw new ArgumentException(SR.Format(SR.Argument_ResolveField, metadataToken2, this), "metadataToken");
			}
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public unsafe override FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
		{
			try
			{
				MetadataToken metadataToken2 = new MetadataToken(metadataToken);
				if (!MetadataImport.IsValidToken(metadataToken2))
				{
					throw new ArgumentOutOfRangeException("metadataToken", SR.Format(SR.Argument_InvalidToken, metadataToken2, this));
				}
				RuntimeTypeHandle[] typeInstantiationContext = null;
				RuntimeTypeHandle[] methodInstantiationContext = null;
				if (genericTypeArguments != null && genericTypeArguments.Length != 0)
				{
					typeInstantiationContext = ConvertToTypeHandleArray(genericTypeArguments);
				}
				if (genericMethodArguments != null && genericMethodArguments.Length != 0)
				{
					methodInstantiationContext = ConvertToTypeHandleArray(genericMethodArguments);
				}
				ModuleHandle moduleHandle = new ModuleHandle(this);
				if (!metadataToken2.IsFieldDef)
				{
					if (!metadataToken2.IsMemberRef)
					{
						throw new ArgumentException(SR.Format(SR.Argument_ResolveField, metadataToken2, this), "metadataToken");
					}
					if (*(byte*)(void*)MetadataImport.GetMemberRefProps(metadataToken2).Signature != 6)
					{
						throw new ArgumentException(SR.Format(SR.Argument_ResolveField, metadataToken2, this), "metadataToken");
					}
				}
				IRuntimeFieldInfo runtimeFieldInfo = moduleHandle.ResolveFieldHandle(metadataToken, typeInstantiationContext, methodInstantiationContext).GetRuntimeFieldInfo();
				RuntimeType runtimeType = RuntimeFieldHandle.GetApproxDeclaringType(runtimeFieldInfo.Value);
				if (runtimeType.IsGenericType || runtimeType.IsArray)
				{
					int parentToken = ModuleHandle.GetMetadataImport(this).GetParentToken(metadataToken);
					runtimeType = (RuntimeType)ResolveType(parentToken, genericTypeArguments, genericMethodArguments);
				}
				return RuntimeType.GetFieldInfo(runtimeType, runtimeFieldInfo);
			}
			catch (MissingFieldException)
			{
				return ResolveLiteralField(metadataToken, genericTypeArguments, genericMethodArguments);
			}
			catch (BadImageFormatException innerException)
			{
				throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, innerException);
			}
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override Type ResolveType(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
		{
			try
			{
				MetadataToken metadataToken2 = new MetadataToken(metadataToken);
				if (metadataToken2.IsGlobalTypeDefToken)
				{
					throw new ArgumentException(SR.Format(SR.Argument_ResolveModuleType, metadataToken2), "metadataToken");
				}
				if (!metadataToken2.IsTypeDef && !metadataToken2.IsTypeSpec && !metadataToken2.IsTypeRef)
				{
					throw new ArgumentException(SR.Format(SR.Argument_ResolveType, metadataToken2, this), "metadataToken");
				}
				RuntimeTypeHandle[] typeInstantiationContext = null;
				RuntimeTypeHandle[] methodInstantiationContext = null;
				if (genericTypeArguments != null && genericTypeArguments.Length != 0)
				{
					typeInstantiationContext = ConvertToTypeHandleArray(genericTypeArguments);
				}
				if (genericMethodArguments != null && genericMethodArguments.Length != 0)
				{
					methodInstantiationContext = ConvertToTypeHandleArray(genericMethodArguments);
				}
				return GetModuleHandleImpl().ResolveTypeHandle(metadataToken, typeInstantiationContext, methodInstantiationContext).GetRuntimeType();
			}
			catch (BadImageFormatException innerException)
			{
				throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, innerException);
			}
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public unsafe override MemberInfo ResolveMember(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
		{
			MetadataToken metadataToken2 = new MetadataToken(metadataToken);
			if (metadataToken2.IsProperty)
			{
				throw new ArgumentException(SR.InvalidOperation_PropertyInfoNotAvailable);
			}
			if (metadataToken2.IsEvent)
			{
				throw new ArgumentException(SR.InvalidOperation_EventInfoNotAvailable);
			}
			if (metadataToken2.IsMethodSpec || metadataToken2.IsMethodDef)
			{
				return ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments);
			}
			if (metadataToken2.IsFieldDef)
			{
				return ResolveField(metadataToken, genericTypeArguments, genericMethodArguments);
			}
			if (metadataToken2.IsTypeRef || metadataToken2.IsTypeDef || metadataToken2.IsTypeSpec)
			{
				return ResolveType(metadataToken, genericTypeArguments, genericMethodArguments);
			}
			if (metadataToken2.IsMemberRef)
			{
				if (!MetadataImport.IsValidToken(metadataToken2))
				{
					throw new ArgumentOutOfRangeException("metadataToken", SR.Format(SR.Argument_InvalidToken, metadataToken2, this));
				}
				if (*(byte*)(void*)MetadataImport.GetMemberRefProps(metadataToken2).Signature == 6)
				{
					return ResolveField(metadataToken2, genericTypeArguments, genericMethodArguments);
				}
				return ResolveMethod(metadataToken2, genericTypeArguments, genericMethodArguments);
			}
			throw new ArgumentException(SR.Format(SR.Argument_ResolveMember, metadataToken2, this), "metadataToken");
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override string ResolveString(int metadataToken)
		{
			MetadataToken metadataToken2 = new MetadataToken(metadataToken);
			if (!metadataToken2.IsString)
			{
				throw new ArgumentException(SR.Format(SR.Argument_ResolveString, metadataToken, this));
			}
			if (!MetadataImport.IsValidToken(metadataToken2))
			{
				throw new ArgumentOutOfRangeException("metadataToken", SR.Format(SR.Argument_InvalidToken, metadataToken2, this));
			}
			string userString = MetadataImport.GetUserString(metadataToken);
			if (userString == null)
			{
				throw new ArgumentException(SR.Format(SR.Argument_ResolveString, metadataToken, this));
			}
			return userString;
		}

		public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
		{
			ModuleHandle.GetPEKind(this, out peKind, out machine);
		}

		[RequiresUnreferencedCode("Methods might be removed because Module methods can't currently be annotated for dynamic access.")]
		protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			return GetMethodInternal(name, bindingAttr, binder, callConvention, types, modifiers);
		}

		[RequiresUnreferencedCode("Methods might be removed because Module methods can't currently be annotated for dynamic access.")]
		internal MethodInfo GetMethodInternal(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			if (RuntimeType == null)
			{
				return null;
			}
			if (types == null)
			{
				return RuntimeType.GetMethod(name, bindingAttr);
			}
			return RuntimeType.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type GetType(string className, bool throwOnError, bool ignoreCase)
		{
			if (className == null)
			{
				throw new ArgumentNullException("className");
			}
			RuntimeType o = null;
			object o2 = null;
			RuntimeModule module = this;
			GetType(new QCallModule(ref module), className, throwOnError, ignoreCase, ObjectHandleOnStack.Create(ref o), ObjectHandleOnStack.Create(ref o2));
			GC.KeepAlive(o2);
			return o;
		}

		[RequiresAssemblyFiles("Returns <Unknown> for modules with no file path")]
		internal string GetFullyQualifiedName()
		{
			string s = null;
			RuntimeModule module = this;
			GetFullyQualifiedName(new QCallModule(ref module), new StringHandleOnStack(ref s));
			return s;
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type[] GetTypes()
		{
			return GetTypes(this);
		}

		public override bool IsResource()
		{
			return IsResource(this);
		}

		[RequiresUnreferencedCode("Fields might be removed")]
		public override FieldInfo[] GetFields(BindingFlags bindingFlags)
		{
			if (RuntimeType == null)
			{
				return Array.Empty<FieldInfo>();
			}
			return RuntimeType.GetFields(bindingFlags);
		}

		[RequiresUnreferencedCode("Fields might be removed")]
		public override FieldInfo GetField(string name, BindingFlags bindingAttr)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (RuntimeType == null)
			{
				return null;
			}
			return RuntimeType.GetField(name, bindingAttr);
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		public override MethodInfo[] GetMethods(BindingFlags bindingFlags)
		{
			if (RuntimeType == null)
			{
				return Array.Empty<MethodInfo>();
			}
			return RuntimeType.GetMethods(bindingFlags);
		}

		internal RuntimeAssembly GetRuntimeAssembly()
		{
			return m_runtimeAssembly;
		}

		protected override ModuleHandle GetModuleHandleImpl()
		{
			return new ModuleHandle(this);
		}

		internal IntPtr GetUnderlyingNativeHandle()
		{
			return m_pData;
		}
	}
	internal sealed class RuntimeParameterInfo : ParameterInfo
	{
		private static readonly Type s_DecimalConstantAttributeType = typeof(DecimalConstantAttribute);

		private static readonly Type s_CustomConstantAttributeType = typeof(CustomConstantAttribute);

		private int m_tkParamDef;

		private MetadataImport m_scope;

		private Signature m_signature;

		private volatile bool m_nameIsCached;

		private readonly bool m_noMetadata;

		private bool m_noDefaultValue;

		private MethodBase m_originalMember;

		public override Type ParameterType
		{
			get
			{
				if (ClassImpl == null)
				{
					RuntimeType classImpl = ((PositionImpl != -1) ? m_signature.Arguments[PositionImpl] : m_signature.ReturnType);
					ClassImpl = classImpl;
				}
				return ClassImpl;
			}
		}

		public override string Name
		{
			get
			{
				if (!m_nameIsCached)
				{
					if (!System.Reflection.MetadataToken.IsNullToken(m_tkParamDef))
					{
						string nameImpl = m_scope.GetName(m_tkParamDef).ToString();
						NameImpl = nameImpl;
					}
					m_nameIsCached = true;
				}
				return NameImpl;
			}
		}

		public override bool HasDefaultValue
		{
			get
			{
				if (m_noMetadata || m_noDefaultValue)
				{
					return false;
				}
				object defaultValueInternal = GetDefaultValueInternal(raw: false);
				return defaultValueInternal != DBNull.Value;
			}
		}

		public override object DefaultValue => GetDefaultValue(raw: false);

		public override object RawDefaultValue => GetDefaultValue(raw: true);

		public override int MetadataToken => m_tkParamDef;

		internal static ParameterInfo[] GetParameters(IRuntimeMethodInfo method, MemberInfo member, Signature sig)
		{
			ParameterInfo returnParameter;
			return GetParameters(method, member, sig, out returnParameter, fetchReturnParameter: false);
		}

		internal static ParameterInfo GetReturnParameter(IRuntimeMethodInfo method, MemberInfo member, Signature sig)
		{
			GetParameters(method, member, sig, out var returnParameter, fetchReturnParameter: true);
			return returnParameter;
		}

		private static ParameterInfo[] GetParameters(IRuntimeMethodInfo methodHandle, MemberInfo member, Signature sig, out ParameterInfo returnParameter, bool fetchReturnParameter)
		{
			returnParameter = null;
			int num = sig.Arguments.Length;
			ParameterInfo[] array = (fetchReturnParameter ? null : ((num == 0) ? Array.Empty<ParameterInfo>() : new ParameterInfo[num]));
			int methodDef = RuntimeMethodHandle.GetMethodDef(methodHandle);
			int num2 = 0;
			if (!System.Reflection.MetadataToken.IsNullToken(methodDef))
			{
				MetadataImport metadataImport = RuntimeTypeHandle.GetMetadataImport(RuntimeMethodHandle.GetDeclaringType(methodHandle));
				metadataImport.EnumParams(methodDef, out var result);
				num2 = result.Length;
				if (num2 > num + 1)
				{
					throw new BadImageFormatException(SR.BadImageFormat_ParameterSignatureMismatch);
				}
				for (int i = 0; i < num2; i++)
				{
					int num3 = result[i];
					metadataImport.GetParamDefProps(num3, out var sequence, out var attributes);
					sequence--;
					if (fetchReturnParameter && sequence == -1)
					{
						if (returnParameter != null)
						{
							throw new BadImageFormatException(SR.BadImageFormat_ParameterSignatureMismatch);
						}
						returnParameter = new RuntimeParameterInfo(sig, metadataImport, num3, sequence, attributes, member);
					}
					else if (!fetchReturnParameter && sequence >= 0)
					{
						if (sequence >= num)
						{
							throw new BadImageFormatException(SR.BadImageFormat_ParameterSignatureMismatch);
						}
						array[sequence] = new RuntimeParameterInfo(sig, metadataImport, num3, sequence, attributes, member);
					}
				}
			}
			if (fetchReturnParameter)
			{
				if (returnParameter == null)
				{
					returnParameter = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, -1, ParameterAttributes.None, member);
				}
			}
			else if (num2 < array.Length + 1)
			{
				for (int j = 0; j < array.Length; j++)
				{
					if (array[j] == null)
					{
						array[j] = new RuntimeParameterInfo(sig, MetadataImport.EmptyImport, 0, j, ParameterAttributes.None, member);
					}
				}
			}
			return array;
		}

		internal void SetName(string name)
		{
			NameImpl = name;
		}

		internal void SetAttributes(ParameterAttributes attributes)
		{
			AttrsImpl = attributes;
		}

		internal RuntimeParameterInfo(RuntimeParameterInfo accessor, RuntimePropertyInfo property)
			: this(accessor, (MemberInfo)property)
		{
			m_signature = property.Signature;
		}

		private RuntimeParameterInfo(RuntimeParameterInfo accessor, MemberInfo member)
		{
			MemberImpl = member;
			m_originalMember = accessor.MemberImpl as MethodBase;
			NameImpl = accessor.Name;
			m_nameIsCached = true;
			ClassImpl = accessor.ParameterType;
			PositionImpl = accessor.Position;
			AttrsImpl = accessor.Attributes;
			m_tkParamDef = (System.Reflection.MetadataToken.IsNullToken(accessor.MetadataToken) ? 134217728 : accessor.MetadataToken);
			m_scope = accessor.m_scope;
		}

		private RuntimeParameterInfo(Signature signature, MetadataImport scope, int tkParamDef, int position, ParameterAttributes attributes, MemberInfo member)
		{
			PositionImpl = position;
			MemberImpl = member;
			m_signature = signature;
			m_tkParamDef = (System.Reflection.MetadataToken.IsNullToken(tkParamDef) ? 134217728 : tkParamDef);
			m_scope = scope;
			AttrsImpl = attributes;
			ClassImpl = null;
			NameImpl = null;
		}

		internal RuntimeParameterInfo(MethodInfo owner, string name, Type parameterType, int position)
		{
			MemberImpl = owner;
			NameImpl = name;
			m_nameIsCached = true;
			m_noMetadata = true;
			ClassImpl = parameterType;
			PositionImpl = position;
			AttrsImpl = ParameterAttributes.None;
			m_tkParamDef = 134217728;
			m_scope = MetadataImport.EmptyImport;
		}

		private object GetDefaultValue(bool raw)
		{
			if (m_noMetadata)
			{
				return null;
			}
			object obj = GetDefaultValueInternal(raw);
			if (obj == DBNull.Value && base.IsOptional)
			{
				obj = Type.Missing;
			}
			return obj;
		}

		private object GetDefaultValueInternal(bool raw)
		{
			if (m_noDefaultValue)
			{
				return DBNull.Value;
			}
			object obj = null;
			if (ParameterType == typeof(DateTime))
			{
				if (raw)
				{
					CustomAttributeTypedArgument customAttributeTypedArgument = RuntimeCustomAttributeData.Filter(CustomAttributeData.GetCustomAttributes(this), typeof(DateTimeConstantAttribute), 0);
					if (customAttributeTypedArgument.ArgumentType != null)
					{
						return new DateTime((long)customAttributeTypedArgument.Value);
					}
				}
				else
				{
					object[] customAttributes = GetCustomAttributes(typeof(DateTimeConstantAttribute), inherit: false);
					if (customAttributes != null && customAttributes.Length != 0)
					{
						return ((DateTimeConstantAttribute)customAttributes[0]).Value;
					}
				}
			}
			if (!System.Reflection.MetadataToken.IsNullToken(m_tkParamDef))
			{
				obj = MdConstant.GetValue(m_scope, m_tkParamDef, ParameterType.GetTypeHandleInternal(), raw);
			}
			if (obj == DBNull.Value)
			{
				if (raw)
				{
					foreach (CustomAttributeData customAttribute in CustomAttributeData.GetCustomAttributes(this))
					{
						Type declaringType = customAttribute.Constructor.DeclaringType;
						if (declaringType == typeof(DateTimeConstantAttribute))
						{
							obj = GetRawDateTimeConstant(customAttribute);
						}
						else if (declaringType == typeof(DecimalConstantAttribute))
						{
							obj = GetRawDecimalConstant(customAttribute);
						}
						else if (declaringType.IsSubclassOf(s_CustomConstantAttributeType))
						{
							obj = GetRawConstant(customAttribute);
						}
					}
				}
				else
				{
					object[] customAttributes2 = GetCustomAttributes(s_CustomConstantAttributeType, inherit: false);
					if (customAttributes2.Length != 0)
					{
						obj = ((CustomConstantAttribute)customAttributes2[0]).Value;
					}
					else
					{
						customAttributes2 = GetCustomAttributes(s_DecimalConstantAttributeType, inherit: false);
						if (customAttributes2.Length != 0)
						{
							obj = ((DecimalConstantAttribute)customAttributes2[0]).Value;
						}
					}
				}
			}
			if (obj == DBNull.Value)
			{
				m_noDefaultValue = true;
			}
			return obj;
		}

		private static decimal GetRawDecimalConstant(CustomAttributeData attr)
		{
			foreach (CustomAttributeNamedArgument namedArgument in attr.NamedArguments)
			{
				if (namedArgument.MemberInfo.Name.Equals("Value"))
				{
					return (decimal)namedArgument.TypedValue.Value;
				}
			}
			ParameterInfo[] parameters = attr.Constructor.GetParameters();
			IList<CustomAttributeTypedArgument> constructorArguments = attr.ConstructorArguments;
			if (parameters[2].ParameterType == typeof(uint))
			{
				int lo = (int)(uint)constructorArguments[4].Value;
				int mid = (int)(uint)constructorArguments[3].Value;
				int hi = (int)(uint)constructorArguments[2].Value;
				byte b = (byte)constructorArguments[1].Value;
				byte scale = (byte)constructorArguments[0].Value;
				return new decimal(lo, mid, hi, b != 0, scale);
			}
			int lo2 = (int)constructorArguments[4].Value;
			int mid2 = (int)constructorArguments[3].Value;
			int hi2 = (int)constructorArguments[2].Value;
			byte b2 = (byte)constructorArguments[1].Value;
			byte scale2 = (byte)constructorArguments[0].Value;
			return new decimal(lo2, mid2, hi2, b2 != 0, scale2);
		}

		private static DateTime GetRawDateTimeConstant(CustomAttributeData attr)
		{
			foreach (CustomAttributeNamedArgument namedArgument in attr.NamedArguments)
			{
				if (namedArgument.MemberInfo.Name.Equals("Value"))
				{
					return new DateTime((long)namedArgument.TypedValue.Value);
				}
			}
			return new DateTime((long)attr.ConstructorArguments[0].Value);
		}

		private static object GetRawConstant(CustomAttributeData attr)
		{
			foreach (CustomAttributeNamedArgument namedArgument in attr.NamedArguments)
			{
				if (namedArgument.MemberInfo.Name.Equals("Value"))
				{
					return namedArgument.TypedValue.Value;
				}
			}
			return DBNull.Value;
		}

		internal RuntimeModule GetRuntimeModule()
		{
			RuntimeMethodInfo runtimeMethodInfo = Member as RuntimeMethodInfo;
			RuntimeConstructorInfo runtimeConstructorInfo = Member as RuntimeConstructorInfo;
			RuntimePropertyInfo runtimePropertyInfo = Member as RuntimePropertyInfo;
			if (runtimeMethodInfo != null)
			{
				return runtimeMethodInfo.GetRuntimeModule();
			}
			if (runtimeConstructorInfo != null)
			{
				return runtimeConstructorInfo.GetRuntimeModule();
			}
			if (runtimePropertyInfo != null)
			{
				return runtimePropertyInfo.GetRuntimeModule();
			}
			return null;
		}

		public override Type[] GetRequiredCustomModifiers()
		{
			if (m_signature != null)
			{
				return m_signature.GetCustomModifiers(PositionImpl + 1, required: true);
			}
			return Type.EmptyTypes;
		}

		public override Type[] GetOptionalCustomModifiers()
		{
			if (m_signature != null)
			{
				return m_signature.GetCustomModifiers(PositionImpl + 1, required: false);
			}
			return Type.EmptyTypes;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			if (System.Reflection.MetadataToken.IsNullToken(m_tkParamDef))
			{
				return Array.Empty<object>();
			}
			return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (System.Reflection.MetadataToken.IsNullToken(m_tkParamDef))
			{
				return Array.Empty<object>();
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			if (System.Reflection.MetadataToken.IsNullToken(m_tkParamDef))
			{
				return false;
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}
	}
	internal sealed class RuntimePropertyInfo : PropertyInfo
	{
		private int m_token;

		private string m_name;

		private unsafe void* m_utf8name;

		private PropertyAttributes m_flags;

		private RuntimeType.RuntimeTypeCache m_reflectedTypeCache;

		private RuntimeMethodInfo m_getterMethod;

		private RuntimeMethodInfo m_setterMethod;

		private MethodInfo[] m_otherMethod;

		private RuntimeType m_declaringType;

		private BindingFlags m_bindingFlags;

		private Signature m_signature;

		private ParameterInfo[] m_parameters;

		internal unsafe Signature Signature
		{
			get
			{
				if (m_signature == null)
				{
					GetRuntimeModule().MetadataImport.GetPropertyProps(m_token, out var _, out var _, out var signature);
					m_signature = new Signature(signature.Signature.ToPointer(), signature.Length, m_declaringType);
				}
				return m_signature;
			}
		}

		internal BindingFlags BindingFlags => m_bindingFlags;

		public override MemberTypes MemberType => MemberTypes.Property;

		public unsafe override string Name => m_name ?? (m_name = new MdUtf8String(m_utf8name).ToString());

		public override Type DeclaringType => m_declaringType;

		public override Type ReflectedType => ReflectedTypeInternal;

		private RuntimeType ReflectedTypeInternal => m_reflectedTypeCache.GetRuntimeType();

		public override int MetadataToken => m_token;

		public override Module Module => GetRuntimeModule();

		public override bool IsCollectible => m_declaringType.IsCollectible;

		public override Type PropertyType => Signature.ReturnType;

		public override PropertyAttributes Attributes => m_flags;

		public override bool CanRead => m_getterMethod != null;

		public override bool CanWrite => m_setterMethod != null;

		internal unsafe RuntimePropertyInfo(int tkProperty, RuntimeType declaredType, RuntimeType.RuntimeTypeCache reflectedTypeCache, out bool isPrivate)
		{
			MetadataImport metadataImport = declaredType.GetRuntimeModule().MetadataImport;
			m_token = tkProperty;
			m_reflectedTypeCache = reflectedTypeCache;
			m_declaringType = declaredType;
			metadataImport.GetPropertyProps(tkProperty, out m_utf8name, out m_flags, out var _);
			Associates.AssignAssociates(metadataImport, tkProperty, declaredType, reflectedTypeCache.GetRuntimeType(), out var _, out var _, out var _, out m_getterMethod, out m_setterMethod, out m_otherMethod, out isPrivate, out m_bindingFlags);
		}

		internal override bool CacheEquals(object o)
		{
			if (o is RuntimePropertyInfo runtimePropertyInfo && runtimePropertyInfo.m_token == m_token)
			{
				return RuntimeTypeHandle.GetModule(m_declaringType).Equals(RuntimeTypeHandle.GetModule(runtimePropertyInfo.m_declaringType));
			}
			return false;
		}

		internal bool EqualsSig(RuntimePropertyInfo target)
		{
			return Signature.CompareSig(Signature, target.Signature);
		}

		public override string ToString()
		{
			ValueStringBuilder sbParamList = new ValueStringBuilder(100);
			sbParamList.Append(PropertyType.FormatTypeName());
			sbParamList.Append(' ');
			sbParamList.Append(Name);
			RuntimeType[] arguments = Signature.Arguments;
			if (arguments.Length != 0)
			{
				sbParamList.Append(" [");
				Type[] parameterTypes = arguments;
				MethodBase.AppendParameters(ref sbParamList, parameterTypes, Signature.CallingConvention);
				sbParamList.Append(']');
			}
			return sbParamList.ToString();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(this, runtimeType);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(this, runtimeType);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return RuntimeCustomAttributeData.GetCustomAttributesInternal(this);
		}

		public sealed override bool HasSameMetadataDefinitionAs(MemberInfo other)
		{
			return HasSameMetadataDefinitionAsCore<RuntimePropertyInfo>(other);
		}

		internal RuntimeModule GetRuntimeModule()
		{
			return m_declaringType.GetRuntimeModule();
		}

		public override Type[] GetRequiredCustomModifiers()
		{
			return Signature.GetCustomModifiers(0, required: true);
		}

		public override Type[] GetOptionalCustomModifiers()
		{
			return Signature.GetCustomModifiers(0, required: false);
		}

		internal object GetConstantValue(bool raw)
		{
			object value = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_token, PropertyType.GetTypeHandleInternal(), raw);
			if (value == DBNull.Value)
			{
				throw new InvalidOperationException(SR.Arg_EnumLitValueNotFound);
			}
			return value;
		}

		public override object GetConstantValue()
		{
			return GetConstantValue(raw: false);
		}

		public override object GetRawConstantValue()
		{
			return GetConstantValue(raw: true);
		}

		public override MethodInfo[] GetAccessors(bool nonPublic)
		{
			List<MethodInfo> list = new List<MethodInfo>();
			if (Associates.IncludeAccessor(m_getterMethod, nonPublic))
			{
				list.Add(m_getterMethod);
			}
			if (Associates.IncludeAccessor(m_setterMethod, nonPublic))
			{
				list.Add(m_setterMethod);
			}
			if (m_otherMethod != null)
			{
				for (int i = 0; i < m_otherMethod.Length; i++)
				{
					if (Associates.IncludeAccessor(m_otherMethod[i], nonPublic))
					{
						list.Add(m_otherMethod[i]);
					}
				}
			}
			return list.ToArray();
		}

		public override RuntimeMethodInfo GetGetMethod(bool nonPublic)
		{
			if (!Associates.IncludeAccessor(m_getterMethod, nonPublic))
			{
				return null;
			}
			return m_getterMethod;
		}

		public override RuntimeMethodInfo GetSetMethod(bool nonPublic)
		{
			if (!Associates.IncludeAccessor(m_setterMethod, nonPublic))
			{
				return null;
			}
			return m_setterMethod;
		}

		public override ParameterInfo[] GetIndexParameters()
		{
			ParameterInfo[] indexParametersNoCopy = GetIndexParametersNoCopy();
			int num = indexParametersNoCopy.Length;
			if (num == 0)
			{
				return indexParametersNoCopy;
			}
			ParameterInfo[] array = new ParameterInfo[num];
			Array.Copy(indexParametersNoCopy, array, num);
			return array;
		}

		internal ParameterInfo[] GetIndexParametersNoCopy()
		{
			if (m_parameters == null)
			{
				int num = 0;
				ParameterInfo[] array = null;
				RuntimeMethodInfo getMethod = GetGetMethod(nonPublic: true);
				if (getMethod != null)
				{
					array = getMethod.GetParametersNoCopy();
					num = array.Length;
				}
				else
				{
					getMethod = GetSetMethod(nonPublic: true);
					if (getMethod != null)
					{
						array = getMethod.GetParametersNoCopy();
						num = array.Length - 1;
					}
				}
				ParameterInfo[] array2 = ((num != 0) ? new ParameterInfo[num] : Array.Empty<ParameterInfo>());
				for (int i = 0; i < array2.Length; i++)
				{
					array2[i] = new RuntimeParameterInfo((RuntimeParameterInfo)array[i], this);
				}
				m_parameters = array2;
			}
			return m_parameters;
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override object GetValue(object obj, object[] index)
		{
			return GetValue(obj, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, index, null);
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
		{
			RuntimeMethodInfo getMethod = GetGetMethod(nonPublic: true);
			if (getMethod == null)
			{
				throw new ArgumentException(SR.Arg_GetMethNotFnd);
			}
			return getMethod.Invoke(obj, invokeAttr, binder, index, null);
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override void SetValue(object obj, object value, object[] index)
		{
			SetValue(obj, value, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, index, null);
		}

		[DebuggerStepThrough]
		[DebuggerHidden]
		public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
		{
			RuntimeMethodInfo setMethod = GetSetMethod(nonPublic: true);
			if (setMethod == null)
			{
				throw new ArgumentException(SR.Arg_SetMethNotFnd);
			}
			if (index == null)
			{
				setMethod.InvokeOneParameter(obj, invokeAttr, binder, value, culture);
				return;
			}
			object[] array = new object[index.Length + 1];
			for (int i = 0; i < index.Length; i++)
			{
				array[i] = index[i];
			}
			array[index.Length] = value;
			setMethod.Invoke(obj, invokeAttr, binder, array, culture);
		}
	}
	internal struct CerHashtable<K, V> where K : class
	{
		private sealed class Table
		{
			internal K[] m_keys;

			internal V[] m_values;

			internal int m_count;

			internal Table(int size)
			{
				size = HashHelpers.GetPrime(size);
				m_keys = new K[size];
				m_values = new V[size];
			}

			internal void Insert(K key, V value)
			{
				int num = CerHashtable<K, V>.GetHashCodeHelper(key);
				if (num < 0)
				{
					num = ~num;
				}
				K[] keys = m_keys;
				int num2 = num % keys.Length;
				while (true)
				{
					K val = keys[num2];
					if (val == null)
					{
						break;
					}
					num2++;
					if (num2 >= keys.Length)
					{
						num2 -= keys.Length;
					}
				}
				m_count++;
				m_values[num2] = value;
				Volatile.Write(ref keys[num2], key);
			}
		}

		private Table m_Table;

		internal V this[K key]
		{
			get
			{
				Table table = Volatile.Read(ref m_Table);
				if (table == null)
				{
					return default(V);
				}
				int num = GetHashCodeHelper(key);
				if (num < 0)
				{
					num = ~num;
				}
				K[] keys = table.m_keys;
				int num2 = num % keys.Length;
				while (true)
				{
					K val = Volatile.Read(ref keys[num2]);
					if (val == null)
					{
						break;
					}
					if (val.Equals(key))
					{
						return table.m_values[num2];
					}
					num2++;
					if (num2 >= keys.Length)
					{
						num2 -= keys.Length;
					}
				}
				return default(V);
			}
			set
			{
				Table table = m_Table;
				if (table != null)
				{
					int num = 2 * (table.m_count + 1);
					if (num >= table.m_keys.Length)
					{
						Rehash(num);
					}
				}
				else
				{
					Rehash(7);
				}
				m_Table.Insert(key, value);
			}
		}

		private static int GetHashCodeHelper(K key)
		{
			if (!(key is string text))
			{
				return key.GetHashCode();
			}
			return text.GetNonRandomizedHashCode();
		}

		private void Rehash(int newSize)
		{
			Table table = new Table(newSize);
			Table table2 = m_Table;
			if (table2 != null)
			{
				K[] keys = table2.m_keys;
				V[] values = table2.m_values;
				for (int i = 0; i < keys.Length; i++)
				{
					K val = keys[i];
					if (val != null)
					{
						table.Insert(val, values[i]);
					}
				}
			}
			Volatile.Write(ref m_Table, table);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class AmbiguousMatchException : SystemException
	{
		public AmbiguousMatchException()
			: base(SR.RFLCT_Ambiguous)
		{
			base.HResult = -2147475171;
		}

		public AmbiguousMatchException(string? message)
			: base(message)
		{
			base.HResult = -2147475171;
		}

		public AmbiguousMatchException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147475171;
		}

		private AmbiguousMatchException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyAlgorithmIdAttribute : Attribute
	{
		[CLSCompliant(false)]
		public uint AlgorithmId { get; }

		public AssemblyAlgorithmIdAttribute(AssemblyHashAlgorithm algorithmId)
		{
			AlgorithmId = (uint)algorithmId;
		}

		[CLSCompliant(false)]
		public AssemblyAlgorithmIdAttribute(uint algorithmId)
		{
			AlgorithmId = algorithmId;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyCompanyAttribute : Attribute
	{
		public string Company { get; }

		public AssemblyCompanyAttribute(string company)
		{
			Company = company;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyConfigurationAttribute : Attribute
	{
		public string Configuration { get; }

		public AssemblyConfigurationAttribute(string configuration)
		{
			Configuration = configuration;
		}
	}
	public enum AssemblyContentType
	{
		Default,
		WindowsRuntime
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyCopyrightAttribute : Attribute
	{
		public string Copyright { get; }

		public AssemblyCopyrightAttribute(string copyright)
		{
			Copyright = copyright;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyCultureAttribute : Attribute
	{
		public string Culture { get; }

		public AssemblyCultureAttribute(string culture)
		{
			Culture = culture;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyDefaultAliasAttribute : Attribute
	{
		public string DefaultAlias { get; }

		public AssemblyDefaultAliasAttribute(string defaultAlias)
		{
			DefaultAlias = defaultAlias;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyDelaySignAttribute : Attribute
	{
		public bool DelaySign { get; }

		public AssemblyDelaySignAttribute(bool delaySign)
		{
			DelaySign = delaySign;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyDescriptionAttribute : Attribute
	{
		public string Description { get; }

		public AssemblyDescriptionAttribute(string description)
		{
			Description = description;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyFileVersionAttribute : Attribute
	{
		public string Version { get; }

		public AssemblyFileVersionAttribute(string version)
		{
			Version = version ?? throw new ArgumentNullException("version");
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyFlagsAttribute : Attribute
	{
		private readonly AssemblyNameFlags _flags;

		[Obsolete("AssemblyFlagsAttribute.Flags has been deprecated. Use AssemblyFlags instead.")]
		[CLSCompliant(false)]
		public uint Flags => (uint)_flags;

		public int AssemblyFlags => (int)_flags;

		[Obsolete("This constructor has been deprecated. Use AssemblyFlagsAttribute(AssemblyNameFlags) instead.")]
		[CLSCompliant(false)]
		public AssemblyFlagsAttribute(uint flags)
		{
			_flags = (AssemblyNameFlags)flags;
		}

		[Obsolete("This constructor has been deprecated. Use AssemblyFlagsAttribute(AssemblyNameFlags) instead.")]
		public AssemblyFlagsAttribute(int assemblyFlags)
		{
			_flags = (AssemblyNameFlags)assemblyFlags;
		}

		public AssemblyFlagsAttribute(AssemblyNameFlags assemblyFlags)
		{
			_flags = assemblyFlags;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyInformationalVersionAttribute : Attribute
	{
		public string InformationalVersion { get; }

		public AssemblyInformationalVersionAttribute(string informationalVersion)
		{
			InformationalVersion = informationalVersion;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyKeyFileAttribute : Attribute
	{
		public string KeyFile { get; }

		public AssemblyKeyFileAttribute(string keyFile)
		{
			KeyFile = keyFile;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyKeyNameAttribute : Attribute
	{
		public string KeyName { get; }

		public AssemblyKeyNameAttribute(string keyName)
		{
			KeyName = keyName;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true, Inherited = false)]
	public sealed class AssemblyMetadataAttribute : Attribute
	{
		public string Key { get; }

		public string? Value { get; }

		public AssemblyMetadataAttribute(string key, string? value)
		{
			Key = key;
			Value = value;
		}
	}
	[Flags]
	public enum AssemblyNameFlags
	{
		None = 0,
		PublicKey = 1,
		EnableJITcompileOptimizer = 0x4000,
		EnableJITcompileTracking = 0x8000,
		Retargetable = 0x100
	}
	internal static class AssemblyNameFormatter
	{
		public static string ComputeDisplayName(string name, Version version, string cultureName, byte[] pkt, AssemblyNameFlags flags = AssemblyNameFlags.None, AssemblyContentType contentType = AssemblyContentType.Default)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendQuoted(name);
			if (version != null)
			{
				Version version2 = version.CanonicalizeVersion();
				if (version2.Major != 65535)
				{
					stringBuilder.Append(", Version=");
					stringBuilder.Append(version2.Major);
					if (version2.Minor != 65535)
					{
						stringBuilder.Append('.');
						stringBuilder.Append(version2.Minor);
						if (version2.Build != 65535)
						{
							stringBuilder.Append('.');
							stringBuilder.Append(version2.Build);
							if (version2.Revision != 65535)
							{
								stringBuilder.Append('.');
								stringBuilder.Append(version2.Revision);
							}
						}
					}
				}
			}
			if (cultureName != null)
			{
				if (cultureName.Length == 0)
				{
					cultureName = "neutral";
				}
				stringBuilder.Append(", Culture=");
				stringBuilder.AppendQuoted(cultureName);
			}
			if (pkt != null)
			{
				if (pkt.Length > 8)
				{
					throw new ArgumentException();
				}
				stringBuilder.Append(", PublicKeyToken=");
				if (pkt.Length == 0)
				{
					stringBuilder.Append("null");
				}
				else
				{
					stringBuilder.Append(HexConverter.ToString(pkt, HexConverter.Casing.Lower));
				}
			}
			if ((flags & AssemblyNameFlags.Retargetable) != 0)
			{
				stringBuilder.Append(", Retargetable=Yes");
			}
			if (contentType == AssemblyContentType.WindowsRuntime)
			{
				stringBuilder.Append(", ContentType=WindowsRuntime");
			}
			return stringBuilder.ToString();
		}

		private static void AppendQuoted(this StringBuilder sb, string s)
		{
			bool flag = false;
			if (s != s.Trim() || s.Contains('"') || s.Contains('\''))
			{
				flag = true;
			}
			if (flag)
			{
				sb.Append('"');
			}
			for (int i = 0; i < s.Length; i++)
			{
				switch (s[i])
				{
				case '"':
				case '\'':
				case ',':
				case '=':
				case '\\':
					sb.Append('\\');
					break;
				case '\t':
					sb.Append("\\t");
					continue;
				case '\r':
					sb.Append("\\r");
					continue;
				case '\n':
					sb.Append("\\n");
					continue;
				}
				sb.Append(s[i]);
			}
			if (flag)
			{
				sb.Append('"');
			}
		}

		private static Version CanonicalizeVersion(this Version version)
		{
			ushort num = (ushort)version.Major;
			ushort num2 = (ushort)version.Minor;
			ushort num3 = (ushort)version.Build;
			ushort num4 = (ushort)version.Revision;
			if (num == version.Major && num2 == version.Minor && num3 == version.Build && num4 == version.Revision)
			{
				return version;
			}
			return new Version(num, num2, num3, num4);
		}
	}
	public class AssemblyNameProxy : MarshalByRefObject
	{
		public AssemblyName GetAssemblyName(string assemblyFile)
		{
			return AssemblyName.GetAssemblyName(assemblyFile);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyProductAttribute : Attribute
	{
		public string Product { get; }

		public AssemblyProductAttribute(string product)
		{
			Product = product;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = false)]
	public sealed class AssemblySignatureKeyAttribute : Attribute
	{
		public string PublicKey { get; }

		public string Countersignature { get; }

		public AssemblySignatureKeyAttribute(string publicKey, string countersignature)
		{
			PublicKey = publicKey;
			Countersignature = countersignature;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyTitleAttribute : Attribute
	{
		public string Title { get; }

		public AssemblyTitleAttribute(string title)
		{
			Title = title;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyTrademarkAttribute : Attribute
	{
		public string Trademark { get; }

		public AssemblyTrademarkAttribute(string trademark)
		{
			Trademark = trademark;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
	public sealed class AssemblyVersionAttribute : Attribute
	{
		public string Version { get; }

		public AssemblyVersionAttribute(string version)
		{
			Version = version;
		}
	}
	public abstract class Binder
	{
		public abstract FieldInfo BindToField(BindingFlags bindingAttr, FieldInfo[] match, object value, CultureInfo? culture);

		public abstract MethodBase BindToMethod(BindingFlags bindingAttr, MethodBase[] match, ref object?[] args, ParameterModifier[]? modifiers, CultureInfo? culture, string[]? names, out object? state);

		public abstract object ChangeType(object value, Type type, CultureInfo? culture);

		public abstract void ReorderArgumentArray(ref object?[] args, object state);

		public abstract MethodBase? SelectMethod(BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[]? modifiers);

		public abstract PropertyInfo? SelectProperty(BindingFlags bindingAttr, PropertyInfo[] match, Type? returnType, Type[]? indexes, ParameterModifier[]? modifiers);
	}
	[Flags]
	public enum BindingFlags
	{
		Default = 0,
		IgnoreCase = 1,
		DeclaredOnly = 2,
		Instance = 4,
		Static = 8,
		Public = 0x10,
		NonPublic = 0x20,
		FlattenHierarchy = 0x40,
		InvokeMethod = 0x100,
		CreateInstance = 0x200,
		GetField = 0x400,
		SetField = 0x800,
		GetProperty = 0x1000,
		SetProperty = 0x2000,
		PutDispProperty = 0x4000,
		PutRefDispProperty = 0x8000,
		ExactBinding = 0x10000,
		SuppressChangeType = 0x20000,
		OptionalParamBinding = 0x40000,
		IgnoreReturn = 0x1000000,
		DoNotWrapExceptions = 0x2000000
	}
	[Flags]
	public enum CallingConventions
	{
		Standard = 1,
		VarArgs = 2,
		Any = 3,
		HasThis = 0x20,
		ExplicitThis = 0x40
	}
	internal enum CorElementType : byte
	{
		ELEMENT_TYPE_END = 0,
		ELEMENT_TYPE_VOID = 1,
		ELEMENT_TYPE_BOOLEAN = 2,
		ELEMENT_TYPE_CHAR = 3,
		ELEMENT_TYPE_I1 = 4,
		ELEMENT_TYPE_U1 = 5,
		ELEMENT_TYPE_I2 = 6,
		ELEMENT_TYPE_U2 = 7,
		ELEMENT_TYPE_I4 = 8,
		ELEMENT_TYPE_U4 = 9,
		ELEMENT_TYPE_I8 = 10,
		ELEMENT_TYPE_U8 = 11,
		ELEMENT_TYPE_R4 = 12,
		ELEMENT_TYPE_R8 = 13,
		ELEMENT_TYPE_STRING = 14,
		ELEMENT_TYPE_PTR = 15,
		ELEMENT_TYPE_BYREF = 16,
		ELEMENT_TYPE_VALUETYPE = 17,
		ELEMENT_TYPE_CLASS = 18,
		ELEMENT_TYPE_VAR = 19,
		ELEMENT_TYPE_ARRAY = 20,
		ELEMENT_TYPE_GENERICINST = 21,
		ELEMENT_TYPE_TYPEDBYREF = 22,
		ELEMENT_TYPE_I = 24,
		ELEMENT_TYPE_U = 25,
		ELEMENT_TYPE_FNPTR = 27,
		ELEMENT_TYPE_OBJECT = 28,
		ELEMENT_TYPE_SZARRAY = 29,
		ELEMENT_TYPE_MVAR = 30,
		ELEMENT_TYPE_CMOD_REQD = 31,
		ELEMENT_TYPE_CMOD_OPT = 32,
		ELEMENT_TYPE_INTERNAL = 33,
		ELEMENT_TYPE_MAX = 34,
		ELEMENT_TYPE_MODIFIER = 64,
		ELEMENT_TYPE_SENTINEL = 65,
		ELEMENT_TYPE_PINNED = 69
	}
	public class CustomAttributeData
	{
		public virtual Type AttributeType => Constructor.DeclaringType;

		public virtual ConstructorInfo Constructor => null;

		public virtual IList<CustomAttributeTypedArgument> ConstructorArguments => null;

		public virtual IList<CustomAttributeNamedArgument> NamedArguments => null;

		public static IList<CustomAttributeData> GetCustomAttributes(MemberInfo target)
		{
			if ((object)target == null)
			{
				throw new ArgumentNullException("target");
			}
			return target.GetCustomAttributesData();
		}

		public static IList<CustomAttributeData> GetCustomAttributes(Module target)
		{
			if ((object)target == null)
			{
				throw new ArgumentNullException("target");
			}
			return target.GetCustomAttributesData();
		}

		public static IList<CustomAttributeData> GetCustomAttributes(Assembly target)
		{
			if ((object)target == null)
			{
				throw new ArgumentNullException("target");
			}
			return target.GetCustomAttributesData();
		}

		public static IList<CustomAttributeData> GetCustomAttributes(ParameterInfo target)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			return target.GetCustomAttributesData();
		}

		protected CustomAttributeData()
		{
		}

		public override string ToString()
		{
			Span<char> initialBuffer = stackalloc char[256];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.Append('[');
			valueStringBuilder.Append(Constructor.DeclaringType.FullName);
			valueStringBuilder.Append('(');
			bool flag = true;
			IList<CustomAttributeTypedArgument> constructorArguments = ConstructorArguments;
			int count = constructorArguments.Count;
			for (int i = 0; i < count; i++)
			{
				if (!flag)
				{
					valueStringBuilder.Append(", ");
				}
				valueStringBuilder.Append(constructorArguments[i].ToString());
				flag = false;
			}
			IList<CustomAttributeNamedArgument> namedArguments = NamedArguments;
			int count2 = namedArguments.Count;
			for (int j = 0; j < count2; j++)
			{
				if (!flag)
				{
					valueStringBuilder.Append(", ");
				}
				valueStringBuilder.Append(namedArguments[j].ToString());
				flag = false;
			}
			valueStringBuilder.Append(")]");
			return valueStringBuilder.ToString();
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		public override bool Equals(object? obj)
		{
			return obj == this;
		}
	}
	public static class CustomAttributeExtensions
	{
		public static Attribute? GetCustomAttribute(this Assembly element, Type attributeType)
		{
			return Attribute.GetCustomAttribute(element, attributeType);
		}

		public static Attribute? GetCustomAttribute(this Module element, Type attributeType)
		{
			return Attribute.GetCustomAttribute(element, attributeType);
		}

		public static Attribute? GetCustomAttribute(this MemberInfo element, Type attributeType)
		{
			return Attribute.GetCustomAttribute(element, attributeType);
		}

		public static Attribute? GetCustomAttribute(this ParameterInfo element, Type attributeType)
		{
			return Attribute.GetCustomAttribute(element, attributeType);
		}

		public static T? GetCustomAttribute<T>(this Assembly element) where T : Attribute
		{
			return (T)element.GetCustomAttribute(typeof(T));
		}

		public static T? GetCustomAttribute<T>(this Module element) where T : Attribute
		{
			return (T)element.GetCustomAttribute(typeof(T));
		}

		public static T? GetCustomAttribute<T>(this MemberInfo element) where T : Attribute
		{
			return (T)element.GetCustomAttribute(typeof(T));
		}

		public static T? GetCustomAttribute<T>(this ParameterInfo element) where T : Attribute
		{
			return (T)element.GetCustomAttribute(typeof(T));
		}

		public static Attribute? GetCustomAttribute(this MemberInfo element, Type attributeType, bool inherit)
		{
			return Attribute.GetCustomAttribute(element, attributeType, inherit);
		}

		public static Attribute? GetCustomAttribute(this ParameterInfo element, Type attributeType, bool inherit)
		{
			return Attribute.GetCustomAttribute(element, attributeType, inherit);
		}

		public static T? GetCustomAttribute<T>(this MemberInfo element, bool inherit) where T : Attribute
		{
			return (T)element.GetCustomAttribute(typeof(T), inherit);
		}

		public static T? GetCustomAttribute<T>(this ParameterInfo element, bool inherit) where T : Attribute
		{
			return (T)element.GetCustomAttribute(typeof(T), inherit);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this Assembly element)
		{
			return Attribute.GetCustomAttributes(element);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this Module element)
		{
			return Attribute.GetCustomAttributes(element);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this MemberInfo element)
		{
			return Attribute.GetCustomAttributes(element);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this ParameterInfo element)
		{
			return Attribute.GetCustomAttributes(element);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this MemberInfo element, bool inherit)
		{
			return Attribute.GetCustomAttributes(element, inherit);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this ParameterInfo element, bool inherit)
		{
			return Attribute.GetCustomAttributes(element, inherit);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this Assembly element, Type attributeType)
		{
			return Attribute.GetCustomAttributes(element, attributeType);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this Module element, Type attributeType)
		{
			return Attribute.GetCustomAttributes(element, attributeType);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this MemberInfo element, Type attributeType)
		{
			return Attribute.GetCustomAttributes(element, attributeType);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this ParameterInfo element, Type attributeType)
		{
			return Attribute.GetCustomAttributes(element, attributeType);
		}

		public static IEnumerable<T> GetCustomAttributes<T>(this Assembly element) where T : Attribute
		{
			return (IEnumerable<T>)element.GetCustomAttributes(typeof(T));
		}

		public static IEnumerable<T> GetCustomAttributes<T>(this Module element) where T : Attribute
		{
			return (IEnumerable<T>)element.GetCustomAttributes(typeof(T));
		}

		public static IEnumerable<T> GetCustomAttributes<T>(this MemberInfo element) where T : Attribute
		{
			return (IEnumerable<T>)element.GetCustomAttributes(typeof(T));
		}

		public static IEnumerable<T> GetCustomAttributes<T>(this ParameterInfo element) where T : Attribute
		{
			return (IEnumerable<T>)element.GetCustomAttributes(typeof(T));
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this MemberInfo element, Type attributeType, bool inherit)
		{
			return Attribute.GetCustomAttributes(element, attributeType, inherit);
		}

		public static IEnumerable<Attribute> GetCustomAttributes(this ParameterInfo element, Type attributeType, bool inherit)
		{
			return Attribute.GetCustomAttributes(element, attributeType, inherit);
		}

		public static IEnumerable<T> GetCustomAttributes<T>(this MemberInfo element, bool inherit) where T : Attribute
		{
			return (IEnumerable<T>)GetCustomAttributes(element, typeof(T), inherit);
		}

		public static IEnumerable<T> GetCustomAttributes<T>(this ParameterInfo element, bool inherit) where T : Attribute
		{
			return (IEnumerable<T>)GetCustomAttributes(element, typeof(T), inherit);
		}

		public static bool IsDefined(this Assembly element, Type attributeType)
		{
			return Attribute.IsDefined(element, attributeType);
		}

		public static bool IsDefined(this Module element, Type attributeType)
		{
			return Attribute.IsDefined(element, attributeType);
		}

		public static bool IsDefined(this MemberInfo element, Type attributeType)
		{
			return Attribute.IsDefined(element, attributeType);
		}

		public static bool IsDefined(this ParameterInfo element, Type attributeType)
		{
			return Attribute.IsDefined(element, attributeType);
		}

		public static bool IsDefined(this MemberInfo element, Type attributeType, bool inherit)
		{
			return Attribute.IsDefined(element, attributeType, inherit);
		}

		public static bool IsDefined(this ParameterInfo element, Type attributeType, bool inherit)
		{
			return Attribute.IsDefined(element, attributeType, inherit);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class CustomAttributeFormatException : FormatException
	{
		public CustomAttributeFormatException()
			: this(SR.Arg_CustomAttributeFormatException)
		{
		}

		public CustomAttributeFormatException(string? message)
			: this(message, null)
		{
		}

		public CustomAttributeFormatException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146232827;
		}

		protected CustomAttributeFormatException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public readonly struct CustomAttributeNamedArgument
	{
		private readonly MemberInfo _memberInfo;

		private readonly CustomAttributeTypedArgument _value;

		internal Type ArgumentType
		{
			get
			{
				if (!(_memberInfo is FieldInfo fieldInfo))
				{
					return ((PropertyInfo)_memberInfo).PropertyType;
				}
				return fieldInfo.FieldType;
			}
		}

		public MemberInfo MemberInfo => _memberInfo;

		public CustomAttributeTypedArgument TypedValue => _value;

		public string MemberName => MemberInfo.Name;

		public bool IsField => MemberInfo is FieldInfo;

		public static bool operator ==(CustomAttributeNamedArgument left, CustomAttributeNamedArgument right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(CustomAttributeNamedArgument left, CustomAttributeNamedArgument right)
		{
			return !left.Equals(right);
		}

		public CustomAttributeNamedArgument(MemberInfo memberInfo, object? value)
		{
			if ((object)memberInfo == null)
			{
				throw new ArgumentNullException("memberInfo");
			}
			Type type;
			if (!(memberInfo is FieldInfo fieldInfo))
			{
				if (!(memberInfo is PropertyInfo propertyInfo))
				{
					throw new ArgumentException(SR.Argument_InvalidMemberForNamedArgument);
				}
				type = propertyInfo.PropertyType;
			}
			else
			{
				type = fieldInfo.FieldType;
			}
			Type argumentType = type;
			_memberInfo = memberInfo;
			_value = new CustomAttributeTypedArgument(argumentType, value);
		}

		public CustomAttributeNamedArgument(MemberInfo memberInfo, CustomAttributeTypedArgument typedArgument)
		{
			_memberInfo = memberInfo ?? throw new ArgumentNullException("memberInfo");
			_value = typedArgument;
		}

		public override string ToString()
		{
			if ((object)_memberInfo == null)
			{
				return base.ToString();
			}
			return MemberInfo.Name + " = " + TypedValue.ToString(ArgumentType != typeof(object));
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		public override bool Equals(object? obj)
		{
			return obj == (object)this;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
	public sealed class DefaultMemberAttribute : Attribute
	{
		public string MemberName { get; }

		public DefaultMemberAttribute(string memberName)
		{
			MemberName = memberName;
		}
	}
	[Flags]
	public enum EventAttributes
	{
		None = 0,
		SpecialName = 0x200,
		RTSpecialName = 0x400,
		ReservedMask = 0x400
	}
	public abstract class EventInfo : MemberInfo
	{
		public override MemberTypes MemberType => MemberTypes.Event;

		public abstract EventAttributes Attributes { get; }

		public bool IsSpecialName => (Attributes & EventAttributes.SpecialName) != 0;

		public virtual MethodInfo? AddMethod => GetAddMethod(nonPublic: true);

		public virtual MethodInfo? RemoveMethod => GetRemoveMethod(nonPublic: true);

		public virtual MethodInfo? RaiseMethod => GetRaiseMethod(nonPublic: true);

		public virtual bool IsMulticast
		{
			get
			{
				Type eventHandlerType = EventHandlerType;
				Type typeFromHandle = typeof(MulticastDelegate);
				return typeFromHandle.IsAssignableFrom(eventHandlerType);
			}
		}

		public virtual Type? EventHandlerType
		{
			get
			{
				MethodInfo addMethod = GetAddMethod(nonPublic: true);
				ParameterInfo[] parametersNoCopy = addMethod.GetParametersNoCopy();
				Type typeFromHandle = typeof(Delegate);
				for (int i = 0; i < parametersNoCopy.Length; i++)
				{
					Type parameterType = parametersNoCopy[i].ParameterType;
					if (parameterType.IsSubclassOf(typeFromHandle))
					{
						return parameterType;
					}
				}
				return null;
			}
		}

		public MethodInfo[] GetOtherMethods()
		{
			return GetOtherMethods(nonPublic: false);
		}

		public virtual MethodInfo[] GetOtherMethods(bool nonPublic)
		{
			throw NotImplemented.ByDesign;
		}

		public MethodInfo? GetAddMethod()
		{
			return GetAddMethod(nonPublic: false);
		}

		public MethodInfo? GetRemoveMethod()
		{
			return GetRemoveMethod(nonPublic: false);
		}

		public MethodInfo? GetRaiseMethod()
		{
			return GetRaiseMethod(nonPublic: false);
		}

		public abstract MethodInfo? GetAddMethod(bool nonPublic);

		public abstract MethodInfo? GetRemoveMethod(bool nonPublic);

		public abstract MethodInfo? GetRaiseMethod(bool nonPublic);

		[DebuggerHidden]
		[DebuggerStepThrough]
		public virtual void AddEventHandler(object? target, Delegate? handler)
		{
			MethodInfo addMethod = GetAddMethod(nonPublic: false);
			if (addMethod == null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NoPublicAddMethod);
			}
			addMethod.Invoke(target, new object[1] { handler });
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public virtual void RemoveEventHandler(object? target, Delegate? handler)
		{
			MethodInfo removeMethod = GetRemoveMethod(nonPublic: false);
			if (removeMethod == null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NoPublicRemoveMethod);
			}
			removeMethod.Invoke(target, new object[1] { handler });
		}

		public override bool Equals(object? obj)
		{
			return base.Equals(obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(EventInfo? left, EventInfo? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(EventInfo? left, EventInfo? right)
		{
			return !(left == right);
		}
	}
	public class ExceptionHandlingClause
	{
		public virtual ExceptionHandlingClauseOptions Flags => ExceptionHandlingClauseOptions.Clause;

		public virtual int TryOffset => 0;

		public virtual int TryLength => 0;

		public virtual int HandlerOffset => 0;

		public virtual int HandlerLength => 0;

		public virtual int FilterOffset
		{
			get
			{
				throw new InvalidOperationException(SR.Arg_EHClauseNotFilter);
			}
		}

		public virtual Type? CatchType => null;

		protected ExceptionHandlingClause()
		{
		}

		public override string ToString()
		{
			return $"Flags={Flags}, TryOffset={TryOffset}, TryLength={TryLength}, HandlerOffset={HandlerOffset}, HandlerLength={HandlerLength}, CatchType={CatchType}";
		}
	}
	[Flags]
	public enum ExceptionHandlingClauseOptions
	{
		Clause = 0,
		Filter = 1,
		Finally = 2,
		Fault = 4
	}
	[Flags]
	public enum FieldAttributes
	{
		FieldAccessMask = 7,
		PrivateScope = 0,
		Private = 1,
		FamANDAssem = 2,
		Assembly = 3,
		Family = 4,
		FamORAssem = 5,
		Public = 6,
		Static = 0x10,
		InitOnly = 0x20,
		Literal = 0x40,
		NotSerialized = 0x80,
		SpecialName = 0x200,
		PinvokeImpl = 0x2000,
		RTSpecialName = 0x400,
		HasFieldMarshal = 0x1000,
		HasDefault = 0x8000,
		HasFieldRVA = 0x100,
		ReservedMask = 0x9500
	}
	[Flags]
	public enum GenericParameterAttributes
	{
		None = 0,
		VarianceMask = 3,
		Covariant = 1,
		Contravariant = 2,
		SpecialConstraintMask = 0x1C,
		ReferenceTypeConstraint = 4,
		NotNullableValueTypeConstraint = 8,
		DefaultConstructorConstraint = 0x10
	}
	public interface ICustomAttributeProvider
	{
		object[] GetCustomAttributes(bool inherit);

		object[] GetCustomAttributes(Type attributeType, bool inherit);

		bool IsDefined(Type attributeType, bool inherit);
	}
	public enum ImageFileMachine
	{
		I386 = 332,
		IA64 = 512,
		AMD64 = 34404,
		ARM = 452
	}
	public struct InterfaceMapping
	{
		public Type TargetType;

		public Type InterfaceType;

		public MethodInfo[] TargetMethods;

		public MethodInfo[] InterfaceMethods;
	}
	public static class IntrospectionExtensions
	{
		public static TypeInfo GetTypeInfo(this Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (type is IReflectableType reflectableType)
			{
				return reflectableType.GetTypeInfo();
			}
			return new TypeDelegator(type);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class InvalidFilterCriteriaException : ApplicationException
	{
		public InvalidFilterCriteriaException()
			: this(SR.Arg_InvalidFilterCriteriaException)
		{
		}

		public InvalidFilterCriteriaException(string? message)
			: this(message, null)
		{
		}

		public InvalidFilterCriteriaException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146232831;
		}

		protected InvalidFilterCriteriaException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public interface IReflect
	{
		Type UnderlyingSystemType { get; }

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		MethodInfo? GetMethod(string name, BindingFlags bindingAttr, Binder? binder, Type[] types, ParameterModifier[]? modifiers);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		MethodInfo? GetMethod(string name, BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		MethodInfo[] GetMethods(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		FieldInfo? GetField(string name, BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		FieldInfo[] GetFields(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		PropertyInfo? GetProperty(string name, BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		PropertyInfo? GetProperty(string name, BindingFlags bindingAttr, Binder? binder, Type? returnType, Type[] types, ParameterModifier[]? modifiers);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		PropertyInfo[] GetProperties(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		MemberInfo[] GetMember(string name, BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		MemberInfo[] GetMembers(BindingFlags bindingAttr);

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		object? InvokeMember(string name, BindingFlags invokeAttr, Binder? binder, object? target, object?[]? args, ParameterModifier[]? modifiers, CultureInfo? culture, string[]? namedParameters);
	}
	public interface IReflectableType
	{
		TypeInfo GetTypeInfo();
	}
	public class LocalVariableInfo
	{
		public virtual Type LocalType => null;

		public virtual int LocalIndex => 0;

		public virtual bool IsPinned => false;

		protected LocalVariableInfo()
		{
		}

		public override string ToString()
		{
			if (IsPinned)
			{
				return $"{LocalType} ({LocalIndex}) (pinned)";
			}
			return $"{LocalType} ({LocalIndex})";
		}
	}
	public class ManifestResourceInfo
	{
		public virtual Assembly? ReferencedAssembly { get; }

		public virtual string? FileName { get; }

		public virtual ResourceLocation ResourceLocation { get; }

		public ManifestResourceInfo(Assembly? containingAssembly, string? containingFileName, ResourceLocation resourceLocation)
		{
			ReferencedAssembly = containingAssembly;
			FileName = containingFileName;
			ResourceLocation = resourceLocation;
		}
	}
	public delegate bool MemberFilter(MemberInfo m, object? filterCriteria);
	[Flags]
	public enum MemberTypes
	{
		Constructor = 1,
		Event = 2,
		Field = 4,
		Method = 8,
		Property = 0x10,
		TypeInfo = 0x20,
		Custom = 0x40,
		NestedType = 0x80,
		All = 0xBF
	}
	[Flags]
	public enum MethodAttributes
	{
		MemberAccessMask = 7,
		PrivateScope = 0,
		Private = 1,
		FamANDAssem = 2,
		Assembly = 3,
		Family = 4,
		FamORAssem = 5,
		Public = 6,
		Static = 0x10,
		Final = 0x20,
		Virtual = 0x40,
		HideBySig = 0x80,
		CheckAccessOnOverride = 0x200,
		VtableLayoutMask = 0x100,
		ReuseSlot = 0,
		NewSlot = 0x100,
		Abstract = 0x400,
		SpecialName = 0x800,
		PinvokeImpl = 0x2000,
		UnmanagedExport = 8,
		RTSpecialName = 0x1000,
		HasSecurity = 0x4000,
		RequireSecObject = 0x8000,
		ReservedMask = 0xD000
	}
	public class MethodBody
	{
		public virtual int LocalSignatureMetadataToken => 0;

		public virtual IList<LocalVariableInfo> LocalVariables
		{
			get
			{
				throw new ArgumentNullException("array");
			}
		}

		public virtual int MaxStackSize => 0;

		public virtual bool InitLocals => false;

		public virtual IList<ExceptionHandlingClause> ExceptionHandlingClauses
		{
			get
			{
				throw new ArgumentNullException("array");
			}
		}

		protected MethodBody()
		{
		}

		public virtual byte[]? GetILAsByteArray()
		{
			return null;
		}
	}
	public enum MethodImplAttributes
	{
		CodeTypeMask = 3,
		IL = 0,
		Native = 1,
		OPTIL = 2,
		Runtime = 3,
		ManagedMask = 4,
		Unmanaged = 4,
		Managed = 0,
		ForwardRef = 16,
		PreserveSig = 128,
		InternalCall = 4096,
		Synchronized = 32,
		NoInlining = 8,
		AggressiveInlining = 256,
		NoOptimization = 64,
		AggressiveOptimization = 512,
		MaxMethodImplVal = 65535
	}
	public abstract class MethodInfo : MethodBase
	{
		public override MemberTypes MemberType => MemberTypes.Method;

		public virtual ParameterInfo ReturnParameter
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual Type ReturnType
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public abstract ICustomAttributeProvider ReturnTypeCustomAttributes { get; }

		internal virtual int GenericParameterCount => GetGenericArguments().Length;

		public override Type[] GetGenericArguments()
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public virtual MethodInfo GetGenericMethodDefinition()
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public virtual MethodInfo MakeGenericMethod(params Type[] typeArguments)
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public abstract MethodInfo GetBaseDefinition();

		public virtual Delegate CreateDelegate(Type delegateType)
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public virtual Delegate CreateDelegate(Type delegateType, object? target)
		{
			throw new NotSupportedException(SR.NotSupported_SubclassOverride);
		}

		public T CreateDelegate<T>() where T : Delegate
		{
			return (T)CreateDelegate(typeof(T));
		}

		public T CreateDelegate<T>(object? target) where T : Delegate
		{
			return (T)CreateDelegate(typeof(T), target);
		}

		public override bool Equals(object? obj)
		{
			return base.Equals(obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(MethodInfo? left, MethodInfo? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(MethodInfo? left, MethodInfo? right)
		{
			return !(left == right);
		}
	}
	public sealed class Missing : ISerializable
	{
		public static readonly Missing Value = new Missing();

		private Missing()
		{
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}
	}
	public abstract class Module : ICustomAttributeProvider, ISerializable
	{
		public static readonly TypeFilter FilterTypeName = (Type m, object c) => FilterTypeNameImpl(m, c, StringComparison.Ordinal);

		public static readonly TypeFilter FilterTypeNameIgnoreCase = (Type m, object c) => FilterTypeNameImpl(m, c, StringComparison.OrdinalIgnoreCase);

		public virtual Assembly Assembly
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		[RequiresAssemblyFiles("Returns <Unknown> for modules with no file path")]
		public virtual string FullyQualifiedName
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		[RequiresAssemblyFiles("Returns <Unknown> for modules with no file path")]
		public virtual string Name
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual int MDStreamVersion
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual Guid ModuleVersionId
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual string ScopeName
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public ModuleHandle ModuleHandle => GetModuleHandleImpl();

		public virtual IEnumerable<CustomAttributeData> CustomAttributes => GetCustomAttributesData();

		public virtual int MetadataToken
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		protected virtual ModuleHandle GetModuleHandleImpl()
		{
			return ModuleHandle.EmptyHandle;
		}

		public virtual void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual bool IsResource()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual bool IsDefined(Type attributeType, bool inherit)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual IList<CustomAttributeData> GetCustomAttributesData()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual object[] GetCustomAttributes(bool inherit)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		public MethodInfo? GetMethod(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			return GetMethodImpl(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, CallingConventions.Any, null, null);
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		public MethodInfo? GetMethod(string name, Type[] types)
		{
			return GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, CallingConventions.Any, types, null);
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		public MethodInfo? GetMethod(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (types == null)
			{
				throw new ArgumentNullException("types");
			}
			for (int i = 0; i < types.Length; i++)
			{
				if (types[i] == null)
				{
					throw new ArgumentNullException("types");
				}
			}
			return GetMethodImpl(name, bindingAttr, binder, callConvention, types, modifiers);
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		protected virtual MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		public MethodInfo[] GetMethods()
		{
			return GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		public virtual MethodInfo[] GetMethods(BindingFlags bindingFlags)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Fields might be removed")]
		public FieldInfo? GetField(string name)
		{
			return GetField(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[RequiresUnreferencedCode("Fields might be removed")]
		public virtual FieldInfo? GetField(string name, BindingFlags bindingAttr)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Fields might be removed")]
		public FieldInfo[] GetFields()
		{
			return GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
		}

		[RequiresUnreferencedCode("Fields might be removed")]
		public virtual FieldInfo[] GetFields(BindingFlags bindingFlags)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type[] GetTypes()
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type? GetType(string className)
		{
			return GetType(className, throwOnError: false, ignoreCase: false);
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type? GetType(string className, bool ignoreCase)
		{
			return GetType(className, throwOnError: false, ignoreCase);
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type? GetType(string className, bool throwOnError, bool ignoreCase)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public virtual Type[] FindTypes(TypeFilter? filter, object? filterCriteria)
		{
			Type[] types = GetTypes();
			int num = 0;
			for (int i = 0; i < types.Length; i++)
			{
				if (filter != null && !filter(types[i], filterCriteria))
				{
					types[i] = null;
				}
				else
				{
					num++;
				}
			}
			if (num == types.Length)
			{
				return types;
			}
			Type[] array = new Type[num];
			num = 0;
			for (int j = 0; j < types.Length; j++)
			{
				if (types[j] != null)
				{
					array[num++] = types[j];
				}
			}
			return array;
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public FieldInfo? ResolveField(int metadataToken)
		{
			return ResolveField(metadataToken, null, null);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public virtual FieldInfo? ResolveField(int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public MemberInfo? ResolveMember(int metadataToken)
		{
			return ResolveMember(metadataToken, null, null);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public virtual MemberInfo? ResolveMember(int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public MethodBase? ResolveMethod(int metadataToken)
		{
			return ResolveMethod(metadataToken, null, null);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public virtual MethodBase? ResolveMethod(int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public virtual byte[] ResolveSignature(int metadataToken)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public virtual string ResolveString(int metadataToken)
		{
			throw NotImplemented.ByDesign;
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public Type ResolveType(int metadataToken)
		{
			return ResolveType(metadataToken, null, null);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public virtual Type ResolveType(int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments)
		{
			throw NotImplemented.ByDesign;
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw NotImplemented.ByDesign;
		}

		public override bool Equals(object? o)
		{
			return base.Equals(o);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(Module? left, Module? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(Module? left, Module? right)
		{
			return !(left == right);
		}

		public override string ToString()
		{
			return ScopeName;
		}

		private static bool FilterTypeNameImpl(Type cls, object filterCriteria, StringComparison comparison)
		{
			if (!(filterCriteria is string text))
			{
				throw new InvalidFilterCriteriaException(SR.InvalidFilterCriteriaException_CritString);
			}
			if (text.Length > 0 && text[^1] == '*')
			{
				ReadOnlySpan<char> value = text.AsSpan(0, text.Length - 1);
				return cls.Name.AsSpan().StartsWith(value, comparison);
			}
			return cls.Name.Equals(text, comparison);
		}
	}
	public delegate Module ModuleResolveEventHandler(object sender, ResolveEventArgs e);
	public sealed class NullabilityInfo
	{
		public Type Type { get; }

		public NullabilityState ReadState { get; internal set; }

		public NullabilityState WriteState { get; internal set; }

		public NullabilityInfo? ElementType { get; }

		public NullabilityInfo[] GenericTypeArguments { get; }

		internal NullabilityInfo(Type type, NullabilityState readState, NullabilityState writeState, NullabilityInfo elementType, NullabilityInfo[] typeArguments)
		{
			Type = type;
			ReadState = readState;
			WriteState = writeState;
			ElementType = elementType;
			GenericTypeArguments = typeArguments;
		}
	}
	public enum NullabilityState
	{
		Unknown,
		NotNull,
		Nullable
	}
	public sealed class NullabilityInfoContext
	{
		[Flags]
		private enum NotAnnotatedStatus
		{
			None = 0,
			Private = 1,
			Internal = 2
		}

		private readonly Dictionary<Module, NotAnnotatedStatus> _publicOnlyModules = new Dictionary<Module, NotAnnotatedStatus>();

		private readonly Dictionary<MemberInfo, NullabilityState> _context = new Dictionary<MemberInfo, NullabilityState>();

		internal static bool IsSupported { get; } = !AppContext.TryGetSwitch("System.Reflection.NullabilityInfoContext.IsSupported", out var isEnabled) || isEnabled;


		private NullabilityState GetNullableContext(MemberInfo memberInfo)
		{
			while (memberInfo != null)
			{
				if (_context.TryGetValue(memberInfo, out var value))
				{
					return value;
				}
				foreach (CustomAttributeData customAttributesDatum in memberInfo.GetCustomAttributesData())
				{
					if (customAttributesDatum.AttributeType.Name == "NullableContextAttribute" && customAttributesDatum.AttributeType.Namespace == "System.Runtime.CompilerServices" && customAttributesDatum.ConstructorArguments.Count == 1)
					{
						value = TranslateByte(customAttributesDatum.ConstructorArguments[0].Value);
						_context.Add(memberInfo, value);
						return value;
					}
				}
				memberInfo = memberInfo.DeclaringType;
			}
			return NullabilityState.Unknown;
		}

		public NullabilityInfo Create(ParameterInfo parameterInfo)
		{
			if (parameterInfo == null)
			{
				throw new ArgumentNullException("parameterInfo");
			}
			EnsureIsSupported();
			if (parameterInfo.Member is MethodInfo method && IsPrivateOrInternalMethodAndAnnotationDisabled(method))
			{
				return new NullabilityInfo(parameterInfo.ParameterType, NullabilityState.Unknown, NullabilityState.Unknown, null, Array.Empty<NullabilityInfo>());
			}
			IList<CustomAttributeData> customAttributesData = parameterInfo.GetCustomAttributesData();
			NullabilityInfo nullabilityInfo = GetNullabilityInfo(parameterInfo.Member, parameterInfo.ParameterType, customAttributesData);
			if (nullabilityInfo.ReadState != 0)
			{
				CheckParameterMetadataType(parameterInfo, nullabilityInfo);
			}
			CheckNullabilityAttributes(nullabilityInfo, customAttributesData);
			return nullabilityInfo;
		}

		private void CheckParameterMetadataType(ParameterInfo parameter, NullabilityInfo nullability)
		{
			if (!(parameter.Member is MethodInfo method))
			{
				return;
			}
			MethodInfo methodMetadataDefinition = GetMethodMetadataDefinition(method);
			ParameterInfo parameterInfo = null;
			if (string.IsNullOrEmpty(parameter.Name))
			{
				parameterInfo = methodMetadataDefinition.ReturnParameter;
			}
			else
			{
				ParameterInfo[] parameters = methodMetadataDefinition.GetParameters();
				for (int i = 0; i < parameters.Length; i++)
				{
					if (parameter.Position == i && parameter.Name == parameters[i].Name)
					{
						parameterInfo = parameters[i];
						break;
					}
				}
			}
			if (parameterInfo != null)
			{
				CheckGenericParameters(nullability, methodMetadataDefinition, parameterInfo.ParameterType);
			}
		}

		private static MethodInfo GetMethodMetadataDefinition(MethodInfo method)
		{
			if (method.IsGenericMethod && !method.IsGenericMethodDefinition)
			{
				method = method.GetGenericMethodDefinition();
			}
			return (MethodInfo)GetMemberMetadataDefinition(method);
		}

		private void CheckNullabilityAttributes(NullabilityInfo nullability, IList<CustomAttributeData> attributes)
		{
			foreach (CustomAttributeData attribute in attributes)
			{
				if (attribute.AttributeType.Namespace == "System.Diagnostics.CodeAnalysis")
				{
					if (attribute.AttributeType.Name == "NotNullAttribute" && nullability.ReadState == NullabilityState.Nullable)
					{
						nullability.ReadState = NullabilityState.NotNull;
						break;
					}
					if ((attribute.AttributeType.Name == "MaybeNullAttribute" || attribute.AttributeType.Name == "MaybeNullWhenAttribute") && nullability.ReadState == NullabilityState.NotNull && !nullability.Type.IsValueType)
					{
						nullability.ReadState = NullabilityState.Nullable;
						break;
					}
					if (attribute.AttributeType.Name == "DisallowNullAttribute" && nullability.WriteState == NullabilityState.Nullable)
					{
						nullability.WriteState = NullabilityState.NotNull;
						break;
					}
					if (attribute.AttributeType.Name == "AllowNullAttribute" && nullability.WriteState == NullabilityState.NotNull && !nullability.Type.IsValueType)
					{
						nullability.WriteState = NullabilityState.Nullable;
						break;
					}
				}
			}
		}

		public NullabilityInfo Create(PropertyInfo propertyInfo)
		{
			if ((object)propertyInfo == null)
			{
				throw new ArgumentNullException("propertyInfo");
			}
			EnsureIsSupported();
			NullabilityInfo nullabilityInfo = GetNullabilityInfo(propertyInfo, propertyInfo.PropertyType, propertyInfo.GetCustomAttributesData());
			MethodInfo getMethod = propertyInfo.GetGetMethod(nonPublic: true);
			MethodInfo setMethod = propertyInfo.GetSetMethod(nonPublic: true);
			if (getMethod != null)
			{
				if (IsPrivateOrInternalMethodAndAnnotationDisabled(getMethod))
				{
					nullabilityInfo.ReadState = NullabilityState.Unknown;
				}
				CheckNullabilityAttributes(nullabilityInfo, getMethod.ReturnParameter.GetCustomAttributesData());
			}
			else
			{
				nullabilityInfo.ReadState = NullabilityState.Unknown;
			}
			if (setMethod != null)
			{
				if (IsPrivateOrInternalMethodAndAnnotationDisabled(setMethod))
				{
					nullabilityInfo.WriteState = NullabilityState.Unknown;
				}
				CheckNullabilityAttributes(nullabilityInfo, setMethod.GetParameters()[0].GetCustomAttributesData());
			}
			else
			{
				nullabilityInfo.WriteState = NullabilityState.Unknown;
			}
			return nullabilityInfo;
		}

		private bool IsPrivateOrInternalMethodAndAnnotationDisabled(MethodInfo method)
		{
			if ((method.IsPrivate || method.IsFamilyAndAssembly || method.IsAssembly) && IsPublicOnly(method.IsPrivate, method.IsFamilyAndAssembly, method.IsAssembly, method.Module))
			{
				return true;
			}
			return false;
		}

		public NullabilityInfo Create(EventInfo eventInfo)
		{
			if ((object)eventInfo == null)
			{
				throw new ArgumentNullException("eventInfo");
			}
			EnsureIsSupported();
			return GetNullabilityInfo(eventInfo, eventInfo.EventHandlerType, eventInfo.GetCustomAttributesData());
		}

		public NullabilityInfo Create(FieldInfo fieldInfo)
		{
			if ((object)fieldInfo == null)
			{
				throw new ArgumentNullException("fieldInfo");
			}
			EnsureIsSupported();
			if (IsPrivateOrInternalFieldAndAnnotationDisabled(fieldInfo))
			{
				return new NullabilityInfo(fieldInfo.FieldType, NullabilityState.Unknown, NullabilityState.Unknown, null, Array.Empty<NullabilityInfo>());
			}
			IList<CustomAttributeData> customAttributesData = fieldInfo.GetCustomAttributesData();
			NullabilityInfo nullabilityInfo = GetNullabilityInfo(fieldInfo, fieldInfo.FieldType, customAttributesData);
			CheckNullabilityAttributes(nullabilityInfo, customAttributesData);
			return nullabilityInfo;
		}

		private static void EnsureIsSupported()
		{
			if (!IsSupported)
			{
				throw new InvalidOperationException(SR.NullabilityInfoContext_NotSupported);
			}
		}

		private bool IsPrivateOrInternalFieldAndAnnotationDisabled(FieldInfo fieldInfo)
		{
			if ((fieldInfo.IsPrivate || fieldInfo.IsFamilyAndAssembly || fieldInfo.IsAssembly) && IsPublicOnly(fieldInfo.IsPrivate, fieldInfo.IsFamilyAndAssembly, fieldInfo.IsAssembly, fieldInfo.Module))
			{
				return true;
			}
			return false;
		}

		private bool IsPublicOnly(bool isPrivate, bool isFamilyAndAssembly, bool isAssembly, Module module)
		{
			if (!_publicOnlyModules.TryGetValue(module, out var value))
			{
				value = PopulateAnnotationInfo(module.GetCustomAttributesData());
				_publicOnlyModules.Add(module, value);
			}
			if (value == NotAnnotatedStatus.None)
			{
				return false;
			}
			if (((isPrivate || isFamilyAndAssembly) && value.HasFlag(NotAnnotatedStatus.Private)) || (isAssembly && value.HasFlag(NotAnnotatedStatus.Internal)))
			{
				return true;
			}
			return false;
		}

		private NotAnnotatedStatus PopulateAnnotationInfo(IList<CustomAttributeData> customAttributes)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out bool flag);
			foreach (CustomAttributeData customAttribute in customAttributes)
			{
				if (customAttribute.AttributeType.Name == "NullablePublicOnlyAttribute" && customAttribute.AttributeType.Namespace == "System.Runtime.CompilerServices" && customAttribute.ConstructorArguments.Count == 1)
				{
					object value = customAttribute.ConstructorArguments[0].Value;
					int num;
					if (value is bool)
					{
						flag = (bool)value;
						num = 1;
					}
					else
					{
						num = 0;
					}
					if (((uint)num & (flag ? 1u : 0u)) != 0)
					{
						return NotAnnotatedStatus.Private | NotAnnotatedStatus.Internal;
					}
					return NotAnnotatedStatus.Private;
				}
			}
			return NotAnnotatedStatus.None;
		}

		private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, IList<CustomAttributeData> customAttributes)
		{
			return GetNullabilityInfo(memberInfo, type, customAttributes, 0);
		}

		private NullabilityInfo GetNullabilityInfo(MemberInfo memberInfo, Type type, IList<CustomAttributeData> customAttributes, int index)
		{
			NullabilityState state = NullabilityState.Unknown;
			NullabilityInfo elementType = null;
			NullabilityInfo[] array = Array.Empty<NullabilityInfo>();
			Type type2 = type;
			if (type.IsValueType)
			{
				type2 = Nullable.GetUnderlyingType(type);
				if (type2 != null)
				{
					state = NullabilityState.Nullable;
				}
				else
				{
					type2 = type;
					state = NullabilityState.NotNull;
				}
			}
			else
			{
				if (!ParseNullableState(customAttributes, index, ref state))
				{
					state = GetNullableContext(memberInfo);
				}
				if (type.IsArray)
				{
					elementType = GetNullabilityInfo(memberInfo, type.GetElementType(), customAttributes, index + 1);
				}
			}
			if (type2.IsGenericType)
			{
				Type[] genericArguments = type2.GetGenericArguments();
				array = new NullabilityInfo[genericArguments.Length];
				int i = 0;
				int num = 0;
				for (; i < genericArguments.Length; i++)
				{
					Type type3 = Nullable.GetUnderlyingType(genericArguments[i]) ?? genericArguments[i];
					if (!type3.IsValueType || type3.IsGenericType)
					{
						num++;
					}
					array[i] = GetNullabilityInfo(memberInfo, genericArguments[i], customAttributes, index + num);
				}
			}
			NullabilityInfo nullabilityInfo = new NullabilityInfo(type, state, state, elementType, array);
			if (!type.IsValueType && state != 0)
			{
				TryLoadGenericMetaTypeNullability(memberInfo, nullabilityInfo);
			}
			return nullabilityInfo;
		}

		private static bool ParseNullableState(IList<CustomAttributeData> customAttributes, int index, ref NullabilityState state)
		{
			foreach (CustomAttributeData customAttribute in customAttributes)
			{
				if (customAttribute.AttributeType.Name == "NullableAttribute" && customAttribute.AttributeType.Namespace == "System.Runtime.CompilerServices" && customAttribute.ConstructorArguments.Count == 1)
				{
					object value = customAttribute.ConstructorArguments[0].Value;
					if (value is byte b)
					{
						state = TranslateByte(b);
						return true;
					}
					if (value is ReadOnlyCollection<CustomAttributeTypedArgument> readOnlyCollection && index < readOnlyCollection.Count)
					{
						object value2 = readOnlyCollection[index].Value;
						if (value2 is byte)
						{
							byte b2 = (byte)value2;
							state = TranslateByte(b2);
							return true;
						}
						break;
					}
					break;
				}
			}
			return false;
		}

		private void TryLoadGenericMetaTypeNullability(MemberInfo memberInfo, NullabilityInfo nullability)
		{
			MemberInfo memberMetadataDefinition = GetMemberMetadataDefinition(memberInfo);
			Type type = null;
			if (memberMetadataDefinition is FieldInfo fieldInfo)
			{
				type = fieldInfo.FieldType;
			}
			else if (memberMetadataDefinition is PropertyInfo property)
			{
				type = GetPropertyMetaType(property);
			}
			if (type != null)
			{
				CheckGenericParameters(nullability, memberMetadataDefinition, type);
			}
		}

		private static MemberInfo GetMemberMetadataDefinition(MemberInfo member)
		{
			Type declaringType = member.DeclaringType;
			if (declaringType != null && declaringType.IsGenericType && !declaringType.IsGenericTypeDefinition)
			{
				return declaringType.GetGenericTypeDefinition().GetMemberWithSameMetadataDefinitionAs(member);
			}
			return member;
		}

		private static Type GetPropertyMetaType(PropertyInfo property)
		{
			MethodInfo getMethod = property.GetGetMethod(nonPublic: true);
			if ((object)getMethod != null)
			{
				return getMethod.ReturnType;
			}
			return property.GetSetMethod(nonPublic: true).GetParameters()[0].ParameterType;
		}

		private void CheckGenericParameters(NullabilityInfo nullability, MemberInfo metaMember, Type metaType)
		{
			if (metaType.IsGenericParameter)
			{
				NullabilityState state = nullability.ReadState;
				if (state == NullabilityState.NotNull && !ParseNullableState(metaType.GetCustomAttributesData(), 0, ref state))
				{
					state = GetNullableContext(metaType);
				}
				nullability.ReadState = state;
				nullability.WriteState = state;
			}
			else
			{
				if (!metaType.ContainsGenericParameters)
				{
					return;
				}
				if (nullability.GenericTypeArguments.Length != 0)
				{
					Type[] genericArguments = metaType.GetGenericArguments();
					for (int i = 0; i < genericArguments.Length; i++)
					{
						if (genericArguments[i].IsGenericParameter)
						{
							NullabilityInfo nullabilityInfo = GetNullabilityInfo(metaMember, genericArguments[i], genericArguments[i].GetCustomAttributesData(), i + 1);
							nullability.GenericTypeArguments[i].ReadState = nullabilityInfo.ReadState;
							nullability.GenericTypeArguments[i].WriteState = nullabilityInfo.WriteState;
						}
						else
						{
							UpdateGenericArrayElements(nullability.GenericTypeArguments[i].ElementType, metaMember, genericArguments[i]);
						}
					}
				}
				else
				{
					UpdateGenericArrayElements(nullability.ElementType, metaMember, metaType);
				}
			}
		}

		private void UpdateGenericArrayElements(NullabilityInfo elementState, MemberInfo metaMember, Type metaType)
		{
			if (metaType.IsArray && elementState != null && metaType.GetElementType().IsGenericParameter)
			{
				Type elementType = metaType.GetElementType();
				NullabilityInfo nullabilityInfo = GetNullabilityInfo(metaMember, elementType, elementType.GetCustomAttributesData(), 0);
				elementState.ReadState = nullabilityInfo.ReadState;
				elementState.WriteState = nullabilityInfo.WriteState;
			}
		}

		private static NullabilityState TranslateByte(object value)
		{
			if (!(value is byte b))
			{
				return NullabilityState.Unknown;
			}
			return TranslateByte(b);
		}

		private static NullabilityState TranslateByte(byte b)
		{
			return b switch
			{
				1 => NullabilityState.NotNull, 
				2 => NullabilityState.Nullable, 
				_ => NullabilityState.Unknown, 
			};
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	public sealed class ObfuscateAssemblyAttribute : Attribute
	{
		public bool AssemblyIsPrivate { get; }

		public bool StripAfterObfuscation { get; set; } = true;


		public ObfuscateAssemblyAttribute(bool assemblyIsPrivate)
		{
			AssemblyIsPrivate = assemblyIsPrivate;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.Delegate, AllowMultiple = true, Inherited = false)]
	public sealed class ObfuscationAttribute : Attribute
	{
		public bool StripAfterObfuscation { get; set; } = true;


		public bool Exclude { get; set; } = true;


		public bool ApplyToMembers { get; set; } = true;


		public string? Feature { get; set; } = "all";

	}
	[Flags]
	public enum ParameterAttributes
	{
		None = 0,
		In = 1,
		Out = 2,
		Lcid = 4,
		Retval = 8,
		Optional = 0x10,
		HasDefault = 0x1000,
		HasFieldMarshal = 0x2000,
		Reserved3 = 0x4000,
		Reserved4 = 0x8000,
		ReservedMask = 0xF000
	}
	public class ParameterInfo : ICustomAttributeProvider, IObjectReference
	{
		protected ParameterAttributes AttrsImpl;

		protected Type? ClassImpl;

		protected object? DefaultValueImpl;

		protected MemberInfo MemberImpl;

		protected string? NameImpl;

		protected int PositionImpl;

		public virtual ParameterAttributes Attributes => AttrsImpl;

		public virtual MemberInfo Member => MemberImpl;

		public virtual string? Name => NameImpl;

		public virtual Type ParameterType => ClassImpl;

		public virtual int Position => PositionImpl;

		public bool IsIn => (Attributes & ParameterAttributes.In) != 0;

		public bool IsLcid => (Attributes & ParameterAttributes.Lcid) != 0;

		public bool IsOptional => (Attributes & ParameterAttributes.Optional) != 0;

		public bool IsOut => (Attributes & ParameterAttributes.Out) != 0;

		public bool IsRetval => (Attributes & ParameterAttributes.Retval) != 0;

		public virtual object? DefaultValue
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual object? RawDefaultValue
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual bool HasDefaultValue
		{
			get
			{
				throw NotImplemented.ByDesign;
			}
		}

		public virtual IEnumerable<CustomAttributeData> CustomAttributes => GetCustomAttributesData();

		public virtual int MetadataToken => 134217728;

		protected ParameterInfo()
		{
		}

		public virtual bool IsDefined(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			return false;
		}

		public virtual IList<CustomAttributeData> GetCustomAttributesData()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual object[] GetCustomAttributes(bool inherit)
		{
			return Array.Empty<object>();
		}

		public virtual object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			return Array.Empty<object>();
		}

		public virtual Type[] GetOptionalCustomModifiers()
		{
			return Type.EmptyTypes;
		}

		public virtual Type[] GetRequiredCustomModifiers()
		{
			return Type.EmptyTypes;
		}

		public object GetRealObject(StreamingContext context)
		{
			if (MemberImpl == null)
			{
				throw new SerializationException(SR.Serialization_InsufficientState);
			}
			switch (MemberImpl.MemberType)
			{
			case MemberTypes.Constructor:
			case MemberTypes.Method:
			{
				if (PositionImpl == -1)
				{
					if (MemberImpl.MemberType == MemberTypes.Method)
					{
						return ((MethodInfo)MemberImpl).ReturnParameter;
					}
					throw new SerializationException(SR.Serialization_BadParameterInfo);
				}
				ParameterInfo[] indexParameters = ((MethodBase)MemberImpl).GetParametersNoCopy();
				if (indexParameters != null && PositionImpl < indexParameters.Length)
				{
					return indexParameters[PositionImpl];
				}
				throw new SerializationException(SR.Serialization_BadParameterInfo);
			}
			case MemberTypes.Property:
			{
				ParameterInfo[] indexParameters = ((PropertyInfo)MemberImpl).GetIndexParameters();
				if (indexParameters != null && PositionImpl > -1 && PositionImpl < indexParameters.Length)
				{
					return indexParameters[PositionImpl];
				}
				throw new SerializationException(SR.Serialization_BadParameterInfo);
			}
			default:
				throw new SerializationException(SR.Serialization_NoParameterInfo);
			}
		}

		public override string ToString()
		{
			string text = ParameterType.FormatTypeName();
			string name = Name;
			if (name != null)
			{
				return text + " " + name;
			}
			return text;
		}
	}
	public readonly struct ParameterModifier
	{
		private readonly bool[] _byRef;

		public bool this[int index]
		{
			get
			{
				return _byRef[index];
			}
			set
			{
				_byRef[index] = value;
			}
		}

		internal bool[] IsByRefArray => _byRef;

		public ParameterModifier(int parameterCount)
		{
			if (parameterCount <= 0)
			{
				throw new ArgumentException(SR.Arg_ParmArraySize);
			}
			_byRef = new bool[parameterCount];
		}
	}
	[CLSCompliant(false)]
	public sealed class Pointer : ISerializable
	{
		private unsafe readonly void* _ptr;

		private readonly Type _ptrType;

		private unsafe Pointer(void* ptr, Type ptrType)
		{
			_ptr = ptr;
			_ptrType = ptrType;
		}

		public unsafe static object Box(void* ptr, Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!type.IsPointer)
			{
				throw new ArgumentException(SR.Arg_MustBePointer, "ptr");
			}
			if (!type.IsRuntimeImplemented())
			{
				throw new ArgumentException(SR.Arg_MustBeType, "ptr");
			}
			return new Pointer(ptr, type);
		}

		public unsafe static void* Unbox(object ptr)
		{
			if (!(ptr is Pointer))
			{
				throw new ArgumentException(SR.Arg_MustBePointer, "ptr");
			}
			return ((Pointer)ptr)._ptr;
		}

		public unsafe override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Pointer pointer)
			{
				return _ptr == pointer._ptr;
			}
			return false;
		}

		public unsafe override int GetHashCode()
		{
			UIntPtr ptr = (UIntPtr)_ptr;
			return ptr.GetHashCode();
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		internal Type GetPointerType()
		{
			return _ptrType;
		}

		internal unsafe IntPtr GetPointerValue()
		{
			return (IntPtr)_ptr;
		}
	}
	[Flags]
	public enum PortableExecutableKinds
	{
		NotAPortableExecutableImage = 0,
		ILOnly = 1,
		Required32Bit = 2,
		PE32Plus = 4,
		Unmanaged32Bit = 8,
		Preferred32Bit = 0x10
	}
	public enum ProcessorArchitecture
	{
		None,
		MSIL,
		X86,
		IA64,
		Amd64,
		Arm
	}
	[Flags]
	public enum PropertyAttributes
	{
		None = 0,
		SpecialName = 0x200,
		RTSpecialName = 0x400,
		HasDefault = 0x1000,
		Reserved2 = 0x2000,
		Reserved3 = 0x4000,
		Reserved4 = 0x8000,
		ReservedMask = 0xF400
	}
	public abstract class PropertyInfo : MemberInfo
	{
		public override MemberTypes MemberType => MemberTypes.Property;

		public abstract Type PropertyType { get; }

		public abstract PropertyAttributes Attributes { get; }

		public bool IsSpecialName => (Attributes & PropertyAttributes.SpecialName) != 0;

		public abstract bool CanRead { get; }

		public abstract bool CanWrite { get; }

		public virtual MethodInfo? GetMethod => GetGetMethod(nonPublic: true);

		public virtual MethodInfo? SetMethod => GetSetMethod(nonPublic: true);

		public abstract ParameterInfo[] GetIndexParameters();

		public MethodInfo[] GetAccessors()
		{
			return GetAccessors(nonPublic: false);
		}

		public abstract MethodInfo[] GetAccessors(bool nonPublic);

		public MethodInfo? GetGetMethod()
		{
			return GetGetMethod(nonPublic: false);
		}

		public abstract MethodInfo? GetGetMethod(bool nonPublic);

		public MethodInfo? GetSetMethod()
		{
			return GetSetMethod(nonPublic: false);
		}

		public abstract MethodInfo? GetSetMethod(bool nonPublic);

		public virtual Type[] GetOptionalCustomModifiers()
		{
			return Type.EmptyTypes;
		}

		public virtual Type[] GetRequiredCustomModifiers()
		{
			return Type.EmptyTypes;
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public object? GetValue(object? obj)
		{
			return GetValue(obj, null);
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public virtual object? GetValue(object? obj, object?[]? index)
		{
			return GetValue(obj, BindingFlags.Default, null, index, null);
		}

		public abstract object? GetValue(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? index, CultureInfo? culture);

		public virtual object? GetConstantValue()
		{
			throw NotImplemented.ByDesign;
		}

		public virtual object? GetRawConstantValue()
		{
			throw NotImplemented.ByDesign;
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public void SetValue(object? obj, object? value)
		{
			SetValue(obj, value, null);
		}

		[DebuggerHidden]
		[DebuggerStepThrough]
		public virtual void SetValue(object? obj, object? value, object?[]? index)
		{
			SetValue(obj, value, BindingFlags.Default, null, index, null);
		}

		public abstract void SetValue(object? obj, object? value, BindingFlags invokeAttr, Binder? binder, object?[]? index, CultureInfo? culture);

		public override bool Equals(object? obj)
		{
			return base.Equals(obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(PropertyInfo? left, PropertyInfo? right)
		{
			if ((object)right == null)
			{
				if ((object)left != null)
				{
					return false;
				}
				return true;
			}
			if ((object)left == right)
			{
				return true;
			}
			return left?.Equals(right) ?? false;
		}

		public static bool operator !=(PropertyInfo? left, PropertyInfo? right)
		{
			return !(left == right);
		}
	}
	public abstract class ReflectionContext
	{
		public abstract Assembly MapAssembly(Assembly assembly);

		public abstract TypeInfo MapType(TypeInfo type);

		public virtual TypeInfo GetTypeForObject(object value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			return MapType(value.GetType().GetTypeInfo());
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class ReflectionTypeLoadException : SystemException, ISerializable
	{
		public Type?[] Types { get; }

		public Exception?[] LoaderExceptions { get; }

		public override string Message => CreateString(isMessage: true);

		public ReflectionTypeLoadException(Type?[]? classes, Exception?[]? exceptions)
			: this(classes, exceptions, null)
		{
		}

		public ReflectionTypeLoadException(Type?[]? classes, Exception?[]? exceptions, string? message)
			: base(message)
		{
			Types = classes ?? Type.EmptyTypes;
			LoaderExceptions = exceptions ?? Array.Empty<Exception>();
			base.HResult = -2146232830;
		}

		private ReflectionTypeLoadException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			Types = Type.EmptyTypes;
			LoaderExceptions = ((Exception[])info.GetValue("Exceptions", typeof(Exception[]))) ?? Array.Empty<Exception>();
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("Types", null, typeof(Type[]));
			info.AddValue("Exceptions", LoaderExceptions, typeof(Exception[]));
		}

		public override string ToString()
		{
			return CreateString(isMessage: false);
		}

		private string CreateString(bool isMessage)
		{
			string text = (isMessage ? base.Message : base.ToString());
			Exception[] loaderExceptions = LoaderExceptions;
			if (loaderExceptions.Length == 0)
			{
				return text;
			}
			StringBuilder stringBuilder = new StringBuilder(text);
			Exception[] array = loaderExceptions;
			foreach (Exception ex in array)
			{
				if (ex != null)
				{
					stringBuilder.AppendLine().Append(isMessage ? ex.Message : ex.ToString());
				}
			}
			return stringBuilder.ToString();
		}
	}
	[Flags]
	public enum ResourceAttributes
	{
		Public = 1,
		Private = 2
	}
	[Flags]
	public enum ResourceLocation
	{
		ContainedInAnotherAssembly = 2,
		ContainedInManifestFile = 4,
		Embedded = 1
	}
	public static class RuntimeReflectionExtensions
	{
		public static IEnumerable<FieldInfo> GetRuntimeFields([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)] this Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		public static IEnumerable<MethodInfo> GetRuntimeMethods([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] this Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		public static IEnumerable<PropertyInfo> GetRuntimeProperties([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] this Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		public static IEnumerable<EventInfo> GetRuntimeEvents([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)] this Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetEvents(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		public static FieldInfo? GetRuntimeField([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] this Type type, string name)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetField(name);
		}

		public static MethodInfo? GetRuntimeMethod([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] this Type type, string name, Type[] parameters)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetMethod(name, parameters);
		}

		public static PropertyInfo? GetRuntimeProperty([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] this Type type, string name)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetProperty(name);
		}

		public static EventInfo? GetRuntimeEvent([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)] this Type type, string name)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetEvent(name);
		}

		public static MethodInfo? GetRuntimeBaseDefinition(this MethodInfo method)
		{
			if (method == null)
			{
				throw new ArgumentNullException("method");
			}
			return method.GetBaseDefinition();
		}

		public static InterfaceMapping GetRuntimeInterfaceMap(this TypeInfo typeInfo, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			if (typeInfo == null)
			{
				throw new ArgumentNullException("typeInfo");
			}
			return typeInfo.GetInterfaceMap(interfaceType);
		}

		public static MethodInfo GetMethodInfo(this Delegate del)
		{
			if ((object)del == null)
			{
				throw new ArgumentNullException("del");
			}
			return del.Method;
		}
	}
	internal sealed class SignatureArrayType : SignatureHasElementType
	{
		private readonly int _rank;

		private readonly bool _isMultiDim;

		public sealed override bool IsSZArray => !_isMultiDim;

		public sealed override bool IsVariableBoundArray => _isMultiDim;

		protected sealed override string Suffix
		{
			get
			{
				if (!_isMultiDim)
				{
					return "[]";
				}
				if (_rank == 1)
				{
					return "[*]";
				}
				return "[" + new string(',', _rank - 1) + "]";
			}
		}

		internal SignatureArrayType(SignatureType elementType, int rank, bool isMultiDim)
			: base(elementType)
		{
			_rank = rank;
			_isMultiDim = isMultiDim;
		}

		protected sealed override bool IsArrayImpl()
		{
			return true;
		}

		protected sealed override bool IsByRefImpl()
		{
			return false;
		}

		protected sealed override bool IsPointerImpl()
		{
			return false;
		}

		public sealed override int GetArrayRank()
		{
			return _rank;
		}
	}
	internal sealed class SignatureByRefType : SignatureHasElementType
	{
		public sealed override bool IsSZArray => false;

		public sealed override bool IsVariableBoundArray => false;

		protected sealed override string Suffix => "&";

		internal SignatureByRefType(SignatureType elementType)
			: base(elementType)
		{
		}

		protected sealed override bool IsArrayImpl()
		{
			return false;
		}

		protected sealed override bool IsByRefImpl()
		{
			return true;
		}

		protected sealed override bool IsPointerImpl()
		{
			return false;
		}

		public sealed override int GetArrayRank()
		{
			throw new ArgumentException(SR.Argument_HasToBeArrayClass);
		}
	}
	internal sealed class SignatureConstructedGenericType : SignatureType
	{
		private readonly Type _genericTypeDefinition;

		private readonly Type[] _genericTypeArguments;

		public sealed override bool IsTypeDefinition => false;

		public sealed override bool IsGenericTypeDefinition => false;

		public sealed override bool IsByRefLike => _genericTypeDefinition.IsByRefLike;

		public sealed override bool IsSZArray => false;

		public sealed override bool IsVariableBoundArray => false;

		public sealed override bool IsConstructedGenericType => true;

		public sealed override bool IsGenericParameter => false;

		public sealed override bool IsGenericTypeParameter => false;

		public sealed override bool IsGenericMethodParameter => false;

		public sealed override bool ContainsGenericParameters
		{
			get
			{
				for (int i = 0; i < _genericTypeArguments.Length; i++)
				{
					if (_genericTypeArguments[i].ContainsGenericParameters)
					{
						return true;
					}
				}
				return false;
			}
		}

		internal sealed override SignatureType ElementType => null;

		public sealed override Type[] GenericTypeArguments => (Type[])_genericTypeArguments.Clone();

		public sealed override int GenericParameterPosition
		{
			get
			{
				throw new InvalidOperationException(SR.Arg_NotGenericParameter);
			}
		}

		public sealed override string Name => _genericTypeDefinition.Name;

		public sealed override string Namespace => _genericTypeDefinition.Namespace;

		internal SignatureConstructedGenericType(Type genericTypeDefinition, Type[] typeArguments)
		{
			if ((object)genericTypeDefinition == null)
			{
				throw new ArgumentNullException("genericTypeDefinition");
			}
			if (typeArguments == null)
			{
				throw new ArgumentNullException("typeArguments");
			}
			typeArguments = (Type[])typeArguments.Clone();
			for (int i = 0; i < typeArguments.Length; i++)
			{
				if ((object)typeArguments[i] == null)
				{
					throw new ArgumentNullException("typeArguments");
				}
			}
			_genericTypeDefinition = genericTypeDefinition;
			_genericTypeArguments = typeArguments;
		}

		protected sealed override bool HasElementTypeImpl()
		{
			return false;
		}

		protected sealed override bool IsArrayImpl()
		{
			return false;
		}

		protected sealed override bool IsByRefImpl()
		{
			return false;
		}

		protected sealed override bool IsPointerImpl()
		{
			return false;
		}

		public sealed override int GetArrayRank()
		{
			throw new ArgumentException(SR.Argument_HasToBeArrayClass);
		}

		public sealed override Type GetGenericTypeDefinition()
		{
			return _genericTypeDefinition;
		}

		public sealed override Type[] GetGenericArguments()
		{
			return GenericTypeArguments;
		}

		public sealed override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(_genericTypeDefinition.ToString());
			stringBuilder.Append('[');
			for (int i = 0; i < _genericTypeArguments.Length; i++)
			{
				if (i != 0)
				{
					stringBuilder.Append(',');
				}
				stringBuilder.Append(_genericTypeArguments[i].ToString());
			}
			stringBuilder.Append(']');
			return stringBuilder.ToString();
		}
	}
	internal sealed class SignatureGenericMethodParameterType : SignatureGenericParameterType
	{
		public sealed override bool IsGenericTypeParameter => false;

		public sealed override bool IsGenericMethodParameter => true;

		public sealed override string Name => "!!" + GenericParameterPosition;

		internal SignatureGenericMethodParameterType(int position)
			: base(position)
		{
		}
	}
	internal abstract class SignatureGenericParameterType : SignatureType
	{
		private readonly int _position;

		public sealed override bool IsTypeDefinition => false;

		public sealed override bool IsGenericTypeDefinition => false;

		public sealed override bool IsByRefLike => false;

		public sealed override bool IsSZArray => false;

		public sealed override bool IsVariableBoundArray => false;

		public sealed override bool IsConstructedGenericType => false;

		public sealed override bool IsGenericParameter => true;

		public abstract override bool IsGenericMethodParameter { get; }

		public sealed override bool ContainsGenericParameters => true;

		internal sealed override SignatureType ElementType => null;

		public sealed override Type[] GenericTypeArguments => Type.EmptyTypes;

		public sealed override int GenericParameterPosition => _position;

		public abstract override string Name { get; }

		public sealed override string Namespace => null;

		protected SignatureGenericParameterType(int position)
		{
			_position = position;
		}

		protected sealed override bool HasElementTypeImpl()
		{
			return false;
		}

		protected sealed override bool IsArrayImpl()
		{
			return false;
		}

		protected sealed override bool IsByRefImpl()
		{
			return false;
		}

		protected sealed override bool IsPointerImpl()
		{
			return false;
		}

		public sealed override int GetArrayRank()
		{
			throw new ArgumentException(SR.Argument_HasToBeArrayClass);
		}

		public sealed override Type GetGenericTypeDefinition()
		{
			throw new InvalidOperationException(SR.InvalidOperation_NotGenericType);
		}

		public sealed override Type[] GetGenericArguments()
		{
			return Type.EmptyTypes;
		}

		public sealed override string ToString()
		{
			return Name;
		}
	}
	internal abstract class SignatureHasElementType : SignatureType
	{
		private readonly SignatureType _elementType;

		public sealed override bool IsTypeDefinition => false;

		public sealed override bool IsGenericTypeDefinition => false;

		public sealed override bool IsByRefLike => false;

		public abstract override bool IsSZArray { get; }

		public abstract override bool IsVariableBoundArray { get; }

		public sealed override bool IsConstructedGenericType => false;

		public sealed override bool IsGenericParameter => false;

		public sealed override bool IsGenericTypeParameter => false;

		public sealed override bool IsGenericMethodParameter => false;

		public sealed override bool ContainsGenericParameters => _elementType.ContainsGenericParameters;

		internal sealed override SignatureType ElementType => _elementType;

		public sealed override Type[] GenericTypeArguments => Type.EmptyTypes;

		public sealed override int GenericParameterPosition
		{
			get
			{
				throw new InvalidOperationException(SR.Arg_NotGenericParameter);
			}
		}

		public sealed override string Name => _elementType.Name + Suffix;

		public sealed override string Namespace => _elementType.Namespace;

		protected abstract string Suffix { get; }

		protected SignatureHasElementType(SignatureType elementType)
		{
			_elementType = elementType;
		}

		protected sealed override bool HasElementTypeImpl()
		{
			return true;
		}

		protected abstract override bool IsArrayImpl();

		protected abstract override bool IsByRefImpl();

		protected abstract override bool IsPointerImpl();

		public abstract override int GetArrayRank();

		public sealed override Type GetGenericTypeDefinition()
		{
			throw new InvalidOperationException(SR.InvalidOperation_NotGenericType);
		}

		public sealed override Type[] GetGenericArguments()
		{
			return Type.EmptyTypes;
		}

		public sealed override string ToString()
		{
			return _elementType.ToString() + Suffix;
		}
	}
	internal sealed class SignaturePointerType : SignatureHasElementType
	{
		public sealed override bool IsSZArray => false;

		public sealed override bool IsVariableBoundArray => false;

		protected sealed override string Suffix => "*";

		internal SignaturePointerType(SignatureType elementType)
			: base(elementType)
		{
		}

		protected sealed override bool IsArrayImpl()
		{
			return false;
		}

		protected sealed override bool IsByRefImpl()
		{
			return false;
		}

		protected sealed override bool IsPointerImpl()
		{
			return true;
		}

		public sealed override int GetArrayRank()
		{
			throw new ArgumentException(SR.Argument_HasToBeArrayClass);
		}
	}
	internal abstract class SignatureType : Type
	{
		public sealed override bool IsSignatureType => true;

		public abstract override bool IsTypeDefinition { get; }

		public abstract override bool IsSZArray { get; }

		public abstract override bool IsVariableBoundArray { get; }

		public abstract override bool IsByRefLike { get; }

		public sealed override bool IsGenericType
		{
			get
			{
				if (!IsGenericTypeDefinition)
				{
					return IsConstructedGenericType;
				}
				return true;
			}
		}

		public abstract override bool IsGenericTypeDefinition { get; }

		public abstract override bool IsConstructedGenericType { get; }

		public abstract override bool IsGenericParameter { get; }

		public abstract override bool IsGenericTypeParameter { get; }

		public abstract override bool IsGenericMethodParameter { get; }

		public abstract override bool ContainsGenericParameters { get; }

		public sealed override MemberTypes MemberType => MemberTypes.TypeInfo;

		public abstract override Type[] GenericTypeArguments { get; }

		public abstract override int GenericParameterPosition { get; }

		internal abstract SignatureType ElementType { get; }

		public sealed override Type UnderlyingSystemType => this;

		public abstract override string Name { get; }

		public abstract override string Namespace { get; }

		public sealed override string FullName => null;

		public sealed override string AssemblyQualifiedName => null;

		public sealed override Assembly Assembly
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override Module Module
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override Type ReflectedType
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override Type BaseType
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override int MetadataToken
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override Type DeclaringType
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override MethodBase DeclaringMethod
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override GenericParameterAttributes GenericParameterAttributes
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override Guid GUID
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override IEnumerable<CustomAttributeData> CustomAttributes
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override bool IsEnum
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override bool IsSecurityCritical
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override bool IsSecuritySafeCritical
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override bool IsSecurityTransparent
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override bool IsSerializable
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override StructLayoutAttribute StructLayoutAttribute
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		public sealed override RuntimeTypeHandle TypeHandle
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SignatureType);
			}
		}

		protected abstract override bool HasElementTypeImpl();

		protected abstract override bool IsArrayImpl();

		protected abstract override bool IsByRefImpl();

		protected abstract override bool IsPointerImpl();

		public sealed override Type MakeArrayType()
		{
			return new SignatureArrayType(this, 1, isMultiDim: false);
		}

		public sealed override Type MakeArrayType(int rank)
		{
			if (rank <= 0)
			{
				throw new IndexOutOfRangeException();
			}
			return new SignatureArrayType(this, rank, isMultiDim: true);
		}

		public sealed override Type MakeByRefType()
		{
			return new SignatureByRefType(this);
		}

		public sealed override Type MakePointerType()
		{
			return new SignaturePointerType(this);
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public sealed override Type MakeGenericType(params Type[] typeArguments)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override Type GetElementType()
		{
			return ElementType;
		}

		public abstract override int GetArrayRank();

		public abstract override Type GetGenericTypeDefinition();

		public abstract override Type[] GetGenericArguments();

		public abstract override string ToString();

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public sealed override Type[] GetInterfaces()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override bool IsAssignableFrom([NotNullWhen(true)] Type c)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override bool HasSameMetadataDefinitionAs(MemberInfo other)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override Type[] GetGenericParameterConstraints()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override bool IsEnumDefined(object value)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override string GetEnumName(object value)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override string[] GetEnumNames()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override Type GetEnumUnderlyingType()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override Array GetEnumValues()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		protected sealed override TypeCode GetTypeCodeImpl()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		protected sealed override TypeAttributes GetAttributeFlagsImpl()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public sealed override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public sealed override EventInfo GetEvent(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public sealed override EventInfo[] GetEvents(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public sealed override FieldInfo GetField(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public sealed override FieldInfo[] GetFields(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public sealed override MemberInfo[] GetMembers(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public sealed override MethodInfo[] GetMethods(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public sealed override Type GetNestedType(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public sealed override Type[] GetNestedTypes(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public sealed override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public sealed override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected sealed override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected sealed override MethodInfo GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected sealed override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public sealed override MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bindingAttr, MemberFilter filter, object filterCriteria)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public sealed override MemberInfo[] GetMember(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public sealed override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)]
		public sealed override MemberInfo[] GetDefaultMembers()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public sealed override EventInfo[] GetEvents()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override object[] GetCustomAttributes(bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override IList<CustomAttributeData> GetCustomAttributesData()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2063:UnrecognizedReflectionPattern", Justification = "Linker doesn't recognize always throwing method. https://github.com/mono/linker/issues/2025")]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public sealed override Type GetInterface(string name, bool ignoreCase)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected sealed override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		protected sealed override bool IsCOMObjectImpl()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		protected sealed override bool IsPrimitiveImpl()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public sealed override Type[] FindInterfaces(TypeFilter filter, object filterCriteria)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		protected sealed override bool IsContextfulImpl()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override bool IsEquivalentTo([NotNullWhen(true)] Type other)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override bool IsInstanceOfType([NotNullWhen(true)] object o)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		protected sealed override bool IsMarshalByRefImpl()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		public sealed override bool IsSubclassOf(Type c)
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}

		protected sealed override bool IsValueTypeImpl()
		{
			throw new NotSupportedException(SR.NotSupported_SignatureType);
		}
	}
	internal static class SignatureTypeExtensions
	{
		public static bool MatchesParameterTypeExactly(this Type pattern, ParameterInfo parameter)
		{
			if (pattern is SignatureType pattern2)
			{
				return pattern2.MatchesExactly(parameter.ParameterType);
			}
			return (object)pattern == parameter.ParameterType;
		}

		internal static bool MatchesExactly(this SignatureType pattern, Type actual)
		{
			if (pattern.IsSZArray)
			{
				if (actual.IsSZArray)
				{
					return pattern.ElementType.MatchesExactly(actual.GetElementType());
				}
				return false;
			}
			if (pattern.IsVariableBoundArray)
			{
				if (actual.IsVariableBoundArray && pattern.GetArrayRank() == actual.GetArrayRank())
				{
					return pattern.ElementType.MatchesExactly(actual.GetElementType());
				}
				return false;
			}
			if (pattern.IsByRef)
			{
				if (actual.IsByRef)
				{
					return pattern.ElementType.MatchesExactly(actual.GetElementType());
				}
				return false;
			}
			if (pattern.IsPointer)
			{
				if (actual.IsPointer)
				{
					return pattern.ElementType.MatchesExactly(actual.GetElementType());
				}
				return false;
			}
			if (pattern.IsConstructedGenericType)
			{
				if (!actual.IsConstructedGenericType)
				{
					return false;
				}
				if (!(pattern.GetGenericTypeDefinition() == actual.GetGenericTypeDefinition()))
				{
					return false;
				}
				Type[] genericTypeArguments = pattern.GenericTypeArguments;
				Type[] genericTypeArguments2 = actual.GenericTypeArguments;
				int num = genericTypeArguments.Length;
				if (num != genericTypeArguments2.Length)
				{
					return false;
				}
				for (int i = 0; i < num; i++)
				{
					Type type = genericTypeArguments[i];
					if (type is SignatureType pattern2)
					{
						if (!pattern2.MatchesExactly(genericTypeArguments2[i]))
						{
							return false;
						}
					}
					else if (type != genericTypeArguments2[i])
					{
						return false;
					}
				}
				return true;
			}
			if (pattern.IsGenericMethodParameter)
			{
				if (!actual.IsGenericMethodParameter)
				{
					return false;
				}
				if (pattern.GenericParameterPosition != actual.GenericParameterPosition)
				{
					return false;
				}
				return true;
			}
			return false;
		}

		internal static Type TryResolveAgainstGenericMethod(this SignatureType signatureType, MethodInfo genericMethod)
		{
			return signatureType.TryResolve(genericMethod.GetGenericArguments());
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Used to find matching method overloads. Only used for assignability checks.")]
		private static Type TryResolve(this SignatureType signatureType, Type[] genericMethodParameters)
		{
			if (signatureType.IsSZArray)
			{
				Type type = signatureType.ElementType.TryResolve(genericMethodParameters);
				if ((object)type == null)
				{
					return null;
				}
				return type.TryMakeArrayType();
			}
			if (signatureType.IsVariableBoundArray)
			{
				Type type2 = signatureType.ElementType.TryResolve(genericMethodParameters);
				if ((object)type2 == null)
				{
					return null;
				}
				return type2.TryMakeArrayType(signatureType.GetArrayRank());
			}
			if (signatureType.IsByRef)
			{
				Type type3 = signatureType.ElementType.TryResolve(genericMethodParameters);
				if ((object)type3 == null)
				{
					return null;
				}
				return type3.TryMakeByRefType();
			}
			if (signatureType.IsPointer)
			{
				Type type4 = signatureType.ElementType.TryResolve(genericMethodParameters);
				if ((object)type4 == null)
				{
					return null;
				}
				return type4.TryMakePointerType();
			}
			if (signatureType.IsConstructedGenericType)
			{
				Type[] genericTypeArguments = signatureType.GenericTypeArguments;
				int num = genericTypeArguments.Length;
				Type[] array = new Type[num];
				for (int i = 0; i < num; i++)
				{
					Type type5 = genericTypeArguments[i];
					if (type5 is SignatureType signatureType2)
					{
						array[i] = signatureType2.TryResolve(genericMethodParameters);
						if (array[i] == null)
						{
							return null;
						}
					}
					else
					{
						array[i] = type5;
					}
				}
				return signatureType.GetGenericTypeDefinition().TryMakeGenericType(array);
			}
			if (signatureType.IsGenericMethodParameter)
			{
				int genericParameterPosition = signatureType.GenericParameterPosition;
				if (genericParameterPosition >= genericMethodParameters.Length)
				{
					return null;
				}
				return genericMethodParameters[genericParameterPosition];
			}
			return null;
		}

		private static Type TryMakeArrayType(this Type type)
		{
			try
			{
				return type.MakeArrayType();
			}
			catch
			{
				return null;
			}
		}

		private static Type TryMakeArrayType(this Type type, int rank)
		{
			try
			{
				return type.MakeArrayType(rank);
			}
			catch
			{
				return null;
			}
		}

		private static Type TryMakeByRefType(this Type type)
		{
			try
			{
				return type.MakeByRefType();
			}
			catch
			{
				return null;
			}
		}

		private static Type TryMakePointerType(this Type type)
		{
			try
			{
				return type.MakePointerType();
			}
			catch
			{
				return null;
			}
		}

		[RequiresUnreferencedCode("Wrapper around MakeGenericType which itself has RequiresUnreferencedCode")]
		private static Type TryMakeGenericType(this Type type, Type[] instantiation)
		{
			try
			{
				return type.MakeGenericType(instantiation);
			}
			catch
			{
				return null;
			}
		}
	}
	[Obsolete("Strong name signing is not supported and throws PlatformNotSupportedException.", DiagnosticId = "SYSLIB0017", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
	public class StrongNameKeyPair : IDeserializationCallback, ISerializable
	{
		public byte[] PublicKey
		{
			get
			{
				throw new PlatformNotSupportedException(SR.PlatformNotSupported_StrongNameSigning);
			}
		}

		public StrongNameKeyPair(FileStream keyPairFile)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_StrongNameSigning);
		}

		public StrongNameKeyPair(byte[] keyPairArray)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_StrongNameSigning);
		}

		protected StrongNameKeyPair(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public StrongNameKeyPair(string keyPairContainer)
		{
			throw new PlatformNotSupportedException(SR.PlatformNotSupported_StrongNameSigning);
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		void IDeserializationCallback.OnDeserialization(object sender)
		{
			throw new PlatformNotSupportedException();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class TargetException : ApplicationException
	{
		public TargetException()
			: this(null)
		{
		}

		public TargetException(string? message)
			: this(message, null)
		{
		}

		public TargetException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146232829;
		}

		protected TargetException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class TargetInvocationException : ApplicationException
	{
		public TargetInvocationException(Exception? inner)
			: base(SR.Arg_TargetInvocationException, inner)
		{
			base.HResult = -2146232828;
		}

		public TargetInvocationException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146232828;
		}

		private TargetInvocationException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class TargetParameterCountException : ApplicationException
	{
		public TargetParameterCountException()
			: base(SR.Arg_TargetParameterCountException)
		{
			base.HResult = -2147352562;
		}

		public TargetParameterCountException(string? message)
			: base(message)
		{
			base.HResult = -2147352562;
		}

		public TargetParameterCountException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2147352562;
		}

		private TargetParameterCountException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Flags]
	public enum TypeAttributes
	{
		VisibilityMask = 7,
		NotPublic = 0,
		Public = 1,
		NestedPublic = 2,
		NestedPrivate = 3,
		NestedFamily = 4,
		NestedAssembly = 5,
		NestedFamANDAssem = 6,
		NestedFamORAssem = 7,
		LayoutMask = 0x18,
		AutoLayout = 0,
		SequentialLayout = 8,
		ExplicitLayout = 0x10,
		ClassSemanticsMask = 0x20,
		Class = 0,
		Interface = 0x20,
		Abstract = 0x80,
		Sealed = 0x100,
		SpecialName = 0x400,
		Import = 0x1000,
		Serializable = 0x2000,
		WindowsRuntime = 0x4000,
		StringFormatMask = 0x30000,
		AnsiClass = 0,
		UnicodeClass = 0x10000,
		AutoClass = 0x20000,
		CustomFormatClass = 0x30000,
		CustomFormatMask = 0xC00000,
		BeforeFieldInit = 0x100000,
		RTSpecialName = 0x800,
		HasSecurity = 0x40000,
		ReservedMask = 0x40800
	}
	public class TypeDelegator : TypeInfo
	{
		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		protected Type typeImpl;

		public override Guid GUID => typeImpl.GUID;

		public override int MetadataToken => typeImpl.MetadataToken;

		public override Module Module => typeImpl.Module;

		public override Assembly Assembly => typeImpl.Assembly;

		public override RuntimeTypeHandle TypeHandle => typeImpl.TypeHandle;

		public override string Name => typeImpl.Name;

		public override string? FullName => typeImpl.FullName;

		public override string? Namespace => typeImpl.Namespace;

		public override string? AssemblyQualifiedName => typeImpl.AssemblyQualifiedName;

		public override Type? BaseType => typeImpl.BaseType;

		public override bool IsTypeDefinition => typeImpl.IsTypeDefinition;

		public override bool IsSZArray => typeImpl.IsSZArray;

		public override bool IsVariableBoundArray => typeImpl.IsVariableBoundArray;

		public override bool IsGenericTypeParameter => typeImpl.IsGenericTypeParameter;

		public override bool IsGenericMethodParameter => typeImpl.IsGenericMethodParameter;

		public override bool IsByRefLike => typeImpl.IsByRefLike;

		public override bool IsConstructedGenericType => typeImpl.IsConstructedGenericType;

		public override bool IsCollectible => typeImpl.IsCollectible;

		public override Type UnderlyingSystemType => typeImpl.UnderlyingSystemType;

		public override bool IsAssignableFrom([NotNullWhen(true)] TypeInfo? typeInfo)
		{
			if (typeInfo == null)
			{
				return false;
			}
			return IsAssignableFrom(typeInfo.AsType());
		}

		protected TypeDelegator()
		{
		}

		public TypeDelegator([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type delegatingType)
		{
			if ((object)delegatingType == null)
			{
				throw new ArgumentNullException("delegatingType");
			}
			typeImpl = delegatingType;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public override object? InvokeMember(string name, BindingFlags invokeAttr, Binder? binder, object? target, object?[]? args, ParameterModifier[]? modifiers, CultureInfo? culture, string[]? namedParameters)
		{
			return typeImpl.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected override ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers)
		{
			return typeImpl.GetConstructor(bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
		{
			return typeImpl.GetConstructors(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
		{
			if (types == null)
			{
				return typeImpl.GetMethod(name, bindingAttr);
			}
			return typeImpl.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
		{
			return typeImpl.GetMethods(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo? GetField(string name, BindingFlags bindingAttr)
		{
			return typeImpl.GetField(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo[] GetFields(BindingFlags bindingAttr)
		{
			return typeImpl.GetFields(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type? GetInterface(string name, bool ignoreCase)
		{
			return typeImpl.GetInterface(name, ignoreCase);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type[] GetInterfaces()
		{
			return typeImpl.GetInterfaces();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo? GetEvent(string name, BindingFlags bindingAttr)
		{
			return typeImpl.GetEvent(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public override EventInfo[] GetEvents()
		{
			return typeImpl.GetEvents();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected override PropertyInfo? GetPropertyImpl(string name, BindingFlags bindingAttr, Binder? binder, Type? returnType, Type[]? types, ParameterModifier[]? modifiers)
		{
			if (returnType == null && types == null)
			{
				return typeImpl.GetProperty(name, bindingAttr);
			}
			return typeImpl.GetProperty(name, bindingAttr, binder, returnType, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
		{
			return typeImpl.GetProperties(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo[] GetEvents(BindingFlags bindingAttr)
		{
			return typeImpl.GetEvents(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type[] GetNestedTypes(BindingFlags bindingAttr)
		{
			return typeImpl.GetNestedTypes(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type? GetNestedType(string name, BindingFlags bindingAttr)
		{
			return typeImpl.GetNestedType(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			return typeImpl.GetMember(name, type, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
		{
			return typeImpl.GetMembers(bindingAttr);
		}

		public override MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo member)
		{
			return typeImpl.GetMemberWithSameMetadataDefinitionAs(member);
		}

		protected override TypeAttributes GetAttributeFlagsImpl()
		{
			return typeImpl.Attributes;
		}

		protected override bool IsArrayImpl()
		{
			return typeImpl.IsArray;
		}

		protected override bool IsPrimitiveImpl()
		{
			return typeImpl.IsPrimitive;
		}

		protected override bool IsByRefImpl()
		{
			return typeImpl.IsByRef;
		}

		protected override bool IsPointerImpl()
		{
			return typeImpl.IsPointer;
		}

		protected override bool IsValueTypeImpl()
		{
			return typeImpl.IsValueType;
		}

		protected override bool IsCOMObjectImpl()
		{
			return typeImpl.IsCOMObject;
		}

		public override Type? GetElementType()
		{
			return typeImpl.GetElementType();
		}

		protected override bool HasElementTypeImpl()
		{
			return typeImpl.HasElementType;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return typeImpl.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return typeImpl.GetCustomAttributes(attributeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return typeImpl.IsDefined(attributeType, inherit);
		}

		public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			return typeImpl.GetInterfaceMap(interfaceType);
		}
	}
	public delegate bool TypeFilter(Type m, object? filterCriteria);
	public abstract class TypeInfo : Type, IReflectableType
	{
		public virtual Type[] GenericTypeParameters
		{
			get
			{
				if (!IsGenericTypeDefinition)
				{
					return Type.EmptyTypes;
				}
				return GetGenericArguments();
			}
		}

		public virtual IEnumerable<ConstructorInfo> DeclaredConstructors
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
			get
			{
				return GetConstructors(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		public virtual IEnumerable<EventInfo> DeclaredEvents
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
			get
			{
				return GetEvents(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		public virtual IEnumerable<FieldInfo> DeclaredFields
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
			get
			{
				return GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		public virtual IEnumerable<MemberInfo> DeclaredMembers
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
			get
			{
				return GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		public virtual IEnumerable<MethodInfo> DeclaredMethods
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
			get
			{
				return GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		public virtual IEnumerable<TypeInfo> DeclaredNestedTypes
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
			get
			{
				Type[] array = GetDeclaredOnlyNestedTypes(this);
				foreach (Type type2 in array)
				{
					yield return type2.GetTypeInfo();
				}
				[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "The yield return state machine doesn't propagate annotations")]
				static Type[] GetDeclaredOnlyNestedTypes(Type type)
				{
					return type.GetNestedTypes(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
			}
		}

		public virtual IEnumerable<PropertyInfo> DeclaredProperties
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
			get
			{
				return GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		public virtual IEnumerable<Type> ImplementedInterfaces
		{
			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
			get
			{
				return GetInterfaces();
			}
		}

		TypeInfo IReflectableType.GetTypeInfo()
		{
			return this;
		}

		public virtual Type AsType()
		{
			return this;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public virtual EventInfo? GetDeclaredEvent(string name)
		{
			return GetEvent(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public virtual FieldInfo? GetDeclaredField(string name)
		{
			return GetField(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public virtual MethodInfo? GetDeclaredMethod(string name)
		{
			return GetMethod(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public virtual TypeInfo? GetDeclaredNestedType(string name)
		{
			return GetNestedType(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetTypeInfo();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public virtual PropertyInfo? GetDeclaredProperty(string name)
		{
			return GetProperty(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public virtual IEnumerable<MethodInfo> GetDeclaredMethods(string name)
		{
			MethodInfo[] array = GetDeclaredOnlyMethods(this);
			foreach (MethodInfo methodInfo in array)
			{
				if (methodInfo.Name == name)
				{
					yield return methodInfo;
				}
			}
			[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "The yield return state machine doesn't propagate annotations")]
			static MethodInfo[] GetDeclaredOnlyMethods(Type type)
			{
				return type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		public virtual bool IsAssignableFrom([NotNullWhen(true)] TypeInfo? typeInfo)
		{
			if (typeInfo == null)
			{
				return false;
			}
			if (this == typeInfo)
			{
				return true;
			}
			if (typeInfo.IsSubclassOf(this))
			{
				return true;
			}
			if (base.IsInterface)
			{
				return typeInfo.ImplementInterface(this);
			}
			if (IsGenericParameter)
			{
				Type[] genericParameterConstraints = GetGenericParameterConstraints();
				for (int i = 0; i < genericParameterConstraints.Length; i++)
				{
					if (!genericParameterConstraints[i].IsAssignableFrom(typeInfo))
					{
						return false;
					}
				}
				return true;
			}
			return false;
		}

		internal static string GetRankString(int rank)
		{
			if (rank <= 0)
			{
				throw new IndexOutOfRangeException();
			}
			if (rank != 1)
			{
				return "[" + new string(',', rank - 1) + "]";
			}
			return "[*]";
		}
	}
}
namespace System.Reflection.Metadata
{
	public static class AssemblyExtensions
	{
		[DllImport("QCall")]
		[return: MarshalAs(UnmanagedType.Bool)]
		private unsafe static extern bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length);

		[CLSCompliant(false)]
		public unsafe static bool TryGetRawMetadata(this Assembly assembly, out byte* blob, out int length)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			blob = null;
			length = 0;
			RuntimeAssembly runtimeAssembly = assembly as RuntimeAssembly;
			if (runtimeAssembly == null)
			{
				return false;
			}
			RuntimeAssembly assembly2 = runtimeAssembly;
			return InternalTryGetRawMetadata(new QCallAssembly(ref assembly2), ref blob, ref length);
		}
	}
	public static class MetadataUpdater
	{
		public static bool IsSupported { get; } = IsApplyUpdateSupported();


		[DllImport("QCall")]
		private unsafe static extern void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength);

		[DllImport("QCall")]
		private static extern bool IsApplyUpdateSupported();

		public unsafe static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDelta, ReadOnlySpan<byte> ilDelta, ReadOnlySpan<byte> pdbDelta)
		{
			if (!(assembly is RuntimeAssembly runtimeAssembly))
			{
				if ((object)assembly == null)
				{
					throw new ArgumentNullException("assembly");
				}
				throw new ArgumentException(SR.Argument_MustBeRuntimeAssembly);
			}
			RuntimeAssembly assembly2 = runtimeAssembly;
			fixed (byte* metadataDelta2 = metadataDelta)
			{
				fixed (byte* ilDelta2 = ilDelta)
				{
					fixed (byte* pdbDelta2 = pdbDelta)
					{
						ApplyUpdate(new QCallAssembly(ref assembly2), metadataDelta2, metadataDelta.Length, ilDelta2, ilDelta.Length, pdbDelta2, pdbDelta.Length);
					}
				}
			}
		}

		internal static string GetCapabilities()
		{
			return "Baseline AddMethodToExistingType AddStaticFieldToExistingType AddInstanceFieldToExistingType NewTypeDefinition ChangeCustomAttributes UpdateParameters";
		}
	}
	internal static class RuntimeTypeMetadataUpdateHandler
	{
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Clearing the caches on a Type isn't affected if a Type is trimmed, or has any of its members trimmed.")]
		public static void ClearCache(Type[] types)
		{
			if (RequiresClearingAllTypes(types))
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (SkipAssembly(assembly))
					{
						continue;
					}
					try
					{
						Type[] types2 = assembly.GetTypes();
						foreach (Type type in types2)
						{
							ClearCache(type);
						}
					}
					catch (ReflectionTypeLoadException)
					{
					}
				}
			}
			else
			{
				foreach (Type type2 in types)
				{
					ClearCache(type2);
				}
			}
		}

		private static bool SkipAssembly(Assembly assembly)
		{
			return typeof(object).Assembly == assembly;
		}

		private static void ClearCache(Type type)
		{
			(type as RuntimeType)?.ClearCache();
		}

		private static bool RequiresClearingAllTypes([NotNullWhen(false)] Type[] types)
		{
			if (types == null)
			{
				return true;
			}
			foreach (Type type in types)
			{
				if (!type.IsSealed)
				{
					return true;
				}
			}
			return false;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	public sealed class MetadataUpdateHandlerAttribute : Attribute
	{
		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public Type HandlerType { get; }

		public MetadataUpdateHandlerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type handlerType)
		{
			HandlerType = handlerType;
		}
	}
}
namespace System.Reflection.Emit
{
	internal sealed class InternalAssemblyBuilder : RuntimeAssembly
	{
		public override string Location
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
			}
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override string CodeBase
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
			}
		}

		public override string ImageRuntimeVersion => Assembly.GetExecutingAssembly().ImageRuntimeVersion;

		private InternalAssemblyBuilder()
		{
		}

		public override bool Equals(object obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (obj is InternalAssemblyBuilder)
			{
				return this == obj;
			}
			return obj.Equals(this);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		public override string[] GetManifestResourceNames()
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override FileStream GetFile(string name)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override FileStream[] GetFiles(bool getResourceModules)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		public override Stream GetManifestResourceStream(Type type, string name)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		public override Stream GetManifestResourceStream(string name)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		public override ManifestResourceInfo GetManifestResourceInfo(string resourceName)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type[] GetExportedTypes()
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}
	}
	public sealed class AssemblyBuilder : Assembly
	{
		internal AssemblyBuilderData _assemblyData;

		private readonly InternalAssemblyBuilder _internalAssemblyBuilder;

		private ModuleBuilder _manifestModuleBuilder;

		private bool _isManifestModuleUsedAsDefinedModule;

		private static readonly object s_assemblyBuilderLock = new object();

		internal object SyncRoot => InternalAssembly.SyncRoot;

		internal InternalAssemblyBuilder InternalAssembly => _internalAssemblyBuilder;

		public override string? FullName => InternalAssembly.FullName;

		public override Module ManifestModule => _manifestModuleBuilder.InternalModule;

		public override bool ReflectionOnly => InternalAssembly.ReflectionOnly;

		public override long HostContext => InternalAssembly.HostContext;

		public override bool IsCollectible => InternalAssembly.IsCollectible;

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override string? CodeBase
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
			}
		}

		public override string Location
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
			}
		}

		public override MethodInfo? EntryPoint => null;

		public override bool IsDynamic => true;

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern RuntimeModule GetInMemoryAssemblyModule(RuntimeAssembly assembly);

		internal ModuleBuilder GetModuleBuilder(InternalModuleBuilder module)
		{
			lock (SyncRoot)
			{
				if (_manifestModuleBuilder.InternalModule == module)
				{
					return _manifestModuleBuilder;
				}
				throw new ArgumentException(null, "module");
			}
		}

		internal AssemblyBuilder(AssemblyName name, AssemblyBuilderAccess access, ref StackCrawlMark stackMark, AssemblyLoadContext assemblyLoadContext, IEnumerable<CustomAttributeBuilder> unsafeAssemblyAttributes)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (access != AssemblyBuilderAccess.Run && access != AssemblyBuilderAccess.RunAndCollect)
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, (int)access), "access");
			}
			name = (AssemblyName)name.Clone();
			List<CustomAttributeBuilder> list = null;
			if (unsafeAssemblyAttributes != null)
			{
				list = new List<CustomAttributeBuilder>(unsafeAssemblyAttributes);
			}
			Assembly o = null;
			CreateDynamicAssembly(ObjectHandleOnStack.Create(ref name), new StackCrawlMarkHandle(ref stackMark), (int)access, ObjectHandleOnStack.Create(ref assemblyLoadContext), ObjectHandleOnStack.Create(ref o));
			_internalAssemblyBuilder = (InternalAssemblyBuilder)o;
			_assemblyData = new AssemblyBuilderData(access);
			InitManifestModule();
			if (list == null)
			{
				return;
			}
			foreach (CustomAttributeBuilder item in list)
			{
				SetCustomAttribute(item);
			}
		}

		[MemberNotNull("_manifestModuleBuilder")]
		private void InitManifestModule()
		{
			InternalModuleBuilder internalModuleBuilder = (InternalModuleBuilder)GetInMemoryAssemblyModule(InternalAssembly);
			_manifestModuleBuilder = new ModuleBuilder(this, internalModuleBuilder);
			_manifestModuleBuilder.Init("RefEmit_InMemoryManifestModule");
			_isManifestModuleUsedAsDefinedModule = false;
		}

		public static AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return InternalDefineDynamicAssembly(name, access, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext, null);
		}

		public static AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, IEnumerable<CustomAttributeBuilder>? assemblyAttributes)
		{
			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
			return InternalDefineDynamicAssembly(name, access, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext, assemblyAttributes);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void CreateDynamicAssembly(ObjectHandleOnStack name, StackCrawlMarkHandle stackMark, int access, ObjectHandleOnStack assemblyLoadContext, ObjectHandleOnStack retAssembly);

		internal static AssemblyBuilder InternalDefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, ref StackCrawlMark stackMark, AssemblyLoadContext assemblyLoadContext, IEnumerable<CustomAttributeBuilder> unsafeAssemblyAttributes)
		{
			lock (s_assemblyBuilderLock)
			{
				return new AssemblyBuilder(name, access, ref stackMark, assemblyLoadContext, unsafeAssemblyAttributes);
			}
		}

		public ModuleBuilder DefineDynamicModule(string name)
		{
			lock (SyncRoot)
			{
				return DefineDynamicModuleInternalNoLock(name);
			}
		}

		private ModuleBuilder DefineDynamicModuleInternalNoLock(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			if (name[0] == '\0')
			{
				throw new ArgumentException(SR.Argument_InvalidName, "name");
			}
			if (_isManifestModuleUsedAsDefinedModule)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NoMultiModuleAssembly);
			}
			ModuleBuilder manifestModuleBuilder = _manifestModuleBuilder;
			_assemblyData._moduleBuilderList.Add(manifestModuleBuilder);
			if (manifestModuleBuilder == _manifestModuleBuilder)
			{
				_isManifestModuleUsedAsDefinedModule = true;
			}
			return manifestModuleBuilder;
		}

		internal static void CheckContext(params Type[][] typess)
		{
			if (typess == null)
			{
				return;
			}
			foreach (Type[] array in typess)
			{
				if (array != null)
				{
					CheckContext(array);
				}
			}
		}

		internal static void CheckContext(params Type[] types)
		{
			if (types == null)
			{
				return;
			}
			foreach (Type type in types)
			{
				if (!(type == null))
				{
					if (type.Module == null || type.Module.Assembly == null)
					{
						throw new ArgumentException(SR.Argument_TypeNotValid);
					}
					_ = type.Module.Assembly == typeof(object).Module.Assembly;
				}
			}
		}

		public override bool Equals(object? obj)
		{
			return InternalAssembly.Equals(obj);
		}

		public override int GetHashCode()
		{
			return InternalAssembly.GetHashCode();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return InternalAssembly.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return InternalAssembly.GetCustomAttributes(attributeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return InternalAssembly.IsDefined(attributeType, inherit);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return InternalAssembly.GetCustomAttributesData();
		}

		public override AssemblyName GetName(bool copiedName)
		{
			return InternalAssembly.GetName(copiedName);
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type? GetType(string name, bool throwOnError, bool ignoreCase)
		{
			return InternalAssembly.GetType(name, throwOnError, ignoreCase);
		}

		public override Module? GetModule(string name)
		{
			return InternalAssembly.GetModule(name);
		}

		[RequiresUnreferencedCode("Assembly references might be removed")]
		public override AssemblyName[] GetReferencedAssemblies()
		{
			return InternalAssembly.GetReferencedAssemblies();
		}

		public override Module[] GetModules(bool getResourceModules)
		{
			return InternalAssembly.GetModules(getResourceModules);
		}

		public override Module[] GetLoadedModules(bool getResourceModules)
		{
			return InternalAssembly.GetLoadedModules(getResourceModules);
		}

		public override Assembly GetSatelliteAssembly(CultureInfo culture)
		{
			return InternalAssembly.GetSatelliteAssembly(culture, null);
		}

		public override Assembly GetSatelliteAssembly(CultureInfo culture, Version? version)
		{
			return InternalAssembly.GetSatelliteAssembly(culture, version);
		}

		public ModuleBuilder? GetDynamicModule(string name)
		{
			lock (SyncRoot)
			{
				return GetDynamicModuleNoLock(name);
			}
		}

		private ModuleBuilder GetDynamicModuleNoLock(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			for (int i = 0; i < _assemblyData._moduleBuilderList.Count; i++)
			{
				ModuleBuilder moduleBuilder = _assemblyData._moduleBuilderList[i];
				if (moduleBuilder._moduleData._moduleName.Equals(name))
				{
					return moduleBuilder;
				}
			}
			return null;
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (binaryAttribute == null)
			{
				throw new ArgumentNullException("binaryAttribute");
			}
			lock (SyncRoot)
			{
				TypeBuilder.DefineCustomAttribute(_manifestModuleBuilder, 536870913, _manifestModuleBuilder.GetConstructorToken(con), binaryAttribute);
			}
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			if (customBuilder == null)
			{
				throw new ArgumentNullException("customBuilder");
			}
			lock (SyncRoot)
			{
				customBuilder.CreateCustomAttribute(_manifestModuleBuilder, 536870913);
			}
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type[] GetExportedTypes()
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override FileStream GetFile(string name)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		[RequiresAssemblyFiles("This member throws an exception for assemblies embedded in a single-file app")]
		public override FileStream[] GetFiles(bool getResourceModules)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		public override ManifestResourceInfo? GetManifestResourceInfo(string resourceName)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		public override string[] GetManifestResourceNames()
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		public override Stream? GetManifestResourceStream(string name)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}

		public override Stream? GetManifestResourceStream(Type type, string name)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
		}
	}
	internal sealed class AssemblyBuilderData
	{
		public readonly List<ModuleBuilder> _moduleBuilderList;

		public readonly AssemblyBuilderAccess _access;

		internal AssemblyBuilderData(AssemblyBuilderAccess access)
		{
			_access = access;
			_moduleBuilderList = new List<ModuleBuilder>();
		}

		public void CheckTypeNameConflict(string strTypeName, TypeBuilder enclosingType)
		{
			for (int i = 0; i < _moduleBuilderList.Count; i++)
			{
				ModuleBuilder moduleBuilder = _moduleBuilderList[i];
				moduleBuilder.CheckTypeNameConflict(strTypeName, enclosingType);
			}
		}
	}
	public sealed class ConstructorBuilder : ConstructorInfo
	{
		private readonly MethodBuilder m_methodBuilder;

		internal bool m_isDefaultConstructor;

		public override int MetadataToken => m_methodBuilder.MetadataToken;

		public override Module Module => m_methodBuilder.Module;

		public override Type? ReflectedType => m_methodBuilder.ReflectedType;

		public override Type? DeclaringType => m_methodBuilder.DeclaringType;

		public override string Name => m_methodBuilder.Name;

		public override MethodAttributes Attributes => m_methodBuilder.Attributes;

		public override RuntimeMethodHandle MethodHandle => m_methodBuilder.MethodHandle;

		public override CallingConventions CallingConvention
		{
			get
			{
				if (DeclaringType.IsGenericType)
				{
					return CallingConventions.HasThis;
				}
				return CallingConventions.Standard;
			}
		}

		public bool InitLocals
		{
			get
			{
				return m_methodBuilder.InitLocals;
			}
			set
			{
				m_methodBuilder.InitLocals = value;
			}
		}

		internal ConstructorBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers, ModuleBuilder mod, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TypeBuilder type)
		{
			m_methodBuilder = new MethodBuilder(name, attributes, callingConvention, null, null, null, parameterTypes, requiredCustomModifiers, optionalCustomModifiers, mod, type);
			type.m_listMethods.Add(m_methodBuilder);
			m_methodBuilder.GetMethodSignature().InternalGetSignature(out var _);
			int metadataToken = m_methodBuilder.MetadataToken;
		}

		internal ConstructorBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes, ModuleBuilder mod, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TypeBuilder type)
			: this(name, attributes, callingConvention, parameterTypes, null, null, mod, type)
		{
		}

		internal override Type[] GetParameterTypes()
		{
			return m_methodBuilder.GetParameterTypes();
		}

		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		private TypeBuilder GetTypeBuilder()
		{
			return m_methodBuilder.GetTypeBuilder();
		}

		internal SignatureHelper GetMethodSignature()
		{
			return m_methodBuilder.GetMethodSignature();
		}

		public override string ToString()
		{
			return m_methodBuilder.ToString();
		}

		public override object Invoke(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override ParameterInfo[] GetParameters()
		{
			ConstructorInfo constructor = GetTypeBuilder().GetConstructor(m_methodBuilder.m_parameterTypes);
			return constructor.GetParameters();
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			return m_methodBuilder.GetMethodImplementationFlags();
		}

		public override object Invoke(BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return m_methodBuilder.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return m_methodBuilder.GetCustomAttributes(attributeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return m_methodBuilder.IsDefined(attributeType, inherit);
		}

		public ParameterBuilder DefineParameter(int iSequence, ParameterAttributes attributes, string? strParamName)
		{
			attributes &= ~ParameterAttributes.ReservedMask;
			return m_methodBuilder.DefineParameter(iSequence, attributes, strParamName);
		}

		public ILGenerator GetILGenerator()
		{
			if (m_isDefaultConstructor)
			{
				throw new InvalidOperationException(SR.InvalidOperation_DefaultConstructorILGen);
			}
			return m_methodBuilder.GetILGenerator();
		}

		public ILGenerator GetILGenerator(int streamSize)
		{
			if (m_isDefaultConstructor)
			{
				throw new InvalidOperationException(SR.InvalidOperation_DefaultConstructorILGen);
			}
			return m_methodBuilder.GetILGenerator(streamSize);
		}

		internal override Type GetReturnType()
		{
			return m_methodBuilder.ReturnType;
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			m_methodBuilder.SetCustomAttribute(con, binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			m_methodBuilder.SetCustomAttribute(customBuilder);
		}

		public void SetImplementationFlags(MethodImplAttributes attributes)
		{
			m_methodBuilder.SetImplementationFlags(attributes);
		}
	}
	public class CustomAttributeBuilder
	{
		internal ConstructorInfo m_con;

		private object[] m_constructorArgs;

		private byte[] m_blob;

		public CustomAttributeBuilder(ConstructorInfo con, object?[] constructorArgs)
			: this(con, constructorArgs, Array.Empty<PropertyInfo>(), Array.Empty<object>(), Array.Empty<FieldInfo>(), Array.Empty<object>())
		{
		}

		public CustomAttributeBuilder(ConstructorInfo con, object?[] constructorArgs, PropertyInfo[] namedProperties, object?[] propertyValues)
			: this(con, constructorArgs, namedProperties, propertyValues, Array.Empty<FieldInfo>(), Array.Empty<object>())
		{
		}

		public CustomAttributeBuilder(ConstructorInfo con, object?[] constructorArgs, FieldInfo[] namedFields, object?[] fieldValues)
			: this(con, constructorArgs, Array.Empty<PropertyInfo>(), Array.Empty<object>(), namedFields, fieldValues)
		{
		}

		public CustomAttributeBuilder(ConstructorInfo con, object?[] constructorArgs, PropertyInfo[] namedProperties, object?[] propertyValues, FieldInfo[] namedFields, object?[] fieldValues)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (constructorArgs == null)
			{
				throw new ArgumentNullException("constructorArgs");
			}
			if (namedProperties == null)
			{
				throw new ArgumentNullException("namedProperties");
			}
			if (propertyValues == null)
			{
				throw new ArgumentNullException("propertyValues");
			}
			if (namedFields == null)
			{
				throw new ArgumentNullException("namedFields");
			}
			if (fieldValues == null)
			{
				throw new ArgumentNullException("fieldValues");
			}
			if (namedProperties.Length != propertyValues.Length)
			{
				throw new ArgumentException(SR.Arg_ArrayLengthsDiffer, "namedProperties, propertyValues");
			}
			if (namedFields.Length != fieldValues.Length)
			{
				throw new ArgumentException(SR.Arg_ArrayLengthsDiffer, "namedFields, fieldValues");
			}
			if ((con.Attributes & MethodAttributes.Static) == MethodAttributes.Static || (con.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private)
			{
				throw new ArgumentException(SR.Argument_BadConstructor);
			}
			if ((con.CallingConvention & CallingConventions.Standard) != CallingConventions.Standard)
			{
				throw new ArgumentException(SR.Argument_BadConstructorCallConv);
			}
			m_con = con;
			m_constructorArgs = new object[constructorArgs.Length];
			Array.Copy(constructorArgs, m_constructorArgs, constructorArgs.Length);
			Type[] parameterTypes = con.GetParameterTypes();
			if (parameterTypes.Length != constructorArgs.Length)
			{
				throw new ArgumentException(SR.Argument_BadParameterCountsForConstructor);
			}
			for (int i = 0; i < parameterTypes.Length; i++)
			{
				if (!ValidateType(parameterTypes[i]))
				{
					throw new ArgumentException(SR.Argument_BadTypeInCustomAttribute);
				}
			}
			for (int i = 0; i < parameterTypes.Length; i++)
			{
				object obj = constructorArgs[i];
				if (obj == null)
				{
					if (parameterTypes[i].IsValueType)
					{
						throw new ArgumentNullException($"{"constructorArgs"}[{i}]");
					}
				}
				else
				{
					VerifyTypeAndPassedObjectType(parameterTypes[i], obj.GetType(), $"{"constructorArgs"}[{i}]");
				}
			}
			MemoryStream output = new MemoryStream();
			BinaryWriter binaryWriter = new BinaryWriter(output);
			binaryWriter.Write((ushort)1);
			for (int i = 0; i < constructorArgs.Length; i++)
			{
				EmitValue(binaryWriter, parameterTypes[i], constructorArgs[i]);
			}
			binaryWriter.Write((ushort)(namedProperties.Length + namedFields.Length));
			for (int i = 0; i < namedProperties.Length; i++)
			{
				PropertyInfo propertyInfo = namedProperties[i];
				if (propertyInfo == null)
				{
					throw new ArgumentNullException("namedProperties[" + i + "]");
				}
				Type propertyType = propertyInfo.PropertyType;
				object obj2 = propertyValues[i];
				if (obj2 == null && propertyType.IsValueType)
				{
					throw new ArgumentNullException("propertyValues[" + i + "]");
				}
				if (!ValidateType(propertyType))
				{
					throw new ArgumentException(SR.Argument_BadTypeInCustomAttribute);
				}
				if (!propertyInfo.CanWrite)
				{
					throw new ArgumentException(SR.Argument_NotAWritableProperty);
				}
				if (propertyInfo.DeclaringType != con.DeclaringType && !(con.DeclaringType is TypeBuilderInstantiation) && !con.DeclaringType.IsSubclassOf(propertyInfo.DeclaringType) && !TypeBuilder.IsTypeEqual(propertyInfo.DeclaringType, con.DeclaringType) && (!(propertyInfo.DeclaringType is TypeBuilder) || !con.DeclaringType.IsSubclassOf(((TypeBuilder)propertyInfo.DeclaringType).BakedRuntimeType)))
				{
					throw new ArgumentException(SR.Argument_BadPropertyForConstructorBuilder);
				}
				if (obj2 != null)
				{
					VerifyTypeAndPassedObjectType(propertyType, obj2.GetType(), $"{"propertyValues"}[{i}]");
				}
				binaryWriter.Write((byte)84);
				EmitType(binaryWriter, propertyType);
				EmitString(binaryWriter, namedProperties[i].Name);
				EmitValue(binaryWriter, propertyType, obj2);
			}
			for (int i = 0; i < namedFields.Length; i++)
			{
				FieldInfo fieldInfo = namedFields[i];
				if (fieldInfo == null)
				{
					throw new ArgumentNullException("namedFields[" + i + "]");
				}
				Type fieldType = fieldInfo.FieldType;
				object obj3 = fieldValues[i];
				if (obj3 == null && fieldType.IsValueType)
				{
					throw new ArgumentNullException("fieldValues[" + i + "]");
				}
				if (!ValidateType(fieldType))
				{
					throw new ArgumentException(SR.Argument_BadTypeInCustomAttribute);
				}
				if (fieldInfo.DeclaringType != con.DeclaringType && !(con.DeclaringType is TypeBuilderInstantiation) && !con.DeclaringType.IsSubclassOf(fieldInfo.DeclaringType) && !TypeBuilder.IsTypeEqual(fieldInfo.DeclaringType, con.DeclaringType) && (!(fieldInfo.DeclaringType is TypeBuilder) || !con.DeclaringType.IsSubclassOf(((TypeBuilder)namedFields[i].DeclaringType).BakedRuntimeType)))
				{
					throw new ArgumentException(SR.Argument_BadFieldForConstructorBuilder);
				}
				if (obj3 != null)
				{
					VerifyTypeAndPassedObjectType(fieldType, obj3.GetType(), $"{"fieldValues"}[{i}]");
				}
				binaryWriter.Write((byte)83);
				EmitType(binaryWriter, fieldType);
				EmitString(binaryWriter, fieldInfo.Name);
				EmitValue(binaryWriter, fieldType, obj3);
			}
			m_blob = ((MemoryStream)binaryWriter.BaseStream).ToArray();
		}

		private bool ValidateType(Type t)
		{
			if (t.IsPrimitive)
			{
				if (t != typeof(IntPtr))
				{
					return t != typeof(UIntPtr);
				}
				return false;
			}
			if (t == typeof(string) || t == typeof(Type))
			{
				return true;
			}
			if (t.IsEnum)
			{
				TypeCode typeCode = Type.GetTypeCode(Enum.GetUnderlyingType(t));
				if ((uint)(typeCode - 5) <= 7u)
				{
					return true;
				}
				return false;
			}
			if (t.IsArray)
			{
				if (t.GetArrayRank() == 1)
				{
					return ValidateType(t.GetElementType());
				}
				return false;
			}
			return t == typeof(object);
		}

		private static void VerifyTypeAndPassedObjectType(Type type, Type passedType, string paramName)
		{
			if (type != typeof(object) && Type.GetTypeCode(passedType) != Type.GetTypeCode(type))
			{
				throw new ArgumentException(SR.Argument_ConstantDoesntMatch);
			}
			if (passedType == typeof(IntPtr) || passedType == typeof(UIntPtr))
			{
				throw new ArgumentException(SR.Format(SR.Argument_BadParameterTypeForCAB, passedType), paramName);
			}
		}

		private static void EmitType(BinaryWriter writer, Type type)
		{
			if (type.IsPrimitive)
			{
				switch (Type.GetTypeCode(type))
				{
				case TypeCode.SByte:
					writer.Write((byte)4);
					break;
				case TypeCode.Byte:
					writer.Write((byte)5);
					break;
				case TypeCode.Char:
					writer.Write((byte)3);
					break;
				case TypeCode.Boolean:
					writer.Write((byte)2);
					break;
				case TypeCode.Int16:
					writer.Write((byte)6);
					break;
				case TypeCode.UInt16:
					writer.Write((byte)7);
					break;
				case TypeCode.Int32:
					writer.Write((byte)8);
					break;
				case TypeCode.UInt32:
					writer.Write((byte)9);
					break;
				case TypeCode.Int64:
					writer.Write((byte)10);
					break;
				case TypeCode.UInt64:
					writer.Write((byte)11);
					break;
				case TypeCode.Single:
					writer.Write((byte)12);
					break;
				case TypeCode.Double:
					writer.Write((byte)13);
					break;
				}
			}
			else if (type.IsEnum)
			{
				writer.Write((byte)85);
				EmitString(writer, type.AssemblyQualifiedName);
			}
			else if (type == typeof(string))
			{
				writer.Write((byte)14);
			}
			else if (type == typeof(Type))
			{
				writer.Write((byte)80);
			}
			else if (type.IsArray)
			{
				writer.Write((byte)29);
				EmitType(writer, type.GetElementType());
			}
			else
			{
				writer.Write((byte)81);
			}
		}

		private static void EmitString(BinaryWriter writer, string str)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(str);
			uint num = (uint)bytes.Length;
			if (num <= 127)
			{
				writer.Write((byte)num);
			}
			else if (num <= 16383)
			{
				writer.Write(BinaryPrimitives.ReverseEndianness((short)(num | 0x8000)));
			}
			else
			{
				writer.Write(BinaryPrimitives.ReverseEndianness(num | 0xC0000000u));
			}
			writer.Write(bytes);
		}

		private static void EmitValue(BinaryWriter writer, Type type, object value)
		{
			if (type.IsEnum)
			{
				switch (Type.GetTypeCode(Enum.GetUnderlyingType(type)))
				{
				case TypeCode.SByte:
					writer.Write((sbyte)value);
					break;
				case TypeCode.Byte:
					writer.Write((byte)value);
					break;
				case TypeCode.Int16:
					writer.Write((short)value);
					break;
				case TypeCode.UInt16:
					writer.Write((ushort)value);
					break;
				case TypeCode.Int32:
					writer.Write((int)value);
					break;
				case TypeCode.UInt32:
					writer.Write((uint)value);
					break;
				case TypeCode.Int64:
					writer.Write((long)value);
					break;
				case TypeCode.UInt64:
					writer.Write((ulong)value);
					break;
				}
				return;
			}
			if (type == typeof(string))
			{
				if (value == null)
				{
					writer.Write(byte.MaxValue);
				}
				else
				{
					EmitString(writer, (string)value);
				}
				return;
			}
			if (type == typeof(Type))
			{
				if (value == null)
				{
					writer.Write(byte.MaxValue);
					return;
				}
				string text = TypeNameBuilder.ToString((Type)value, TypeNameBuilder.Format.AssemblyQualifiedName);
				if (text == null)
				{
					throw new ArgumentException(SR.Format(SR.Argument_InvalidTypeForCA, value.GetType()));
				}
				EmitString(writer, text);
				return;
			}
			if (type.IsArray)
			{
				if (value == null)
				{
					writer.Write(uint.MaxValue);
					return;
				}
				Array array = (Array)value;
				Type elementType = type.GetElementType();
				writer.Write(array.Length);
				for (int i = 0; i < array.Length; i++)
				{
					EmitValue(writer, elementType, array.GetValue(i));
				}
				return;
			}
			if (type.IsPrimitive)
			{
				switch (Type.GetTypeCode(type))
				{
				case TypeCode.SByte:
					writer.Write((sbyte)value);
					break;
				case TypeCode.Byte:
					writer.Write((byte)value);
					break;
				case TypeCode.Char:
					writer.Write(Convert.ToUInt16((char)value));
					break;
				case TypeCode.Boolean:
					writer.Write((byte)(((bool)value) ? 1u : 0u));
					break;
				case TypeCode.Int16:
					writer.Write((short)value);
					break;
				case TypeCode.UInt16:
					writer.Write((ushort)value);
					break;
				case TypeCode.Int32:
					writer.Write((int)value);
					break;
				case TypeCode.UInt32:
					writer.Write((uint)value);
					break;
				case TypeCode.Int64:
					writer.Write((long)value);
					break;
				case TypeCode.UInt64:
					writer.Write((ulong)value);
					break;
				case TypeCode.Single:
					writer.Write((float)value);
					break;
				case TypeCode.Double:
					writer.Write((double)value);
					break;
				}
				return;
			}
			if (type == typeof(object))
			{
				Type type2 = ((value == null) ? typeof(string) : ((value is Type) ? typeof(Type) : value.GetType()));
				if (type2 == typeof(object))
				{
					throw new ArgumentException(SR.Format(SR.Argument_BadParameterTypeForCAB, type2));
				}
				EmitType(writer, type2);
				EmitValue(writer, type2, value);
				return;
			}
			string p = "null";
			if (value != null)
			{
				p = value.GetType().ToString();
			}
			throw new ArgumentException(SR.Format(SR.Argument_BadParameterTypeForCAB, p));
		}

		internal void CreateCustomAttribute(ModuleBuilder mod, int tkOwner)
		{
			TypeBuilder.DefineCustomAttribute(mod, tkOwner, mod.GetConstructorToken(m_con), m_blob);
		}
	}
	internal sealed class DynamicILGenerator : ILGenerator
	{
		internal DynamicScope m_scope;

		private int m_methodSigToken;

		internal DynamicILGenerator(DynamicMethod method, byte[] methodSignature, int size)
			: base(method, size)
		{
			m_scope = new DynamicScope();
			m_methodSigToken = m_scope.GetTokenFor(methodSignature);
		}

		internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm)
		{
			dm.m_methodHandle = ModuleHandle.GetDynamicMethod(dm, module, m_methodBuilder.Name, (byte[])m_scope[m_methodSigToken], new DynamicResolver(this));
		}

		public override LocalBuilder DeclareLocal(Type localType, bool pinned)
		{
			if (localType == null)
			{
				throw new ArgumentNullException("localType");
			}
			RuntimeType runtimeType = localType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType);
			}
			LocalBuilder result = new LocalBuilder(m_localCount, localType, m_methodBuilder);
			m_localSignature.AddArgument(localType, pinned);
			m_localCount++;
			return result;
		}

		public override void Emit(OpCode opcode, MethodInfo meth)
		{
			if (meth == null)
			{
				throw new ArgumentNullException("meth");
			}
			int num = 0;
			int num2 = 0;
			DynamicMethod dynamicMethod = meth as DynamicMethod;
			if (dynamicMethod == null)
			{
				RuntimeMethodInfo runtimeMethodInfo = meth as RuntimeMethodInfo;
				if (runtimeMethodInfo == null)
				{
					throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, "meth");
				}
				RuntimeType runtimeType = runtimeMethodInfo.GetRuntimeType();
				num2 = ((!(runtimeType != null) || (!runtimeType.IsGenericType && !runtimeType.IsArray)) ? GetTokenFor(runtimeMethodInfo) : GetTokenFor(runtimeMethodInfo, runtimeType));
			}
			else
			{
				if (opcode.Equals(OpCodes.Ldtoken) || opcode.Equals(OpCodes.Ldftn) || opcode.Equals(OpCodes.Ldvirtftn))
				{
					throw new ArgumentException(SR.Argument_InvalidOpCodeOnDynamicMethod);
				}
				num2 = GetTokenFor(dynamicMethod);
			}
			EnsureCapacity(7);
			InternalEmit(opcode);
			if (opcode.StackBehaviourPush == StackBehaviour.Varpush && meth.ReturnType != typeof(void))
			{
				num++;
			}
			if (opcode.StackBehaviourPop == StackBehaviour.Varpop)
			{
				num -= meth.GetParametersNoCopy().Length;
			}
			if (!meth.IsStatic && !opcode.Equals(OpCodes.Newobj) && !opcode.Equals(OpCodes.Ldtoken) && !opcode.Equals(OpCodes.Ldftn))
			{
				num--;
			}
			UpdateStackSize(opcode, num);
			PutInteger4(num2);
		}

		public override void Emit(OpCode opcode, ConstructorInfo con)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			RuntimeConstructorInfo runtimeConstructorInfo = con as RuntimeConstructorInfo;
			if (runtimeConstructorInfo == null)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, "con");
			}
			RuntimeType runtimeType = runtimeConstructorInfo.GetRuntimeType();
			int value = ((!(runtimeType != null) || (!runtimeType.IsGenericType && !runtimeType.IsArray)) ? GetTokenFor(runtimeConstructorInfo) : GetTokenFor(runtimeConstructorInfo, runtimeType));
			EnsureCapacity(7);
			InternalEmit(opcode);
			UpdateStackSize(opcode, 1);
			PutInteger4(value);
		}

		public override void Emit(OpCode opcode, Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			RuntimeType runtimeType = type as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType);
			}
			int tokenFor = GetTokenFor(runtimeType);
			EnsureCapacity(7);
			InternalEmit(opcode);
			PutInteger4(tokenFor);
		}

		public override void Emit(OpCode opcode, FieldInfo field)
		{
			if (field == null)
			{
				throw new ArgumentNullException("field");
			}
			RuntimeFieldInfo runtimeFieldInfo = field as RuntimeFieldInfo;
			if (runtimeFieldInfo == null)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, "field");
			}
			int value = ((!(field.DeclaringType == null)) ? GetTokenFor(runtimeFieldInfo, runtimeFieldInfo.GetRuntimeType()) : GetTokenFor(runtimeFieldInfo));
			EnsureCapacity(7);
			InternalEmit(opcode);
			PutInteger4(value);
		}

		public override void Emit(OpCode opcode, string str)
		{
			if (str == null)
			{
				throw new ArgumentNullException("str");
			}
			int tokenForString = GetTokenForString(str);
			EnsureCapacity(7);
			InternalEmit(opcode);
			PutInteger4(tokenForString);
		}

		public override void EmitCalli(OpCode opcode, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
		{
			int num = 0;
			if (optionalParameterTypes != null && (callingConvention & CallingConventions.VarArgs) == 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotAVarArgCallingConvention);
			}
			SignatureHelper memberRefSignature = GetMemberRefSignature(callingConvention, returnType, parameterTypes, optionalParameterTypes);
			EnsureCapacity(7);
			Emit(OpCodes.Calli);
			if (returnType != typeof(void))
			{
				num++;
			}
			if (parameterTypes != null)
			{
				num -= parameterTypes.Length;
			}
			if (optionalParameterTypes != null)
			{
				num -= optionalParameterTypes.Length;
			}
			if ((callingConvention & CallingConventions.HasThis) == CallingConventions.HasThis)
			{
				num--;
			}
			num--;
			UpdateStackSize(OpCodes.Calli, num);
			int tokenForSig = GetTokenForSig(memberRefSignature.GetSignature(appendEndOfSig: true));
			PutInteger4(tokenForSig);
		}

		public override void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes)
		{
			int num = 0;
			int num2 = 0;
			if (parameterTypes != null)
			{
				num2 = parameterTypes.Length;
			}
			SignatureHelper methodSigHelper = SignatureHelper.GetMethodSigHelper(unmanagedCallConv, returnType);
			if (parameterTypes != null)
			{
				for (int i = 0; i < num2; i++)
				{
					methodSigHelper.AddArgument(parameterTypes[i]);
				}
			}
			if (returnType != typeof(void))
			{
				num++;
			}
			if (parameterTypes != null)
			{
				num -= num2;
			}
			num--;
			UpdateStackSize(OpCodes.Calli, num);
			EnsureCapacity(7);
			Emit(OpCodes.Calli);
			int tokenForSig = GetTokenForSig(methodSigHelper.GetSignature(appendEndOfSig: true));
			PutInteger4(tokenForSig);
		}

		public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
		{
			if (methodInfo == null)
			{
				throw new ArgumentNullException("methodInfo");
			}
			if (!opcode.Equals(OpCodes.Call) && !opcode.Equals(OpCodes.Callvirt) && !opcode.Equals(OpCodes.Newobj))
			{
				throw new ArgumentException(SR.Argument_NotMethodCallOpcode, "opcode");
			}
			if (methodInfo.ContainsGenericParameters)
			{
				throw new ArgumentException(SR.Argument_GenericsInvalid, "methodInfo");
			}
			if (methodInfo.DeclaringType != null && methodInfo.DeclaringType.ContainsGenericParameters)
			{
				throw new ArgumentException(SR.Argument_GenericsInvalid, "methodInfo");
			}
			int num = 0;
			int memberRefToken = GetMemberRefToken(methodInfo, optionalParameterTypes);
			EnsureCapacity(7);
			InternalEmit(opcode);
			if (methodInfo.ReturnType != typeof(void))
			{
				num++;
			}
			num -= methodInfo.GetParameterTypes().Length;
			if (!(methodInfo is SymbolMethod) && !methodInfo.IsStatic && !opcode.Equals(OpCodes.Newobj))
			{
				num--;
			}
			if (optionalParameterTypes != null)
			{
				num -= optionalParameterTypes.Length;
			}
			UpdateStackSize(opcode, num);
			PutInteger4(memberRefToken);
		}

		public override void Emit(OpCode opcode, SignatureHelper signature)
		{
			if (signature == null)
			{
				throw new ArgumentNullException("signature");
			}
			int num = 0;
			EnsureCapacity(7);
			InternalEmit(opcode);
			if (opcode.StackBehaviourPop == StackBehaviour.Varpop)
			{
				num -= signature.ArgumentCount;
				num--;
				UpdateStackSize(opcode, num);
			}
			int tokenForSig = GetTokenForSig(signature.GetSignature(appendEndOfSig: true));
			PutInteger4(tokenForSig);
		}

		public override void BeginExceptFilterBlock()
		{
			if (base.CurrExcStackCount == 0)
			{
				throw new NotSupportedException(SR.Argument_NotInExceptionBlock);
			}
			__ExceptionInfo _ExceptionInfo = base.CurrExcStack[base.CurrExcStackCount - 1];
			Label endLabel = _ExceptionInfo.GetEndLabel();
			Emit(OpCodes.Leave, endLabel);
			UpdateStackSize(OpCodes.Nop, 1);
			_ExceptionInfo.MarkFilterAddr(ILOffset);
		}

		public override void BeginCatchBlock(Type exceptionType)
		{
			if (base.CurrExcStackCount == 0)
			{
				throw new NotSupportedException(SR.Argument_NotInExceptionBlock);
			}
			__ExceptionInfo _ExceptionInfo = base.CurrExcStack[base.CurrExcStackCount - 1];
			RuntimeType runtimeType = exceptionType as RuntimeType;
			if (_ExceptionInfo.GetCurrentState() == 1)
			{
				if (exceptionType != null)
				{
					throw new ArgumentException(SR.Argument_ShouldNotSpecifyExceptionType);
				}
				Emit(OpCodes.Endfilter);
				_ExceptionInfo.MarkCatchAddr(ILOffset, null);
				return;
			}
			if (exceptionType == null)
			{
				throw new ArgumentNullException("exceptionType");
			}
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeType);
			}
			Label endLabel = _ExceptionInfo.GetEndLabel();
			Emit(OpCodes.Leave, endLabel);
			UpdateStackSize(OpCodes.Nop, 1);
			_ExceptionInfo.MarkCatchAddr(ILOffset, exceptionType);
			_ExceptionInfo.m_filterAddr[_ExceptionInfo.m_currentCatch - 1] = GetTokenFor(runtimeType);
		}

		public override void UsingNamespace(string ns)
		{
			throw new NotSupportedException(SR.InvalidOperation_NotAllowedInDynamicMethod);
		}

		public override void BeginScope()
		{
			throw new NotSupportedException(SR.InvalidOperation_NotAllowedInDynamicMethod);
		}

		public override void EndScope()
		{
			throw new NotSupportedException(SR.InvalidOperation_NotAllowedInDynamicMethod);
		}

		private int GetMemberRefToken(MethodBase methodInfo, Type[] optionalParameterTypes)
		{
			if (optionalParameterTypes != null && (methodInfo.CallingConvention & CallingConventions.VarArgs) == 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotAVarArgCallingConvention);
			}
			RuntimeMethodInfo runtimeMethodInfo = methodInfo as RuntimeMethodInfo;
			DynamicMethod dynamicMethod = methodInfo as DynamicMethod;
			if (runtimeMethodInfo == null && dynamicMethod == null)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, "methodInfo");
			}
			ParameterInfo[] parametersNoCopy = methodInfo.GetParametersNoCopy();
			Type[] array;
			Type[][] array2;
			Type[][] array3;
			if (parametersNoCopy != null && parametersNoCopy.Length != 0)
			{
				array = new Type[parametersNoCopy.Length];
				array2 = new Type[array.Length][];
				array3 = new Type[array.Length][];
				for (int i = 0; i < parametersNoCopy.Length; i++)
				{
					array[i] = parametersNoCopy[i].ParameterType;
					array2[i] = parametersNoCopy[i].GetRequiredCustomModifiers();
					array3[i] = parametersNoCopy[i].GetOptionalCustomModifiers();
				}
			}
			else
			{
				array = null;
				array2 = null;
				array3 = null;
			}
			SignatureHelper memberRefSignature = GetMemberRefSignature(methodInfo.CallingConvention, MethodBuilder.GetMethodBaseReturnType(methodInfo), array, array2, array3, optionalParameterTypes);
			if (runtimeMethodInfo != null)
			{
				return GetTokenForVarArgMethod(runtimeMethodInfo, memberRefSignature);
			}
			return GetTokenForVarArgMethod(dynamicMethod, memberRefSignature);
		}

		internal override SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers, Type[] optionalParameterTypes)
		{
			SignatureHelper methodSigHelper = SignatureHelper.GetMethodSigHelper(null, call, returnType, null, null, parameterTypes, requiredCustomModifiers, optionalCustomModifiers);
			if (optionalParameterTypes != null && optionalParameterTypes.Length != 0)
			{
				methodSigHelper.AddSentinel();
				methodSigHelper.AddArguments(optionalParameterTypes, null, null);
			}
			return methodSigHelper;
		}

		internal override void RecordTokenFixup()
		{
		}

		private int GetTokenFor(RuntimeType rtType)
		{
			return m_scope.GetTokenFor(rtType.TypeHandle);
		}

		private int GetTokenFor(RuntimeFieldInfo runtimeField)
		{
			return m_scope.GetTokenFor(runtimeField.FieldHandle);
		}

		private int GetTokenFor(RuntimeFieldInfo runtimeField, RuntimeType rtType)
		{
			return m_scope.GetTokenFor(runtimeField.FieldHandle, rtType.TypeHandle);
		}

		private int GetTokenFor(RuntimeConstructorInfo rtMeth)
		{
			return m_scope.GetTokenFor(rtMeth.MethodHandle);
		}

		private int GetTokenFor(RuntimeConstructorInfo rtMeth, RuntimeType rtType)
		{
			return m_scope.GetTokenFor(rtMeth.MethodHandle, rtType.TypeHandle);
		}

		private int GetTokenFor(RuntimeMethodInfo rtMeth)
		{
			return m_scope.GetTokenFor(rtMeth.MethodHandle);
		}

		private int GetTokenFor(RuntimeMethodInfo rtMeth, RuntimeType rtType)
		{
			return m_scope.GetTokenFor(rtMeth.MethodHandle, rtType.TypeHandle);
		}

		private int GetTokenFor(DynamicMethod dm)
		{
			return m_scope.GetTokenFor(dm);
		}

		private int GetTokenForVarArgMethod(RuntimeMethodInfo rtMeth, SignatureHelper sig)
		{
			VarArgMethod varArgMethod = new VarArgMethod(rtMeth, sig);
			return m_scope.GetTokenFor(varArgMethod);
		}

		private int GetTokenForVarArgMethod(DynamicMethod dm, SignatureHelper sig)
		{
			VarArgMethod varArgMethod = new VarArgMethod(dm, sig);
			return m_scope.GetTokenFor(varArgMethod);
		}

		private int GetTokenForString(string s)
		{
			return m_scope.GetTokenFor(s);
		}

		private int GetTokenForSig(byte[] sig)
		{
			return m_scope.GetTokenFor(sig);
		}
	}
	internal sealed class DynamicResolver : Resolver
	{
		private sealed class DestroyScout
		{
			internal RuntimeMethodHandleInternal m_methodHandle;

			~DestroyScout()
			{
				if (!m_methodHandle.IsNullHandle())
				{
					if (RuntimeMethodHandle.GetResolver(m_methodHandle) != null)
					{
						GC.ReRegisterForFinalize(this);
					}
					else
					{
						RuntimeMethodHandle.Destroy(m_methodHandle);
					}
				}
			}
		}

		[Flags]
		internal enum SecurityControlFlags
		{
			Default = 0,
			SkipVisibilityChecks = 1,
			RestrictedSkipVisibilityChecks = 2,
			HasCreationContext = 4,
			CanSkipCSEvaluation = 8
		}

		private __ExceptionInfo[] m_exceptions;

		private byte[] m_exceptionHeader;

		private DynamicMethod m_method;

		private byte[] m_code;

		private byte[] m_localSignature;

		private int m_stackSize;

		private DynamicScope m_scope;

		internal DynamicResolver(DynamicILGenerator ilGenerator)
		{
			m_stackSize = ilGenerator.GetMaxStackSize();
			m_exceptions = ilGenerator.GetExceptions();
			m_code = ilGenerator.BakeByteArray();
			m_localSignature = ilGenerator.m_localSignature.InternalGetSignatureArray();
			m_scope = ilGenerator.m_scope;
			m_method = (DynamicMethod)ilGenerator.m_methodBuilder;
			m_method.m_resolver = this;
		}

		internal DynamicResolver(DynamicILInfo dynamicILInfo)
		{
			m_stackSize = dynamicILInfo.MaxStackSize;
			m_code = dynamicILInfo.Code;
			m_localSignature = dynamicILInfo.LocalSignature;
			m_exceptionHeader = dynamicILInfo.Exceptions;
			m_scope = dynamicILInfo.DynamicScope;
			m_method = dynamicILInfo.DynamicMethod;
			m_method.m_resolver = this;
		}

		~DynamicResolver()
		{
			DynamicMethod method = m_method;
			if (!(method == null) && method.m_methodHandle != null)
			{
				DestroyScout destroyScout;
				try
				{
					destroyScout = new DestroyScout();
				}
				catch
				{
					GC.ReRegisterForFinalize(this);
					return;
				}
				destroyScout.m_methodHandle = method.m_methodHandle.Value;
			}
		}

		internal override RuntimeType GetJitContext(out int securityControlFlags)
		{
			SecurityControlFlags securityControlFlags2 = SecurityControlFlags.Default;
			if (m_method.m_restrictedSkipVisibility)
			{
				securityControlFlags2 |= SecurityControlFlags.RestrictedSkipVisibilityChecks;
			}
			else if (m_method.m_skipVisibility)
			{
				securityControlFlags2 |= SecurityControlFlags.SkipVisibilityChecks;
			}
			RuntimeType typeOwner = m_method.m_typeOwner;
			securityControlFlags = (int)securityControlFlags2;
			return typeOwner;
		}

		private static int CalculateNumberOfExceptions(__ExceptionInfo[] excp)
		{
			int num = 0;
			if (excp == null)
			{
				return 0;
			}
			for (int i = 0; i < excp.Length; i++)
			{
				num += excp[i].GetNumberOfCatches();
			}
			return num;
		}

		internal override byte[] GetCodeInfo(out int stackSize, out int initLocals, out int EHCount)
		{
			stackSize = m_stackSize;
			if (m_exceptionHeader != null && m_exceptionHeader.Length != 0)
			{
				if (m_exceptionHeader.Length < 4)
				{
					throw new FormatException();
				}
				byte b = m_exceptionHeader[0];
				if ((b & 0x40u) != 0)
				{
					int num = m_exceptionHeader[3] << 16;
					num |= m_exceptionHeader[2] << 8;
					num |= m_exceptionHeader[1];
					EHCount = (num - 4) / 24;
				}
				else
				{
					EHCount = (m_exceptionHeader[1] - 2) / 12;
				}
			}
			else
			{
				EHCount = CalculateNumberOfExceptions(m_exceptions);
			}
			initLocals = (m_method.InitLocals ? 1 : 0);
			return m_code;
		}

		internal override byte[] GetLocalsSignature()
		{
			return m_localSignature;
		}

		internal override byte[] GetRawEHInfo()
		{
			return m_exceptionHeader;
		}

		internal unsafe override void GetEHInfo(int excNumber, void* exc)
		{
			for (int i = 0; i < m_exceptions.Length; i++)
			{
				int numberOfCatches = m_exceptions[i].GetNumberOfCatches();
				if (excNumber < numberOfCatches)
				{
					((CORINFO_EH_CLAUSE*)exc)->Flags = m_exceptions[i].GetExceptionTypes()[excNumber];
					((CORINFO_EH_CLAUSE*)exc)->TryOffset = m_exceptions[i].GetStartAddress();
					if ((((CORINFO_EH_CLAUSE*)exc)->Flags & 2) != 2)
					{
						((CORINFO_EH_CLAUSE*)exc)->TryLength = m_exceptions[i].GetEndAddress() - ((CORINFO_EH_CLAUSE*)exc)->TryOffset;
					}
					else
					{
						((CORINFO_EH_CLAUSE*)exc)->TryLength = m_exceptions[i].GetFinallyEndAddress() - ((CORINFO_EH_CLAUSE*)exc)->TryOffset;
					}
					((CORINFO_EH_CLAUSE*)exc)->HandlerOffset = m_exceptions[i].GetCatchAddresses()[excNumber];
					((CORINFO_EH_CLAUSE*)exc)->HandlerLength = m_exceptions[i].GetCatchEndAddresses()[excNumber] - ((CORINFO_EH_CLAUSE*)exc)->HandlerOffset;
					((CORINFO_EH_CLAUSE*)exc)->ClassTokenOrFilterOffset = m_exceptions[i].GetFilterAddresses()[excNumber];
					break;
				}
				excNumber -= numberOfCatches;
			}
		}

		internal override string GetStringLiteral(int token)
		{
			return m_scope.GetString(token);
		}

		internal override void ResolveToken(int token, out IntPtr typeHandle, out IntPtr methodHandle, out IntPtr fieldHandle)
		{
			typeHandle = default(IntPtr);
			methodHandle = default(IntPtr);
			fieldHandle = default(IntPtr);
			object obj = m_scope[token];
			if (obj == null)
			{
				throw new InvalidProgramException();
			}
			if (obj is RuntimeTypeHandle)
			{
				typeHandle = ((RuntimeTypeHandle)obj).Value;
				return;
			}
			if (obj is RuntimeMethodHandle)
			{
				methodHandle = ((RuntimeMethodHandle)obj).Value;
				return;
			}
			if (obj is RuntimeFieldHandle)
			{
				fieldHandle = ((RuntimeFieldHandle)obj).Value;
				return;
			}
			DynamicMethod dynamicMethod = obj as DynamicMethod;
			if (dynamicMethod != null)
			{
				methodHandle = dynamicMethod.GetMethodDescriptor().Value;
			}
			else if (obj is GenericMethodInfo genericMethodInfo)
			{
				methodHandle = genericMethodInfo.m_methodHandle.Value;
				typeHandle = genericMethodInfo.m_context.Value;
			}
			else if (obj is GenericFieldInfo genericFieldInfo)
			{
				fieldHandle = genericFieldInfo.m_fieldHandle.Value;
				typeHandle = genericFieldInfo.m_context.Value;
			}
			else if (obj is VarArgMethod varArgMethod)
			{
				if (varArgMethod.m_dynamicMethod == null)
				{
					methodHandle = varArgMethod.m_method.MethodHandle.Value;
					typeHandle = varArgMethod.m_method.GetDeclaringTypeInternal().GetTypeHandleInternal().Value;
				}
				else
				{
					methodHandle = varArgMethod.m_dynamicMethod.GetMethodDescriptor().Value;
				}
			}
		}

		internal override byte[] ResolveSignature(int token, int fromMethod)
		{
			return m_scope.ResolveSignature(token, fromMethod);
		}

		internal override MethodInfo GetDynamicMethod()
		{
			return m_method.GetMethodInfo();
		}
	}
	public class DynamicILInfo
	{
		private DynamicMethod m_method;

		private DynamicScope m_scope;

		private byte[] m_exceptions;

		private byte[] m_code;

		private byte[] m_localSignature;

		private int m_maxStackSize;

		private int m_methodSignature;

		internal byte[] LocalSignature => m_localSignature ?? (m_localSignature = SignatureHelper.GetLocalVarSigHelper().InternalGetSignatureArray());

		internal byte[] Exceptions => m_exceptions;

		internal byte[] Code => m_code;

		internal int MaxStackSize => m_maxStackSize;

		public DynamicMethod DynamicMethod => m_method;

		internal DynamicScope DynamicScope => m_scope;

		internal DynamicILInfo(DynamicMethod method, byte[] methodSignature)
		{
			m_scope = new DynamicScope();
			m_method = method;
			m_methodSignature = m_scope.GetTokenFor(methodSignature);
			m_exceptions = Array.Empty<byte>();
			m_code = Array.Empty<byte>();
			m_localSignature = Array.Empty<byte>();
		}

		internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm)
		{
			dm.m_methodHandle = ModuleHandle.GetDynamicMethod(dm, module, m_method.Name, (byte[])m_scope[m_methodSignature], new DynamicResolver(this));
		}

		public void SetCode(byte[]? code, int maxStackSize)
		{
			m_code = ((code != null) ? ((byte[])code.Clone()) : Array.Empty<byte>());
			m_maxStackSize = maxStackSize;
		}

		[CLSCompliant(false)]
		public unsafe void SetCode(byte* code, int codeSize, int maxStackSize)
		{
			if (codeSize < 0)
			{
				throw new ArgumentOutOfRangeException("codeSize", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (codeSize > 0 && code == null)
			{
				throw new ArgumentNullException("code");
			}
			m_code = new Span<byte>(code, codeSize).ToArray();
			m_maxStackSize = maxStackSize;
		}

		public void SetExceptions(byte[]? exceptions)
		{
			m_exceptions = ((exceptions != null) ? ((byte[])exceptions.Clone()) : Array.Empty<byte>());
		}

		[CLSCompliant(false)]
		public unsafe void SetExceptions(byte* exceptions, int exceptionsSize)
		{
			if (exceptionsSize < 0)
			{
				throw new ArgumentOutOfRangeException("exceptionsSize", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (exceptionsSize > 0 && exceptions == null)
			{
				throw new ArgumentNullException("exceptions");
			}
			m_exceptions = new Span<byte>(exceptions, exceptionsSize).ToArray();
		}

		public void SetLocalSignature(byte[]? localSignature)
		{
			m_localSignature = ((localSignature != null) ? ((byte[])localSignature.Clone()) : Array.Empty<byte>());
		}

		[CLSCompliant(false)]
		public unsafe void SetLocalSignature(byte* localSignature, int signatureSize)
		{
			if (signatureSize < 0)
			{
				throw new ArgumentOutOfRangeException("signatureSize", SR.ArgumentOutOfRange_GenericPositive);
			}
			if (signatureSize > 0 && localSignature == null)
			{
				throw new ArgumentNullException("localSignature");
			}
			m_localSignature = new Span<byte>(localSignature, signatureSize).ToArray();
		}

		public int GetTokenFor(RuntimeMethodHandle method)
		{
			return DynamicScope.GetTokenFor(method);
		}

		public int GetTokenFor(DynamicMethod method)
		{
			return DynamicScope.GetTokenFor(method);
		}

		public int GetTokenFor(RuntimeMethodHandle method, RuntimeTypeHandle contextType)
		{
			return DynamicScope.GetTokenFor(method, contextType);
		}

		public int GetTokenFor(RuntimeFieldHandle field)
		{
			return DynamicScope.GetTokenFor(field);
		}

		public int GetTokenFor(RuntimeFieldHandle field, RuntimeTypeHandle contextType)
		{
			return DynamicScope.GetTokenFor(field, contextType);
		}

		public int GetTokenFor(RuntimeTypeHandle type)
		{
			return DynamicScope.GetTokenFor(type);
		}

		public int GetTokenFor(string literal)
		{
			return DynamicScope.GetTokenFor(literal);
		}

		public int GetTokenFor(byte[] signature)
		{
			return DynamicScope.GetTokenFor(signature);
		}
	}
	internal sealed class DynamicScope
	{
		internal readonly List<object> m_tokens = new List<object> { null };

		internal object this[int token]
		{
			get
			{
				token &= 0xFFFFFF;
				if (token < 0 || token > m_tokens.Count)
				{
					return null;
				}
				return m_tokens[token];
			}
		}

		internal int GetTokenFor(VarArgMethod varArgMethod)
		{
			m_tokens.Add(varArgMethod);
			return (m_tokens.Count - 1) | 0xA000000;
		}

		internal string GetString(int token)
		{
			return this[token] as string;
		}

		internal byte[] ResolveSignature(int token, int fromMethod)
		{
			if (fromMethod == 0)
			{
				return (byte[])this[token];
			}
			if (!(this[token] is VarArgMethod varArgMethod))
			{
				return null;
			}
			return varArgMethod.m_signature.GetSignature(appendEndOfSig: true);
		}

		public int GetTokenFor(RuntimeMethodHandle method)
		{
			IRuntimeMethodInfo methodInfo = method.GetMethodInfo();
			if (methodInfo != null)
			{
				RuntimeMethodHandleInternal value = methodInfo.Value;
				if (!RuntimeMethodHandle.IsDynamicMethod(value))
				{
					RuntimeType declaringType = RuntimeMethodHandle.GetDeclaringType(value);
					if (declaringType != null && RuntimeTypeHandle.HasInstantiation(declaringType))
					{
						MethodBase methodBase = RuntimeType.GetMethodBase(methodInfo);
						Type genericTypeDefinition = methodBase.DeclaringType.GetGenericTypeDefinition();
						throw new ArgumentException(SR.Format(SR.Argument_MethodDeclaringTypeGenericLcg, methodBase, genericTypeDefinition));
					}
				}
			}
			m_tokens.Add(method);
			return (m_tokens.Count - 1) | 0x6000000;
		}

		public int GetTokenFor(RuntimeMethodHandle method, RuntimeTypeHandle typeContext)
		{
			m_tokens.Add(new GenericMethodInfo(method, typeContext));
			return (m_tokens.Count - 1) | 0x6000000;
		}

		public int GetTokenFor(DynamicMethod method)
		{
			m_tokens.Add(method);
			return (m_tokens.Count - 1) | 0x6000000;
		}

		public int GetTokenFor(RuntimeFieldHandle field)
		{
			m_tokens.Add(field);
			return (m_tokens.Count - 1) | 0x4000000;
		}

		public int GetTokenFor(RuntimeFieldHandle field, RuntimeTypeHandle typeContext)
		{
			m_tokens.Add(new GenericFieldInfo(field, typeContext));
			return (m_tokens.Count - 1) | 0x4000000;
		}

		public int GetTokenFor(RuntimeTypeHandle type)
		{
			m_tokens.Add(type);
			return (m_tokens.Count - 1) | 0x2000000;
		}

		public int GetTokenFor(string literal)
		{
			m_tokens.Add(literal);
			return (m_tokens.Count - 1) | 0x70000000;
		}

		public int GetTokenFor(byte[] signature)
		{
			m_tokens.Add(signature);
			return (m_tokens.Count - 1) | 0x11000000;
		}
	}
	internal sealed class GenericMethodInfo
	{
		internal RuntimeMethodHandle m_methodHandle;

		internal RuntimeTypeHandle m_context;

		internal GenericMethodInfo(RuntimeMethodHandle methodHandle, RuntimeTypeHandle context)
		{
			m_methodHandle = methodHandle;
			m_context = context;
		}
	}
	internal sealed class GenericFieldInfo
	{
		internal RuntimeFieldHandle m_fieldHandle;

		internal RuntimeTypeHandle m_context;

		internal GenericFieldInfo(RuntimeFieldHandle fieldHandle, RuntimeTypeHandle context)
		{
			m_fieldHandle = fieldHandle;
			m_context = context;
		}
	}
	internal sealed class VarArgMethod
	{
		internal RuntimeMethodInfo m_method;

		internal DynamicMethod m_dynamicMethod;

		internal SignatureHelper m_signature;

		internal VarArgMethod(DynamicMethod dm, SignatureHelper signature)
		{
			m_dynamicMethod = dm;
			m_signature = signature;
		}

		internal VarArgMethod(RuntimeMethodInfo method, SignatureHelper signature)
		{
			m_method = method;
			m_signature = signature;
		}
	}
	public sealed class DynamicMethod : MethodInfo
	{
		internal sealed class RTDynamicMethod : MethodInfo
		{
			internal DynamicMethod m_owner;

			private RuntimeParameterInfo[] m_parameters;

			private string m_name;

			private MethodAttributes m_attributes;

			private CallingConventions m_callingConvention;

			public override string Name => m_name;

			public override Type DeclaringType => null;

			public override Type ReflectedType => null;

			public override Module Module => m_owner.m_module;

			public override RuntimeMethodHandle MethodHandle
			{
				get
				{
					throw new InvalidOperationException(SR.InvalidOperation_NotAllowedInDynamicMethod);
				}
			}

			public override MethodAttributes Attributes => m_attributes;

			public override CallingConventions CallingConvention => m_callingConvention;

			public override bool IsSecurityCritical => m_owner.IsSecurityCritical;

			public override bool IsSecuritySafeCritical => m_owner.IsSecuritySafeCritical;

			public override bool IsSecurityTransparent => m_owner.IsSecurityTransparent;

			public override Type ReturnType => m_owner.m_returnType;

			public override ParameterInfo ReturnParameter => new RuntimeParameterInfo(this, null, m_owner.m_returnType, -1);

			public override ICustomAttributeProvider ReturnTypeCustomAttributes => new EmptyCAHolder();

			internal RTDynamicMethod(DynamicMethod owner, string name, MethodAttributes attributes, CallingConventions callingConvention)
			{
				m_owner = owner;
				m_name = name;
				m_attributes = attributes;
				m_callingConvention = callingConvention;
			}

			public override string ToString()
			{
				ValueStringBuilder sbParamList = new ValueStringBuilder(100);
				sbParamList.Append(ReturnType.FormatTypeName());
				sbParamList.Append(' ');
				sbParamList.Append(Name);
				sbParamList.Append('(');
				MethodBase.AppendParameters(ref sbParamList, GetParameterTypes(), CallingConvention);
				sbParamList.Append(')');
				return sbParamList.ToString();
			}

			public override MethodInfo GetBaseDefinition()
			{
				return this;
			}

			public override ParameterInfo[] GetParameters()
			{
				ParameterInfo[] array = LoadParameters();
				ParameterInfo[] array2 = array;
				ParameterInfo[] array3 = new ParameterInfo[array2.Length];
				Array.Copy(array2, array3, array2.Length);
				return array3;
			}

			public override MethodImplAttributes GetMethodImplementationFlags()
			{
				return MethodImplAttributes.NoInlining;
			}

			public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
			{
				throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, "this");
			}

			public override object[] GetCustomAttributes(Type attributeType, bool inherit)
			{
				if (attributeType == null)
				{
					throw new ArgumentNullException("attributeType");
				}
				if (attributeType.IsAssignableFrom(typeof(MethodImplAttribute)))
				{
					return new object[1]
					{
						new MethodImplAttribute((MethodImplOptions)GetMethodImplementationFlags())
					};
				}
				return Array.Empty<object>();
			}

			public override object[] GetCustomAttributes(bool inherit)
			{
				return new object[1]
				{
					new MethodImplAttribute((MethodImplOptions)GetMethodImplementationFlags())
				};
			}

			public override bool IsDefined(Type attributeType, bool inherit)
			{
				if (attributeType == null)
				{
					throw new ArgumentNullException("attributeType");
				}
				if (attributeType.IsAssignableFrom(typeof(MethodImplAttribute)))
				{
					return true;
				}
				return false;
			}

			internal RuntimeParameterInfo[] LoadParameters()
			{
				if (m_parameters == null)
				{
					Type[] parameterTypes = m_owner.m_parameterTypes;
					Type[] array = parameterTypes;
					RuntimeParameterInfo[] array2 = new RuntimeParameterInfo[array.Length];
					for (int i = 0; i < array.Length; i++)
					{
						array2[i] = new RuntimeParameterInfo(this, null, array[i], i);
					}
					if (m_parameters == null)
					{
						m_parameters = array2;
					}
				}
				return m_parameters;
			}
		}

		private RuntimeType[] m_parameterTypes;

		internal IRuntimeMethodInfo m_methodHandle;

		private RuntimeType m_returnType;

		private DynamicILGenerator m_ilGenerator;

		private DynamicILInfo m_DynamicILInfo;

		private bool m_fInitLocals;

		private RuntimeModule m_module;

		internal bool m_skipVisibility;

		internal RuntimeType m_typeOwner;

		private RTDynamicMethod m_dynMethod;

		internal DynamicResolver m_resolver;

		internal bool m_restrictedSkipVisibility;

		private static volatile InternalModuleBuilder s_anonymouslyHostedDynamicMethodsModule;

		private static readonly object s_anonymouslyHostedDynamicMethodsModuleLock = new object();

		public override string Name => m_dynMethod.Name;

		public override Type? DeclaringType => m_dynMethod.DeclaringType;

		public override Type? ReflectedType => m_dynMethod.ReflectedType;

		public override Module Module => m_dynMethod.Module;

		public override RuntimeMethodHandle MethodHandle
		{
			get
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotAllowedInDynamicMethod);
			}
		}

		public override MethodAttributes Attributes => m_dynMethod.Attributes;

		public override CallingConventions CallingConvention => m_dynMethod.CallingConvention;

		public override bool IsSecurityCritical => true;

		public override bool IsSecuritySafeCritical => false;

		public override bool IsSecurityTransparent => false;

		public override Type ReturnType => m_dynMethod.ReturnType;

		public override ParameterInfo ReturnParameter => m_dynMethod.ReturnParameter;

		public override ICustomAttributeProvider ReturnTypeCustomAttributes => m_dynMethod.ReturnTypeCustomAttributes;

		public bool InitLocals
		{
			get
			{
				return m_fInitLocals;
			}
			set
			{
				m_fInitLocals = value;
			}
		}

		public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes)
		{
			Init(name, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, returnType, parameterTypes, null, null, skipVisibility: false, transparentMethod: true);
		}

		public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes, bool restrictedSkipVisibility)
		{
			Init(name, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, returnType, parameterTypes, null, null, restrictedSkipVisibility, transparentMethod: true);
		}

		public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes, Module m)
		{
			if (m == null)
			{
				throw new ArgumentNullException("m");
			}
			Init(name, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, returnType, parameterTypes, null, m, skipVisibility: false, transparentMethod: false);
		}

		public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes, Module m, bool skipVisibility)
		{
			if (m == null)
			{
				throw new ArgumentNullException("m");
			}
			Init(name, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, returnType, parameterTypes, null, m, skipVisibility, transparentMethod: false);
		}

		public DynamicMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, Module m, bool skipVisibility)
		{
			if (m == null)
			{
				throw new ArgumentNullException("m");
			}
			Init(name, attributes, callingConvention, returnType, parameterTypes, null, m, skipVisibility, transparentMethod: false);
		}

		public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes, Type owner)
		{
			if (owner == null)
			{
				throw new ArgumentNullException("owner");
			}
			Init(name, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, returnType, parameterTypes, owner, null, skipVisibility: false, transparentMethod: false);
		}

		public DynamicMethod(string name, Type? returnType, Type[]? parameterTypes, Type owner, bool skipVisibility)
		{
			if (owner == null)
			{
				throw new ArgumentNullException("owner");
			}
			Init(name, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, returnType, parameterTypes, owner, null, skipVisibility, transparentMethod: false);
		}

		public DynamicMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, Type owner, bool skipVisibility)
		{
			if (owner == null)
			{
				throw new ArgumentNullException("owner");
			}
			Init(name, attributes, callingConvention, returnType, parameterTypes, owner, null, skipVisibility, transparentMethod: false);
		}

		private static void CheckConsistency(MethodAttributes attributes, CallingConventions callingConvention)
		{
			if ((attributes & ~MethodAttributes.MemberAccessMask) != MethodAttributes.Static)
			{
				throw new NotSupportedException(SR.NotSupported_DynamicMethodFlags);
			}
			if ((attributes & MethodAttributes.MemberAccessMask) != MethodAttributes.Public)
			{
				throw new NotSupportedException(SR.NotSupported_DynamicMethodFlags);
			}
			if (callingConvention != CallingConventions.Standard && callingConvention != CallingConventions.VarArgs)
			{
				throw new NotSupportedException(SR.NotSupported_DynamicMethodFlags);
			}
			if (callingConvention == CallingConventions.VarArgs)
			{
				throw new NotSupportedException(SR.NotSupported_DynamicMethodFlags);
			}
		}

		private static RuntimeModule GetDynamicMethodsModule()
		{
			if (s_anonymouslyHostedDynamicMethodsModule != null)
			{
				return s_anonymouslyHostedDynamicMethodsModule;
			}
			lock (s_anonymouslyHostedDynamicMethodsModuleLock)
			{
				if (s_anonymouslyHostedDynamicMethodsModule != null)
				{
					return s_anonymouslyHostedDynamicMethodsModule;
				}
				AssemblyName name = new AssemblyName("Anonymously Hosted DynamicMethods Assembly");
				StackCrawlMark stackMark = StackCrawlMark.LookForMe;
				AssemblyBuilder assemblyBuilder = AssemblyBuilder.InternalDefineDynamicAssembly(name, AssemblyBuilderAccess.Run, ref stackMark, null, null);
				s_anonymouslyHostedDynamicMethodsModule = (InternalModuleBuilder)assemblyBuilder.ManifestModule;
			}
			return s_anonymouslyHostedDynamicMethodsModule;
		}

		[MemberNotNull("m_parameterTypes")]
		[MemberNotNull("m_returnType")]
		[MemberNotNull("m_dynMethod")]
		private void Init(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] signature, Type owner, Module m, bool skipVisibility, bool transparentMethod)
		{
			CheckConsistency(attributes, callingConvention);
			if (signature != null)
			{
				m_parameterTypes = new RuntimeType[signature.Length];
				for (int i = 0; i < signature.Length; i++)
				{
					if (signature[i] == null)
					{
						throw new ArgumentException(SR.Arg_InvalidTypeInSignature);
					}
					m_parameterTypes[i] = signature[i].UnderlyingSystemType as RuntimeType;
					if (m_parameterTypes[i] == null || m_parameterTypes[i] == typeof(void))
					{
						throw new ArgumentException(SR.Arg_InvalidTypeInSignature);
					}
				}
			}
			else
			{
				m_parameterTypes = Array.Empty<RuntimeType>();
			}
			m_returnType = ((returnType == null) ? ((RuntimeType)typeof(void)) : (returnType.UnderlyingSystemType as RuntimeType));
			if (m_returnType == null)
			{
				throw new NotSupportedException(SR.Arg_InvalidTypeInRetType);
			}
			if (transparentMethod)
			{
				m_module = GetDynamicMethodsModule();
				if (skipVisibility)
				{
					m_restrictedSkipVisibility = true;
				}
			}
			else
			{
				if (m != null)
				{
					m_module = m.ModuleHandle.GetRuntimeModule();
				}
				else
				{
					RuntimeType runtimeType = null;
					if (owner != null)
					{
						runtimeType = owner.UnderlyingSystemType as RuntimeType;
					}
					if (runtimeType != null)
					{
						if (runtimeType.HasElementType || runtimeType.ContainsGenericParameters || runtimeType.IsGenericParameter || runtimeType.IsInterface)
						{
							throw new ArgumentException(SR.Argument_InvalidTypeForDynamicMethod);
						}
						m_typeOwner = runtimeType;
						m_module = runtimeType.GetRuntimeModule();
					}
				}
				m_skipVisibility = skipVisibility;
			}
			m_ilGenerator = null;
			m_fInitLocals = true;
			m_methodHandle = null;
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			m_dynMethod = new RTDynamicMethod(this, name, attributes, callingConvention);
		}

		public sealed override Delegate CreateDelegate(Type delegateType)
		{
			if (m_restrictedSkipVisibility)
			{
				GetMethodDescriptor();
				IRuntimeMethodInfo methodHandle = m_methodHandle;
				RuntimeHelpers.CompileMethod(methodHandle?.Value ?? RuntimeMethodHandleInternal.EmptyHandle);
				GC.KeepAlive(methodHandle);
			}
			MulticastDelegate multicastDelegate = (MulticastDelegate)Delegate.CreateDelegateNoSecurityCheck(delegateType, null, GetMethodDescriptor());
			multicastDelegate.StoreDynamicMethod(GetMethodInfo());
			return multicastDelegate;
		}

		public sealed override Delegate CreateDelegate(Type delegateType, object? target)
		{
			if (m_restrictedSkipVisibility)
			{
				GetMethodDescriptor();
				IRuntimeMethodInfo methodHandle = m_methodHandle;
				RuntimeHelpers.CompileMethod(methodHandle?.Value ?? RuntimeMethodHandleInternal.EmptyHandle);
				GC.KeepAlive(methodHandle);
			}
			MulticastDelegate multicastDelegate = (MulticastDelegate)Delegate.CreateDelegateNoSecurityCheck(delegateType, target, GetMethodDescriptor());
			multicastDelegate.StoreDynamicMethod(GetMethodInfo());
			return multicastDelegate;
		}

		internal RuntimeMethodHandle GetMethodDescriptor()
		{
			if (m_methodHandle == null)
			{
				lock (this)
				{
					if (m_methodHandle == null)
					{
						if (m_DynamicILInfo != null)
						{
							m_DynamicILInfo.GetCallableMethod(m_module, this);
						}
						else
						{
							if (m_ilGenerator == null || m_ilGenerator.ILOffset == 0)
							{
								throw new InvalidOperationException(SR.Format(SR.InvalidOperation_BadEmptyMethodBody, Name));
							}
							m_ilGenerator.GetCallableMethod(m_module, this);
						}
					}
				}
			}
			return new RuntimeMethodHandle(m_methodHandle);
		}

		public override string ToString()
		{
			return m_dynMethod.ToString();
		}

		public override MethodInfo GetBaseDefinition()
		{
			return this;
		}

		public override ParameterInfo[] GetParameters()
		{
			return m_dynMethod.GetParameters();
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			return m_dynMethod.GetMethodImplementationFlags();
		}

		public override object? Invoke(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture)
		{
			if ((CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
			{
				throw new NotSupportedException(SR.NotSupported_CallToVarArg);
			}
			GetMethodDescriptor();
			Signature signature = new Signature(m_methodHandle, m_parameterTypes, m_returnType, CallingConvention);
			int num = signature.Arguments.Length;
			int num2 = ((parameters != null) ? parameters.Length : 0);
			if (num != num2)
			{
				throw new TargetParameterCountException(SR.Arg_ParmCnt);
			}
			bool wrapExceptions = (invokeAttr & BindingFlags.DoNotWrapExceptions) == 0;
			StackAllocedArguments stackArgs = default(StackAllocedArguments);
			Span<object> arguments = default(Span<object>);
			if (num2 != 0)
			{
				arguments = CheckArguments(ref stackArgs, parameters, binder, invokeAttr, culture, signature);
			}
			object result = RuntimeMethodHandle.InvokeMethod(null, in arguments, signature, constructor: false, wrapExceptions);
			for (int i = 0; i < arguments.Length; i++)
			{
				parameters[i] = arguments[i];
			}
			GC.KeepAlive(this);
			return result;
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return m_dynMethod.GetCustomAttributes(attributeType, inherit);
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return m_dynMethod.GetCustomAttributes(inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return m_dynMethod.IsDefined(attributeType, inherit);
		}

		public ParameterBuilder? DefineParameter(int position, ParameterAttributes attributes, string? parameterName)
		{
			if (position < 0 || position > m_parameterTypes.Length)
			{
				throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_ParamSequence);
			}
			position--;
			if (position >= 0)
			{
				RuntimeParameterInfo[] array = m_dynMethod.LoadParameters();
				array[position].SetName(parameterName);
				array[position].SetAttributes(attributes);
			}
			return null;
		}

		public DynamicILInfo GetDynamicILInfo()
		{
			if (m_DynamicILInfo == null)
			{
				CallingConventions callingConvention = CallingConvention;
				Type returnType = ReturnType;
				Type[] parameterTypes = m_parameterTypes;
				byte[] signature = SignatureHelper.GetMethodSigHelper(null, callingConvention, returnType, null, null, parameterTypes, null, null).GetSignature(appendEndOfSig: true);
				m_DynamicILInfo = new DynamicILInfo(this, signature);
			}
			return m_DynamicILInfo;
		}

		public ILGenerator GetILGenerator()
		{
			return GetILGenerator(64);
		}

		public ILGenerator GetILGenerator(int streamSize)
		{
			if (m_ilGenerator == null)
			{
				CallingConventions callingConvention = CallingConvention;
				Type returnType = ReturnType;
				Type[] parameterTypes = m_parameterTypes;
				byte[] signature = SignatureHelper.GetMethodSigHelper(null, callingConvention, returnType, null, null, parameterTypes, null, null).GetSignature(appendEndOfSig: true);
				m_ilGenerator = new DynamicILGenerator(this, signature, streamSize);
			}
			return m_ilGenerator;
		}

		internal MethodInfo GetMethodInfo()
		{
			return m_dynMethod;
		}
	}
	public sealed class EnumBuilder : TypeInfo
	{
		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		internal TypeBuilder m_typeBuilder;

		private FieldBuilder m_underlyingField;

		public FieldBuilder UnderlyingField => m_underlyingField;

		public override string Name => m_typeBuilder.Name;

		public override Guid GUID => m_typeBuilder.GUID;

		public override Module Module => m_typeBuilder.Module;

		public override Assembly Assembly => m_typeBuilder.Assembly;

		public override RuntimeTypeHandle TypeHandle => m_typeBuilder.TypeHandle;

		public override string? FullName => m_typeBuilder.FullName;

		public override string? AssemblyQualifiedName => m_typeBuilder.AssemblyQualifiedName;

		public override string? Namespace => m_typeBuilder.Namespace;

		public override Type? BaseType => m_typeBuilder.BaseType;

		public override bool IsByRefLike => false;

		public override bool IsTypeDefinition => true;

		public override bool IsSZArray => false;

		public override bool IsConstructedGenericType => false;

		public override Type UnderlyingSystemType => GetEnumUnderlyingType();

		public override Type? DeclaringType => m_typeBuilder.DeclaringType;

		public override Type? ReflectedType => m_typeBuilder.ReflectedType;

		public override bool IsAssignableFrom([NotNullWhen(true)] TypeInfo? typeInfo)
		{
			if (typeInfo == null)
			{
				return false;
			}
			return IsAssignableFrom(typeInfo.AsType());
		}

		public FieldBuilder DefineLiteral(string literalName, object? literalValue)
		{
			FieldBuilder fieldBuilder = m_typeBuilder.DefineField(literalName, this, FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
			fieldBuilder.SetConstant(literalValue);
			return fieldBuilder;
		}

		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public TypeInfo? CreateTypeInfo()
		{
			return m_typeBuilder.CreateTypeInfo();
		}

		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public Type? CreateType()
		{
			return m_typeBuilder.CreateType();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public override object? InvokeMember(string name, BindingFlags invokeAttr, Binder? binder, object? target, object?[]? args, ParameterModifier[]? modifiers, CultureInfo? culture, string[]? namedParameters)
		{
			return m_typeBuilder.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected override ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers)
		{
			return m_typeBuilder.GetConstructor(bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetConstructors(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
		{
			if (types == null)
			{
				return m_typeBuilder.GetMethod(name, bindingAttr);
			}
			return m_typeBuilder.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetMethods(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo? GetField(string name, BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetField(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo[] GetFields(BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetFields(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type? GetInterface(string name, bool ignoreCase)
		{
			return m_typeBuilder.GetInterface(name, ignoreCase);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type[] GetInterfaces()
		{
			return m_typeBuilder.GetInterfaces();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo? GetEvent(string name, BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetEvent(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public override EventInfo[] GetEvents()
		{
			return m_typeBuilder.GetEvents();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder? binder, Type? returnType, Type[]? types, ParameterModifier[]? modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetProperties(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type[] GetNestedTypes(BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetNestedTypes(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type? GetNestedType(string name, BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetNestedType(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetMember(name, type, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetMembers(bindingAttr);
		}

		public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			return m_typeBuilder.GetInterfaceMap(interfaceType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo[] GetEvents(BindingFlags bindingAttr)
		{
			return m_typeBuilder.GetEvents(bindingAttr);
		}

		protected override TypeAttributes GetAttributeFlagsImpl()
		{
			return m_typeBuilder.Attributes;
		}

		protected override bool IsArrayImpl()
		{
			return false;
		}

		protected override bool IsPrimitiveImpl()
		{
			return false;
		}

		protected override bool IsValueTypeImpl()
		{
			return true;
		}

		protected override bool IsByRefImpl()
		{
			return false;
		}

		protected override bool IsPointerImpl()
		{
			return false;
		}

		protected override bool IsCOMObjectImpl()
		{
			return false;
		}

		public override Type? GetElementType()
		{
			return m_typeBuilder.GetElementType();
		}

		protected override bool HasElementTypeImpl()
		{
			return m_typeBuilder.HasElementType;
		}

		public override Type GetEnumUnderlyingType()
		{
			return m_underlyingField.FieldType;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return m_typeBuilder.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return m_typeBuilder.GetCustomAttributes(attributeType, inherit);
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			m_typeBuilder.SetCustomAttribute(con, binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			m_typeBuilder.SetCustomAttribute(customBuilder);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return m_typeBuilder.IsDefined(attributeType, inherit);
		}

		public override Type MakePointerType()
		{
			return SymbolType.FormCompoundType("*", this, 0);
		}

		public override Type MakeByRefType()
		{
			return SymbolType.FormCompoundType("&", this, 0);
		}

		public override Type MakeArrayType()
		{
			return SymbolType.FormCompoundType("[]", this, 0);
		}

		public override Type MakeArrayType(int rank)
		{
			string rankString = TypeInfo.GetRankString(rank);
			return SymbolType.FormCompoundType(rankString, this, 0);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2064:UnrecognizedReflectionPattern", Justification = "Reflection.Emit is not subject to trimming")]
		internal EnumBuilder(string name, Type underlyingType, TypeAttributes visibility, ModuleBuilder module)
		{
			if (((uint)visibility & 0xFFFFFFF8u) != 0)
			{
				throw new ArgumentException(SR.Argument_ShouldOnlySetVisibilityFlags, "name");
			}
			m_typeBuilder = new TypeBuilder(name, visibility | TypeAttributes.Sealed, typeof(Enum), null, module, PackingSize.Unspecified, 0, null);
			m_underlyingField = m_typeBuilder.DefineField("value__", underlyingType, FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName);
		}
	}
	public sealed class EventBuilder
	{
		private string m_name;

		private int m_evToken;

		private ModuleBuilder m_module;

		private EventAttributes m_attributes;

		private TypeBuilder m_type;

		internal EventBuilder(ModuleBuilder mod, string name, EventAttributes attr, TypeBuilder type, int evToken)
		{
			m_name = name;
			m_module = mod;
			m_attributes = attr;
			m_evToken = evToken;
			m_type = type;
		}

		private void SetMethodSemantics(MethodBuilder mdBuilder, MethodSemanticsAttributes semantics)
		{
			if (mdBuilder == null)
			{
				throw new ArgumentNullException("mdBuilder");
			}
			m_type.ThrowIfCreated();
			ModuleBuilder module = m_module;
			TypeBuilder.DefineMethodSemantics(new QCallModule(ref module), m_evToken, semantics, mdBuilder.MetadataToken);
		}

		public void SetAddOnMethod(MethodBuilder mdBuilder)
		{
			SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.AddOn);
		}

		public void SetRemoveOnMethod(MethodBuilder mdBuilder)
		{
			SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.RemoveOn);
		}

		public void SetRaiseMethod(MethodBuilder mdBuilder)
		{
			SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Fire);
		}

		public void AddOtherMethod(MethodBuilder mdBuilder)
		{
			SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Other);
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (binaryAttribute == null)
			{
				throw new ArgumentNullException("binaryAttribute");
			}
			m_type.ThrowIfCreated();
			TypeBuilder.DefineCustomAttribute(m_module, m_evToken, m_module.GetConstructorToken(con), binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			if (customBuilder == null)
			{
				throw new ArgumentNullException("customBuilder");
			}
			m_type.ThrowIfCreated();
			customBuilder.CreateCustomAttribute(m_module, m_evToken);
		}
	}
	public sealed class FieldBuilder : FieldInfo
	{
		private int m_fieldTok;

		private TypeBuilder m_typeBuilder;

		private string m_fieldName;

		private FieldAttributes m_Attributes;

		private Type m_fieldType;

		public override int MetadataToken => m_fieldTok;

		public override Module Module => m_typeBuilder.Module;

		public override string Name => m_fieldName;

		public override Type? DeclaringType
		{
			get
			{
				if (m_typeBuilder.m_isHiddenGlobalType)
				{
					return null;
				}
				return m_typeBuilder;
			}
		}

		public override Type? ReflectedType
		{
			get
			{
				if (m_typeBuilder.m_isHiddenGlobalType)
				{
					return null;
				}
				return m_typeBuilder;
			}
		}

		public override Type FieldType => m_fieldType;

		public override RuntimeFieldHandle FieldHandle
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_DynamicModule);
			}
		}

		public override FieldAttributes Attributes => m_Attributes;

		internal FieldBuilder(TypeBuilder typeBuilder, string fieldName, Type type, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes)
		{
			if (fieldName == null)
			{
				throw new ArgumentNullException("fieldName");
			}
			if (fieldName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "fieldName");
			}
			if (fieldName[0] == '\0')
			{
				throw new ArgumentException(SR.Argument_IllegalName, "fieldName");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (type == typeof(void))
			{
				throw new ArgumentException(SR.Argument_BadFieldType);
			}
			m_fieldName = fieldName;
			m_typeBuilder = typeBuilder;
			m_fieldType = type;
			m_Attributes = attributes & ~FieldAttributes.ReservedMask;
			SignatureHelper fieldSigHelper = SignatureHelper.GetFieldSigHelper(m_typeBuilder.Module);
			fieldSigHelper.AddArgument(type, requiredCustomModifiers, optionalCustomModifiers);
			int length;
			byte[] signature = fieldSigHelper.InternalGetSignature(out length);
			ModuleBuilder module = m_typeBuilder.GetModuleBuilder();
			m_fieldTok = TypeBuilder.DefineField(new QCallModule(ref module), typeBuilder.TypeToken, fieldName, signature, length, m_Attributes);
		}

		internal void SetData(byte[] data, int size)
		{
			ModuleBuilder module = m_typeBuilder.GetModuleBuilder();
			ModuleBuilder.SetFieldRVAContent(new QCallModule(ref module), m_fieldTok, data, size);
		}

		public override object? GetValue(object? obj)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override void SetValue(object? obj, object? val, BindingFlags invokeAttr, Binder? binder, CultureInfo? culture)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public void SetOffset(int iOffset)
		{
			m_typeBuilder.ThrowIfCreated();
			ModuleBuilder module = m_typeBuilder.GetModuleBuilder();
			TypeBuilder.SetFieldLayoutOffset(new QCallModule(ref module), m_fieldTok, iOffset);
		}

		public void SetConstant(object? defaultValue)
		{
			m_typeBuilder.ThrowIfCreated();
			if (defaultValue == null && m_fieldType.IsValueType && (!m_fieldType.IsGenericType || !(m_fieldType.GetGenericTypeDefinition() == typeof(Nullable<>))))
			{
				throw new ArgumentException(SR.Argument_ConstantNull);
			}
			TypeBuilder.SetConstantValue(m_typeBuilder.GetModuleBuilder(), m_fieldTok, m_fieldType, defaultValue);
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (binaryAttribute == null)
			{
				throw new ArgumentNullException("binaryAttribute");
			}
			ModuleBuilder moduleBuilder = m_typeBuilder.Module as ModuleBuilder;
			m_typeBuilder.ThrowIfCreated();
			TypeBuilder.DefineCustomAttribute(moduleBuilder, m_fieldTok, moduleBuilder.GetConstructorToken(con), binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			if (customBuilder == null)
			{
				throw new ArgumentNullException("customBuilder");
			}
			m_typeBuilder.ThrowIfCreated();
			ModuleBuilder mod = m_typeBuilder.Module as ModuleBuilder;
			customBuilder.CreateCustomAttribute(mod, m_fieldTok);
		}
	}
	public sealed class GenericTypeParameterBuilder : TypeInfo
	{
		internal TypeBuilder m_type;

		public override Type? DeclaringType => m_type.DeclaringType;

		public override Type? ReflectedType => m_type.ReflectedType;

		public override string Name => m_type.Name;

		public override Module Module => m_type.Module;

		public override bool IsByRefLike => false;

		public override int MetadataToken => m_type.MetadataToken;

		public override Guid GUID
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override Assembly Assembly => m_type.Assembly;

		public override RuntimeTypeHandle TypeHandle
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override string? FullName => null;

		public override string? Namespace => null;

		public override string? AssemblyQualifiedName => null;

		public override Type? BaseType => m_type.BaseType;

		public override bool IsTypeDefinition => false;

		public override bool IsSZArray => false;

		public override Type UnderlyingSystemType => this;

		public override bool IsGenericTypeDefinition => false;

		public override bool IsGenericType => false;

		public override bool IsGenericParameter => true;

		public override bool IsConstructedGenericType => false;

		public override int GenericParameterPosition => m_type.GenericParameterPosition;

		public override bool ContainsGenericParameters => m_type.ContainsGenericParameters;

		public override GenericParameterAttributes GenericParameterAttributes => m_type.GenericParameterAttributes;

		public override MethodBase? DeclaringMethod => m_type.DeclaringMethod;

		public override bool IsAssignableFrom([NotNullWhen(true)] TypeInfo? typeInfo)
		{
			if (typeInfo == null)
			{
				return false;
			}
			return IsAssignableFrom(typeInfo.AsType());
		}

		internal GenericTypeParameterBuilder(TypeBuilder type)
		{
			m_type = type;
		}

		public override string ToString()
		{
			return m_type.Name;
		}

		public override bool Equals(object? o)
		{
			GenericTypeParameterBuilder genericTypeParameterBuilder = o as GenericTypeParameterBuilder;
			if (genericTypeParameterBuilder == null)
			{
				return false;
			}
			return (object)genericTypeParameterBuilder.m_type == m_type;
		}

		public override int GetHashCode()
		{
			return m_type.GetHashCode();
		}

		public override Type MakePointerType()
		{
			return SymbolType.FormCompoundType("*", this, 0);
		}

		public override Type MakeByRefType()
		{
			return SymbolType.FormCompoundType("&", this, 0);
		}

		public override Type MakeArrayType()
		{
			return SymbolType.FormCompoundType("[]", this, 0);
		}

		public override Type MakeArrayType(int rank)
		{
			string rankString = TypeInfo.GetRankString(rank);
			return SymbolType.FormCompoundType(rankString, this, 0) as SymbolType;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public override object InvokeMember(string name, BindingFlags invokeAttr, Binder? binder, object? target, object?[]? args, ParameterModifier[]? modifiers, CultureInfo? culture, string[]? namedParameters)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo GetField(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo[] GetFields(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2063:UnrecognizedReflectionPattern", Justification = "Linker doesn't recognize always throwing method. https://github.com/mono/linker/issues/2025")]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type GetInterface(string name, bool ignoreCase)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type[] GetInterfaces()
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public override EventInfo[] GetEvents()
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder? binder, Type? returnType, Type[]? types, ParameterModifier[]? modifiers)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type[] GetNestedTypes(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type GetNestedType(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo[] GetEvents(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		protected override TypeAttributes GetAttributeFlagsImpl()
		{
			return TypeAttributes.Public;
		}

		protected override bool IsArrayImpl()
		{
			return false;
		}

		protected override bool IsByRefImpl()
		{
			return false;
		}

		protected override bool IsPointerImpl()
		{
			return false;
		}

		protected override bool IsPrimitiveImpl()
		{
			return false;
		}

		protected override bool IsCOMObjectImpl()
		{
			return false;
		}

		public override Type GetElementType()
		{
			throw new NotSupportedException();
		}

		protected override bool HasElementTypeImpl()
		{
			return false;
		}

		public override Type[] GetGenericArguments()
		{
			throw new InvalidOperationException();
		}

		public override Type GetGenericTypeDefinition()
		{
			throw new InvalidOperationException();
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public override Type MakeGenericType(params Type[] typeArguments)
		{
			throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericTypeDefinition, this));
		}

		protected override bool IsValueTypeImpl()
		{
			return false;
		}

		public override bool IsAssignableFrom([NotNullWhen(true)] Type? c)
		{
			throw new NotSupportedException();
		}

		public override bool IsSubclassOf(Type c)
		{
			throw new NotSupportedException();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			throw new NotSupportedException();
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new NotSupportedException();
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new NotSupportedException();
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			m_type.SetGenParamCustomAttribute(con, binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			m_type.SetGenParamCustomAttribute(customBuilder);
		}

		public void SetBaseTypeConstraint([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? baseTypeConstraint)
		{
			AssemblyBuilder.CheckContext(baseTypeConstraint);
			m_type.SetParent(baseTypeConstraint);
		}

		public void SetInterfaceConstraints(params Type[]? interfaceConstraints)
		{
			AssemblyBuilder.CheckContext(interfaceConstraints);
			m_type.SetInterfaces(interfaceConstraints);
		}

		public void SetGenericParameterAttributes(GenericParameterAttributes genericParameterAttributes)
		{
			m_type.SetGenParamAttributes(genericParameterAttributes);
		}
	}
	public class ILGenerator
	{
		private int m_length;

		private byte[] m_ILStream;

		private int[] m_labelList;

		private int m_labelCount;

		private __FixupData[] m_fixupData;

		private int m_fixupCount;

		private int[] m_RelocFixupList;

		private int m_RelocFixupCount;

		private int m_exceptionCount;

		private int m_currExcStackCount;

		private __ExceptionInfo[] m_exceptions;

		private __ExceptionInfo[] m_currExcStack;

		internal ScopeTree m_ScopeTree;

		internal MethodInfo m_methodBuilder;

		internal int m_localCount;

		internal SignatureHelper m_localSignature;

		private int m_maxStackSize;

		private int m_maxMidStack;

		private int m_maxMidStackCur;

		internal int CurrExcStackCount => m_currExcStackCount;

		internal __ExceptionInfo[]? CurrExcStack => m_currExcStack;

		public virtual int ILOffset => m_length;

		internal static T[] EnlargeArray<T>(T[] incoming)
		{
			return EnlargeArray(incoming, incoming.Length * 2);
		}

		internal static T[] EnlargeArray<T>(T[] incoming, int requiredSize)
		{
			T[] array = new T[requiredSize];
			Array.Copy(incoming, array, incoming.Length);
			return array;
		}

		internal ILGenerator(MethodInfo methodBuilder)
			: this(methodBuilder, 64)
		{
		}

		internal ILGenerator(MethodInfo methodBuilder, int size)
		{
			m_ILStream = new byte[Math.Max(size, 16)];
			m_ScopeTree = new ScopeTree();
			m_methodBuilder = methodBuilder;
			m_localSignature = SignatureHelper.GetLocalVarSigHelper((m_methodBuilder as MethodBuilder)?.GetTypeBuilder().Module);
		}

		internal virtual void RecordTokenFixup()
		{
			if (m_RelocFixupList == null)
			{
				m_RelocFixupList = new int[8];
			}
			else if (m_RelocFixupList.Length <= m_RelocFixupCount)
			{
				m_RelocFixupList = EnlargeArray(m_RelocFixupList);
			}
			m_RelocFixupList[m_RelocFixupCount++] = m_length;
		}

		internal void InternalEmit(OpCode opcode)
		{
			short value = opcode.Value;
			if (opcode.Size != 1)
			{
				BinaryPrimitives.WriteInt16BigEndian(m_ILStream.AsSpan(m_length), value);
				m_length += 2;
			}
			else
			{
				m_ILStream[m_length++] = (byte)value;
			}
			UpdateStackSize(opcode, opcode.StackChange());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void UpdateStackSize(OpCode opcode, int stackchange)
		{
			m_maxMidStackCur += stackchange;
			if (m_maxMidStackCur > m_maxMidStack)
			{
				m_maxMidStack = m_maxMidStackCur;
			}
			else if (m_maxMidStackCur < 0)
			{
				m_maxMidStackCur = 0;
			}
			if (opcode.EndsUncondJmpBlk())
			{
				m_maxStackSize += m_maxMidStack;
				m_maxMidStack = 0;
				m_maxMidStackCur = 0;
			}
		}

		private int GetMethodToken(MethodBase method, Type[] optionalParameterTypes, bool useMethodDef)
		{
			return ((ModuleBuilder)m_methodBuilder.Module).GetMethodTokenInternal(method, optionalParameterTypes, useMethodDef);
		}

		internal SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
		{
			return GetMemberRefSignature(call, returnType, parameterTypes, null, null, optionalParameterTypes);
		}

		internal virtual SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers, Type[] optionalParameterTypes)
		{
			return GetMemberRefSignature(call, returnType, parameterTypes, requiredCustomModifiers, optionalCustomModifiers, optionalParameterTypes, 0);
		}

		private SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers, Type[] optionalParameterTypes, int cGenericParameters)
		{
			return ((ModuleBuilder)m_methodBuilder.Module).GetMemberRefSignature(call, returnType, parameterTypes, requiredCustomModifiers, optionalCustomModifiers, optionalParameterTypes, cGenericParameters);
		}

		internal byte[] BakeByteArray()
		{
			if (m_currExcStackCount != 0)
			{
				throw new ArgumentException(SR.Argument_UnclosedExceptionBlock);
			}
			if (m_length == 0)
			{
				return null;
			}
			byte[] array = new byte[m_length];
			Array.Copy(m_ILStream, array, m_length);
			for (int i = 0; i < m_fixupCount; i++)
			{
				__FixupData _FixupData = m_fixupData[i];
				int num = GetLabelPos(_FixupData.m_fixupLabel) - (_FixupData.m_fixupPos + _FixupData.m_fixupInstSize);
				if (_FixupData.m_fixupInstSize == 1)
				{
					if (num < -128 || num > 127)
					{
						throw new NotSupportedException(SR.Format(SR.NotSupported_IllegalOneByteBranch, _FixupData.m_fixupPos, num));
					}
					array[_FixupData.m_fixupPos] = (byte)num;
				}
				else
				{
					BinaryPrimitives.WriteInt32LittleEndian(array.AsSpan(_FixupData.m_fixupPos), num);
				}
			}
			return array;
		}

		internal __ExceptionInfo[] GetExceptions()
		{
			if (m_currExcStackCount != 0)
			{
				throw new NotSupportedException(SR.Argument_UnclosedExceptionBlock);
			}
			if (m_exceptionCount == 0)
			{
				return null;
			}
			__ExceptionInfo[] array = new __ExceptionInfo[m_exceptionCount];
			Array.Copy(m_exceptions, array, m_exceptionCount);
			SortExceptions(array);
			return array;
		}

		internal void EnsureCapacity(int size)
		{
			if (m_length + size >= m_ILStream.Length)
			{
				IncreaseCapacity(size);
			}
		}

		private void IncreaseCapacity(int size)
		{
			byte[] array = new byte[Math.Max(m_ILStream.Length * 2, m_length + size)];
			Array.Copy(m_ILStream, array, m_ILStream.Length);
			m_ILStream = array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void PutInteger4(int value)
		{
			BinaryPrimitives.WriteInt32LittleEndian(m_ILStream.AsSpan(m_length), value);
			m_length += 4;
		}

		private int GetLabelPos(Label lbl)
		{
			int labelValue = lbl.GetLabelValue();
			if (labelValue < 0 || labelValue >= m_labelCount || m_labelList == null)
			{
				throw new ArgumentException(SR.Argument_BadLabel);
			}
			if (m_labelList[labelValue] < 0)
			{
				throw new ArgumentException(SR.Argument_BadLabelContent);
			}
			return m_labelList[labelValue];
		}

		private void AddFixup(Label lbl, int pos, int instSize)
		{
			if (m_fixupData == null)
			{
				m_fixupData = new __FixupData[8];
			}
			else if (m_fixupData.Length <= m_fixupCount)
			{
				m_fixupData = EnlargeArray(m_fixupData);
			}
			m_fixupData[m_fixupCount++] = new __FixupData
			{
				m_fixupPos = pos,
				m_fixupLabel = lbl,
				m_fixupInstSize = instSize
			};
		}

		internal int GetMaxStackSize()
		{
			return m_maxStackSize;
		}

		private static void SortExceptions(__ExceptionInfo[] exceptions)
		{
			for (int i = 0; i < exceptions.Length; i++)
			{
				int num = i;
				for (int j = i + 1; j < exceptions.Length; j++)
				{
					if (exceptions[num].IsInner(exceptions[j]))
					{
						num = j;
					}
				}
				__ExceptionInfo _ExceptionInfo = exceptions[i];
				exceptions[i] = exceptions[num];
				exceptions[num] = _ExceptionInfo;
			}
		}

		internal int[] GetTokenFixups()
		{
			if (m_RelocFixupCount == 0)
			{
				return null;
			}
			int[] array = new int[m_RelocFixupCount];
			Array.Copy(m_RelocFixupList, array, m_RelocFixupCount);
			return array;
		}

		public virtual void Emit(OpCode opcode)
		{
			EnsureCapacity(3);
			InternalEmit(opcode);
		}

		public virtual void Emit(OpCode opcode, byte arg)
		{
			EnsureCapacity(4);
			InternalEmit(opcode);
			m_ILStream[m_length++] = arg;
		}

		[CLSCompliant(false)]
		public void Emit(OpCode opcode, sbyte arg)
		{
			EnsureCapacity(4);
			InternalEmit(opcode);
			m_ILStream[m_length++] = (byte)arg;
		}

		public virtual void Emit(OpCode opcode, short arg)
		{
			EnsureCapacity(5);
			InternalEmit(opcode);
			BinaryPrimitives.WriteInt16LittleEndian(m_ILStream.AsSpan(m_length), arg);
			m_length += 2;
		}

		public virtual void Emit(OpCode opcode, int arg)
		{
			if (opcode.Equals(OpCodes.Ldc_I4))
			{
				OpCode opCode;
				switch (arg)
				{
				case -1:
					opCode = OpCodes.Ldc_I4_M1;
					goto IL_009b;
				case 0:
					opCode = OpCodes.Ldc_I4_0;
					goto IL_009b;
				case 1:
					opCode = OpCodes.Ldc_I4_1;
					goto IL_009b;
				case 2:
					opCode = OpCodes.Ldc_I4_2;
					goto IL_009b;
				case 3:
					opCode = OpCodes.Ldc_I4_3;
					goto IL_009b;
				case 4:
					opCode = OpCodes.Ldc_I4_4;
					goto IL_009b;
				case 5:
					opCode = OpCodes.Ldc_I4_5;
					goto IL_009b;
				case 6:
					opCode = OpCodes.Ldc_I4_6;
					goto IL_009b;
				case 7:
					opCode = OpCodes.Ldc_I4_7;
					goto IL_009b;
				case 8:
					{
						opCode = OpCodes.Ldc_I4_8;
						goto IL_009b;
					}
					IL_009b:
					opcode = opCode;
					Emit(opcode);
					return;
				}
				if (arg >= -128 && arg <= 127)
				{
					Emit(OpCodes.Ldc_I4_S, (sbyte)arg);
					return;
				}
			}
			else if (opcode.Equals(OpCodes.Ldarg))
			{
				if ((uint)arg <= 3u)
				{
					Emit(arg switch
					{
						0 => OpCodes.Ldarg_0, 
						1 => OpCodes.Ldarg_1, 
						2 => OpCodes.Ldarg_2, 
						_ => OpCodes.Ldarg_3, 
					});
					return;
				}
				if ((uint)arg <= 255u)
				{
					Emit(OpCodes.Ldarg_S, (byte)arg);
					return;
				}
				if ((uint)arg <= 65535u)
				{
					Emit(OpCodes.Ldarg, (short)arg);
					return;
				}
			}
			else if (opcode.Equals(OpCodes.Ldarga))
			{
				if ((uint)arg <= 255u)
				{
					Emit(OpCodes.Ldarga_S, (byte)arg);
					return;
				}
				if ((uint)arg <= 65535u)
				{
					Emit(OpCodes.Ldarga, (short)arg);
					return;
				}
			}
			else if (opcode.Equals(OpCodes.Starg))
			{
				if ((uint)arg <= 255u)
				{
					Emit(OpCodes.Starg_S, (byte)arg);
					return;
				}
				if ((uint)arg <= 65535u)
				{
					Emit(OpCodes.Starg, (short)arg);
					return;
				}
			}
			EnsureCapacity(7);
			InternalEmit(opcode);
			PutInteger4(arg);
		}

		public virtual void Emit(OpCode opcode, MethodInfo meth)
		{
			if (meth == null)
			{
				throw new ArgumentNullException("meth");
			}
			if (opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj))
			{
				EmitCall(opcode, meth, null);
				return;
			}
			bool useMethodDef = opcode.Equals(OpCodes.Ldtoken) || opcode.Equals(OpCodes.Ldftn) || opcode.Equals(OpCodes.Ldvirtftn);
			int methodToken = GetMethodToken(meth, null, useMethodDef);
			EnsureCapacity(7);
			InternalEmit(opcode);
			UpdateStackSize(opcode, 0);
			RecordTokenFixup();
			PutInteger4(methodToken);
		}

		public virtual void EmitCalli(OpCode opcode, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, Type[]? optionalParameterTypes)
		{
			int num = 0;
			if (optionalParameterTypes != null && (callingConvention & CallingConventions.VarArgs) == 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotAVarArgCallingConvention);
			}
			ModuleBuilder moduleBuilder = (ModuleBuilder)m_methodBuilder.Module;
			SignatureHelper memberRefSignature = GetMemberRefSignature(callingConvention, returnType, parameterTypes, optionalParameterTypes);
			EnsureCapacity(7);
			Emit(OpCodes.Calli);
			if (returnType != typeof(void))
			{
				num++;
			}
			if (parameterTypes != null)
			{
				num -= parameterTypes.Length;
			}
			if (optionalParameterTypes != null)
			{
				num -= optionalParameterTypes.Length;
			}
			if ((callingConvention & CallingConventions.HasThis) == CallingConventions.HasThis)
			{
				num--;
			}
			num--;
			UpdateStackSize(OpCodes.Calli, num);
			RecordTokenFixup();
			PutInteger4(moduleBuilder.GetSignatureToken(memberRefSignature));
		}

		public virtual void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type? returnType, Type[]? parameterTypes)
		{
			int num = 0;
			int num2 = 0;
			ModuleBuilder moduleBuilder = (ModuleBuilder)m_methodBuilder.Module;
			if (parameterTypes != null)
			{
				num2 = parameterTypes.Length;
			}
			SignatureHelper methodSigHelper = SignatureHelper.GetMethodSigHelper(moduleBuilder, unmanagedCallConv, returnType);
			if (parameterTypes != null)
			{
				for (int i = 0; i < num2; i++)
				{
					methodSigHelper.AddArgument(parameterTypes[i]);
				}
			}
			if (returnType != typeof(void))
			{
				num++;
			}
			if (parameterTypes != null)
			{
				num -= num2;
			}
			num--;
			UpdateStackSize(OpCodes.Calli, num);
			EnsureCapacity(7);
			Emit(OpCodes.Calli);
			RecordTokenFixup();
			PutInteger4(moduleBuilder.GetSignatureToken(methodSigHelper));
		}

		public virtual void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[]? optionalParameterTypes)
		{
			if (methodInfo == null)
			{
				throw new ArgumentNullException("methodInfo");
			}
			if (!opcode.Equals(OpCodes.Call) && !opcode.Equals(OpCodes.Callvirt) && !opcode.Equals(OpCodes.Newobj))
			{
				throw new ArgumentException(SR.Argument_NotMethodCallOpcode, "opcode");
			}
			int num = 0;
			int methodToken = GetMethodToken(methodInfo, optionalParameterTypes, useMethodDef: false);
			EnsureCapacity(7);
			InternalEmit(opcode);
			if (methodInfo.ReturnType != typeof(void))
			{
				num++;
			}
			Type[] parameterTypes = methodInfo.GetParameterTypes();
			if (parameterTypes != null)
			{
				num -= parameterTypes.Length;
			}
			if (!(methodInfo is SymbolMethod) && !methodInfo.IsStatic && !opcode.Equals(OpCodes.Newobj))
			{
				num--;
			}
			if (optionalParameterTypes != null)
			{
				num -= optionalParameterTypes.Length;
			}
			UpdateStackSize(opcode, num);
			RecordTokenFixup();
			PutInteger4(methodToken);
		}

		public virtual void Emit(OpCode opcode, SignatureHelper signature)
		{
			if (signature == null)
			{
				throw new ArgumentNullException("signature");
			}
			int num = 0;
			ModuleBuilder moduleBuilder = (ModuleBuilder)m_methodBuilder.Module;
			int signatureToken = moduleBuilder.GetSignatureToken(signature);
			int value = signatureToken;
			EnsureCapacity(7);
			InternalEmit(opcode);
			if (opcode.StackBehaviourPop == StackBehaviour.Varpop)
			{
				num -= signature.ArgumentCount;
				num--;
				UpdateStackSize(opcode, num);
			}
			RecordTokenFixup();
			PutInteger4(value);
		}

		public virtual void Emit(OpCode opcode, ConstructorInfo con)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			int num = 0;
			int methodToken = GetMethodToken(con, null, useMethodDef: true);
			EnsureCapacity(7);
			InternalEmit(opcode);
			if (opcode.StackBehaviourPush == StackBehaviour.Varpush)
			{
				num++;
			}
			if (opcode.StackBehaviourPop == StackBehaviour.Varpop)
			{
				Type[] parameterTypes = con.GetParameterTypes();
				if (parameterTypes != null)
				{
					num -= parameterTypes.Length;
				}
			}
			UpdateStackSize(opcode, num);
			RecordTokenFixup();
			PutInteger4(methodToken);
		}

		public virtual void Emit(OpCode opcode, Type cls)
		{
			ModuleBuilder moduleBuilder = (ModuleBuilder)m_methodBuilder.Module;
			int value = ((!(opcode == OpCodes.Ldtoken) || !(cls != null) || !cls.IsGenericTypeDefinition) ? moduleBuilder.GetTypeTokenInternal(cls) : moduleBuilder.GetTypeToken(cls));
			EnsureCapacity(7);
			InternalEmit(opcode);
			RecordTokenFixup();
			PutInteger4(value);
		}

		public virtual void Emit(OpCode opcode, long arg)
		{
			EnsureCapacity(11);
			InternalEmit(opcode);
			BinaryPrimitives.WriteInt64LittleEndian(m_ILStream.AsSpan(m_length), arg);
			m_length += 8;
		}

		public virtual void Emit(OpCode opcode, float arg)
		{
			EnsureCapacity(7);
			InternalEmit(opcode);
			BinaryPrimitives.WriteInt32LittleEndian(m_ILStream.AsSpan(m_length), BitConverter.SingleToInt32Bits(arg));
			m_length += 4;
		}

		public virtual void Emit(OpCode opcode, double arg)
		{
			EnsureCapacity(11);
			InternalEmit(opcode);
			BinaryPrimitives.WriteInt64LittleEndian(m_ILStream.AsSpan(m_length), BitConverter.DoubleToInt64Bits(arg));
			m_length += 8;
		}

		public virtual void Emit(OpCode opcode, Label label)
		{
			EnsureCapacity(7);
			InternalEmit(opcode);
			if (OpCodes.TakesSingleByteArgument(opcode))
			{
				AddFixup(label, m_length++, 1);
				return;
			}
			AddFixup(label, m_length, 4);
			m_length += 4;
		}

		public virtual void Emit(OpCode opcode, Label[] labels)
		{
			if (labels == null)
			{
				throw new ArgumentNullException("labels");
			}
			int num = labels.Length;
			EnsureCapacity(num * 4 + 7);
			InternalEmit(opcode);
			PutInteger4(num);
			int num2 = num * 4;
			int num3 = 0;
			while (num2 > 0)
			{
				AddFixup(labels[num3], m_length, num2);
				m_length += 4;
				num2 -= 4;
				num3++;
			}
		}

		public virtual void Emit(OpCode opcode, FieldInfo field)
		{
			ModuleBuilder moduleBuilder = (ModuleBuilder)m_methodBuilder.Module;
			int fieldToken = moduleBuilder.GetFieldToken(field);
			EnsureCapacity(7);
			InternalEmit(opcode);
			RecordTokenFixup();
			PutInteger4(fieldToken);
		}

		public virtual void Emit(OpCode opcode, string str)
		{
			ModuleBuilder moduleBuilder = (ModuleBuilder)m_methodBuilder.Module;
			int stringConstant = moduleBuilder.GetStringConstant(str);
			EnsureCapacity(7);
			InternalEmit(opcode);
			PutInteger4(stringConstant);
		}

		public virtual void Emit(OpCode opcode, LocalBuilder local)
		{
			if (local == null)
			{
				throw new ArgumentNullException("local");
			}
			int localIndex = local.GetLocalIndex();
			if (local.GetMethodBuilder() != m_methodBuilder)
			{
				throw new ArgumentException(SR.Argument_UnmatchedMethodForLocal, "local");
			}
			if (opcode.Equals(OpCodes.Ldloc))
			{
				switch (localIndex)
				{
				case 0:
					opcode = OpCodes.Ldloc_0;
					break;
				case 1:
					opcode = OpCodes.Ldloc_1;
					break;
				case 2:
					opcode = OpCodes.Ldloc_2;
					break;
				case 3:
					opcode = OpCodes.Ldloc_3;
					break;
				default:
					if (localIndex <= 255)
					{
						opcode = OpCodes.Ldloc_S;
					}
					break;
				}
			}
			else if (opcode.Equals(OpCodes.Stloc))
			{
				switch (localIndex)
				{
				case 0:
					opcode = OpCodes.Stloc_0;
					break;
				case 1:
					opcode = OpCodes.Stloc_1;
					break;
				case 2:
					opcode = OpCodes.Stloc_2;
					break;
				case 3:
					opcode = OpCodes.Stloc_3;
					break;
				default:
					if (localIndex <= 255)
					{
						opcode = OpCodes.Stloc_S;
					}
					break;
				}
			}
			else if (opcode.Equals(OpCodes.Ldloca) && localIndex <= 255)
			{
				opcode = OpCodes.Ldloca_S;
			}
			EnsureCapacity(7);
			InternalEmit(opcode);
			if (opcode.OperandType == OperandType.InlineNone)
			{
				return;
			}
			if (!OpCodes.TakesSingleByteArgument(opcode))
			{
				BinaryPrimitives.WriteInt16LittleEndian(m_ILStream.AsSpan(m_length), (short)localIndex);
				m_length += 2;
				return;
			}
			if (localIndex > 255)
			{
				throw new InvalidOperationException(SR.InvalidOperation_BadInstructionOrIndexOutOfBound);
			}
			m_ILStream[m_length++] = (byte)localIndex;
		}

		public virtual Label BeginExceptionBlock()
		{
			if (m_exceptions == null)
			{
				m_exceptions = new __ExceptionInfo[2];
			}
			if (m_currExcStack == null)
			{
				m_currExcStack = new __ExceptionInfo[2];
			}
			if (m_exceptionCount >= m_exceptions.Length)
			{
				m_exceptions = EnlargeArray(m_exceptions);
			}
			if (m_currExcStackCount >= m_currExcStack.Length)
			{
				m_currExcStack = EnlargeArray(m_currExcStack);
			}
			Label label = DefineLabel();
			__ExceptionInfo _ExceptionInfo = new __ExceptionInfo(m_length, label);
			m_exceptions[m_exceptionCount++] = _ExceptionInfo;
			m_currExcStack[m_currExcStackCount++] = _ExceptionInfo;
			return label;
		}

		public virtual void EndExceptionBlock()
		{
			if (m_currExcStackCount == 0)
			{
				throw new NotSupportedException(SR.Argument_NotInExceptionBlock);
			}
			__ExceptionInfo _ExceptionInfo = m_currExcStack[m_currExcStackCount - 1];
			m_currExcStack[--m_currExcStackCount] = null;
			Label endLabel = _ExceptionInfo.GetEndLabel();
			switch (_ExceptionInfo.GetCurrentState())
			{
			case 0:
			case 1:
				throw new InvalidOperationException(SR.Argument_BadExceptionCodeGen);
			case 2:
				Emit(OpCodes.Leave, endLabel);
				break;
			case 3:
			case 4:
				Emit(OpCodes.Endfinally);
				break;
			}
			Label loc = ((m_labelList[endLabel.GetLabelValue()] != -1) ? _ExceptionInfo.m_finallyEndLabel : endLabel);
			MarkLabel(loc);
			_ExceptionInfo.Done(m_length);
		}

		public virtual void BeginExceptFilterBlock()
		{
			if (m_currExcStackCount == 0)
			{
				throw new NotSupportedException(SR.Argument_NotInExceptionBlock);
			}
			__ExceptionInfo _ExceptionInfo = m_currExcStack[m_currExcStackCount - 1];
			Emit(OpCodes.Leave, _ExceptionInfo.GetEndLabel());
			_ExceptionInfo.MarkFilterAddr(m_length);
		}

		public virtual void BeginCatchBlock(Type exceptionType)
		{
			if (m_currExcStackCount == 0)
			{
				throw new NotSupportedException(SR.Argument_NotInExceptionBlock);
			}
			__ExceptionInfo _ExceptionInfo = m_currExcStack[m_currExcStackCount - 1];
			if (_ExceptionInfo.GetCurrentState() == 1)
			{
				if (exceptionType != null)
				{
					throw new ArgumentException(SR.Argument_ShouldNotSpecifyExceptionType);
				}
				Emit(OpCodes.Endfilter);
			}
			else
			{
				if (exceptionType == null)
				{
					throw new ArgumentNullException("exceptionType");
				}
				Emit(OpCodes.Leave, _ExceptionInfo.GetEndLabel());
			}
			_ExceptionInfo.MarkCatchAddr(m_length, exceptionType);
		}

		public virtual void BeginFaultBlock()
		{
			if (m_currExcStackCount == 0)
			{
				throw new NotSupportedException(SR.Argument_NotInExceptionBlock);
			}
			__ExceptionInfo _ExceptionInfo = m_currExcStack[m_currExcStackCount - 1];
			Emit(OpCodes.Leave, _ExceptionInfo.GetEndLabel());
			_ExceptionInfo.MarkFaultAddr(m_length);
		}

		public virtual void BeginFinallyBlock()
		{
			if (m_currExcStackCount == 0)
			{
				throw new NotSupportedException(SR.Argument_NotInExceptionBlock);
			}
			__ExceptionInfo _ExceptionInfo = m_currExcStack[m_currExcStackCount - 1];
			int currentState = _ExceptionInfo.GetCurrentState();
			Label endLabel = _ExceptionInfo.GetEndLabel();
			int num = 0;
			if (currentState != 0)
			{
				Emit(OpCodes.Leave, endLabel);
				num = m_length;
			}
			MarkLabel(endLabel);
			Label label = DefineLabel();
			_ExceptionInfo.SetFinallyEndLabel(label);
			Emit(OpCodes.Leave, label);
			if (num == 0)
			{
				num = m_length;
			}
			_ExceptionInfo.MarkFinallyAddr(m_length, num);
		}

		public virtual Label DefineLabel()
		{
			if (m_labelList == null)
			{
				m_labelList = new int[4];
			}
			if (m_labelCount >= m_labelList.Length)
			{
				m_labelList = EnlargeArray(m_labelList);
			}
			m_labelList[m_labelCount] = -1;
			return new Label(m_labelCount++);
		}

		public virtual void MarkLabel(Label loc)
		{
			int labelValue = loc.GetLabelValue();
			if (m_labelList == null || labelValue < 0 || labelValue >= m_labelList.Length)
			{
				throw new ArgumentException(SR.Argument_InvalidLabel);
			}
			if (m_labelList[labelValue] != -1)
			{
				throw new ArgumentException(SR.Argument_RedefinedLabel);
			}
			m_labelList[labelValue] = m_length;
		}

		public virtual void ThrowException([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type excType)
		{
			if (excType == null)
			{
				throw new ArgumentNullException("excType");
			}
			if (!excType.IsSubclassOf(typeof(Exception)) && excType != typeof(Exception))
			{
				throw new ArgumentException(SR.Argument_NotExceptionType);
			}
			ConstructorInfo constructor = excType.GetConstructor(Type.EmptyTypes);
			if (constructor == null)
			{
				throw new ArgumentException(SR.Argument_MissingDefaultConstructor);
			}
			Emit(OpCodes.Newobj, constructor);
			Emit(OpCodes.Throw);
		}

		public virtual void EmitWriteLine(string value)
		{
			Emit(OpCodes.Ldstr, value);
			Type[] types = new Type[1] { typeof(string) };
			Type type = Type.GetType("System.Console, System.Console", throwOnError: true);
			MethodInfo method = type.GetMethod("WriteLine", types);
			Emit(OpCodes.Call, method);
		}

		public virtual void EmitWriteLine(LocalBuilder localBuilder)
		{
			if (m_methodBuilder == null)
			{
				throw new ArgumentException(SR.InvalidOperation_BadILGeneratorUsage);
			}
			Type type = Type.GetType("System.Console, System.Console", throwOnError: true);
			MethodInfo method = type.GetMethod("get_Out");
			Emit(OpCodes.Call, method);
			Emit(OpCodes.Ldloc, localBuilder);
			Type[] array = new Type[1];
			Type localType = localBuilder.LocalType;
			if (localType is TypeBuilder || localType is EnumBuilder)
			{
				throw new ArgumentException(SR.NotSupported_OutputStreamUsingTypeBuilder);
			}
			array[0] = localType;
			MethodInfo method2 = typeof(TextWriter).GetMethod("WriteLine", array);
			if (method2 == null)
			{
				throw new ArgumentException(SR.Argument_EmitWriteLineType, "localBuilder");
			}
			Emit(OpCodes.Callvirt, method2);
		}

		public virtual void EmitWriteLine(FieldInfo fld)
		{
			if (fld == null)
			{
				throw new ArgumentNullException("fld");
			}
			Type type = Type.GetType("System.Console, System.Console", throwOnError: true);
			MethodInfo method = type.GetMethod("get_Out");
			Emit(OpCodes.Call, method);
			if ((fld.Attributes & FieldAttributes.Static) != 0)
			{
				Emit(OpCodes.Ldsfld, fld);
			}
			else
			{
				Emit(OpCodes.Ldarg, (short)0);
				Emit(OpCodes.Ldfld, fld);
			}
			Type[] array = new Type[1];
			Type fieldType = fld.FieldType;
			if (fieldType is TypeBuilder || fieldType is EnumBuilder)
			{
				throw new NotSupportedException(SR.NotSupported_OutputStreamUsingTypeBuilder);
			}
			array[0] = fieldType;
			MethodInfo method2 = typeof(TextWriter).GetMethod("WriteLine", array);
			if (method2 == null)
			{
				throw new ArgumentException(SR.Argument_EmitWriteLineType, "fld");
			}
			Emit(OpCodes.Callvirt, method2);
		}

		public virtual LocalBuilder DeclareLocal(Type localType)
		{
			return DeclareLocal(localType, pinned: false);
		}

		public virtual LocalBuilder DeclareLocal(Type localType, bool pinned)
		{
			MethodBuilder methodBuilder = m_methodBuilder as MethodBuilder;
			if (methodBuilder == null)
			{
				throw new NotSupportedException();
			}
			if (methodBuilder.IsTypeCreated())
			{
				throw new InvalidOperationException(SR.InvalidOperation_TypeHasBeenCreated);
			}
			if (localType == null)
			{
				throw new ArgumentNullException("localType");
			}
			if (methodBuilder.m_bIsBaked)
			{
				throw new InvalidOperationException(SR.InvalidOperation_MethodBaked);
			}
			m_localSignature.AddArgument(localType, pinned);
			return new LocalBuilder(m_localCount++, localType, methodBuilder, pinned);
		}

		public virtual void UsingNamespace(string usingNamespace)
		{
			if (usingNamespace == null)
			{
				throw new ArgumentNullException("usingNamespace");
			}
			if (usingNamespace.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "usingNamespace");
			}
			MethodBuilder methodBuilder = m_methodBuilder as MethodBuilder;
			if (methodBuilder == null)
			{
				throw new NotSupportedException();
			}
			int currentActiveScopeIndex = methodBuilder.GetILGenerator().m_ScopeTree.GetCurrentActiveScopeIndex();
			if (currentActiveScopeIndex == -1)
			{
				methodBuilder.m_localSymInfo.AddUsingNamespace(usingNamespace);
			}
			else
			{
				m_ScopeTree.AddUsingNamespaceToCurrentScope(usingNamespace);
			}
		}

		public virtual void BeginScope()
		{
			m_ScopeTree.AddScopeInfo(ScopeAction.Open, m_length);
		}

		public virtual void EndScope()
		{
			m_ScopeTree.AddScopeInfo(ScopeAction.Close, m_length);
		}
	}
	internal struct __FixupData
	{
		internal Label m_fixupLabel;

		internal int m_fixupPos;

		internal int m_fixupInstSize;
	}
	internal sealed class __ExceptionInfo
	{
		internal int m_startAddr;

		internal int[] m_filterAddr;

		internal int[] m_catchAddr;

		internal int[] m_catchEndAddr;

		internal int[] m_type;

		internal Type[] m_catchClass;

		internal Label m_endLabel;

		internal Label m_finallyEndLabel;

		internal int m_endAddr;

		internal int m_endFinally;

		internal int m_currentCatch;

		private int m_currentState;

		internal __ExceptionInfo(int startAddr, Label endLabel)
		{
			m_startAddr = startAddr;
			m_endAddr = -1;
			m_filterAddr = new int[4];
			m_catchAddr = new int[4];
			m_catchEndAddr = new int[4];
			m_catchClass = new Type[4];
			m_currentCatch = 0;
			m_endLabel = endLabel;
			m_type = new int[4];
			m_endFinally = -1;
			m_currentState = 0;
		}

		private void MarkHelper(int catchorfilterAddr, int catchEndAddr, Type catchClass, int type)
		{
			int currentCatch = m_currentCatch;
			if (currentCatch >= m_catchAddr.Length)
			{
				m_filterAddr = ILGenerator.EnlargeArray(m_filterAddr);
				m_catchAddr = ILGenerator.EnlargeArray(m_catchAddr);
				m_catchEndAddr = ILGenerator.EnlargeArray(m_catchEndAddr);
				m_catchClass = ILGenerator.EnlargeArray(m_catchClass);
				m_type = ILGenerator.EnlargeArray(m_type);
			}
			if (type == 1)
			{
				m_type[currentCatch] = type;
				m_filterAddr[currentCatch] = catchorfilterAddr;
				m_catchAddr[currentCatch] = -1;
				if (currentCatch > 0)
				{
					m_catchEndAddr[currentCatch - 1] = catchorfilterAddr;
				}
			}
			else
			{
				m_catchClass[currentCatch] = catchClass;
				if (m_type[currentCatch] != 1)
				{
					m_type[currentCatch] = type;
				}
				m_catchAddr[currentCatch] = catchorfilterAddr;
				if (currentCatch > 0 && m_type[currentCatch] != 1)
				{
					m_catchEndAddr[currentCatch - 1] = catchEndAddr;
				}
				m_catchEndAddr[currentCatch] = -1;
				m_currentCatch++;
			}
			if (m_endAddr == -1)
			{
				m_endAddr = catchorfilterAddr;
			}
		}

		internal void MarkFilterAddr(int filterAddr)
		{
			m_currentState = 1;
			MarkHelper(filterAddr, filterAddr, null, 1);
		}

		internal void MarkFaultAddr(int faultAddr)
		{
			m_currentState = 4;
			MarkHelper(faultAddr, faultAddr, null, 4);
		}

		internal void MarkCatchAddr(int catchAddr, Type catchException)
		{
			m_currentState = 2;
			MarkHelper(catchAddr, catchAddr, catchException, 0);
		}

		internal void MarkFinallyAddr(int finallyAddr, int endCatchAddr)
		{
			if (m_endFinally != -1)
			{
				throw new ArgumentException(SR.Argument_TooManyFinallyClause);
			}
			m_currentState = 3;
			m_endFinally = finallyAddr;
			MarkHelper(finallyAddr, endCatchAddr, null, 2);
		}

		internal void Done(int endAddr)
		{
			m_catchEndAddr[m_currentCatch - 1] = endAddr;
			m_currentState = 5;
		}

		internal int GetStartAddress()
		{
			return m_startAddr;
		}

		internal int GetEndAddress()
		{
			return m_endAddr;
		}

		internal int GetFinallyEndAddress()
		{
			return m_endFinally;
		}

		internal Label GetEndLabel()
		{
			return m_endLabel;
		}

		internal int[] GetFilterAddresses()
		{
			return m_filterAddr;
		}

		internal int[] GetCatchAddresses()
		{
			return m_catchAddr;
		}

		internal int[] GetCatchEndAddresses()
		{
			return m_catchEndAddr;
		}

		internal Type[] GetCatchClass()
		{
			return m_catchClass;
		}

		internal int GetNumberOfCatches()
		{
			return m_currentCatch;
		}

		internal int[] GetExceptionTypes()
		{
			return m_type;
		}

		internal void SetFinallyEndLabel(Label lbl)
		{
			m_finallyEndLabel = lbl;
		}

		internal bool IsInner(__ExceptionInfo exc)
		{
			int num = exc.m_currentCatch - 1;
			int num2 = m_currentCatch - 1;
			if (exc.m_catchEndAddr[num] < m_catchEndAddr[num2])
			{
				return true;
			}
			if (exc.m_catchEndAddr[num] != m_catchEndAddr[num2])
			{
				return false;
			}
			return exc.GetEndAddress() > GetEndAddress();
		}

		internal int GetCurrentState()
		{
			return m_currentState;
		}
	}
	internal enum ScopeAction : sbyte
	{
		Open = -1,
		Close = 1
	}
	internal sealed class ScopeTree
	{
		internal int[] m_iOffsets;

		internal ScopeAction[] m_ScopeActions;

		internal int m_iCount;

		internal int m_iOpenScopeCount;

		internal LocalSymInfo[] m_localSymInfos;

		internal ScopeTree()
		{
			m_iOpenScopeCount = 0;
			m_iCount = 0;
		}

		internal int GetCurrentActiveScopeIndex()
		{
			if (m_iCount == 0)
			{
				return -1;
			}
			int num = m_iCount - 1;
			int num2 = 0;
			while (num2 > 0 || m_ScopeActions[num] == ScopeAction.Close)
			{
				num2 += (int)m_ScopeActions[num];
				num--;
			}
			return num;
		}

		internal void AddUsingNamespaceToCurrentScope(string strNamespace)
		{
			int currentActiveScopeIndex = GetCurrentActiveScopeIndex();
			ref LocalSymInfo reference = ref m_localSymInfos[currentActiveScopeIndex];
			if (reference == null)
			{
				reference = new LocalSymInfo();
			}
			m_localSymInfos[currentActiveScopeIndex].AddUsingNamespace(strNamespace);
		}

		internal void AddScopeInfo(ScopeAction sa, int iOffset)
		{
			if (sa == ScopeAction.Close && m_iOpenScopeCount <= 0)
			{
				throw new ArgumentException(SR.Argument_UnmatchingSymScope);
			}
			EnsureCapacity();
			m_ScopeActions[m_iCount] = sa;
			m_iOffsets[m_iCount] = iOffset;
			m_localSymInfos[m_iCount] = null;
			checked
			{
				m_iCount++;
			}
			m_iOpenScopeCount += 0 - sa;
		}

		internal void EnsureCapacity()
		{
			if (m_iCount == 0)
			{
				m_iOffsets = new int[16];
				m_ScopeActions = new ScopeAction[16];
				m_localSymInfos = new LocalSymInfo[16];
			}
			else if (m_iCount == m_iOffsets.Length)
			{
				int num = checked(m_iCount * 2);
				int[] array = new int[num];
				Array.Copy(m_iOffsets, array, m_iCount);
				m_iOffsets = array;
				ScopeAction[] array2 = new ScopeAction[num];
				Array.Copy(m_ScopeActions, array2, m_iCount);
				m_ScopeActions = array2;
				LocalSymInfo[] array3 = new LocalSymInfo[num];
				Array.Copy(m_localSymInfos, array3, m_iCount);
				m_localSymInfos = array3;
			}
		}
	}
	public sealed class LocalBuilder : LocalVariableInfo
	{
		private int m_localIndex;

		private Type m_localType;

		private MethodInfo m_methodBuilder;

		private bool m_isPinned;

		public override bool IsPinned => m_isPinned;

		public override Type LocalType => m_localType;

		public override int LocalIndex => m_localIndex;

		internal LocalBuilder(int localIndex, Type localType, MethodInfo methodBuilder)
			: this(localIndex, localType, methodBuilder, isPinned: false)
		{
		}

		internal LocalBuilder(int localIndex, Type localType, MethodInfo methodBuilder, bool isPinned)
		{
			m_isPinned = isPinned;
			m_localIndex = localIndex;
			m_localType = localType;
			m_methodBuilder = methodBuilder;
		}

		internal int GetLocalIndex()
		{
			return m_localIndex;
		}

		internal MethodInfo GetMethodBuilder()
		{
			return m_methodBuilder;
		}
	}
	public sealed class MethodBuilder : MethodInfo
	{
		internal string m_strName;

		private int m_token;

		private readonly ModuleBuilder m_module;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		internal TypeBuilder m_containingType;

		private int[] m_mdMethodFixups;

		private byte[] m_localSignature;

		internal LocalSymInfo m_localSymInfo;

		internal ILGenerator m_ilGenerator;

		private byte[] m_ubBody;

		private ExceptionHandler[] m_exceptions;

		internal bool m_bIsBaked;

		private bool m_fInitLocals;

		private readonly MethodAttributes m_iAttributes;

		private readonly CallingConventions m_callingConvention;

		private MethodImplAttributes m_dwMethodImplFlags;

		private SignatureHelper m_signature;

		internal Type[] m_parameterTypes;

		private Type m_returnType;

		private Type[] m_returnTypeRequiredCustomModifiers;

		private Type[] m_returnTypeOptionalCustomModifiers;

		private Type[][] m_parameterTypeRequiredCustomModifiers;

		private Type[][] m_parameterTypeOptionalCustomModifiers;

		private GenericTypeParameterBuilder[] m_inst;

		private bool m_bIsGenMethDef;

		internal bool m_canBeRuntimeImpl;

		internal bool m_isDllImport;

		internal int ExceptionHandlerCount
		{
			get
			{
				if (m_exceptions == null)
				{
					return 0;
				}
				return m_exceptions.Length;
			}
		}

		public override string Name => m_strName;

		public override int MetadataToken => GetToken();

		public override Module Module => m_containingType.Module;

		public override Type? DeclaringType
		{
			get
			{
				if (m_containingType.m_isHiddenGlobalType)
				{
					return null;
				}
				return m_containingType;
			}
		}

		public override ICustomAttributeProvider ReturnTypeCustomAttributes => new EmptyCAHolder();

		public override Type? ReflectedType => DeclaringType;

		public override MethodAttributes Attributes => m_iAttributes;

		public override CallingConventions CallingConvention => m_callingConvention;

		public override RuntimeMethodHandle MethodHandle
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_DynamicModule);
			}
		}

		public override bool IsSecurityCritical => true;

		public override bool IsSecuritySafeCritical => false;

		public override bool IsSecurityTransparent => false;

		public override Type ReturnType => m_returnType;

		public override ParameterInfo ReturnParameter
		{
			get
			{
				if (!m_bIsBaked || m_containingType == null || m_containingType.BakedRuntimeType == null)
				{
					throw new InvalidOperationException(SR.InvalidOperation_TypeNotCreated);
				}
				MethodInfo method = m_containingType.GetMethod(m_strName, m_parameterTypes);
				return method.ReturnParameter;
			}
		}

		public override bool IsGenericMethodDefinition => m_bIsGenMethDef;

		public override bool ContainsGenericParameters
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override bool IsGenericMethod => m_inst != null;

		public bool InitLocals
		{
			get
			{
				ThrowIfGeneric();
				return m_fInitLocals;
			}
			set
			{
				ThrowIfGeneric();
				m_fInitLocals = value;
			}
		}

		internal MethodBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, ModuleBuilder mod, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] TypeBuilder type)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			if (name[0] == '\0')
			{
				throw new ArgumentException(SR.Argument_IllegalName, "name");
			}
			if (mod == null)
			{
				throw new ArgumentNullException("mod");
			}
			if (parameterTypes != null)
			{
				foreach (Type type2 in parameterTypes)
				{
					if (type2 == null)
					{
						throw new ArgumentNullException("parameterTypes");
					}
				}
			}
			m_strName = name;
			m_module = mod;
			m_containingType = type;
			m_returnType = returnType ?? typeof(void);
			if ((attributes & MethodAttributes.Static) == 0)
			{
				callingConvention |= CallingConventions.HasThis;
			}
			else if ((attributes & MethodAttributes.Virtual) != 0 && (attributes & MethodAttributes.Abstract) == 0)
			{
				throw new ArgumentException(SR.Arg_NoStaticVirtual);
			}
			m_callingConvention = callingConvention;
			if (parameterTypes != null)
			{
				m_parameterTypes = new Type[parameterTypes.Length];
				Array.Copy(parameterTypes, m_parameterTypes, parameterTypes.Length);
			}
			else
			{
				m_parameterTypes = null;
			}
			m_returnTypeRequiredCustomModifiers = returnTypeRequiredCustomModifiers;
			m_returnTypeOptionalCustomModifiers = returnTypeOptionalCustomModifiers;
			m_parameterTypeRequiredCustomModifiers = parameterTypeRequiredCustomModifiers;
			m_parameterTypeOptionalCustomModifiers = parameterTypeOptionalCustomModifiers;
			m_iAttributes = attributes;
			m_bIsBaked = false;
			m_fInitLocals = true;
			m_localSymInfo = new LocalSymInfo();
			m_ubBody = null;
			m_ilGenerator = null;
			m_dwMethodImplFlags = MethodImplAttributes.IL;
		}

		internal void CreateMethodBodyHelper(ILGenerator il)
		{
			if (il == null)
			{
				throw new ArgumentNullException("il");
			}
			int num = 0;
			ModuleBuilder module = m_module;
			m_containingType.ThrowIfCreated();
			if (m_bIsBaked)
			{
				throw new InvalidOperationException(SR.InvalidOperation_MethodHasBody);
			}
			if (il.m_methodBuilder != this && il.m_methodBuilder != null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_BadILGeneratorUsage);
			}
			ThrowIfShouldNotHaveBody();
			if (il.m_ScopeTree.m_iOpenScopeCount != 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_OpenLocalVariableScope);
			}
			m_ubBody = il.BakeByteArray();
			m_mdMethodFixups = il.GetTokenFixups();
			__ExceptionInfo[] exceptions = il.GetExceptions();
			int num2 = CalculateNumberOfExceptions(exceptions);
			if (num2 > 0)
			{
				m_exceptions = new ExceptionHandler[num2];
				for (int i = 0; i < exceptions.Length; i++)
				{
					int[] filterAddresses = exceptions[i].GetFilterAddresses();
					int[] catchAddresses = exceptions[i].GetCatchAddresses();
					int[] catchEndAddresses = exceptions[i].GetCatchEndAddresses();
					Type[] catchClass = exceptions[i].GetCatchClass();
					int numberOfCatches = exceptions[i].GetNumberOfCatches();
					int startAddress = exceptions[i].GetStartAddress();
					int endAddress = exceptions[i].GetEndAddress();
					int[] exceptionTypes = exceptions[i].GetExceptionTypes();
					for (int j = 0; j < numberOfCatches; j++)
					{
						int exceptionTypeToken = 0;
						if (catchClass[j] != null)
						{
							exceptionTypeToken = module.GetTypeTokenInternal(catchClass[j]);
						}
						switch (exceptionTypes[j])
						{
						case 0:
						case 1:
						case 4:
							m_exceptions[num++] = new ExceptionHandler(startAddress, endAddress, filterAddresses[j], catchAddresses[j], catchEndAddresses[j], exceptionTypes[j], exceptionTypeToken);
							break;
						case 2:
							m_exceptions[num++] = new ExceptionHandler(startAddress, exceptions[i].GetFinallyEndAddress(), filterAddresses[j], catchAddresses[j], catchEndAddresses[j], exceptionTypes[j], exceptionTypeToken);
							break;
						}
					}
				}
			}
			m_bIsBaked = true;
		}

		internal void ReleaseBakedStructures()
		{
			if (m_bIsBaked)
			{
				m_ubBody = null;
				m_localSymInfo = null;
				m_mdMethodFixups = null;
				m_localSignature = null;
				m_exceptions = null;
			}
		}

		internal override Type[] GetParameterTypes()
		{
			return m_parameterTypes ?? (m_parameterTypes = Type.EmptyTypes);
		}

		internal static Type GetMethodBaseReturnType(MethodBase method)
		{
			if (method is MethodInfo methodInfo)
			{
				return methodInfo.ReturnType;
			}
			if (method is ConstructorInfo constructorInfo)
			{
				return constructorInfo.GetReturnType();
			}
			return null;
		}

		internal void SetToken(int token)
		{
			m_token = token;
		}

		internal byte[] GetBody()
		{
			return m_ubBody;
		}

		internal int[] GetTokenFixups()
		{
			return m_mdMethodFixups;
		}

		internal SignatureHelper GetMethodSignature()
		{
			if (m_parameterTypes == null)
			{
				m_parameterTypes = Type.EmptyTypes;
			}
			m_signature = SignatureHelper.GetMethodSigHelper(m_module, m_callingConvention, (m_inst != null) ? m_inst.Length : 0, m_returnType, m_returnTypeRequiredCustomModifiers, m_returnTypeOptionalCustomModifiers, m_parameterTypes, m_parameterTypeRequiredCustomModifiers, m_parameterTypeOptionalCustomModifiers);
			return m_signature;
		}

		internal byte[] GetLocalSignature(out int signatureLength)
		{
			if (m_localSignature != null)
			{
				signatureLength = m_localSignature.Length;
				return m_localSignature;
			}
			if (m_ilGenerator != null && m_ilGenerator.m_localCount != 0)
			{
				return m_ilGenerator.m_localSignature.InternalGetSignature(out signatureLength);
			}
			return SignatureHelper.GetLocalVarSigHelper(m_module).InternalGetSignature(out signatureLength);
		}

		internal int GetMaxStack()
		{
			if (m_ilGenerator != null)
			{
				return m_ilGenerator.GetMaxStackSize() + ExceptionHandlerCount;
			}
			return 16;
		}

		internal ExceptionHandler[] GetExceptionHandlers()
		{
			return m_exceptions;
		}

		internal static int CalculateNumberOfExceptions(__ExceptionInfo[] excp)
		{
			int num = 0;
			if (excp == null)
			{
				return 0;
			}
			for (int i = 0; i < excp.Length; i++)
			{
				num += excp[i].GetNumberOfCatches();
			}
			return num;
		}

		internal bool IsTypeCreated()
		{
			if (m_containingType != null)
			{
				return m_containingType.IsCreated();
			}
			return false;
		}

		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		internal TypeBuilder GetTypeBuilder()
		{
			return m_containingType;
		}

		internal ModuleBuilder GetModuleBuilder()
		{
			return m_module;
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is MethodBuilder))
			{
				return false;
			}
			if (!m_strName.Equals(((MethodBuilder)obj).m_strName))
			{
				return false;
			}
			if (m_iAttributes != ((MethodBuilder)obj).m_iAttributes)
			{
				return false;
			}
			SignatureHelper methodSignature = ((MethodBuilder)obj).GetMethodSignature();
			if (methodSignature.Equals(GetMethodSignature()))
			{
				return true;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return m_strName.GetHashCode();
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder(1000);
			stringBuilder.Append("Name: ").Append(m_strName).AppendLine(" ");
			stringBuilder.Append("Attributes: ").Append((int)m_iAttributes).AppendLine();
			stringBuilder.Append("Method Signature: ").Append(GetMethodSignature()).AppendLine();
			stringBuilder.AppendLine();
			return stringBuilder.ToString();
		}

		public override object Invoke(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			return m_dwMethodImplFlags;
		}

		public override MethodInfo GetBaseDefinition()
		{
			return this;
		}

		public override ParameterInfo[] GetParameters()
		{
			if (!m_bIsBaked || m_containingType == null || m_containingType.BakedRuntimeType == null)
			{
				throw new NotSupportedException(SR.InvalidOperation_TypeNotCreated);
			}
			MethodInfo method = m_containingType.GetMethod(m_strName, m_parameterTypes);
			return method.GetParameters();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override MethodInfo GetGenericMethodDefinition()
		{
			if (!IsGenericMethod)
			{
				throw new InvalidOperationException();
			}
			return this;
		}

		public override Type[] GetGenericArguments()
		{
			Type[] inst = m_inst;
			return inst ?? Type.EmptyTypes;
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public override MethodInfo MakeGenericMethod(params Type[] typeArguments)
		{
			return MethodBuilderInstantiation.MakeGenericMethod(this, typeArguments);
		}

		public GenericTypeParameterBuilder[] DefineGenericParameters(params string[] names)
		{
			if (names == null)
			{
				throw new ArgumentNullException("names");
			}
			if (names.Length == 0)
			{
				throw new ArgumentException(SR.Arg_EmptyArray, "names");
			}
			if (m_inst != null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_GenericParametersAlreadySet);
			}
			for (int i = 0; i < names.Length; i++)
			{
				if (names[i] == null)
				{
					throw new ArgumentNullException("names");
				}
			}
			if (m_token != 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_MethodBuilderBaked);
			}
			m_bIsGenMethDef = true;
			m_inst = new GenericTypeParameterBuilder[names.Length];
			for (int j = 0; j < names.Length; j++)
			{
				m_inst[j] = new GenericTypeParameterBuilder(new TypeBuilder(names[j], j, this));
			}
			return m_inst;
		}

		internal void ThrowIfGeneric()
		{
			if (IsGenericMethod && !IsGenericMethodDefinition)
			{
				throw new InvalidOperationException();
			}
		}

		private int GetToken()
		{
			if (m_token != 0)
			{
				return m_token;
			}
			MethodBuilder methodBuilder = null;
			int result = 0;
			lock (m_containingType.m_listMethods)
			{
				if (m_token != 0)
				{
					return m_token;
				}
				int i;
				for (i = m_containingType.m_lastTokenizedMethod + 1; i < m_containingType.m_listMethods.Count; i++)
				{
					methodBuilder = m_containingType.m_listMethods[i];
					result = methodBuilder.GetTokenNoLock();
					if (methodBuilder == this)
					{
						break;
					}
				}
				m_containingType.m_lastTokenizedMethod = i;
				return result;
			}
		}

		private int GetTokenNoLock()
		{
			int length;
			byte[] signature = GetMethodSignature().InternalGetSignature(out length);
			ModuleBuilder module = m_module;
			int tkMethod = (m_token = TypeBuilder.DefineMethod(new QCallModule(ref module), m_containingType.MetadataToken, m_strName, signature, length, Attributes));
			if (m_inst != null)
			{
				GenericTypeParameterBuilder[] inst = m_inst;
				foreach (GenericTypeParameterBuilder genericTypeParameterBuilder in inst)
				{
					if (!genericTypeParameterBuilder.m_type.IsCreated())
					{
						genericTypeParameterBuilder.m_type.CreateType();
					}
				}
			}
			TypeBuilder.SetMethodImpl(new QCallModule(ref module), tkMethod, m_dwMethodImplFlags);
			return m_token;
		}

		public void SetParameters(params Type[] parameterTypes)
		{
			AssemblyBuilder.CheckContext(parameterTypes);
			SetSignature(null, null, null, parameterTypes, null, null);
		}

		public void SetReturnType(Type? returnType)
		{
			AssemblyBuilder.CheckContext(returnType);
			SetSignature(returnType, null, null, null, null, null);
		}

		public void SetSignature(Type? returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers, Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers)
		{
			if (m_token == 0)
			{
				AssemblyBuilder.CheckContext(returnType);
				AssemblyBuilder.CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
				AssemblyBuilder.CheckContext(parameterTypeRequiredCustomModifiers);
				AssemblyBuilder.CheckContext(parameterTypeOptionalCustomModifiers);
				ThrowIfGeneric();
				if (returnType != null)
				{
					m_returnType = returnType;
				}
				if (parameterTypes != null)
				{
					m_parameterTypes = new Type[parameterTypes.Length];
					Array.Copy(parameterTypes, m_parameterTypes, parameterTypes.Length);
				}
				m_returnTypeRequiredCustomModifiers = returnTypeRequiredCustomModifiers;
				m_returnTypeOptionalCustomModifiers = returnTypeOptionalCustomModifiers;
				m_parameterTypeRequiredCustomModifiers = parameterTypeRequiredCustomModifiers;
				m_parameterTypeOptionalCustomModifiers = parameterTypeOptionalCustomModifiers;
			}
		}

		public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, string? strParamName)
		{
			if (position < 0)
			{
				throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_ParamSequence);
			}
			ThrowIfGeneric();
			m_containingType.ThrowIfCreated();
			if (position > 0 && (m_parameterTypes == null || position > m_parameterTypes.Length))
			{
				throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_ParamSequence);
			}
			attributes &= ~ParameterAttributes.ReservedMask;
			return new ParameterBuilder(this, position, attributes, strParamName);
		}

		public void SetImplementationFlags(MethodImplAttributes attributes)
		{
			ThrowIfGeneric();
			m_containingType.ThrowIfCreated();
			m_dwMethodImplFlags = attributes;
			m_canBeRuntimeImpl = true;
			ModuleBuilder module = m_module;
			TypeBuilder.SetMethodImpl(new QCallModule(ref module), MetadataToken, attributes);
		}

		public ILGenerator GetILGenerator()
		{
			ThrowIfGeneric();
			ThrowIfShouldNotHaveBody();
			return m_ilGenerator ?? (m_ilGenerator = new ILGenerator(this));
		}

		public ILGenerator GetILGenerator(int size)
		{
			ThrowIfGeneric();
			ThrowIfShouldNotHaveBody();
			return m_ilGenerator ?? (m_ilGenerator = new ILGenerator(this, size));
		}

		private void ThrowIfShouldNotHaveBody()
		{
			if ((m_dwMethodImplFlags & MethodImplAttributes.CodeTypeMask) != 0 || (m_dwMethodImplFlags & MethodImplAttributes.ManagedMask) != 0 || (m_iAttributes & MethodAttributes.PinvokeImpl) != 0 || m_isDllImport)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ShouldNotHaveMethodBody);
			}
		}

		internal Module GetModule()
		{
			return GetModuleBuilder();
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			if ((object)con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (binaryAttribute == null)
			{
				throw new ArgumentNullException("binaryAttribute");
			}
			ThrowIfGeneric();
			TypeBuilder.DefineCustomAttribute(m_module, MetadataToken, m_module.GetConstructorToken(con), binaryAttribute);
			if (IsKnownCA(con))
			{
				ParseCA(con);
			}
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			if (customBuilder == null)
			{
				throw new ArgumentNullException("customBuilder");
			}
			ThrowIfGeneric();
			customBuilder.CreateCustomAttribute(m_module, MetadataToken);
			if (IsKnownCA(customBuilder.m_con))
			{
				ParseCA(customBuilder.m_con);
			}
		}

		private static bool IsKnownCA(ConstructorInfo con)
		{
			Type declaringType = con.DeclaringType;
			if (!(declaringType == typeof(MethodImplAttribute)))
			{
				return declaringType == typeof(DllImportAttribute);
			}
			return true;
		}

		private void ParseCA(ConstructorInfo con)
		{
			Type declaringType = con.DeclaringType;
			if (declaringType == typeof(MethodImplAttribute))
			{
				m_canBeRuntimeImpl = true;
			}
			else if (declaringType == typeof(DllImportAttribute))
			{
				m_canBeRuntimeImpl = true;
				m_isDllImport = true;
			}
		}
	}
	internal sealed class LocalSymInfo
	{
		internal int m_iLocalSymCount;

		internal string[] m_namespace;

		internal int m_iNameSpaceCount;

		internal LocalSymInfo()
		{
			m_iLocalSymCount = 0;
			m_iNameSpaceCount = 0;
		}

		private void EnsureCapacityNamespace()
		{
			if (m_iNameSpaceCount == 0)
			{
				m_namespace = new string[16];
			}
			else if (m_iNameSpaceCount == m_namespace.Length)
			{
				string[] array = new string[checked(m_iNameSpaceCount * 2)];
				Array.Copy(m_namespace, array, m_iNameSpaceCount);
				m_namespace = array;
			}
		}

		internal void AddUsingNamespace(string strNamespace)
		{
			EnsureCapacityNamespace();
			m_namespace[m_iNameSpaceCount] = strNamespace;
			checked
			{
				m_iNameSpaceCount++;
			}
		}
	}
	internal readonly struct ExceptionHandler : IEquatable<ExceptionHandler>
	{
		internal readonly int m_exceptionClass;

		internal readonly int m_tryStartOffset;

		internal readonly int m_tryEndOffset;

		internal readonly int m_filterOffset;

		internal readonly int m_handlerStartOffset;

		internal readonly int m_handlerEndOffset;

		internal readonly ExceptionHandlingClauseOptions m_kind;

		internal ExceptionHandler(int tryStartOffset, int tryEndOffset, int filterOffset, int handlerStartOffset, int handlerEndOffset, int kind, int exceptionTypeToken)
		{
			m_tryStartOffset = tryStartOffset;
			m_tryEndOffset = tryEndOffset;
			m_filterOffset = filterOffset;
			m_handlerStartOffset = handlerStartOffset;
			m_handlerEndOffset = handlerEndOffset;
			m_kind = (ExceptionHandlingClauseOptions)kind;
			m_exceptionClass = exceptionTypeToken;
		}

		public override int GetHashCode()
		{
			return m_exceptionClass ^ m_tryStartOffset ^ m_tryEndOffset ^ m_filterOffset ^ m_handlerStartOffset ^ m_handlerEndOffset ^ (int)m_kind;
		}

		public override bool Equals(object obj)
		{
			if (obj is ExceptionHandler)
			{
				return Equals((ExceptionHandler)obj);
			}
			return false;
		}

		public bool Equals(ExceptionHandler other)
		{
			if (other.m_exceptionClass == m_exceptionClass && other.m_tryStartOffset == m_tryStartOffset && other.m_tryEndOffset == m_tryEndOffset && other.m_filterOffset == m_filterOffset && other.m_handlerStartOffset == m_handlerStartOffset && other.m_handlerEndOffset == m_handlerEndOffset)
			{
				return other.m_kind == m_kind;
			}
			return false;
		}
	}
	internal sealed class MethodBuilderInstantiation : MethodInfo
	{
		internal MethodInfo m_method;

		private Type[] m_inst;

		public override MemberTypes MemberType => m_method.MemberType;

		public override string Name => m_method.Name;

		public override Type DeclaringType => m_method.DeclaringType;

		public override Type ReflectedType => m_method.ReflectedType;

		public override Module Module => m_method.Module;

		public override RuntimeMethodHandle MethodHandle
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_DynamicModule);
			}
		}

		public override MethodAttributes Attributes => m_method.Attributes;

		public override CallingConventions CallingConvention => m_method.CallingConvention;

		public override bool IsGenericMethodDefinition => false;

		public override bool ContainsGenericParameters
		{
			get
			{
				for (int i = 0; i < m_inst.Length; i++)
				{
					if (m_inst[i].ContainsGenericParameters)
					{
						return true;
					}
				}
				if (DeclaringType != null && DeclaringType.ContainsGenericParameters)
				{
					return true;
				}
				return false;
			}
		}

		public override bool IsGenericMethod => true;

		public override Type ReturnType => m_method.ReturnType;

		public override ParameterInfo ReturnParameter
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override ICustomAttributeProvider ReturnTypeCustomAttributes
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		internal static MethodInfo MakeGenericMethod(MethodInfo method, Type[] inst)
		{
			if (!method.IsGenericMethodDefinition)
			{
				throw new InvalidOperationException();
			}
			return new MethodBuilderInstantiation(method, inst);
		}

		internal MethodBuilderInstantiation(MethodInfo method, Type[] inst)
		{
			m_method = method;
			m_inst = inst;
		}

		internal override Type[] GetParameterTypes()
		{
			return m_method.GetParameterTypes();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return m_method.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return m_method.GetCustomAttributes(attributeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return m_method.IsDefined(attributeType, inherit);
		}

		public override ParameterInfo[] GetParameters()
		{
			throw new NotSupportedException();
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			return m_method.GetMethodImplementationFlags();
		}

		public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			throw new NotSupportedException();
		}

		public override Type[] GetGenericArguments()
		{
			return m_inst;
		}

		public override MethodInfo GetGenericMethodDefinition()
		{
			return m_method;
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public override MethodInfo MakeGenericMethod(params Type[] arguments)
		{
			throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericMethodDefinition, this));
		}

		public override MethodInfo GetBaseDefinition()
		{
			throw new NotSupportedException();
		}
	}
	internal sealed class InternalModuleBuilder : RuntimeModule
	{
		private InternalModuleBuilder()
		{
		}

		public override bool Equals(object obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (obj is InternalModuleBuilder)
			{
				return this == obj;
			}
			return obj.Equals(this);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
	}
	public class ModuleBuilder : Module
	{
		private Dictionary<string, Type> _typeBuilderDict;

		internal ModuleBuilderData _moduleData;

		internal InternalModuleBuilder _internalModuleBuilder;

		private readonly AssemblyBuilder _assemblyBuilder;

		internal AssemblyBuilder ContainingAssemblyBuilder => _assemblyBuilder;

		internal object SyncRoot => ContainingAssemblyBuilder.SyncRoot;

		internal InternalModuleBuilder InternalModule => _internalModuleBuilder;

		[RequiresAssemblyFiles("Returns <Unknown> for modules with no file path")]
		public override string FullyQualifiedName => _moduleData._moduleName;

		public override int MDStreamVersion => InternalModule.MDStreamVersion;

		public override Guid ModuleVersionId => InternalModule.ModuleVersionId;

		public override int MetadataToken => InternalModule.MetadataToken;

		public override string ScopeName => InternalModule.ScopeName;

		[RequiresAssemblyFiles("Returns <Unknown> for modules with no file path")]
		public override string Name => InternalModule.Name;

		public override Assembly Assembly => _assemblyBuilder;

		internal static string UnmangleTypeName(string typeName)
		{
			int startIndex = typeName.Length - 1;
			while (true)
			{
				startIndex = typeName.LastIndexOf('+', startIndex);
				if (startIndex == -1)
				{
					break;
				}
				bool flag = true;
				int num = startIndex;
				while (typeName[--num] == '\\')
				{
					flag = !flag;
				}
				if (flag)
				{
					break;
				}
				startIndex = num;
			}
			return typeName.Substring(startIndex + 1);
		}

		internal ModuleBuilder(AssemblyBuilder assemblyBuilder, InternalModuleBuilder internalModuleBuilder)
		{
			_internalModuleBuilder = internalModuleBuilder;
			_assemblyBuilder = assemblyBuilder;
		}

		internal void AddType(string name, Type type)
		{
			_typeBuilderDict.Add(name, type);
		}

		internal void CheckTypeNameConflict(string strTypeName, Type enclosingType)
		{
			if (_typeBuilderDict.TryGetValue(strTypeName, out var value) && (object)value.DeclaringType == enclosingType)
			{
				throw new ArgumentException(SR.Argument_DuplicateTypeName);
			}
		}

		private static Type GetType(string strFormat, Type baseType)
		{
			if (string.IsNullOrEmpty(strFormat))
			{
				return baseType;
			}
			return SymbolType.FormCompoundType(strFormat, baseType, 0);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, string strRefedModuleFileName, int tkResolution);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken);

		private int GetMemberRef(Module refedModule, int tr, int defToken)
		{
			ModuleBuilder module = this;
			RuntimeModule module2 = GetRuntimeModuleFromModule(refedModule);
			return GetMemberRef(new QCallModule(ref module), new QCallModule(ref module2), tr, defToken);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length);

		private int GetMemberRefFromSignature(int tr, string methodName, byte[] signature, int length)
		{
			ModuleBuilder module = this;
			return GetMemberRefFromSignature(new QCallModule(ref module), tr, methodName, signature, length);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method);

		private int GetMemberRefOfMethodInfo(int tr, RuntimeMethodInfo method)
		{
			ModuleBuilder module = this;
			int memberRefOfMethodInfo = GetMemberRefOfMethodInfo(new QCallModule(ref module), tr, ((IRuntimeMethodInfo)method).Value);
			GC.KeepAlive(method);
			return memberRefOfMethodInfo;
		}

		private int GetMemberRefOfMethodInfo(int tr, RuntimeConstructorInfo method)
		{
			ModuleBuilder module = this;
			int memberRefOfMethodInfo = GetMemberRefOfMethodInfo(new QCallModule(ref module), tr, ((IRuntimeMethodInfo)method).Value);
			GC.KeepAlive(method);
			return memberRefOfMethodInfo;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField);

		private int GetMemberRefOfFieldInfo(int tkType, RuntimeTypeHandle declaringType, RuntimeFieldInfo runtimeField)
		{
			ModuleBuilder module = this;
			return GetMemberRefOfFieldInfo(new QCallModule(ref module), tkType, new QCallTypeHandle(ref declaringType), runtimeField.MetadataToken);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length);

		private int GetTokenFromTypeSpec(byte[] signature, int length)
		{
			ModuleBuilder module = this;
			return GetTokenFromTypeSpec(new QCallModule(ref module), signature, length);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int GetStringConstant(QCallModule module, string str, int length);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void SetFieldRVAContent(QCallModule module, int fdToken, byte[] data, int length);

		internal virtual Type FindTypeBuilderWithName(string strTypeName, bool ignoreCase)
		{
			Type value;
			if (ignoreCase)
			{
				foreach (string key in _typeBuilderDict.Keys)
				{
					if (string.Equals(key, strTypeName, StringComparison.OrdinalIgnoreCase))
					{
						return _typeBuilderDict[key];
					}
				}
			}
			else if (_typeBuilderDict.TryGetValue(strTypeName, out value))
			{
				return value;
			}
			return null;
		}

		private int GetTypeRefNested(Type type, Module refedModule, string strRefedModuleFileName)
		{
			Type declaringType = type.DeclaringType;
			int tkResolution = 0;
			string text = type.FullName;
			if (declaringType != null)
			{
				tkResolution = GetTypeRefNested(declaringType, refedModule, strRefedModuleFileName);
				text = UnmangleTypeName(text);
			}
			ModuleBuilder module = this;
			RuntimeModule module2 = GetRuntimeModuleFromModule(refedModule);
			return GetTypeRef(new QCallModule(ref module), text, new QCallModule(ref module2), strRefedModuleFileName, tkResolution);
		}

		internal int InternalGetConstructorToken(ConstructorInfo con, bool usingRef)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			int typeTokenInternal;
			if (con is ConstructorBuilder constructorBuilder)
			{
				if (!usingRef && constructorBuilder.Module.Equals(this))
				{
					return constructorBuilder.MetadataToken;
				}
				typeTokenInternal = GetTypeTokenInternal(con.ReflectedType);
				return GetMemberRef(con.ReflectedType.Module, typeTokenInternal, constructorBuilder.MetadataToken);
			}
			if (con is ConstructorOnTypeBuilderInstantiation constructorOnTypeBuilderInstantiation)
			{
				if (usingRef)
				{
					throw new InvalidOperationException();
				}
				typeTokenInternal = GetTypeTokenInternal(con.DeclaringType);
				return GetMemberRef(con.DeclaringType.Module, typeTokenInternal, constructorOnTypeBuilderInstantiation.MetadataToken);
			}
			if (con is RuntimeConstructorInfo method && !con.ReflectedType.IsArray)
			{
				typeTokenInternal = GetTypeTokenInternal(con.ReflectedType);
				return GetMemberRefOfMethodInfo(typeTokenInternal, method);
			}
			ParameterInfo[] parameters = con.GetParameters();
			if (parameters == null)
			{
				throw new ArgumentException(SR.Argument_InvalidConstructorInfo);
			}
			Type[] array = new Type[parameters.Length];
			Type[][] array2 = new Type[parameters.Length][];
			Type[][] array3 = new Type[parameters.Length][];
			for (int i = 0; i < parameters.Length; i++)
			{
				if (parameters[i] == null)
				{
					throw new ArgumentException(SR.Argument_InvalidConstructorInfo);
				}
				array[i] = parameters[i].ParameterType;
				array2[i] = parameters[i].GetRequiredCustomModifiers();
				array3[i] = parameters[i].GetOptionalCustomModifiers();
			}
			typeTokenInternal = GetTypeTokenInternal(con.ReflectedType);
			SignatureHelper methodSigHelper = SignatureHelper.GetMethodSigHelper(this, con.CallingConvention, null, null, null, array, array2, array3);
			int length;
			byte[] signature = methodSigHelper.InternalGetSignature(out length);
			return GetMemberRefFromSignature(typeTokenInternal, con.Name, signature, length);
		}

		internal void Init(string strModuleName)
		{
			_moduleData = new ModuleBuilderData(this, strModuleName);
			_typeBuilderDict = new Dictionary<string, Type>();
		}

		protected override ModuleHandle GetModuleHandleImpl()
		{
			return new ModuleHandle(InternalModule);
		}

		private static RuntimeModule GetRuntimeModuleFromModule(Module m)
		{
			ModuleBuilder moduleBuilder = m as ModuleBuilder;
			if (moduleBuilder != null)
			{
				return moduleBuilder.InternalModule;
			}
			return m as RuntimeModule;
		}

		private int GetMemberRefToken(MethodBase method, Type[] optionalParameterTypes)
		{
			int cGenericParameters = 0;
			if (method.IsGenericMethod)
			{
				if (!method.IsGenericMethodDefinition)
				{
					throw new InvalidOperationException();
				}
				cGenericParameters = method.GetGenericArguments().Length;
			}
			if (optionalParameterTypes != null && (method.CallingConvention & CallingConventions.VarArgs) == 0)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotAVarArgCallingConvention);
			}
			MethodInfo methodInfo = method as MethodInfo;
			SignatureHelper memberRefSignature;
			if (method.DeclaringType.IsGenericType)
			{
				MethodBase genericMethodBaseDefinition = GetGenericMethodBaseDefinition(method);
				memberRefSignature = GetMemberRefSignature(genericMethodBaseDefinition, cGenericParameters);
			}
			else
			{
				memberRefSignature = GetMemberRefSignature(method, cGenericParameters);
			}
			if (optionalParameterTypes != null && optionalParameterTypes.Length != 0)
			{
				memberRefSignature.AddSentinel();
				memberRefSignature.AddArguments(optionalParameterTypes, null, null);
			}
			int length;
			byte[] signature = memberRefSignature.InternalGetSignature(out length);
			int tr;
			if (!method.DeclaringType.IsGenericType)
			{
				tr = ((!method.Module.Equals(this)) ? GetTypeToken(method.DeclaringType) : ((!(methodInfo != null)) ? GetConstructorToken(method as ConstructorInfo) : GetMethodToken(methodInfo)));
			}
			else
			{
				int length2;
				byte[] signature2 = SignatureHelper.GetTypeSigToken(this, method.DeclaringType).InternalGetSignature(out length2);
				tr = GetTokenFromTypeSpec(signature2, length2);
			}
			return GetMemberRefFromSignature(tr, method.Name, signature, length);
		}

		internal SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers, Type[] optionalParameterTypes, int cGenericParameters)
		{
			SignatureHelper methodSigHelper = SignatureHelper.GetMethodSigHelper(this, call, cGenericParameters, returnType, null, null, parameterTypes, requiredCustomModifiers, optionalCustomModifiers);
			if (optionalParameterTypes != null && optionalParameterTypes.Length != 0)
			{
				methodSigHelper.AddSentinel();
				methodSigHelper.AddArguments(optionalParameterTypes, null, null);
			}
			return methodSigHelper;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Module.ResolveMethod is marked as RequiresUnreferencedCode because it relies on tokens which are not guaranteed to be stable across trimming. So if somebody hardcodes a token it could break. The usage here is not like that as all these tokens come from existing metadata loaded from some IL and so trimming has no effect (the tokens are read AFTER trimming occured).")]
		private static MethodBase GetGenericMethodBaseDefinition(MethodBase methodBase)
		{
			MethodInfo methodInfo = methodBase as MethodInfo;
			if (methodBase is MethodOnTypeBuilderInstantiation methodOnTypeBuilderInstantiation)
			{
				return methodOnTypeBuilderInstantiation.m_method;
			}
			if (methodBase is ConstructorOnTypeBuilderInstantiation constructorOnTypeBuilderInstantiation)
			{
				return constructorOnTypeBuilderInstantiation.m_ctor;
			}
			if (methodBase is MethodBuilder || methodBase is ConstructorBuilder)
			{
				return methodBase;
			}
			if (methodBase.IsGenericMethod)
			{
				MethodBase genericMethodDefinition = methodInfo.GetGenericMethodDefinition();
				return genericMethodDefinition.Module.ResolveMethod(methodBase.MetadataToken, genericMethodDefinition.DeclaringType?.GetGenericArguments(), genericMethodDefinition.GetGenericArguments());
			}
			return methodBase.Module.ResolveMethod(methodBase.MetadataToken, methodBase.DeclaringType?.GetGenericArguments(), null);
		}

		internal SignatureHelper GetMemberRefSignature(MethodBase method, int cGenericParameters)
		{
			MethodBase methodBase = method;
			if (!(methodBase is MethodBuilder methodBuilder))
			{
				if (!(methodBase is ConstructorBuilder constructorBuilder))
				{
					if (!(methodBase is MethodOnTypeBuilderInstantiation methodOnTypeBuilderInstantiation))
					{
						if (methodBase is ConstructorOnTypeBuilderInstantiation constructorOnTypeBuilderInstantiation)
						{
							if (constructorOnTypeBuilderInstantiation.m_ctor is ConstructorBuilder constructorBuilder2)
							{
								return constructorBuilder2.GetMethodSignature();
							}
							ConstructorOnTypeBuilderInstantiation constructorOnTypeBuilderInstantiation2 = constructorOnTypeBuilderInstantiation;
							method = constructorOnTypeBuilderInstantiation2.m_ctor;
						}
					}
					else
					{
						if (methodOnTypeBuilderInstantiation.m_method is MethodBuilder methodBuilder2)
						{
							return methodBuilder2.GetMethodSignature();
						}
						MethodOnTypeBuilderInstantiation methodOnTypeBuilderInstantiation2 = methodOnTypeBuilderInstantiation;
						method = methodOnTypeBuilderInstantiation2.m_method;
					}
					ParameterInfo[] parametersNoCopy = method.GetParametersNoCopy();
					Type[] array = new Type[parametersNoCopy.Length];
					Type[][] array2 = new Type[array.Length][];
					Type[][] array3 = new Type[array.Length][];
					for (int i = 0; i < parametersNoCopy.Length; i++)
					{
						array[i] = parametersNoCopy[i].ParameterType;
						array2[i] = parametersNoCopy[i].GetRequiredCustomModifiers();
						array3[i] = parametersNoCopy[i].GetOptionalCustomModifiers();
					}
					ParameterInfo parameterInfo = ((method is MethodInfo methodInfo) ? methodInfo.ReturnParameter : null);
					return SignatureHelper.GetMethodSigHelper(this, method.CallingConvention, cGenericParameters, parameterInfo?.ParameterType, parameterInfo?.GetRequiredCustomModifiers(), parameterInfo?.GetOptionalCustomModifiers(), array, array2, array3);
				}
				return constructorBuilder.GetMethodSignature();
			}
			return methodBuilder.GetMethodSignature();
		}

		public override bool Equals(object? obj)
		{
			return InternalModule.Equals(obj);
		}

		public override int GetHashCode()
		{
			return InternalModule.GetHashCode();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return InternalModule.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return InternalModule.GetCustomAttributes(attributeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return InternalModule.IsDefined(attributeType, inherit);
		}

		public override IList<CustomAttributeData> GetCustomAttributesData()
		{
			return InternalModule.GetCustomAttributesData();
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type[] GetTypes()
		{
			lock (SyncRoot)
			{
				return GetTypesNoLock();
			}
		}

		internal Type[] GetTypesNoLock()
		{
			Type[] array = new Type[_typeBuilderDict.Count];
			int num = 0;
			foreach (Type value in _typeBuilderDict.Values)
			{
				EnumBuilder enumBuilder = value as EnumBuilder;
				TypeBuilder typeBuilder = ((!(enumBuilder != null)) ? ((TypeBuilder)value) : enumBuilder.m_typeBuilder);
				if (typeBuilder.IsCreated())
				{
					array[num++] = typeBuilder.UnderlyingSystemType;
				}
				else
				{
					array[num++] = value;
				}
			}
			return array;
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type? GetType(string className)
		{
			return GetType(className, throwOnError: false, ignoreCase: false);
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type? GetType(string className, bool ignoreCase)
		{
			return GetType(className, throwOnError: false, ignoreCase);
		}

		[RequiresUnreferencedCode("Types might be removed")]
		public override Type? GetType(string className, bool throwOnError, bool ignoreCase)
		{
			lock (SyncRoot)
			{
				return GetTypeNoLock(className, throwOnError, ignoreCase);
			}
		}

		[RequiresUnreferencedCode("Types might be removed")]
		private Type GetTypeNoLock(string className, bool throwOnError, bool ignoreCase)
		{
			Type type = InternalModule.GetType(className, throwOnError, ignoreCase);
			if (type != null)
			{
				return type;
			}
			string text = null;
			string text2 = null;
			int num = 0;
			while (num <= className.Length)
			{
				int num2 = className.AsSpan(num).IndexOfAny('[', '*', '&');
				if (num2 == -1)
				{
					text = className;
					text2 = null;
					break;
				}
				num2 += num;
				int num3 = 0;
				int num4 = num2 - 1;
				while (num4 >= 0 && className[num4] == '\\')
				{
					num3++;
					num4--;
				}
				if (num3 % 2 == 1)
				{
					num = num2 + 1;
					continue;
				}
				text = className.Substring(0, num2);
				text2 = className.Substring(num2);
				break;
			}
			if (text == null)
			{
				text = className;
				text2 = null;
			}
			text = text.Replace("\\\\", "\\").Replace("\\[", "[").Replace("\\*", "*")
				.Replace("\\&", "&");
			if (text2 != null)
			{
				type = InternalModule.GetType(text, throwOnError: false, ignoreCase);
			}
			if (type == null)
			{
				type = FindTypeBuilderWithName(text, ignoreCase);
				if (type == null && Assembly is AssemblyBuilder)
				{
					List<ModuleBuilder> moduleBuilderList = ContainingAssemblyBuilder._assemblyData._moduleBuilderList;
					int count = moduleBuilderList.Count;
					for (int i = 0; i < count; i++)
					{
						if (!(type == null))
						{
							break;
						}
						ModuleBuilder moduleBuilder = moduleBuilderList[i];
						type = moduleBuilder.FindTypeBuilderWithName(text, ignoreCase);
					}
				}
				if (type == null)
				{
					return null;
				}
			}
			if (text2 == null)
			{
				return type;
			}
			return GetType(text2, type);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override byte[] ResolveSignature(int metadataToken)
		{
			return InternalModule.ResolveSignature(metadataToken);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override MethodBase? ResolveMethod(int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments)
		{
			return InternalModule.ResolveMethod(metadataToken, genericTypeArguments, genericMethodArguments);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override FieldInfo? ResolveField(int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments)
		{
			return InternalModule.ResolveField(metadataToken, genericTypeArguments, genericMethodArguments);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override Type ResolveType(int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments)
		{
			return InternalModule.ResolveType(metadataToken, genericTypeArguments, genericMethodArguments);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override MemberInfo? ResolveMember(int metadataToken, Type[]? genericTypeArguments, Type[]? genericMethodArguments)
		{
			return InternalModule.ResolveMember(metadataToken, genericTypeArguments, genericMethodArguments);
		}

		[RequiresUnreferencedCode("Trimming changes metadata tokens")]
		public override string ResolveString(int metadataToken)
		{
			return InternalModule.ResolveString(metadataToken);
		}

		public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine)
		{
			InternalModule.GetPEKind(out peKind, out machine);
		}

		public override bool IsResource()
		{
			return InternalModule.IsResource();
		}

		[RequiresUnreferencedCode("Fields might be removed")]
		public override FieldInfo[] GetFields(BindingFlags bindingFlags)
		{
			return InternalModule.GetFields(bindingFlags);
		}

		[RequiresUnreferencedCode("Fields might be removed")]
		public override FieldInfo? GetField(string name, BindingFlags bindingAttr)
		{
			return InternalModule.GetField(name, bindingAttr);
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		public override MethodInfo[] GetMethods(BindingFlags bindingFlags)
		{
			return InternalModule.GetMethods(bindingFlags);
		}

		[RequiresUnreferencedCode("Methods might be removed")]
		protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
		{
			return InternalModule.GetMethodInternal(name, bindingAttr, binder, callConvention, types, modifiers);
		}

		public TypeBuilder DefineType(string name)
		{
			lock (SyncRoot)
			{
				return DefineTypeNoLock(name, TypeAttributes.NotPublic, null, null, PackingSize.Unspecified, 0);
			}
		}

		public TypeBuilder DefineType(string name, TypeAttributes attr)
		{
			lock (SyncRoot)
			{
				return DefineTypeNoLock(name, attr, null, null, PackingSize.Unspecified, 0);
			}
		}

		public TypeBuilder DefineType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent)
		{
			lock (SyncRoot)
			{
				AssemblyBuilder.CheckContext(parent);
				return DefineTypeNoLock(name, attr, parent, null, PackingSize.Unspecified, 0);
			}
		}

		public TypeBuilder DefineType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, int typesize)
		{
			lock (SyncRoot)
			{
				return DefineTypeNoLock(name, attr, parent, null, PackingSize.Unspecified, typesize);
			}
		}

		public TypeBuilder DefineType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, PackingSize packingSize, int typesize)
		{
			lock (SyncRoot)
			{
				return DefineTypeNoLock(name, attr, parent, null, packingSize, typesize);
			}
		}

		public TypeBuilder DefineType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, Type[]? interfaces)
		{
			lock (SyncRoot)
			{
				return DefineTypeNoLock(name, attr, parent, interfaces, PackingSize.Unspecified, 0);
			}
		}

		private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type parent, Type[] interfaces, PackingSize packingSize, int typesize)
		{
			return new TypeBuilder(name, attr, parent, interfaces, this, packingSize, typesize, null);
		}

		public TypeBuilder DefineType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, PackingSize packsize)
		{
			lock (SyncRoot)
			{
				return DefineTypeNoLock(name, attr, parent, packsize);
			}
		}

		private TypeBuilder DefineTypeNoLock(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type parent, PackingSize packsize)
		{
			return new TypeBuilder(name, attr, parent, null, this, packsize, 0, null);
		}

		public EnumBuilder DefineEnum(string name, TypeAttributes visibility, Type underlyingType)
		{
			AssemblyBuilder.CheckContext(underlyingType);
			lock (SyncRoot)
			{
				EnumBuilder enumBuilder = DefineEnumNoLock(name, visibility, underlyingType);
				_typeBuilderDict[name] = enumBuilder;
				return enumBuilder;
			}
		}

		private EnumBuilder DefineEnumNoLock(string name, TypeAttributes visibility, Type underlyingType)
		{
			return new EnumBuilder(name, underlyingType, visibility, this);
		}

		[RequiresUnreferencedCode("P/Invoke marshalling may dynamically access members that could be trimmed.")]
		public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
		{
			return DefinePInvokeMethod(name, dllName, name, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet);
		}

		[RequiresUnreferencedCode("P/Invoke marshalling may dynamically access members that could be trimmed.")]
		public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
		{
			lock (SyncRoot)
			{
				if ((attributes & MethodAttributes.Static) == 0)
				{
					throw new ArgumentException(SR.Argument_GlobalFunctionHasToBeStatic);
				}
				AssemblyBuilder.CheckContext(returnType);
				AssemblyBuilder.CheckContext(parameterTypes);
				return _moduleData._globalTypeBuilder.DefinePInvokeMethod(name, dllName, entryName, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet);
			}
		}

		public MethodBuilder DefineGlobalMethod(string name, MethodAttributes attributes, Type? returnType, Type[]? parameterTypes)
		{
			return DefineGlobalMethod(name, attributes, CallingConventions.Standard, returnType, parameterTypes);
		}

		public MethodBuilder DefineGlobalMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes)
		{
			return DefineGlobalMethod(name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null);
		}

		public MethodBuilder DefineGlobalMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? requiredReturnTypeCustomModifiers, Type[]? optionalReturnTypeCustomModifiers, Type[]? parameterTypes, Type[][]? requiredParameterTypeCustomModifiers, Type[][]? optionalParameterTypeCustomModifiers)
		{
			lock (SyncRoot)
			{
				return DefineGlobalMethodNoLock(name, attributes, callingConvention, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
			}
		}

		private MethodBuilder DefineGlobalMethodNoLock(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
		{
			if (_moduleData._hasGlobalBeenCreated)
			{
				throw new InvalidOperationException(SR.InvalidOperation_GlobalsHaveBeenCreated);
			}
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			if ((attributes & MethodAttributes.Static) == 0)
			{
				throw new ArgumentException(SR.Argument_GlobalFunctionHasToBeStatic);
			}
			AssemblyBuilder.CheckContext(returnType);
			AssemblyBuilder.CheckContext(requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes);
			AssemblyBuilder.CheckContext(requiredParameterTypeCustomModifiers);
			AssemblyBuilder.CheckContext(optionalParameterTypeCustomModifiers);
			return _moduleData._globalTypeBuilder.DefineMethod(name, attributes, callingConvention, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
		}

		public void CreateGlobalFunctions()
		{
			lock (SyncRoot)
			{
				CreateGlobalFunctionsNoLock();
			}
		}

		private void CreateGlobalFunctionsNoLock()
		{
			if (_moduleData._hasGlobalBeenCreated)
			{
				throw new InvalidOperationException(SR.InvalidOperation_NotADebugModule);
			}
			_moduleData._globalTypeBuilder.CreateType();
			_moduleData._hasGlobalBeenCreated = true;
		}

		public FieldBuilder DefineInitializedData(string name, byte[] data, FieldAttributes attributes)
		{
			lock (SyncRoot)
			{
				return DefineInitializedDataNoLock(name, data, attributes);
			}
		}

		private FieldBuilder DefineInitializedDataNoLock(string name, byte[] data, FieldAttributes attributes)
		{
			if (_moduleData._hasGlobalBeenCreated)
			{
				throw new InvalidOperationException(SR.InvalidOperation_GlobalsHaveBeenCreated);
			}
			return _moduleData._globalTypeBuilder.DefineInitializedData(name, data, attributes);
		}

		public FieldBuilder DefineUninitializedData(string name, int size, FieldAttributes attributes)
		{
			lock (SyncRoot)
			{
				return DefineUninitializedDataNoLock(name, size, attributes);
			}
		}

		private FieldBuilder DefineUninitializedDataNoLock(string name, int size, FieldAttributes attributes)
		{
			if (_moduleData._hasGlobalBeenCreated)
			{
				throw new InvalidOperationException(SR.InvalidOperation_GlobalsHaveBeenCreated);
			}
			return _moduleData._globalTypeBuilder.DefineUninitializedData(name, size, attributes);
		}

		internal int GetTypeTokenInternal(Type type)
		{
			return GetTypeTokenInternal(type, getGenericDefinition: false);
		}

		private int GetTypeTokenInternal(Type type, bool getGenericDefinition)
		{
			lock (SyncRoot)
			{
				return GetTypeTokenWorkerNoLock(type, getGenericDefinition);
			}
		}

		internal int GetTypeToken(Type type)
		{
			return GetTypeTokenInternal(type, getGenericDefinition: true);
		}

		private int GetTypeTokenWorkerNoLock(Type type, bool getGenericDefinition)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			AssemblyBuilder.CheckContext(type);
			if (type.IsByRef)
			{
				throw new ArgumentException(SR.Argument_CannotGetTypeTokenForByRef);
			}
			if ((type.IsGenericType && (!type.IsGenericTypeDefinition || !getGenericDefinition)) || type.IsGenericParameter || type.IsArray || type.IsPointer)
			{
				int length;
				byte[] signature = SignatureHelper.GetTypeSigToken(this, type).InternalGetSignature(out length);
				return GetTokenFromTypeSpec(signature, length);
			}
			Module module = type.Module;
			if (module.Equals(this))
			{
				TypeBuilder typeBuilder = null;
				EnumBuilder enumBuilder = type as EnumBuilder;
				typeBuilder = ((enumBuilder != null) ? enumBuilder.m_typeBuilder : (type as TypeBuilder));
				if (typeBuilder != null)
				{
					return typeBuilder.TypeToken;
				}
				if (type is GenericTypeParameterBuilder genericTypeParameterBuilder)
				{
					return genericTypeParameterBuilder.MetadataToken;
				}
				return GetTypeRefNested(type, this, string.Empty);
			}
			ModuleBuilder moduleBuilder = module as ModuleBuilder;
			string strRefedModuleFileName = string.Empty;
			if (module.Assembly.Equals(Assembly))
			{
				if (moduleBuilder == null)
				{
					moduleBuilder = ContainingAssemblyBuilder.GetModuleBuilder((InternalModuleBuilder)module);
				}
				strRefedModuleFileName = moduleBuilder._moduleData._moduleName;
			}
			return GetTypeRefNested(type, module, strRefedModuleFileName);
		}

		internal int GetMethodToken(MethodInfo method)
		{
			lock (SyncRoot)
			{
				return GetMethodTokenNoLock(method, getGenericTypeDefinition: false);
			}
		}

		private int GetMethodTokenNoLock(MethodInfo method, bool getGenericTypeDefinition)
		{
			if (method == null)
			{
				throw new ArgumentNullException("method");
			}
			int num = 0;
			int tr;
			if (method is MethodBuilder methodBuilder)
			{
				int metadataToken = methodBuilder.MetadataToken;
				if (method.Module.Equals(this))
				{
					return metadataToken;
				}
				if (method.DeclaringType == null)
				{
					throw new InvalidOperationException(SR.InvalidOperation_CannotImportGlobalFromDifferentModule);
				}
				tr = (getGenericTypeDefinition ? GetTypeToken(method.DeclaringType) : GetTypeTokenInternal(method.DeclaringType));
				return GetMemberRef(method.DeclaringType.Module, tr, metadataToken);
			}
			if (method is MethodOnTypeBuilderInstantiation)
			{
				return GetMemberRefToken(method, null);
			}
			if (method is SymbolMethod symbolMethod)
			{
				if (symbolMethod.GetModule() == this)
				{
					return symbolMethod.MetadataToken;
				}
				return symbolMethod.GetToken(this);
			}
			Type declaringType = method.DeclaringType;
			if (declaringType == null)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CannotImportGlobalFromDifferentModule);
			}
			if (declaringType.IsArray)
			{
				ParameterInfo[] parameters = method.GetParameters();
				Type[] array = new Type[parameters.Length];
				for (int i = 0; i < parameters.Length; i++)
				{
					array[i] = parameters[i].ParameterType;
				}
				return GetArrayMethodToken(declaringType, method.Name, method.CallingConvention, method.ReturnType, array);
			}
			if (method is RuntimeMethodInfo method2)
			{
				tr = (getGenericTypeDefinition ? GetTypeToken(declaringType) : GetTypeTokenInternal(declaringType));
				return GetMemberRefOfMethodInfo(tr, method2);
			}
			ParameterInfo[] parameters2 = method.GetParameters();
			Type[] array2 = new Type[parameters2.Length];
			Type[][] array3 = new Type[array2.Length][];
			Type[][] array4 = new Type[array2.Length][];
			for (int j = 0; j < parameters2.Length; j++)
			{
				array2[j] = parameters2[j].ParameterType;
				array3[j] = parameters2[j].GetRequiredCustomModifiers();
				array4[j] = parameters2[j].GetOptionalCustomModifiers();
			}
			tr = (getGenericTypeDefinition ? GetTypeToken(declaringType) : GetTypeTokenInternal(declaringType));
			SignatureHelper methodSigHelper;
			try
			{
				methodSigHelper = SignatureHelper.GetMethodSigHelper(this, method.CallingConvention, method.ReturnType, method.ReturnParameter.GetRequiredCustomModifiers(), method.ReturnParameter.GetOptionalCustomModifiers(), array2, array3, array4);
			}
			catch (NotImplementedException)
			{
				methodSigHelper = SignatureHelper.GetMethodSigHelper(this, method.ReturnType, array2);
			}
			int length;
			byte[] signature = methodSigHelper.InternalGetSignature(out length);
			return GetMemberRefFromSignature(tr, method.Name, signature, length);
		}

		internal int GetMethodTokenInternal(MethodBase method, Type[] optionalParameterTypes, bool useMethodDef)
		{
			MethodInfo methodInfo = method as MethodInfo;
			if (method.IsGenericMethod)
			{
				MethodInfo methodInfo2 = methodInfo;
				bool isGenericMethodDefinition = methodInfo.IsGenericMethodDefinition;
				if (!isGenericMethodDefinition)
				{
					methodInfo2 = methodInfo.GetGenericMethodDefinition();
				}
				int num = ((Equals(methodInfo2.Module) && (!(methodInfo2.DeclaringType != null) || !methodInfo2.DeclaringType.IsGenericType)) ? GetMethodToken(methodInfo2) : GetMemberRefToken(methodInfo2, null));
				if (isGenericMethodDefinition && useMethodDef)
				{
					return num;
				}
				int length;
				byte[] signature = SignatureHelper.GetMethodSpecSigHelper(this, methodInfo.GetGenericArguments()).InternalGetSignature(out length);
				ModuleBuilder module = this;
				return TypeBuilder.DefineMethodSpec(new QCallModule(ref module), num, signature, length);
			}
			if ((method.CallingConvention & CallingConventions.VarArgs) == 0 && (method.DeclaringType == null || !method.DeclaringType.IsGenericType))
			{
				if (methodInfo != null)
				{
					return GetMethodToken(methodInfo);
				}
				return GetConstructorToken(method as ConstructorInfo);
			}
			return GetMemberRefToken(method, optionalParameterTypes);
		}

		internal int GetArrayMethodToken(Type arrayClass, string methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
		{
			lock (SyncRoot)
			{
				return GetArrayMethodTokenNoLock(arrayClass, methodName, callingConvention, returnType, parameterTypes);
			}
		}

		private int GetArrayMethodTokenNoLock(Type arrayClass, string methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
		{
			if (arrayClass == null)
			{
				throw new ArgumentNullException("arrayClass");
			}
			if (methodName == null)
			{
				throw new ArgumentNullException("methodName");
			}
			if (methodName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "methodName");
			}
			if (!arrayClass.IsArray)
			{
				throw new ArgumentException(SR.Argument_HasToBeArrayClass);
			}
			AssemblyBuilder.CheckContext(returnType, arrayClass);
			AssemblyBuilder.CheckContext(parameterTypes);
			SignatureHelper methodSigHelper = SignatureHelper.GetMethodSigHelper(this, callingConvention, returnType, null, null, parameterTypes, null, null);
			int length;
			byte[] signature = methodSigHelper.InternalGetSignature(out length);
			int typeTokenInternal = GetTypeTokenInternal(arrayClass);
			ModuleBuilder module = this;
			return GetArrayMethodToken(new QCallModule(ref module), typeTokenInternal, methodName, signature, length);
		}

		public MethodInfo GetArrayMethod(Type arrayClass, string methodName, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes)
		{
			AssemblyBuilder.CheckContext(returnType, arrayClass);
			AssemblyBuilder.CheckContext(parameterTypes);
			int arrayMethodToken = GetArrayMethodToken(arrayClass, methodName, callingConvention, returnType, parameterTypes);
			return new SymbolMethod(this, arrayMethodToken, arrayClass, methodName, callingConvention, returnType, parameterTypes);
		}

		internal int GetConstructorToken(ConstructorInfo con)
		{
			return InternalGetConstructorToken(con, usingRef: false);
		}

		internal int GetFieldToken(FieldInfo field)
		{
			lock (SyncRoot)
			{
				return GetFieldTokenNoLock(field);
			}
		}

		private int GetFieldTokenNoLock(FieldInfo field)
		{
			if (field == null)
			{
				throw new ArgumentNullException("field");
			}
			int num = 0;
			int tokenFromTypeSpec;
			if (field is FieldBuilder fieldBuilder)
			{
				if (field.DeclaringType != null && field.DeclaringType.IsGenericType)
				{
					int length;
					byte[] signature = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length);
					tokenFromTypeSpec = GetTokenFromTypeSpec(signature, length);
					return GetMemberRef(this, tokenFromTypeSpec, fieldBuilder.MetadataToken);
				}
				if (fieldBuilder.Module.Equals(this))
				{
					return fieldBuilder.MetadataToken;
				}
				if (field.DeclaringType == null)
				{
					throw new InvalidOperationException(SR.InvalidOperation_CannotImportGlobalFromDifferentModule);
				}
				tokenFromTypeSpec = GetTypeTokenInternal(field.DeclaringType);
				return GetMemberRef(field.ReflectedType.Module, tokenFromTypeSpec, fieldBuilder.MetadataToken);
			}
			if (field is RuntimeFieldInfo runtimeField)
			{
				if (field.DeclaringType == null)
				{
					throw new InvalidOperationException(SR.InvalidOperation_CannotImportGlobalFromDifferentModule);
				}
				if (field.DeclaringType != null && field.DeclaringType.IsGenericType)
				{
					int length2;
					byte[] signature2 = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length2);
					tokenFromTypeSpec = GetTokenFromTypeSpec(signature2, length2);
					return GetMemberRefOfFieldInfo(tokenFromTypeSpec, field.DeclaringType.GetTypeHandleInternal(), runtimeField);
				}
				tokenFromTypeSpec = GetTypeTokenInternal(field.DeclaringType);
				return GetMemberRefOfFieldInfo(tokenFromTypeSpec, field.DeclaringType.GetTypeHandleInternal(), runtimeField);
			}
			if (field is FieldOnTypeBuilderInstantiation fieldOnTypeBuilderInstantiation)
			{
				FieldInfo fieldInfo = fieldOnTypeBuilderInstantiation.FieldInfo;
				int length3;
				byte[] signature3 = SignatureHelper.GetTypeSigToken(this, field.DeclaringType).InternalGetSignature(out length3);
				tokenFromTypeSpec = GetTokenFromTypeSpec(signature3, length3);
				return GetMemberRef(fieldInfo.ReflectedType.Module, tokenFromTypeSpec, fieldOnTypeBuilderInstantiation.MetadataToken);
			}
			tokenFromTypeSpec = GetTypeTokenInternal(field.ReflectedType);
			SignatureHelper fieldSigHelper = SignatureHelper.GetFieldSigHelper(this);
			fieldSigHelper.AddArgument(field.FieldType, field.GetRequiredCustomModifiers(), field.GetOptionalCustomModifiers());
			int length4;
			byte[] signature4 = fieldSigHelper.InternalGetSignature(out length4);
			return GetMemberRefFromSignature(tokenFromTypeSpec, field.Name, signature4, length4);
		}

		internal int GetStringConstant(string str)
		{
			if (str == null)
			{
				throw new ArgumentNullException("str");
			}
			ModuleBuilder module = this;
			return GetStringConstant(new QCallModule(ref module), str, str.Length);
		}

		internal int GetSignatureToken(SignatureHelper sigHelper)
		{
			if (sigHelper == null)
			{
				throw new ArgumentNullException("sigHelper");
			}
			int length;
			byte[] signature = sigHelper.InternalGetSignature(out length);
			ModuleBuilder module = this;
			return TypeBuilder.GetTokenFromSig(new QCallModule(ref module), signature, length);
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (binaryAttribute == null)
			{
				throw new ArgumentNullException("binaryAttribute");
			}
			TypeBuilder.DefineCustomAttribute(this, 1, GetConstructorToken(con), binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			if (customBuilder == null)
			{
				throw new ArgumentNullException("customBuilder");
			}
			customBuilder.CreateCustomAttribute(this, 1);
		}
	}
	internal sealed class ModuleBuilderData
	{
		public readonly TypeBuilder _globalTypeBuilder;

		public readonly string _moduleName;

		public bool _hasGlobalBeenCreated;

		internal ModuleBuilderData(ModuleBuilder module, string moduleName)
		{
			_globalTypeBuilder = new TypeBuilder(module);
			_moduleName = moduleName;
		}
	}
	public class ParameterBuilder
	{
		private readonly string _name;

		private readonly int _position;

		private readonly ParameterAttributes _attributes;

		private MethodBuilder _methodBuilder;

		private int _token;

		public virtual string? Name => _name;

		public virtual int Position => _position;

		public virtual int Attributes => (int)_attributes;

		public bool IsIn => (_attributes & ParameterAttributes.In) != 0;

		public bool IsOut => (_attributes & ParameterAttributes.Out) != 0;

		public bool IsOptional => (_attributes & ParameterAttributes.Optional) != 0;

		public virtual void SetConstant(object? defaultValue)
		{
			TypeBuilder.SetConstantValue(_methodBuilder.GetModuleBuilder(), _token, (_position == 0) ? _methodBuilder.ReturnType : _methodBuilder.m_parameterTypes[_position - 1], defaultValue);
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (binaryAttribute == null)
			{
				throw new ArgumentNullException("binaryAttribute");
			}
			TypeBuilder.DefineCustomAttribute(_methodBuilder.GetModuleBuilder(), _token, ((ModuleBuilder)_methodBuilder.GetModule()).GetConstructorToken(con), binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			if (customBuilder == null)
			{
				throw new ArgumentNullException("customBuilder");
			}
			customBuilder.CreateCustomAttribute((ModuleBuilder)_methodBuilder.GetModule(), _token);
		}

		internal ParameterBuilder(MethodBuilder methodBuilder, int sequence, ParameterAttributes attributes, string paramName)
		{
			_position = sequence;
			_name = paramName;
			_methodBuilder = methodBuilder;
			_attributes = attributes;
			ModuleBuilder module = _methodBuilder.GetModuleBuilder();
			_token = TypeBuilder.SetParamInfo(new QCallModule(ref module), _methodBuilder.MetadataToken, sequence, attributes, paramName);
		}
	}
	public sealed class PropertyBuilder : PropertyInfo
	{
		private string m_name;

		private int m_tkProperty;

		private ModuleBuilder m_moduleBuilder;

		private PropertyAttributes m_attributes;

		private Type m_returnType;

		private MethodInfo m_getMethod;

		private MethodInfo m_setMethod;

		private TypeBuilder m_containingType;

		public override Module Module => m_containingType.Module;

		public override Type PropertyType => m_returnType;

		public override PropertyAttributes Attributes => m_attributes;

		public override bool CanRead
		{
			get
			{
				if (m_getMethod != null)
				{
					return true;
				}
				return false;
			}
		}

		public override bool CanWrite
		{
			get
			{
				if (m_setMethod != null)
				{
					return true;
				}
				return false;
			}
		}

		public override string Name => m_name;

		public override Type? DeclaringType => m_containingType;

		public override Type? ReflectedType => m_containingType;

		internal PropertyBuilder(ModuleBuilder mod, string name, SignatureHelper sig, PropertyAttributes attr, Type returnType, int prToken, TypeBuilder containingType)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			if (name[0] == '\0')
			{
				throw new ArgumentException(SR.Argument_IllegalName, "name");
			}
			m_name = name;
			m_moduleBuilder = mod;
			m_attributes = attr;
			m_returnType = returnType;
			m_tkProperty = prToken;
			m_containingType = containingType;
		}

		public void SetConstant(object? defaultValue)
		{
			m_containingType.ThrowIfCreated();
			TypeBuilder.SetConstantValue(m_moduleBuilder, m_tkProperty, m_returnType, defaultValue);
		}

		private void SetMethodSemantics(MethodBuilder mdBuilder, MethodSemanticsAttributes semantics)
		{
			if (mdBuilder == null)
			{
				throw new ArgumentNullException("mdBuilder");
			}
			m_containingType.ThrowIfCreated();
			ModuleBuilder module = m_moduleBuilder;
			TypeBuilder.DefineMethodSemantics(new QCallModule(ref module), m_tkProperty, semantics, mdBuilder.MetadataToken);
		}

		public void SetGetMethod(MethodBuilder mdBuilder)
		{
			SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Getter);
			m_getMethod = mdBuilder;
		}

		public void SetSetMethod(MethodBuilder mdBuilder)
		{
			SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Setter);
			m_setMethod = mdBuilder;
		}

		public void AddOtherMethod(MethodBuilder mdBuilder)
		{
			SetMethodSemantics(mdBuilder, MethodSemanticsAttributes.Other);
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (binaryAttribute == null)
			{
				throw new ArgumentNullException("binaryAttribute");
			}
			m_containingType.ThrowIfCreated();
			TypeBuilder.DefineCustomAttribute(m_moduleBuilder, m_tkProperty, m_moduleBuilder.GetConstructorToken(con), binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			if (customBuilder == null)
			{
				throw new ArgumentNullException("customBuilder");
			}
			m_containingType.ThrowIfCreated();
			customBuilder.CreateCustomAttribute(m_moduleBuilder, m_tkProperty);
		}

		public override object GetValue(object? obj, object?[]? index)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override object GetValue(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? index, CultureInfo? culture)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override void SetValue(object? obj, object? value, object?[]? index)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override void SetValue(object? obj, object? value, BindingFlags invokeAttr, Binder? binder, object?[]? index, CultureInfo? culture)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override MethodInfo[] GetAccessors(bool nonPublic)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override MethodInfo? GetGetMethod(bool nonPublic)
		{
			if (nonPublic || m_getMethod == null)
			{
				return m_getMethod;
			}
			if ((m_getMethod.Attributes & MethodAttributes.Public) == MethodAttributes.Public)
			{
				return m_getMethod;
			}
			return null;
		}

		public override MethodInfo? GetSetMethod(bool nonPublic)
		{
			if (nonPublic || m_setMethod == null)
			{
				return m_setMethod;
			}
			if ((m_setMethod.Attributes & MethodAttributes.Public) == MethodAttributes.Public)
			{
				return m_setMethod;
			}
			return null;
		}

		public override ParameterInfo[] GetIndexParameters()
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}
	}
	public sealed class SignatureHelper
	{
		private byte[] m_signature;

		private int m_currSig;

		private int m_sizeLoc;

		private ModuleBuilder m_module;

		private bool m_sigDone;

		private int m_argCount;

		internal int ArgumentCount => m_argCount;

		public static SignatureHelper GetMethodSigHelper(Module? mod, Type? returnType, Type[]? parameterTypes)
		{
			return GetMethodSigHelper(mod, CallingConventions.Standard, returnType, null, null, parameterTypes, null, null);
		}

		public static SignatureHelper GetMethodSigHelper(Module? mod, CallingConventions callingConvention, Type? returnType)
		{
			return GetMethodSigHelper(mod, callingConvention, returnType, null, null, null, null, null);
		}

		internal static SignatureHelper GetMethodSpecSigHelper(Module scope, Type[] inst)
		{
			SignatureHelper signatureHelper = new SignatureHelper(scope, MdSigCallingConvention.GenericInst);
			signatureHelper.AddData(inst.Length);
			foreach (Type clsArgument in inst)
			{
				signatureHelper.AddArgument(clsArgument);
			}
			return signatureHelper;
		}

		internal static SignatureHelper GetMethodSigHelper(Module scope, CallingConventions callingConvention, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
		{
			return GetMethodSigHelper(scope, callingConvention, 0, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
		}

		internal static SignatureHelper GetMethodSigHelper(Module scope, CallingConventions callingConvention, int cGenericParam, Type returnType, Type[] requiredReturnTypeCustomModifiers, Type[] optionalReturnTypeCustomModifiers, Type[] parameterTypes, Type[][] requiredParameterTypeCustomModifiers, Type[][] optionalParameterTypeCustomModifiers)
		{
			if (returnType == null)
			{
				returnType = typeof(void);
			}
			MdSigCallingConvention mdSigCallingConvention = MdSigCallingConvention.Default;
			if ((callingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
			{
				mdSigCallingConvention = MdSigCallingConvention.Vararg;
			}
			if (cGenericParam > 0)
			{
				mdSigCallingConvention |= MdSigCallingConvention.Generic;
			}
			if ((callingConvention & CallingConventions.HasThis) == CallingConventions.HasThis)
			{
				mdSigCallingConvention |= MdSigCallingConvention.HasThis;
			}
			SignatureHelper signatureHelper = new SignatureHelper(scope, mdSigCallingConvention, cGenericParam, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers);
			signatureHelper.AddArguments(parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
			return signatureHelper;
		}

		internal static SignatureHelper GetMethodSigHelper(Module mod, CallingConvention unmanagedCallConv, Type returnType)
		{
			if ((object)returnType == null)
			{
				returnType = typeof(void);
			}
			MdSigCallingConvention callingConvention;
			switch (unmanagedCallConv)
			{
			case CallingConvention.Cdecl:
				callingConvention = MdSigCallingConvention.C;
				break;
			case CallingConvention.Winapi:
			case CallingConvention.StdCall:
				callingConvention = MdSigCallingConvention.StdCall;
				break;
			case CallingConvention.ThisCall:
				callingConvention = MdSigCallingConvention.ThisCall;
				break;
			case CallingConvention.FastCall:
				callingConvention = MdSigCallingConvention.FastCall;
				break;
			default:
				throw new ArgumentException(SR.Argument_UnknownUnmanagedCallConv, "unmanagedCallConv");
			}
			return new SignatureHelper(mod, callingConvention, returnType, null, null);
		}

		public static SignatureHelper GetLocalVarSigHelper()
		{
			return GetLocalVarSigHelper(null);
		}

		public static SignatureHelper GetMethodSigHelper(CallingConventions callingConvention, Type? returnType)
		{
			return GetMethodSigHelper(null, callingConvention, returnType);
		}

		internal static SignatureHelper GetMethodSigHelper(CallingConvention unmanagedCallingConvention, Type returnType)
		{
			return GetMethodSigHelper(null, unmanagedCallingConvention, returnType);
		}

		public static SignatureHelper GetLocalVarSigHelper(Module? mod)
		{
			return new SignatureHelper(mod, MdSigCallingConvention.LocalSig);
		}

		public static SignatureHelper GetFieldSigHelper(Module? mod)
		{
			return new SignatureHelper(mod, MdSigCallingConvention.Field);
		}

		public static SignatureHelper GetPropertySigHelper(Module? mod, Type? returnType, Type[]? parameterTypes)
		{
			return GetPropertySigHelper(mod, returnType, null, null, parameterTypes, null, null);
		}

		public static SignatureHelper GetPropertySigHelper(Module? mod, Type? returnType, Type[]? requiredReturnTypeCustomModifiers, Type[]? optionalReturnTypeCustomModifiers, Type[]? parameterTypes, Type[][]? requiredParameterTypeCustomModifiers, Type[][]? optionalParameterTypeCustomModifiers)
		{
			return GetPropertySigHelper(mod, (CallingConventions)0, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers, parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
		}

		public static SignatureHelper GetPropertySigHelper(Module? mod, CallingConventions callingConvention, Type? returnType, Type[]? requiredReturnTypeCustomModifiers, Type[]? optionalReturnTypeCustomModifiers, Type[]? parameterTypes, Type[][]? requiredParameterTypeCustomModifiers, Type[][]? optionalParameterTypeCustomModifiers)
		{
			if (returnType == null)
			{
				returnType = typeof(void);
			}
			MdSigCallingConvention mdSigCallingConvention = MdSigCallingConvention.Property;
			if ((callingConvention & CallingConventions.HasThis) == CallingConventions.HasThis)
			{
				mdSigCallingConvention |= MdSigCallingConvention.HasThis;
			}
			SignatureHelper signatureHelper = new SignatureHelper(mod, mdSigCallingConvention, returnType, requiredReturnTypeCustomModifiers, optionalReturnTypeCustomModifiers);
			signatureHelper.AddArguments(parameterTypes, requiredParameterTypeCustomModifiers, optionalParameterTypeCustomModifiers);
			return signatureHelper;
		}

		internal static SignatureHelper GetTypeSigToken(Module module, Type type)
		{
			if (module == null)
			{
				throw new ArgumentNullException("module");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			return new SignatureHelper(module, type);
		}

		private SignatureHelper(Module mod, MdSigCallingConvention callingConvention)
		{
			Init(mod, callingConvention);
		}

		private SignatureHelper(Module mod, MdSigCallingConvention callingConvention, int cGenericParameters, Type returnType, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers)
		{
			Init(mod, callingConvention, cGenericParameters);
			if (callingConvention == MdSigCallingConvention.Field)
			{
				throw new ArgumentException(SR.Argument_BadFieldSig);
			}
			AddOneArgTypeHelper(returnType, requiredCustomModifiers, optionalCustomModifiers);
		}

		private SignatureHelper(Module mod, MdSigCallingConvention callingConvention, Type returnType, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers)
			: this(mod, callingConvention, 0, returnType, requiredCustomModifiers, optionalCustomModifiers)
		{
		}

		private SignatureHelper(Module mod, Type type)
		{
			Init(mod);
			AddOneArgTypeHelper(type);
		}

		[MemberNotNull("m_signature")]
		private void Init(Module mod)
		{
			m_signature = new byte[32];
			m_currSig = 0;
			m_module = mod as ModuleBuilder;
			m_argCount = 0;
			m_sigDone = false;
			m_sizeLoc = -1;
			if (m_module == null && mod != null)
			{
				throw new ArgumentException(SR.NotSupported_MustBeModuleBuilder);
			}
		}

		[MemberNotNull("m_signature")]
		private void Init(Module mod, MdSigCallingConvention callingConvention)
		{
			Init(mod, callingConvention, 0);
		}

		[MemberNotNull("m_signature")]
		private void Init(Module mod, MdSigCallingConvention callingConvention, int cGenericParam)
		{
			Init(mod);
			AddData((int)callingConvention);
			if (callingConvention == MdSigCallingConvention.Field || callingConvention == MdSigCallingConvention.GenericInst)
			{
				m_sizeLoc = -1;
				return;
			}
			if (cGenericParam > 0)
			{
				AddData(cGenericParam);
			}
			m_sizeLoc = m_currSig++;
		}

		private void AddOneArgTypeHelper(Type argument, bool pinned)
		{
			if (pinned)
			{
				AddElementType(CorElementType.ELEMENT_TYPE_PINNED);
			}
			AddOneArgTypeHelper(argument);
		}

		private void AddOneArgTypeHelper(Type clsArgument, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers)
		{
			if (optionalCustomModifiers != null)
			{
				foreach (Type type in optionalCustomModifiers)
				{
					if (type == null)
					{
						throw new ArgumentNullException("optionalCustomModifiers");
					}
					if (type.HasElementType)
					{
						throw new ArgumentException(SR.Argument_ArraysInvalid, "optionalCustomModifiers");
					}
					if (type.ContainsGenericParameters)
					{
						throw new ArgumentException(SR.Argument_GenericsInvalid, "optionalCustomModifiers");
					}
					AddElementType(CorElementType.ELEMENT_TYPE_CMOD_OPT);
					int typeToken = m_module.GetTypeToken(type);
					AddToken(typeToken);
				}
			}
			if (requiredCustomModifiers != null)
			{
				foreach (Type type2 in requiredCustomModifiers)
				{
					if (type2 == null)
					{
						throw new ArgumentNullException("requiredCustomModifiers");
					}
					if (type2.HasElementType)
					{
						throw new ArgumentException(SR.Argument_ArraysInvalid, "requiredCustomModifiers");
					}
					if (type2.ContainsGenericParameters)
					{
						throw new ArgumentException(SR.Argument_GenericsInvalid, "requiredCustomModifiers");
					}
					AddElementType(CorElementType.ELEMENT_TYPE_CMOD_REQD);
					int typeToken2 = m_module.GetTypeToken(type2);
					AddToken(typeToken2);
				}
			}
			AddOneArgTypeHelper(clsArgument);
		}

		private void AddOneArgTypeHelper(Type clsArgument)
		{
			AddOneArgTypeHelperWorker(clsArgument, lastWasGenericInst: false);
		}

		private void AddOneArgTypeHelperWorker(Type clsArgument, bool lastWasGenericInst)
		{
			if (clsArgument.IsGenericParameter)
			{
				if (clsArgument.DeclaringMethod != null)
				{
					AddElementType(CorElementType.ELEMENT_TYPE_MVAR);
				}
				else
				{
					AddElementType(CorElementType.ELEMENT_TYPE_VAR);
				}
				AddData(clsArgument.GenericParameterPosition);
				return;
			}
			if (clsArgument.IsGenericType && (!clsArgument.IsGenericTypeDefinition || !lastWasGenericInst))
			{
				AddElementType(CorElementType.ELEMENT_TYPE_GENERICINST);
				AddOneArgTypeHelperWorker(clsArgument.GetGenericTypeDefinition(), lastWasGenericInst: true);
				Type[] genericArguments = clsArgument.GetGenericArguments();
				AddData(genericArguments.Length);
				Type[] array = genericArguments;
				foreach (Type clsArgument2 in array)
				{
					AddOneArgTypeHelper(clsArgument2);
				}
				return;
			}
			if (clsArgument is TypeBuilder)
			{
				TypeBuilder typeBuilder = (TypeBuilder)clsArgument;
				int clsToken = ((!typeBuilder.Module.Equals(m_module)) ? m_module.GetTypeToken(clsArgument) : typeBuilder.TypeToken);
				if (clsArgument.IsValueType)
				{
					InternalAddTypeToken(clsToken, CorElementType.ELEMENT_TYPE_VALUETYPE);
				}
				else
				{
					InternalAddTypeToken(clsToken, CorElementType.ELEMENT_TYPE_CLASS);
				}
				return;
			}
			if (clsArgument is EnumBuilder)
			{
				TypeBuilder typeBuilder2 = ((EnumBuilder)clsArgument).m_typeBuilder;
				int clsToken2 = ((!typeBuilder2.Module.Equals(m_module)) ? m_module.GetTypeToken(clsArgument) : typeBuilder2.TypeToken);
				if (clsArgument.IsValueType)
				{
					InternalAddTypeToken(clsToken2, CorElementType.ELEMENT_TYPE_VALUETYPE);
				}
				else
				{
					InternalAddTypeToken(clsToken2, CorElementType.ELEMENT_TYPE_CLASS);
				}
				return;
			}
			if (clsArgument.IsByRef)
			{
				AddElementType(CorElementType.ELEMENT_TYPE_BYREF);
				clsArgument = clsArgument.GetElementType();
				AddOneArgTypeHelper(clsArgument);
				return;
			}
			if (clsArgument.IsPointer)
			{
				AddElementType(CorElementType.ELEMENT_TYPE_PTR);
				AddOneArgTypeHelper(clsArgument.GetElementType());
				return;
			}
			if (clsArgument.IsArray)
			{
				if (clsArgument.IsSZArray)
				{
					AddElementType(CorElementType.ELEMENT_TYPE_SZARRAY);
					AddOneArgTypeHelper(clsArgument.GetElementType());
					return;
				}
				AddElementType(CorElementType.ELEMENT_TYPE_ARRAY);
				AddOneArgTypeHelper(clsArgument.GetElementType());
				int arrayRank = clsArgument.GetArrayRank();
				AddData(arrayRank);
				AddData(0);
				AddData(arrayRank);
				for (int j = 0; j < arrayRank; j++)
				{
					AddData(0);
				}
				return;
			}
			CorElementType corElementType = CorElementType.ELEMENT_TYPE_MAX;
			if (clsArgument is RuntimeType)
			{
				corElementType = RuntimeTypeHandle.GetCorElementType((RuntimeType)clsArgument);
				if (corElementType == CorElementType.ELEMENT_TYPE_CLASS)
				{
					if (clsArgument == typeof(object))
					{
						corElementType = CorElementType.ELEMENT_TYPE_OBJECT;
					}
					else if (clsArgument == typeof(string))
					{
						corElementType = CorElementType.ELEMENT_TYPE_STRING;
					}
				}
			}
			if (IsSimpleType(corElementType))
			{
				AddElementType(corElementType);
			}
			else if (m_module == null)
			{
				InternalAddRuntimeType(clsArgument);
			}
			else if (clsArgument.IsValueType)
			{
				InternalAddTypeToken(m_module.GetTypeToken(clsArgument), CorElementType.ELEMENT_TYPE_VALUETYPE);
			}
			else
			{
				InternalAddTypeToken(m_module.GetTypeToken(clsArgument), CorElementType.ELEMENT_TYPE_CLASS);
			}
		}

		private void AddData(int data)
		{
			if (m_currSig + 4 > m_signature.Length)
			{
				m_signature = ExpandArray(m_signature);
			}
			if (data <= 127)
			{
				m_signature[m_currSig++] = (byte)data;
				return;
			}
			if (data <= 16383)
			{
				BinaryPrimitives.WriteInt16BigEndian(m_signature.AsSpan(m_currSig), (short)(data | 0x8000));
				m_currSig += 2;
				return;
			}
			if (data <= 536870911)
			{
				BinaryPrimitives.WriteInt32BigEndian(m_signature.AsSpan(m_currSig), (int)(data | 0xC0000000u));
				m_currSig += 4;
				return;
			}
			throw new ArgumentException(SR.Argument_LargeInteger);
		}

		private void AddElementType(CorElementType cvt)
		{
			if (m_currSig + 1 > m_signature.Length)
			{
				m_signature = ExpandArray(m_signature);
			}
			m_signature[m_currSig++] = (byte)cvt;
		}

		private void AddToken(int token)
		{
			int num = token & 0xFFFFFF;
			MetadataTokenType metadataTokenType = (MetadataTokenType)(token & -16777216);
			if (num > 67108863)
			{
				throw new ArgumentException(SR.Argument_LargeInteger);
			}
			num <<= 2;
			switch (metadataTokenType)
			{
			case MetadataTokenType.TypeRef:
				num |= 1;
				break;
			case MetadataTokenType.TypeSpec:
				num |= 2;
				break;
			}
			AddData(num);
		}

		private void InternalAddTypeToken(int clsToken, CorElementType CorType)
		{
			AddElementType(CorType);
			AddToken(clsToken);
		}

		private unsafe void InternalAddRuntimeType(Type type)
		{
			AddElementType(CorElementType.ELEMENT_TYPE_INTERNAL);
			IntPtr value = type.GetTypeHandleInternal().Value;
			if (m_currSig + sizeof(void*) > m_signature.Length)
			{
				m_signature = ExpandArray(m_signature);
			}
			byte* ptr = (byte*)(&value);
			for (int i = 0; i < sizeof(void*); i++)
			{
				m_signature[m_currSig++] = ptr[i];
			}
		}

		private static byte[] ExpandArray(byte[] inArray)
		{
			return ExpandArray(inArray, inArray.Length * 2);
		}

		private static byte[] ExpandArray(byte[] inArray, int requiredLength)
		{
			if (requiredLength < inArray.Length)
			{
				requiredLength = inArray.Length * 2;
			}
			byte[] array = new byte[requiredLength];
			Buffer.BlockCopy(inArray, 0, array, 0, inArray.Length);
			return array;
		}

		private void IncrementArgCounts()
		{
			if (m_sizeLoc != -1)
			{
				m_argCount++;
			}
		}

		private void SetNumberOfSignatureElements(bool forceCopy)
		{
			int currSig = m_currSig;
			if (m_sizeLoc != -1)
			{
				if (m_argCount < 128 && !forceCopy)
				{
					m_signature[m_sizeLoc] = (byte)m_argCount;
					return;
				}
				int num = ((m_argCount < 128) ? 1 : ((m_argCount >= 16384) ? 4 : 2));
				byte[] array = new byte[m_currSig + num - 1];
				array[0] = m_signature[0];
				Buffer.BlockCopy(m_signature, m_sizeLoc + 1, array, m_sizeLoc + num, currSig - (m_sizeLoc + 1));
				m_signature = array;
				m_currSig = m_sizeLoc;
				AddData(m_argCount);
				m_currSig = currSig + (num - 1);
			}
		}

		internal static bool IsSimpleType(CorElementType type)
		{
			if ((int)type <= 14)
			{
				return true;
			}
			if (type == CorElementType.ELEMENT_TYPE_TYPEDBYREF || type == CorElementType.ELEMENT_TYPE_I || type == CorElementType.ELEMENT_TYPE_U || type == CorElementType.ELEMENT_TYPE_OBJECT)
			{
				return true;
			}
			return false;
		}

		internal byte[] InternalGetSignature(out int length)
		{
			if (!m_sigDone)
			{
				m_sigDone = true;
				SetNumberOfSignatureElements(forceCopy: false);
			}
			length = m_currSig;
			return m_signature;
		}

		internal byte[] InternalGetSignatureArray()
		{
			int argCount = m_argCount;
			int currSig = m_currSig;
			int num = currSig;
			num = ((argCount < 127) ? (num + 1) : ((argCount >= 16383) ? (num + 4) : (num + 2)));
			byte[] array = new byte[num];
			int dstOffset = 0;
			array[dstOffset++] = m_signature[0];
			if (argCount <= 127)
			{
				array[dstOffset++] = (byte)((uint)argCount & 0xFFu);
			}
			else if (argCount <= 16383)
			{
				array[dstOffset++] = (byte)((uint)(argCount >> 8) | 0x80u);
				array[dstOffset++] = (byte)((uint)argCount & 0xFFu);
			}
			else
			{
				if (argCount > 536870911)
				{
					throw new ArgumentException(SR.Argument_LargeInteger);
				}
				array[dstOffset++] = (byte)((uint)(argCount >> 24) | 0xC0u);
				array[dstOffset++] = (byte)((uint)(argCount >> 16) & 0xFFu);
				array[dstOffset++] = (byte)((uint)(argCount >> 8) & 0xFFu);
				array[dstOffset++] = (byte)((uint)argCount & 0xFFu);
			}
			Buffer.BlockCopy(m_signature, 2, array, dstOffset, currSig - 2);
			array[num - 1] = 0;
			return array;
		}

		public void AddArgument(Type clsArgument)
		{
			AddArgument(clsArgument, null, null);
		}

		public void AddArgument(Type argument, bool pinned)
		{
			if (argument == null)
			{
				throw new ArgumentNullException("argument");
			}
			IncrementArgCounts();
			AddOneArgTypeHelper(argument, pinned);
		}

		public void AddArguments(Type[]? arguments, Type[][]? requiredCustomModifiers, Type[][]? optionalCustomModifiers)
		{
			if (requiredCustomModifiers != null && (arguments == null || requiredCustomModifiers.Length != arguments.Length))
			{
				throw new ArgumentException(SR.Format(SR.Argument_MismatchedArrays, "requiredCustomModifiers", "arguments"));
			}
			if (optionalCustomModifiers != null && (arguments == null || optionalCustomModifiers.Length != arguments.Length))
			{
				throw new ArgumentException(SR.Format(SR.Argument_MismatchedArrays, "optionalCustomModifiers", "arguments"));
			}
			if (arguments != null)
			{
				for (int i = 0; i < arguments.Length; i++)
				{
					AddArgument(arguments[i], (requiredCustomModifiers != null) ? requiredCustomModifiers[i] : null, (optionalCustomModifiers != null) ? optionalCustomModifiers[i] : null);
				}
			}
		}

		public void AddArgument(Type argument, Type[]? requiredCustomModifiers, Type[]? optionalCustomModifiers)
		{
			if (m_sigDone)
			{
				throw new ArgumentException(SR.Argument_SigIsFinalized);
			}
			if (argument == null)
			{
				throw new ArgumentNullException("argument");
			}
			IncrementArgCounts();
			AddOneArgTypeHelper(argument, requiredCustomModifiers, optionalCustomModifiers);
		}

		public void AddSentinel()
		{
			AddElementType(CorElementType.ELEMENT_TYPE_SENTINEL);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is SignatureHelper))
			{
				return false;
			}
			SignatureHelper signatureHelper = (SignatureHelper)obj;
			if (!signatureHelper.m_module.Equals(m_module) || signatureHelper.m_currSig != m_currSig || signatureHelper.m_sizeLoc != m_sizeLoc || signatureHelper.m_sigDone != m_sigDone)
			{
				return false;
			}
			for (int i = 0; i < m_currSig; i++)
			{
				if (m_signature[i] != signatureHelper.m_signature[i])
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = m_module.GetHashCode() + m_currSig + m_sizeLoc;
			if (m_sigDone)
			{
				num++;
			}
			for (int i = 0; i < m_currSig; i++)
			{
				num += m_signature[i].GetHashCode();
			}
			return num;
		}

		public byte[] GetSignature()
		{
			return GetSignature(appendEndOfSig: false);
		}

		internal byte[] GetSignature(bool appendEndOfSig)
		{
			if (!m_sigDone)
			{
				if (appendEndOfSig)
				{
					AddElementType(CorElementType.ELEMENT_TYPE_END);
				}
				SetNumberOfSignatureElements(forceCopy: true);
				m_sigDone = true;
			}
			if (m_signature.Length > m_currSig)
			{
				byte[] array = new byte[m_currSig];
				Array.Copy(m_signature, array, m_currSig);
				m_signature = array;
			}
			return m_signature;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("Length: ").Append(m_currSig).AppendLine();
			if (m_sizeLoc != -1)
			{
				stringBuilder.Append("Arguments: ").Append(m_signature[m_sizeLoc]).AppendLine();
			}
			else
			{
				stringBuilder.AppendLine("Field Signature");
			}
			stringBuilder.AppendLine("Signature: ");
			for (int i = 0; i <= m_currSig; i++)
			{
				stringBuilder.Append(m_signature[i]).Append("  ");
			}
			stringBuilder.AppendLine();
			return stringBuilder.ToString();
		}
	}
	internal sealed class SymbolMethod : MethodInfo
	{
		private ModuleBuilder m_module;

		private Type m_containingType;

		private string m_name;

		private CallingConventions m_callingConvention;

		private Type m_returnType;

		private int m_token;

		private Type[] m_parameterTypes;

		public override int MetadataToken => m_token;

		public override Module Module => m_module;

		public override Type ReflectedType => m_containingType;

		public override string Name => m_name;

		public override Type DeclaringType => m_containingType;

		public override MethodAttributes Attributes
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SymbolMethod);
			}
		}

		public override CallingConventions CallingConvention => m_callingConvention;

		public override RuntimeMethodHandle MethodHandle
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_SymbolMethod);
			}
		}

		public override Type ReturnType => m_returnType;

		public override ICustomAttributeProvider ReturnTypeCustomAttributes => new EmptyCAHolder();

		internal SymbolMethod(ModuleBuilder mod, int token, Type arrayClass, string methodName, CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
		{
			m_token = token;
			m_returnType = returnType ?? typeof(void);
			if (parameterTypes != null)
			{
				m_parameterTypes = new Type[parameterTypes.Length];
				Array.Copy(parameterTypes, m_parameterTypes, parameterTypes.Length);
			}
			else
			{
				m_parameterTypes = Type.EmptyTypes;
			}
			m_module = mod;
			m_containingType = arrayClass;
			m_name = methodName;
			m_callingConvention = callingConvention;
			SignatureHelper.GetMethodSigHelper(mod, callingConvention, returnType, null, null, parameterTypes, null, null);
		}

		internal override Type[] GetParameterTypes()
		{
			return m_parameterTypes;
		}

		internal int GetToken(ModuleBuilder mod)
		{
			return mod.GetArrayMethodToken(m_containingType, m_name, m_callingConvention, m_returnType, m_parameterTypes);
		}

		public override ParameterInfo[] GetParameters()
		{
			throw new NotSupportedException(SR.NotSupported_SymbolMethod);
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			throw new NotSupportedException(SR.NotSupported_SymbolMethod);
		}

		public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			throw new NotSupportedException(SR.NotSupported_SymbolMethod);
		}

		public override MethodInfo GetBaseDefinition()
		{
			return this;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_SymbolMethod);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_SymbolMethod);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_SymbolMethod);
		}

		public Module GetModule()
		{
			return m_module;
		}
	}
	internal enum TypeKind
	{
		IsArray = 1,
		IsPointer,
		IsByRef
	}
	internal sealed class SymbolType : TypeInfo
	{
		internal TypeKind m_typeKind;

		internal Type m_baseType;

		internal int m_cRank;

		internal int[] m_iaLowerBound;

		internal int[] m_iaUpperBound;

		private string m_format;

		private bool m_isSzArray = true;

		public override bool IsTypeDefinition => false;

		public override bool IsSZArray
		{
			get
			{
				if (m_cRank <= 1)
				{
					return m_isSzArray;
				}
				return false;
			}
		}

		public override Guid GUID
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_NonReflectedType);
			}
		}

		public override Module Module
		{
			get
			{
				Type baseType = m_baseType;
				while (baseType is SymbolType)
				{
					baseType = ((SymbolType)baseType).m_baseType;
				}
				return baseType.Module;
			}
		}

		public override Assembly Assembly
		{
			get
			{
				Type baseType = m_baseType;
				while (baseType is SymbolType)
				{
					baseType = ((SymbolType)baseType).m_baseType;
				}
				return baseType.Assembly;
			}
		}

		public override RuntimeTypeHandle TypeHandle
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_NonReflectedType);
			}
		}

		public override string Name
		{
			get
			{
				string text = m_format;
				Type baseType = m_baseType;
				while (baseType is SymbolType)
				{
					text = ((SymbolType)baseType).m_format + text;
					baseType = ((SymbolType)baseType).m_baseType;
				}
				return baseType.Name + text;
			}
		}

		public override string FullName => TypeNameBuilder.ToString(this, TypeNameBuilder.Format.FullName);

		public override string AssemblyQualifiedName => TypeNameBuilder.ToString(this, TypeNameBuilder.Format.AssemblyQualifiedName);

		public override string Namespace => m_baseType.Namespace;

		public override Type BaseType => typeof(Array);

		public override bool IsConstructedGenericType => false;

		public override Type UnderlyingSystemType => this;

		public override bool IsAssignableFrom([NotNullWhen(true)] TypeInfo typeInfo)
		{
			if (typeInfo == null)
			{
				return false;
			}
			return IsAssignableFrom(typeInfo.AsType());
		}

		internal static Type FormCompoundType(string format, Type baseType, int curIndex)
		{
			if (format == null || curIndex == format.Length)
			{
				return baseType;
			}
			if (format[curIndex] == '&')
			{
				SymbolType symbolType = new SymbolType(TypeKind.IsByRef);
				symbolType.SetFormat(format, curIndex, 1);
				curIndex++;
				if (curIndex != format.Length)
				{
					throw new ArgumentException(SR.Argument_BadSigFormat);
				}
				symbolType.SetElementType(baseType);
				return symbolType;
			}
			if (format[curIndex] == '[')
			{
				SymbolType symbolType = new SymbolType(TypeKind.IsArray);
				int num = curIndex;
				curIndex++;
				int num2 = 0;
				int num3 = -1;
				while (format[curIndex] != ']')
				{
					if (format[curIndex] == '*')
					{
						symbolType.m_isSzArray = false;
						curIndex++;
					}
					if ((format[curIndex] >= '0' && format[curIndex] <= '9') || format[curIndex] == '-')
					{
						bool flag = false;
						if (format[curIndex] == '-')
						{
							flag = true;
							curIndex++;
						}
						while (format[curIndex] >= '0' && format[curIndex] <= '9')
						{
							num2 *= 10;
							num2 += format[curIndex] - 48;
							curIndex++;
						}
						if (flag)
						{
							num2 = -num2;
						}
						num3 = num2 - 1;
					}
					if (format[curIndex] == '.')
					{
						curIndex++;
						if (format[curIndex] != '.')
						{
							throw new ArgumentException(SR.Argument_BadSigFormat);
						}
						curIndex++;
						if ((format[curIndex] >= '0' && format[curIndex] <= '9') || format[curIndex] == '-')
						{
							bool flag2 = false;
							num3 = 0;
							if (format[curIndex] == '-')
							{
								flag2 = true;
								curIndex++;
							}
							while (format[curIndex] >= '0' && format[curIndex] <= '9')
							{
								num3 *= 10;
								num3 += format[curIndex] - 48;
								curIndex++;
							}
							if (flag2)
							{
								num3 = -num3;
							}
							if (num3 < num2)
							{
								throw new ArgumentException(SR.Argument_BadSigFormat);
							}
						}
					}
					if (format[curIndex] == ',')
					{
						curIndex++;
						symbolType.SetBounds(num2, num3);
						num2 = 0;
						num3 = -1;
					}
					else if (format[curIndex] != ']')
					{
						throw new ArgumentException(SR.Argument_BadSigFormat);
					}
				}
				symbolType.SetBounds(num2, num3);
				curIndex++;
				symbolType.SetFormat(format, num, curIndex - num);
				symbolType.SetElementType(baseType);
				return FormCompoundType(format, symbolType, curIndex);
			}
			if (format[curIndex] == '*')
			{
				SymbolType symbolType = new SymbolType(TypeKind.IsPointer);
				symbolType.SetFormat(format, curIndex, 1);
				curIndex++;
				symbolType.SetElementType(baseType);
				return FormCompoundType(format, symbolType, curIndex);
			}
			return null;
		}

		internal SymbolType(TypeKind typeKind)
		{
			m_typeKind = typeKind;
			m_iaLowerBound = new int[4];
			m_iaUpperBound = new int[4];
		}

		internal void SetElementType(Type baseType)
		{
			if ((object)baseType == null)
			{
				throw new ArgumentNullException("baseType");
			}
			m_baseType = baseType;
		}

		private void SetBounds(int lower, int upper)
		{
			if (lower != 0 || upper != -1)
			{
				m_isSzArray = false;
			}
			if (m_iaLowerBound.Length <= m_cRank)
			{
				int[] array = new int[m_cRank * 2];
				Array.Copy(m_iaLowerBound, array, m_cRank);
				m_iaLowerBound = array;
				Array.Copy(m_iaUpperBound, array, m_cRank);
				m_iaUpperBound = array;
			}
			m_iaLowerBound[m_cRank] = lower;
			m_iaUpperBound[m_cRank] = upper;
			m_cRank++;
		}

		internal void SetFormat(string format, int curIndex, int length)
		{
			m_format = format.Substring(curIndex, length);
		}

		public override Type MakePointerType()
		{
			return FormCompoundType(m_format + "*", m_baseType, 0);
		}

		public override Type MakeByRefType()
		{
			return FormCompoundType(m_format + "&", m_baseType, 0);
		}

		public override Type MakeArrayType()
		{
			return FormCompoundType(m_format + "[]", m_baseType, 0);
		}

		public override Type MakeArrayType(int rank)
		{
			string rankString = TypeInfo.GetRankString(rank);
			return FormCompoundType(m_format + rankString, m_baseType, 0) as SymbolType;
		}

		public override int GetArrayRank()
		{
			if (!base.IsArray)
			{
				throw new NotSupportedException(SR.NotSupported_SubclassOverride);
			}
			return m_cRank;
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		public override string ToString()
		{
			return TypeNameBuilder.ToString(this, TypeNameBuilder.Format.ToString);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo GetField(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo[] GetFields(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2063:UnrecognizedReflectionPattern", Justification = "Linker doesn't recognize always throwing method. https://github.com/mono/linker/issues/2025")]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type GetInterface(string name, bool ignoreCase)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type[] GetInterfaces()
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public override EventInfo[] GetEvents()
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type[] GetNestedTypes(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type GetNestedType(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo[] GetEvents(BindingFlags bindingAttr)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		protected override TypeAttributes GetAttributeFlagsImpl()
		{
			Type baseType = m_baseType;
			while (baseType is SymbolType)
			{
				baseType = ((SymbolType)baseType).m_baseType;
			}
			return baseType.Attributes;
		}

		protected override bool IsArrayImpl()
		{
			return m_typeKind == TypeKind.IsArray;
		}

		protected override bool IsPointerImpl()
		{
			return m_typeKind == TypeKind.IsPointer;
		}

		protected override bool IsByRefImpl()
		{
			return m_typeKind == TypeKind.IsByRef;
		}

		protected override bool IsPrimitiveImpl()
		{
			return false;
		}

		protected override bool IsValueTypeImpl()
		{
			return false;
		}

		protected override bool IsCOMObjectImpl()
		{
			return false;
		}

		public override Type GetElementType()
		{
			return m_baseType;
		}

		protected override bool HasElementTypeImpl()
		{
			return m_baseType != null;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new NotSupportedException(SR.NotSupported_NonReflectedType);
		}
	}
	public sealed class TypeBuilder : TypeInfo
	{
		private sealed class CustAttr
		{
			private readonly ConstructorInfo m_con;

			private readonly byte[] m_binaryAttribute;

			private readonly CustomAttributeBuilder m_customBuilder;

			public CustAttr(ConstructorInfo con, byte[] binaryAttribute)
			{
				if ((object)con == null)
				{
					throw new ArgumentNullException("con");
				}
				if (binaryAttribute == null)
				{
					throw new ArgumentNullException("binaryAttribute");
				}
				m_con = con;
				m_binaryAttribute = binaryAttribute;
			}

			public CustAttr(CustomAttributeBuilder customBuilder)
			{
				if (customBuilder == null)
				{
					throw new ArgumentNullException("customBuilder");
				}
				m_customBuilder = customBuilder;
			}

			public void Bake(ModuleBuilder module, int token)
			{
				if (m_customBuilder == null)
				{
					DefineCustomAttribute(module, token, module.GetConstructorToken(m_con), m_binaryAttribute);
				}
				else
				{
					m_customBuilder.CreateCustomAttribute(module, token);
				}
			}
		}

		public const int UnspecifiedTypeSize = 0;

		private List<CustAttr> m_ca;

		private int m_tdType;

		private readonly ModuleBuilder m_module;

		private readonly string m_strName;

		private readonly string m_strNameSpace;

		private string m_strFullQualName;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		private Type m_typeParent;

		private List<Type> m_typeInterfaces;

		private readonly TypeAttributes m_iAttr;

		private GenericParameterAttributes m_genParamAttributes;

		internal List<MethodBuilder> m_listMethods;

		internal int m_lastTokenizedMethod;

		private int m_constructorCount;

		private readonly int m_iTypeSize;

		private readonly PackingSize m_iPackingSize;

		private readonly TypeBuilder m_DeclaringType;

		private Type m_enumUnderlyingType;

		internal bool m_isHiddenGlobalType;

		private bool m_hasBeenCreated;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		private RuntimeType m_bakedRuntimeType;

		private readonly int m_genParamPos;

		private GenericTypeParameterBuilder[] m_inst;

		private readonly bool m_bIsGenParam;

		private readonly MethodBuilder m_declMeth;

		private readonly TypeBuilder m_genTypeDef;

		internal object SyncRoot => m_module.SyncRoot;

		internal RuntimeType BakedRuntimeType => m_bakedRuntimeType;

		public override Type? DeclaringType => m_DeclaringType;

		public override Type? ReflectedType => m_DeclaringType;

		public override string Name => m_strName;

		public override Module Module => GetModuleBuilder();

		public override bool IsByRefLike => false;

		public override int MetadataToken => m_tdType;

		public override Guid GUID
		{
			get
			{
				if (!IsCreated())
				{
					throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
				}
				return m_bakedRuntimeType.GUID;
			}
		}

		public override Assembly Assembly => m_module.Assembly;

		public override RuntimeTypeHandle TypeHandle
		{
			get
			{
				throw new NotSupportedException(SR.NotSupported_DynamicModule);
			}
		}

		public override string? FullName => m_strFullQualName ?? (m_strFullQualName = TypeNameBuilder.ToString(this, TypeNameBuilder.Format.FullName));

		public override string? Namespace => m_strNameSpace;

		public override string? AssemblyQualifiedName => TypeNameBuilder.ToString(this, TypeNameBuilder.Format.AssemblyQualifiedName);

		public override Type? BaseType => m_typeParent;

		public override bool IsTypeDefinition => true;

		public override bool IsSZArray => false;

		public override bool IsSecurityCritical => true;

		public override bool IsSecuritySafeCritical => false;

		public override bool IsSecurityTransparent => false;

		public override Type UnderlyingSystemType
		{
			get
			{
				if (m_bakedRuntimeType != null)
				{
					return m_bakedRuntimeType;
				}
				if (IsEnum)
				{
					if (m_enumUnderlyingType == null)
					{
						throw new InvalidOperationException(SR.InvalidOperation_NoUnderlyingTypeOnEnum);
					}
					return m_enumUnderlyingType;
				}
				return this;
			}
		}

		public override GenericParameterAttributes GenericParameterAttributes => m_genParamAttributes;

		public override bool IsGenericTypeDefinition => IsGenericType;

		public override bool IsGenericType => m_inst != null;

		public override bool IsGenericParameter => m_bIsGenParam;

		public override bool IsConstructedGenericType => false;

		public override int GenericParameterPosition => m_genParamPos;

		public override MethodBase? DeclaringMethod => m_declMeth;

		public int Size => m_iTypeSize;

		public PackingSize PackingSize => m_iPackingSize;

		internal int TypeToken
		{
			get
			{
				if (IsGenericParameter)
				{
					ThrowIfCreated();
				}
				return m_tdType;
			}
		}

		public override bool IsAssignableFrom([NotNullWhen(true)] TypeInfo? typeInfo)
		{
			if (typeInfo == null)
			{
				return false;
			}
			return IsAssignableFrom(typeInfo.AsType());
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2055:UnrecognizedReflectionPattern", Justification = "MakeGenericType is only called on a TypeBuilder which is not subject to trimming")]
		public static MethodInfo GetMethod(Type type, MethodInfo method)
		{
			if (!(type is TypeBuilder) && !(type is TypeBuilderInstantiation))
			{
				throw new ArgumentException(SR.Argument_MustBeTypeBuilder);
			}
			if (method.IsGenericMethod && !method.IsGenericMethodDefinition)
			{
				throw new ArgumentException(SR.Argument_NeedGenericMethodDefinition, "method");
			}
			if (method.DeclaringType == null || !method.DeclaringType.IsGenericTypeDefinition)
			{
				throw new ArgumentException(SR.Argument_MethodNeedGenericDeclaringType, "method");
			}
			if (type.GetGenericTypeDefinition() != method.DeclaringType)
			{
				throw new ArgumentException(SR.Argument_InvalidMethodDeclaringType, "type");
			}
			if (type.IsGenericTypeDefinition)
			{
				type = type.MakeGenericType(type.GetGenericArguments());
			}
			if (!(type is TypeBuilderInstantiation))
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "type");
			}
			return MethodOnTypeBuilderInstantiation.GetMethod(method, type as TypeBuilderInstantiation);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2055:UnrecognizedReflectionPattern", Justification = "MakeGenericType is only called on a TypeBuilder which is not subject to trimming")]
		public static ConstructorInfo GetConstructor(Type type, ConstructorInfo constructor)
		{
			if (!(type is TypeBuilder) && !(type is TypeBuilderInstantiation))
			{
				throw new ArgumentException(SR.Argument_MustBeTypeBuilder);
			}
			if (!constructor.DeclaringType.IsGenericTypeDefinition)
			{
				throw new ArgumentException(SR.Argument_ConstructorNeedGenericDeclaringType, "constructor");
			}
			if (!(type is TypeBuilderInstantiation))
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "type");
			}
			if (type is TypeBuilder && type.IsGenericTypeDefinition)
			{
				type = type.MakeGenericType(type.GetGenericArguments());
			}
			if (type.GetGenericTypeDefinition() != constructor.DeclaringType)
			{
				throw new ArgumentException(SR.Argument_InvalidConstructorDeclaringType, "type");
			}
			return ConstructorOnTypeBuilderInstantiation.GetConstructor(constructor, type as TypeBuilderInstantiation);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2055:UnrecognizedReflectionPattern", Justification = "MakeGenericType is only called on a TypeBuilder which is not subject to trimming")]
		public static FieldInfo GetField(Type type, FieldInfo field)
		{
			if (!(type is TypeBuilder) && !(type is TypeBuilderInstantiation))
			{
				throw new ArgumentException(SR.Argument_MustBeTypeBuilder);
			}
			if (!field.DeclaringType.IsGenericTypeDefinition)
			{
				throw new ArgumentException(SR.Argument_FieldNeedGenericDeclaringType, "field");
			}
			if (!(type is TypeBuilderInstantiation))
			{
				throw new ArgumentException(SR.Argument_NeedNonGenericType, "type");
			}
			if (type is TypeBuilder && type.IsGenericTypeDefinition)
			{
				type = type.MakeGenericType(type.GetGenericArguments());
			}
			if (type.GetGenericTypeDefinition() != field.DeclaringType)
			{
				throw new ArgumentException(SR.Argument_InvalidFieldDeclaringType, "type");
			}
			return FieldOnTypeBuilderInstantiation.GetField(field, type as TypeBuilderInstantiation);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void SetParentType(QCallModule module, int tdTypeDef, int tkParent);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int DefineMethod(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, MethodAttributes attributes);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int DefineField(QCallModule module, int tkParent, string name, byte[] signature, int sigLength, FieldAttributes attributes);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void SetMethodIL(QCallModule module, int tk, bool isInitLocals, byte[] body, int bodyLength, byte[] LocalSig, int sigLength, int maxStackSize, ExceptionHandler[] exceptions, int numExceptions, int[] tokenFixups, int numTokenFixups);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void DefineCustomAttribute(QCallModule module, int tkAssociate, int tkConstructor, byte[] attr, int attrLength);

		internal static void DefineCustomAttribute(ModuleBuilder module, int tkAssociate, int tkConstructor, byte[] attr)
		{
			byte[] array = null;
			if (attr != null)
			{
				array = new byte[attr.Length];
				Buffer.BlockCopy(attr, 0, array, 0, attr.Length);
			}
			DefineCustomAttribute(new QCallModule(ref module), tkAssociate, tkConstructor, array, (array != null) ? array.Length : 0);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int DefineProperty(QCallModule module, int tkParent, string name, PropertyAttributes attributes, byte[] signature, int sigLength);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void DefineMethodSemantics(QCallModule module, int tkAssociation, MethodSemanticsAttributes semantics, int tkMethod);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int SetParamInfo(QCallModule module, int tkMethod, int iSequence, ParameterAttributes iParamAttributes, string strParamName);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern void SetConstantValue(QCallModule module, int tk, int corType, void* pValue);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags);

		internal static bool IsTypeEqual(Type t1, Type t2)
		{
			if (t1 == t2)
			{
				return true;
			}
			TypeBuilder typeBuilder = null;
			TypeBuilder typeBuilder2 = null;
			Type type;
			if (t1 is TypeBuilder)
			{
				typeBuilder = (TypeBuilder)t1;
				type = typeBuilder.m_bakedRuntimeType;
			}
			else
			{
				type = t1;
			}
			Type type2;
			if (t2 is TypeBuilder)
			{
				typeBuilder2 = (TypeBuilder)t2;
				type2 = typeBuilder2.m_bakedRuntimeType;
			}
			else
			{
				type2 = t2;
			}
			if (typeBuilder != null && typeBuilder2 != null && (object)typeBuilder == typeBuilder2)
			{
				return true;
			}
			if (type != null && type2 != null && type == type2)
			{
				return true;
			}
			return false;
		}

		internal unsafe static void SetConstantValue(ModuleBuilder module, int tk, Type destType, object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				if (destType.IsByRef)
				{
					destType = destType.GetElementType();
				}
				destType = Nullable.GetUnderlyingType(destType) ?? destType;
				if (destType.IsEnum)
				{
					Type type2;
					if (destType is EnumBuilder enumBuilder)
					{
						type2 = enumBuilder.GetEnumUnderlyingType();
						if (type != enumBuilder.m_typeBuilder.m_bakedRuntimeType && type != type2)
						{
							throw new ArgumentException(SR.Argument_ConstantDoesntMatch);
						}
					}
					else if (destType is TypeBuilder typeBuilder)
					{
						type2 = typeBuilder.m_enumUnderlyingType;
						if (type2 == null || (type != typeBuilder.UnderlyingSystemType && type != type2))
						{
							throw new ArgumentException(SR.Argument_ConstantDoesntMatch);
						}
					}
					else
					{
						type2 = Enum.GetUnderlyingType(destType);
						if (type != destType && type != type2)
						{
							throw new ArgumentException(SR.Argument_ConstantDoesntMatch);
						}
					}
					type = type2;
				}
				else if (!destType.IsAssignableFrom(type))
				{
					throw new ArgumentException(SR.Argument_ConstantDoesntMatch);
				}
				CorElementType corElementType = RuntimeTypeHandle.GetCorElementType((RuntimeType)type);
				if (corElementType - 2 <= CorElementType.ELEMENT_TYPE_U8)
				{
					fixed (byte* pValue = &value.GetRawData())
					{
						SetConstantValue(new QCallModule(ref module), tk, (int)corElementType, pValue);
					}
					return;
				}
				if (type == typeof(string))
				{
					fixed (char* pValue2 = (string)value)
					{
						SetConstantValue(new QCallModule(ref module), tk, 14, pValue2);
					}
					return;
				}
				if (!(type == typeof(DateTime)))
				{
					throw new ArgumentException(SR.Format(SR.Argument_ConstantNotSupported, type));
				}
				long ticks = ((DateTime)value).Ticks;
				SetConstantValue(new QCallModule(ref module), tk, 10, &ticks);
			}
			else
			{
				SetConstantValue(new QCallModule(ref module), tk, 18, null);
			}
		}

		internal TypeBuilder(ModuleBuilder module)
		{
			m_tdType = 33554432;
			m_isHiddenGlobalType = true;
			m_module = module;
			m_listMethods = new List<MethodBuilder>();
			m_lastTokenizedMethod = -1;
		}

		internal TypeBuilder(string szName, int genParamPos, MethodBuilder declMeth)
		{
			m_strName = szName;
			m_genParamPos = genParamPos;
			m_bIsGenParam = true;
			m_typeInterfaces = new List<Type>();
			m_declMeth = declMeth;
			m_DeclaringType = m_declMeth.GetTypeBuilder();
			m_module = declMeth.GetModuleBuilder();
		}

		private TypeBuilder(string szName, int genParamPos, TypeBuilder declType)
		{
			m_strName = szName;
			m_genParamPos = genParamPos;
			m_bIsGenParam = true;
			m_typeInterfaces = new List<Type>();
			m_DeclaringType = declType;
			m_module = declType.GetModuleBuilder();
		}

		internal TypeBuilder(string fullname, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type parent, Type[] interfaces, ModuleBuilder module, PackingSize iPackingSize, int iTypeSize, TypeBuilder enclosingType)
		{
			if (fullname == null)
			{
				throw new ArgumentNullException("fullname");
			}
			if (fullname.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "fullname");
			}
			if (fullname[0] == '\0')
			{
				throw new ArgumentException(SR.Argument_IllegalName, "fullname");
			}
			if (fullname.Length > 1023)
			{
				throw new ArgumentException(SR.Argument_TypeNameTooLong, "fullname");
			}
			m_module = module;
			m_DeclaringType = enclosingType;
			AssemblyBuilder containingAssemblyBuilder = m_module.ContainingAssemblyBuilder;
			containingAssemblyBuilder._assemblyData.CheckTypeNameConflict(fullname, enclosingType);
			if (enclosingType != null && ((attr & TypeAttributes.VisibilityMask) == TypeAttributes.Public || (attr & TypeAttributes.VisibilityMask) == 0))
			{
				throw new ArgumentException(SR.Argument_BadNestedTypeFlags, "attr");
			}
			int[] array = null;
			if (interfaces != null)
			{
				for (int i = 0; i < interfaces.Length; i++)
				{
					if (interfaces[i] == null)
					{
						throw new ArgumentNullException("interfaces");
					}
				}
				array = new int[interfaces.Length + 1];
				for (int i = 0; i < interfaces.Length; i++)
				{
					array[i] = m_module.GetTypeTokenInternal(interfaces[i]);
				}
			}
			int num = fullname.LastIndexOf('.');
			if (num == -1 || num == 0)
			{
				m_strNameSpace = string.Empty;
				m_strName = fullname;
			}
			else
			{
				m_strNameSpace = fullname.Substring(0, num);
				m_strName = fullname.Substring(num + 1);
			}
			VerifyTypeAttributes(attr);
			m_iAttr = attr;
			SetParent(parent);
			m_listMethods = new List<MethodBuilder>();
			m_lastTokenizedMethod = -1;
			SetInterfaces(interfaces);
			int tkParent = 0;
			if (m_typeParent != null)
			{
				tkParent = m_module.GetTypeTokenInternal(m_typeParent);
			}
			int tkEnclosingType = 0;
			if (enclosingType != null)
			{
				tkEnclosingType = enclosingType.m_tdType;
			}
			m_tdType = DefineType(new QCallModule(ref module), fullname, tkParent, m_iAttr, tkEnclosingType, array);
			m_iPackingSize = iPackingSize;
			m_iTypeSize = iTypeSize;
			if (m_iPackingSize != 0 || m_iTypeSize != 0)
			{
				SetClassLayout(new QCallModule(ref module), m_tdType, m_iPackingSize, m_iTypeSize);
			}
			m_module.AddType(FullName, this);
		}

		private FieldBuilder DefineDataHelper(string name, byte[] data, int size, FieldAttributes attributes)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			if (size <= 0 || size >= 4128768)
			{
				throw new ArgumentException(SR.Argument_BadSizeForData);
			}
			ThrowIfCreated();
			string text = "$ArrayType$" + size;
			Type type = m_module.FindTypeBuilderWithName(text, ignoreCase: false);
			TypeBuilder typeBuilder = type as TypeBuilder;
			if (typeBuilder == null)
			{
				TypeAttributes attr = TypeAttributes.Public | TypeAttributes.ExplicitLayout | TypeAttributes.Sealed;
				typeBuilder = m_module.DefineType(text, attr, typeof(ValueType), PackingSize.Size1, size);
				typeBuilder.CreateType();
			}
			FieldBuilder fieldBuilder = DefineField(name, typeBuilder, attributes | FieldAttributes.Static);
			fieldBuilder.SetData(data, size);
			return fieldBuilder;
		}

		private void VerifyTypeAttributes(TypeAttributes attr)
		{
			if (DeclaringType == null)
			{
				if ((attr & TypeAttributes.VisibilityMask) != 0 && (attr & TypeAttributes.VisibilityMask) != TypeAttributes.Public)
				{
					throw new ArgumentException(SR.Argument_BadTypeAttrNestedVisibilityOnNonNestedType);
				}
			}
			else if ((attr & TypeAttributes.VisibilityMask) == 0 || (attr & TypeAttributes.VisibilityMask) == TypeAttributes.Public)
			{
				throw new ArgumentException(SR.Argument_BadTypeAttrNonNestedVisibilityNestedType);
			}
			if ((attr & TypeAttributes.LayoutMask) != 0 && (attr & TypeAttributes.LayoutMask) != TypeAttributes.SequentialLayout && (attr & TypeAttributes.LayoutMask) != TypeAttributes.ExplicitLayout)
			{
				throw new ArgumentException(SR.Argument_BadTypeAttrInvalidLayout);
			}
			if ((attr & TypeAttributes.ReservedMask) != 0)
			{
				throw new ArgumentException(SR.Argument_BadTypeAttrReservedBitsSet);
			}
		}

		public bool IsCreated()
		{
			return m_hasBeenCreated;
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int DefineType(QCallModule module, string fullname, int tkParent, TypeAttributes attributes, int tkEnclosingType, int[] interfaceTokens);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern int DefineGenericParam(QCallModule module, string name, int tkParent, GenericParameterAttributes attributes, int position, int[] constraints);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type);

		internal void ThrowIfCreated()
		{
			if (IsCreated())
			{
				throw new InvalidOperationException(SR.InvalidOperation_TypeHasBeenCreated);
			}
		}

		internal ModuleBuilder GetModuleBuilder()
		{
			return m_module;
		}

		internal void SetGenParamAttributes(GenericParameterAttributes genericParameterAttributes)
		{
			m_genParamAttributes = genericParameterAttributes;
		}

		internal void SetGenParamCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			CustAttr genParamCustomAttributeNoLock = new CustAttr(con, binaryAttribute);
			lock (SyncRoot)
			{
				SetGenParamCustomAttributeNoLock(genParamCustomAttributeNoLock);
			}
		}

		internal void SetGenParamCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			CustAttr genParamCustomAttributeNoLock = new CustAttr(customBuilder);
			lock (SyncRoot)
			{
				SetGenParamCustomAttributeNoLock(genParamCustomAttributeNoLock);
			}
		}

		private void SetGenParamCustomAttributeNoLock(CustAttr ca)
		{
			if (m_ca == null)
			{
				m_ca = new List<CustAttr>();
			}
			m_ca.Add(ca);
		}

		public override string ToString()
		{
			return TypeNameBuilder.ToString(this, TypeNameBuilder.Format.ToString);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public override object? InvokeMember(string name, BindingFlags invokeAttr, Binder? binder, object? target, object?[]? args, ParameterModifier[]? modifiers, CultureInfo? culture, string[]? namedParameters)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected override ConstructorInfo? GetConstructorImpl(BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[] types, ParameterModifier[]? modifiers)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetConstructor(bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetConstructors(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			if (types == null)
			{
				return m_bakedRuntimeType.GetMethod(name, bindingAttr);
			}
			return m_bakedRuntimeType.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetMethods(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo? GetField(string name, BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetField(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo[] GetFields(BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetFields(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type? GetInterface(string name, bool ignoreCase)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetInterface(name, ignoreCase);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type[] GetInterfaces()
		{
			if (m_bakedRuntimeType != null)
			{
				return m_bakedRuntimeType.GetInterfaces();
			}
			if (m_typeInterfaces == null)
			{
				return Type.EmptyTypes;
			}
			return m_typeInterfaces.ToArray();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo? GetEvent(string name, BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetEvent(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public override EventInfo[] GetEvents()
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetEvents();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder? binder, Type? returnType, Type[]? types, ParameterModifier[]? modifiers)
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetProperties(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type[] GetNestedTypes(BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetNestedTypes(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type? GetNestedType(string name, BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetNestedType(name, bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetMember(name, type, bindingAttr);
		}

		public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetInterfaceMap(interfaceType);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo[] GetEvents(BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetEvents(bindingAttr);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return m_bakedRuntimeType.GetMembers(bindingAttr);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "The GetInterfaces technically requires all interfaces to be preservedBut in this case it acts only on TypeBuilder which is never trimmed (as it's runtime created).")]
		public override bool IsAssignableFrom([NotNullWhen(true)] Type? c)
		{
			if (IsTypeEqual(c, this))
			{
				return true;
			}
			TypeBuilder typeBuilder = c as TypeBuilder;
			Type type = ((!(typeBuilder != null)) ? c : typeBuilder.m_bakedRuntimeType);
			if (type != null && type is RuntimeType)
			{
				if (m_bakedRuntimeType == null)
				{
					return false;
				}
				return m_bakedRuntimeType.IsAssignableFrom(type);
			}
			if (typeBuilder == null)
			{
				return false;
			}
			if (typeBuilder.IsSubclassOf(this))
			{
				return true;
			}
			if (!base.IsInterface)
			{
				return false;
			}
			Type[] interfaces = typeBuilder.GetInterfaces();
			for (int i = 0; i < interfaces.Length; i++)
			{
				if (IsTypeEqual(interfaces[i], this))
				{
					return true;
				}
				if (interfaces[i].IsSubclassOf(this))
				{
					return true;
				}
			}
			return false;
		}

		protected override TypeAttributes GetAttributeFlagsImpl()
		{
			return m_iAttr;
		}

		protected override bool IsArrayImpl()
		{
			return false;
		}

		protected override bool IsByRefImpl()
		{
			return false;
		}

		protected override bool IsPointerImpl()
		{
			return false;
		}

		protected override bool IsPrimitiveImpl()
		{
			return false;
		}

		protected override bool IsCOMObjectImpl()
		{
			if ((GetAttributeFlagsImpl() & TypeAttributes.Import) == 0)
			{
				return false;
			}
			return true;
		}

		public override Type GetElementType()
		{
			throw new NotSupportedException(SR.NotSupported_DynamicModule);
		}

		protected override bool HasElementTypeImpl()
		{
			return false;
		}

		public override bool IsSubclassOf(Type c)
		{
			Type type = this;
			if (IsTypeEqual(type, c))
			{
				return false;
			}
			type = type.BaseType;
			while (type != null)
			{
				if (IsTypeEqual(type, c))
				{
					return true;
				}
				type = type.BaseType;
			}
			return false;
		}

		public override Type MakePointerType()
		{
			return SymbolType.FormCompoundType("*", this, 0);
		}

		public override Type MakeByRefType()
		{
			return SymbolType.FormCompoundType("&", this, 0);
		}

		public override Type MakeArrayType()
		{
			return SymbolType.FormCompoundType("[]", this, 0);
		}

		public override Type MakeArrayType(int rank)
		{
			string rankString = TypeInfo.GetRankString(rank);
			return SymbolType.FormCompoundType(rankString, this, 0);
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			return CustomAttribute.GetCustomAttributes(m_bakedRuntimeType, typeof(object) as RuntimeType, inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.GetCustomAttributes(m_bakedRuntimeType, runtimeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			if (!IsCreated())
			{
				throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
			}
			if (attributeType == null)
			{
				throw new ArgumentNullException("attributeType");
			}
			RuntimeType runtimeType = attributeType.UnderlyingSystemType as RuntimeType;
			if (runtimeType == null)
			{
				throw new ArgumentException(SR.Arg_MustBeType, "attributeType");
			}
			return CustomAttribute.IsDefined(m_bakedRuntimeType, runtimeType, inherit);
		}

		internal void SetInterfaces(params Type[] interfaces)
		{
			ThrowIfCreated();
			m_typeInterfaces = new List<Type>();
			if (interfaces != null)
			{
				m_typeInterfaces.AddRange(interfaces);
			}
		}

		public GenericTypeParameterBuilder[] DefineGenericParameters(params string[] names)
		{
			if (names == null)
			{
				throw new ArgumentNullException("names");
			}
			if (names.Length == 0)
			{
				throw new ArgumentException(SR.Arg_EmptyArray, "names");
			}
			for (int i = 0; i < names.Length; i++)
			{
				if (names[i] == null)
				{
					throw new ArgumentNullException("names");
				}
			}
			if (m_inst != null)
			{
				throw new InvalidOperationException();
			}
			m_inst = new GenericTypeParameterBuilder[names.Length];
			for (int j = 0; j < names.Length; j++)
			{
				m_inst[j] = new GenericTypeParameterBuilder(new TypeBuilder(names[j], j, this));
			}
			return m_inst;
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public override Type MakeGenericType(params Type[] typeArguments)
		{
			AssemblyBuilder.CheckContext(typeArguments);
			return TypeBuilderInstantiation.MakeGenericType(this, typeArguments);
		}

		public override Type[] GetGenericArguments()
		{
			Type[] inst = m_inst;
			return inst ?? Type.EmptyTypes;
		}

		public override Type GetGenericTypeDefinition()
		{
			if (IsGenericTypeDefinition)
			{
				return this;
			}
			if (m_genTypeDef == null)
			{
				throw new InvalidOperationException();
			}
			return m_genTypeDef;
		}

		public void DefineMethodOverride(MethodInfo methodInfoBody, MethodInfo methodInfoDeclaration)
		{
			lock (SyncRoot)
			{
				DefineMethodOverrideNoLock(methodInfoBody, methodInfoDeclaration);
			}
		}

		private void DefineMethodOverrideNoLock(MethodInfo methodInfoBody, MethodInfo methodInfoDeclaration)
		{
			if (methodInfoBody == null)
			{
				throw new ArgumentNullException("methodInfoBody");
			}
			if (methodInfoDeclaration == null)
			{
				throw new ArgumentNullException("methodInfoDeclaration");
			}
			ThrowIfCreated();
			if ((object)methodInfoBody.DeclaringType != this)
			{
				throw new ArgumentException(SR.ArgumentException_BadMethodImplBody);
			}
			int methodToken = m_module.GetMethodToken(methodInfoBody);
			int methodToken2 = m_module.GetMethodToken(methodInfoDeclaration);
			ModuleBuilder module = m_module;
			DefineMethodImpl(new QCallModule(ref module), m_tdType, methodToken, methodToken2);
		}

		public MethodBuilder DefineMethod(string name, MethodAttributes attributes, Type? returnType, Type[]? parameterTypes)
		{
			return DefineMethod(name, attributes, CallingConventions.Standard, returnType, parameterTypes);
		}

		public MethodBuilder DefineMethod(string name, MethodAttributes attributes)
		{
			return DefineMethod(name, attributes, CallingConventions.Standard, null, null);
		}

		public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention)
		{
			return DefineMethod(name, attributes, callingConvention, null, null);
		}

		public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes)
		{
			return DefineMethod(name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null);
		}

		public MethodBuilder DefineMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers, Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers)
		{
			lock (SyncRoot)
			{
				return DefineMethodNoLock(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2082:UnrecognizedReflectionPattern", Justification = "Reflection.Emit is not subject to trimming")]
		private MethodBuilder DefineMethodNoLock(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			AssemblyBuilder.CheckContext(returnType);
			AssemblyBuilder.CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
			AssemblyBuilder.CheckContext(parameterTypeRequiredCustomModifiers);
			AssemblyBuilder.CheckContext(parameterTypeOptionalCustomModifiers);
			if (parameterTypes != null)
			{
				if (parameterTypeOptionalCustomModifiers != null && parameterTypeOptionalCustomModifiers.Length != parameterTypes.Length)
				{
					throw new ArgumentException(SR.Format(SR.Argument_MismatchedArrays, "parameterTypeOptionalCustomModifiers", "parameterTypes"));
				}
				if (parameterTypeRequiredCustomModifiers != null && parameterTypeRequiredCustomModifiers.Length != parameterTypes.Length)
				{
					throw new ArgumentException(SR.Format(SR.Argument_MismatchedArrays, "parameterTypeRequiredCustomModifiers", "parameterTypes"));
				}
			}
			ThrowIfCreated();
			MethodBuilder methodBuilder = new MethodBuilder(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, m_module, this);
			if (!m_isHiddenGlobalType && (methodBuilder.Attributes & MethodAttributes.SpecialName) != 0 && methodBuilder.Name.Equals(ConstructorInfo.ConstructorName))
			{
				m_constructorCount++;
			}
			m_listMethods.Add(methodBuilder);
			return methodBuilder;
		}

		[RequiresUnreferencedCode("P/Invoke marshalling may dynamically access members that could be trimmed.")]
		public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
		{
			return DefinePInvokeMethodHelper(name, dllName, name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null, nativeCallConv, nativeCharSet);
		}

		[RequiresUnreferencedCode("P/Invoke marshalling may dynamically access members that could be trimmed.")]
		public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet)
		{
			return DefinePInvokeMethodHelper(name, dllName, entryName, attributes, callingConvention, returnType, null, null, parameterTypes, null, null, nativeCallConv, nativeCharSet);
		}

		[RequiresUnreferencedCode("P/Invoke marshalling may dynamically access members that could be trimmed.")]
		public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type? returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers, Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet)
		{
			return DefinePInvokeMethodHelper(name, dllName, entryName, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, nativeCallConv, nativeCharSet);
		}

		[RequiresUnreferencedCode("P/Invoke marshalling may dynamically access members that could be trimmed.")]
		private MethodBuilder DefinePInvokeMethodHelper(string name, string dllName, string importName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet)
		{
			AssemblyBuilder.CheckContext(returnType);
			AssemblyBuilder.CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
			AssemblyBuilder.CheckContext(parameterTypeRequiredCustomModifiers);
			AssemblyBuilder.CheckContext(parameterTypeOptionalCustomModifiers);
			lock (SyncRoot)
			{
				if (name == null)
				{
					throw new ArgumentNullException("name");
				}
				if (name.Length == 0)
				{
					throw new ArgumentException(SR.Argument_EmptyName, "name");
				}
				if (dllName == null)
				{
					throw new ArgumentNullException("dllName");
				}
				if (dllName.Length == 0)
				{
					throw new ArgumentException(SR.Argument_EmptyName, "dllName");
				}
				if (importName == null)
				{
					throw new ArgumentNullException("importName");
				}
				if (importName.Length == 0)
				{
					throw new ArgumentException(SR.Argument_EmptyName, "importName");
				}
				if ((attributes & MethodAttributes.Abstract) != 0)
				{
					throw new ArgumentException(SR.Argument_BadPInvokeMethod);
				}
				if ((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.ClassSemanticsMask)
				{
					throw new ArgumentException(SR.Argument_BadPInvokeOnInterface);
				}
				ThrowIfCreated();
				attributes |= MethodAttributes.PinvokeImpl;
				MethodBuilder methodBuilder = new MethodBuilder(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, m_module, this);
				methodBuilder.GetMethodSignature().InternalGetSignature(out var _);
				if (m_listMethods.Contains(methodBuilder))
				{
					throw new ArgumentException(SR.Argument_MethodRedefined);
				}
				m_listMethods.Add(methodBuilder);
				int metadataToken = methodBuilder.MetadataToken;
				int num = 0;
				switch (nativeCallConv)
				{
				case CallingConvention.Winapi:
					num = 256;
					break;
				case CallingConvention.Cdecl:
					num = 512;
					break;
				case CallingConvention.StdCall:
					num = 768;
					break;
				case CallingConvention.ThisCall:
					num = 1024;
					break;
				case CallingConvention.FastCall:
					num = 1280;
					break;
				}
				switch (nativeCharSet)
				{
				case CharSet.None:
					num |= 0;
					break;
				case CharSet.Ansi:
					num |= 2;
					break;
				case CharSet.Unicode:
					num |= 4;
					break;
				case CharSet.Auto:
					num |= 6;
					break;
				}
				ModuleBuilder module = m_module;
				SetPInvokeData(new QCallModule(ref module), dllName, importName, metadataToken, num);
				methodBuilder.SetToken(metadataToken);
				return methodBuilder;
			}
		}

		public ConstructorBuilder DefineTypeInitializer()
		{
			lock (SyncRoot)
			{
				return DefineTypeInitializerNoLock();
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2082:UnrecognizedReflectionPattern", Justification = "Reflection.Emit is not subject to trimming")]
		private ConstructorBuilder DefineTypeInitializerNoLock()
		{
			ThrowIfCreated();
			return new ConstructorBuilder(ConstructorInfo.TypeConstructorName, MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.SpecialName, CallingConventions.Standard, null, m_module, this);
		}

		public ConstructorBuilder DefineDefaultConstructor(MethodAttributes attributes)
		{
			if ((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.ClassSemanticsMask)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ConstructorNotAllowedOnInterface);
			}
			lock (SyncRoot)
			{
				return DefineDefaultConstructorNoLock(attributes);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2055:UnrecognizedReflectionPattern", Justification = "MakeGenericType is only called on a TypeBuilderInstantiation which is not subject to trimming")]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern", Justification = "GetConstructor is only called on a TypeBuilderInstantiation which is not subject to trimming")]
		private ConstructorBuilder DefineDefaultConstructorNoLock(MethodAttributes attributes)
		{
			ConstructorInfo constructorInfo = null;
			if (m_typeParent is TypeBuilderInstantiation)
			{
				Type type = m_typeParent.GetGenericTypeDefinition();
				if (type is TypeBuilder)
				{
					type = ((TypeBuilder)type).m_bakedRuntimeType;
				}
				if (type == null)
				{
					throw new NotSupportedException(SR.NotSupported_DynamicModule);
				}
				Type type2 = type.MakeGenericType(m_typeParent.GetGenericArguments());
				constructorInfo = ((!(type2 is TypeBuilderInstantiation)) ? type2.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null) : GetConstructor(type2, type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null)));
			}
			if (constructorInfo == null)
			{
				constructorInfo = m_typeParent.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			}
			if (constructorInfo == null)
			{
				throw new NotSupportedException(SR.NotSupported_NoParentDefaultConstructor);
			}
			ConstructorBuilder constructorBuilder = DefineConstructor(attributes, CallingConventions.Standard, null);
			m_constructorCount++;
			ILGenerator iLGenerator = constructorBuilder.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Call, constructorInfo);
			iLGenerator.Emit(OpCodes.Ret);
			constructorBuilder.m_isDefaultConstructor = true;
			return constructorBuilder;
		}

		public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, Type[]? parameterTypes)
		{
			return DefineConstructor(attributes, callingConvention, parameterTypes, null, null);
		}

		public ConstructorBuilder DefineConstructor(MethodAttributes attributes, CallingConventions callingConvention, Type[]? parameterTypes, Type[][]? requiredCustomModifiers, Type[][]? optionalCustomModifiers)
		{
			if ((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.ClassSemanticsMask && (attributes & MethodAttributes.Static) != MethodAttributes.Static)
			{
				throw new InvalidOperationException(SR.InvalidOperation_ConstructorNotAllowedOnInterface);
			}
			lock (SyncRoot)
			{
				return DefineConstructorNoLock(attributes, callingConvention, parameterTypes, requiredCustomModifiers, optionalCustomModifiers);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2082:UnrecognizedReflectionPattern", Justification = "Reflection.Emit is not subject to trimming")]
		private ConstructorBuilder DefineConstructorNoLock(MethodAttributes attributes, CallingConventions callingConvention, Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers)
		{
			AssemblyBuilder.CheckContext(parameterTypes);
			AssemblyBuilder.CheckContext(requiredCustomModifiers);
			AssemblyBuilder.CheckContext(optionalCustomModifiers);
			ThrowIfCreated();
			string name = (((attributes & MethodAttributes.Static) != 0) ? ConstructorInfo.TypeConstructorName : ConstructorInfo.ConstructorName);
			attributes |= MethodAttributes.SpecialName;
			ConstructorBuilder result = new ConstructorBuilder(name, attributes, callingConvention, parameterTypes, requiredCustomModifiers, optionalCustomModifiers, m_module, this);
			m_constructorCount++;
			return result;
		}

		public TypeBuilder DefineNestedType(string name)
		{
			lock (SyncRoot)
			{
				return DefineNestedTypeNoLock(name, TypeAttributes.NestedPrivate, null, null, PackingSize.Unspecified, 0);
			}
		}

		public TypeBuilder DefineNestedType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, Type[]? interfaces)
		{
			lock (SyncRoot)
			{
				AssemblyBuilder.CheckContext(parent);
				AssemblyBuilder.CheckContext(interfaces);
				return DefineNestedTypeNoLock(name, attr, parent, interfaces, PackingSize.Unspecified, 0);
			}
		}

		public TypeBuilder DefineNestedType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent)
		{
			lock (SyncRoot)
			{
				return DefineNestedTypeNoLock(name, attr, parent, null, PackingSize.Unspecified, 0);
			}
		}

		public TypeBuilder DefineNestedType(string name, TypeAttributes attr)
		{
			lock (SyncRoot)
			{
				return DefineNestedTypeNoLock(name, attr, null, null, PackingSize.Unspecified, 0);
			}
		}

		public TypeBuilder DefineNestedType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, int typeSize)
		{
			lock (SyncRoot)
			{
				return DefineNestedTypeNoLock(name, attr, parent, null, PackingSize.Unspecified, typeSize);
			}
		}

		public TypeBuilder DefineNestedType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, PackingSize packSize)
		{
			lock (SyncRoot)
			{
				return DefineNestedTypeNoLock(name, attr, parent, null, packSize, 0);
			}
		}

		public TypeBuilder DefineNestedType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent, PackingSize packSize, int typeSize)
		{
			lock (SyncRoot)
			{
				return DefineNestedTypeNoLock(name, attr, parent, null, packSize, typeSize);
			}
		}

		private TypeBuilder DefineNestedTypeNoLock(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type parent, Type[] interfaces, PackingSize packSize, int typeSize)
		{
			return new TypeBuilder(name, attr, parent, interfaces, m_module, packSize, typeSize, this);
		}

		public FieldBuilder DefineField(string fieldName, Type type, FieldAttributes attributes)
		{
			return DefineField(fieldName, type, null, null, attributes);
		}

		public FieldBuilder DefineField(string fieldName, Type type, Type[]? requiredCustomModifiers, Type[]? optionalCustomModifiers, FieldAttributes attributes)
		{
			lock (SyncRoot)
			{
				return DefineFieldNoLock(fieldName, type, requiredCustomModifiers, optionalCustomModifiers, attributes);
			}
		}

		private FieldBuilder DefineFieldNoLock(string fieldName, Type type, Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes)
		{
			ThrowIfCreated();
			AssemblyBuilder.CheckContext(type);
			AssemblyBuilder.CheckContext(requiredCustomModifiers);
			if (m_enumUnderlyingType == null && IsEnum && (attributes & FieldAttributes.Static) == 0)
			{
				m_enumUnderlyingType = type;
			}
			return new FieldBuilder(this, fieldName, type, requiredCustomModifiers, optionalCustomModifiers, attributes);
		}

		public FieldBuilder DefineInitializedData(string name, byte[] data, FieldAttributes attributes)
		{
			lock (SyncRoot)
			{
				return DefineInitializedDataNoLock(name, data, attributes);
			}
		}

		private FieldBuilder DefineInitializedDataNoLock(string name, byte[] data, FieldAttributes attributes)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			return DefineDataHelper(name, data, data.Length, attributes);
		}

		public FieldBuilder DefineUninitializedData(string name, int size, FieldAttributes attributes)
		{
			lock (SyncRoot)
			{
				return DefineUninitializedDataNoLock(name, size, attributes);
			}
		}

		private FieldBuilder DefineUninitializedDataNoLock(string name, int size, FieldAttributes attributes)
		{
			return DefineDataHelper(name, null, size, attributes);
		}

		public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, Type returnType, Type[]? parameterTypes)
		{
			return DefineProperty(name, attributes, returnType, null, null, parameterTypes, null, null);
		}

		public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, CallingConventions callingConvention, Type returnType, Type[]? parameterTypes)
		{
			return DefineProperty(name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null);
		}

		public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, Type returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers, Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers)
		{
			return DefineProperty(name, attributes, (CallingConventions)0, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
		}

		public PropertyBuilder DefineProperty(string name, PropertyAttributes attributes, CallingConventions callingConvention, Type returnType, Type[]? returnTypeRequiredCustomModifiers, Type[]? returnTypeOptionalCustomModifiers, Type[]? parameterTypes, Type[][]? parameterTypeRequiredCustomModifiers, Type[][]? parameterTypeOptionalCustomModifiers)
		{
			lock (SyncRoot)
			{
				return DefinePropertyNoLock(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
			}
		}

		private PropertyBuilder DefinePropertyNoLock(string name, PropertyAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			AssemblyBuilder.CheckContext(returnType);
			AssemblyBuilder.CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes);
			AssemblyBuilder.CheckContext(parameterTypeRequiredCustomModifiers);
			AssemblyBuilder.CheckContext(parameterTypeOptionalCustomModifiers);
			ThrowIfCreated();
			SignatureHelper propertySigHelper = SignatureHelper.GetPropertySigHelper(m_module, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers);
			int length;
			byte[] signature = propertySigHelper.InternalGetSignature(out length);
			ModuleBuilder module = m_module;
			int prToken = DefineProperty(new QCallModule(ref module), m_tdType, name, attributes, signature, length);
			return new PropertyBuilder(m_module, name, propertySigHelper, attributes, returnType, prToken, this);
		}

		public EventBuilder DefineEvent(string name, EventAttributes attributes, Type eventtype)
		{
			lock (SyncRoot)
			{
				return DefineEventNoLock(name, attributes, eventtype);
			}
		}

		private EventBuilder DefineEventNoLock(string name, EventAttributes attributes, Type eventtype)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyName, "name");
			}
			if (name[0] == '\0')
			{
				throw new ArgumentException(SR.Argument_IllegalName, "name");
			}
			AssemblyBuilder.CheckContext(eventtype);
			ThrowIfCreated();
			int typeTokenInternal = m_module.GetTypeTokenInternal(eventtype);
			ModuleBuilder module = m_module;
			int evToken = DefineEvent(new QCallModule(ref module), m_tdType, name, attributes, typeTokenInternal);
			return new EventBuilder(m_module, name, attributes, this, evToken);
		}

		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public TypeInfo? CreateTypeInfo()
		{
			lock (SyncRoot)
			{
				return CreateTypeNoLock();
			}
		}

		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public Type? CreateType()
		{
			lock (SyncRoot)
			{
				return CreateTypeNoLock();
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2083:UnrecognizedReflectionPattern", Justification = "Reflection.Emit is not subject to trimming")]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		private TypeInfo CreateTypeNoLock()
		{
			if (IsCreated())
			{
				return m_bakedRuntimeType;
			}
			if (m_typeInterfaces == null)
			{
				m_typeInterfaces = new List<Type>();
			}
			int[] array = new int[m_typeInterfaces.Count];
			for (int i = 0; i < m_typeInterfaces.Count; i++)
			{
				array[i] = m_module.GetTypeTokenInternal(m_typeInterfaces[i]);
			}
			int num = 0;
			if (m_typeParent != null)
			{
				num = m_module.GetTypeTokenInternal(m_typeParent);
			}
			ModuleBuilder module = m_module;
			if (IsGenericParameter)
			{
				int[] array2;
				if (m_typeParent != null)
				{
					array2 = new int[m_typeInterfaces.Count + 2];
					array2[^2] = num;
				}
				else
				{
					array2 = new int[m_typeInterfaces.Count + 1];
				}
				for (int j = 0; j < m_typeInterfaces.Count; j++)
				{
					array2[j] = m_module.GetTypeTokenInternal(m_typeInterfaces[j]);
				}
				int tkParent = ((m_declMeth == null) ? m_DeclaringType.m_tdType : m_declMeth.MetadataToken);
				m_tdType = DefineGenericParam(new QCallModule(ref module), m_strName, tkParent, m_genParamAttributes, m_genParamPos, array2);
				if (m_ca != null)
				{
					foreach (CustAttr item in m_ca)
					{
						item.Bake(m_module, MetadataToken);
					}
				}
				m_hasBeenCreated = true;
				return this;
			}
			if (((uint)m_tdType & 0xFFFFFFu) != 0 && ((uint)num & 0xFFFFFFu) != 0)
			{
				SetParentType(new QCallModule(ref module), m_tdType, num);
			}
			if (m_inst != null)
			{
				GenericTypeParameterBuilder[] inst = m_inst;
				foreach (GenericTypeParameterBuilder genericTypeParameterBuilder in inst)
				{
					genericTypeParameterBuilder.m_type.CreateType();
				}
			}
			if (!m_isHiddenGlobalType && m_constructorCount == 0 && (m_iAttr & TypeAttributes.ClassSemanticsMask) == 0 && !base.IsValueType && (m_iAttr & (TypeAttributes.Abstract | TypeAttributes.Sealed)) != (TypeAttributes.Abstract | TypeAttributes.Sealed))
			{
				DefineDefaultConstructor(MethodAttributes.Public);
			}
			int count = m_listMethods.Count;
			for (int l = 0; l < count; l++)
			{
				MethodBuilder methodBuilder = m_listMethods[l];
				if (methodBuilder.IsGenericMethodDefinition)
				{
					int metadataToken = methodBuilder.MetadataToken;
				}
				MethodAttributes attributes = methodBuilder.Attributes;
				if ((methodBuilder.GetMethodImplementationFlags() & (MethodImplAttributes)135) != 0 || (attributes & MethodAttributes.PinvokeImpl) != 0)
				{
					continue;
				}
				int signatureLength;
				byte[] localSignature = methodBuilder.GetLocalSignature(out signatureLength);
				if ((attributes & MethodAttributes.Abstract) != 0 && (m_iAttr & TypeAttributes.Abstract) == 0)
				{
					throw new InvalidOperationException(SR.InvalidOperation_BadTypeAttributesNotAbstract);
				}
				byte[] body = methodBuilder.GetBody();
				if ((attributes & MethodAttributes.Abstract) != 0)
				{
					if (body != null)
					{
						throw new InvalidOperationException(SR.Format(SR.InvalidOperation_BadMethodBody, methodBuilder.Name));
					}
				}
				else if (body == null || body.Length == 0)
				{
					if (methodBuilder.m_ilGenerator != null)
					{
						methodBuilder.CreateMethodBodyHelper(methodBuilder.GetILGenerator());
					}
					body = methodBuilder.GetBody();
					if ((body == null || body.Length == 0) && !methodBuilder.m_canBeRuntimeImpl)
					{
						throw new InvalidOperationException(SR.Format(SR.InvalidOperation_BadEmptyMethodBody, methodBuilder.Name));
					}
				}
				int maxStack = methodBuilder.GetMaxStack();
				ExceptionHandler[] exceptionHandlers = methodBuilder.GetExceptionHandlers();
				int[] tokenFixups = methodBuilder.GetTokenFixups();
				SetMethodIL(new QCallModule(ref module), methodBuilder.MetadataToken, methodBuilder.InitLocals, body, (body != null) ? body.Length : 0, localSignature, signatureLength, maxStack, exceptionHandlers, (exceptionHandlers != null) ? exceptionHandlers.Length : 0, tokenFixups, (tokenFixups != null) ? tokenFixups.Length : 0);
				if (m_module.ContainingAssemblyBuilder._assemblyData._access == AssemblyBuilderAccess.Run)
				{
					methodBuilder.ReleaseBakedStructures();
				}
			}
			m_hasBeenCreated = true;
			RuntimeType o = null;
			TermCreateClass(new QCallModule(ref module), m_tdType, ObjectHandleOnStack.Create(ref o));
			if (!m_isHiddenGlobalType)
			{
				m_bakedRuntimeType = o;
				if (m_DeclaringType != null && m_DeclaringType.m_bakedRuntimeType != null)
				{
					m_DeclaringType.m_bakedRuntimeType.InvalidateCachedNestedType();
				}
				return o;
			}
			return null;
		}

		public void SetParent([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type? parent)
		{
			ThrowIfCreated();
			if (parent != null)
			{
				AssemblyBuilder.CheckContext(parent);
				if (parent.IsInterface)
				{
					throw new ArgumentException(SR.Argument_CannotSetParentToInterface);
				}
				m_typeParent = parent;
			}
			else if ((m_iAttr & TypeAttributes.ClassSemanticsMask) != TypeAttributes.ClassSemanticsMask)
			{
				m_typeParent = typeof(object);
			}
			else
			{
				if ((m_iAttr & TypeAttributes.Abstract) == 0)
				{
					throw new InvalidOperationException(SR.InvalidOperation_BadInterfaceNotAbstract);
				}
				m_typeParent = null;
			}
		}

		public void AddInterfaceImplementation([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type interfaceType)
		{
			if (interfaceType == null)
			{
				throw new ArgumentNullException("interfaceType");
			}
			AssemblyBuilder.CheckContext(interfaceType);
			ThrowIfCreated();
			int typeTokenInternal = m_module.GetTypeTokenInternal(interfaceType);
			ModuleBuilder module = m_module;
			AddInterfaceImpl(new QCallModule(ref module), m_tdType, typeTokenInternal);
			m_typeInterfaces.Add(interfaceType);
		}

		public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
		{
			if (con == null)
			{
				throw new ArgumentNullException("con");
			}
			if (binaryAttribute == null)
			{
				throw new ArgumentNullException("binaryAttribute");
			}
			DefineCustomAttribute(m_module, m_tdType, m_module.GetConstructorToken(con), binaryAttribute);
		}

		public void SetCustomAttribute(CustomAttributeBuilder customBuilder)
		{
			if (customBuilder == null)
			{
				throw new ArgumentNullException("customBuilder");
			}
			customBuilder.CreateCustomAttribute(m_module, m_tdType);
		}
	}
	internal sealed class TypeBuilderInstantiation : TypeInfo
	{
		private Type m_type;

		private Type[] m_inst;

		private string m_strFullQualName;

		internal Hashtable m_hashtable;

		public override Type DeclaringType => m_type.DeclaringType;

		public override Type ReflectedType => m_type.ReflectedType;

		public override string Name => m_type.Name;

		public override Module Module => m_type.Module;

		public override Guid GUID
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override Assembly Assembly => m_type.Assembly;

		public override RuntimeTypeHandle TypeHandle
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override string FullName => m_strFullQualName ?? (m_strFullQualName = TypeNameBuilder.ToString(this, TypeNameBuilder.Format.FullName));

		public override string Namespace => m_type.Namespace;

		public override string AssemblyQualifiedName => TypeNameBuilder.ToString(this, TypeNameBuilder.Format.AssemblyQualifiedName);

		public override Type BaseType
		{
			get
			{
				Type baseType = m_type.BaseType;
				if (baseType == null)
				{
					return null;
				}
				TypeBuilderInstantiation typeBuilderInstantiation = baseType as TypeBuilderInstantiation;
				if (typeBuilderInstantiation == null)
				{
					return baseType;
				}
				return typeBuilderInstantiation.Substitute(GetGenericArguments());
			}
		}

		public override bool IsTypeDefinition => false;

		public override bool IsSZArray => false;

		public override Type UnderlyingSystemType => this;

		public override bool IsGenericTypeDefinition => false;

		public override bool IsGenericType => true;

		public override bool IsConstructedGenericType => true;

		public override bool IsGenericParameter => false;

		public override int GenericParameterPosition
		{
			get
			{
				throw new InvalidOperationException();
			}
		}

		public override bool ContainsGenericParameters
		{
			get
			{
				for (int i = 0; i < m_inst.Length; i++)
				{
					if (m_inst[i].ContainsGenericParameters)
					{
						return true;
					}
				}
				return false;
			}
		}

		public override MethodBase DeclaringMethod => null;

		public override bool IsAssignableFrom([NotNullWhen(true)] TypeInfo typeInfo)
		{
			if (typeInfo == null)
			{
				return false;
			}
			return IsAssignableFrom(typeInfo.AsType());
		}

		internal static Type MakeGenericType(Type type, Type[] typeArguments)
		{
			if (!type.IsGenericTypeDefinition)
			{
				throw new InvalidOperationException();
			}
			if (typeArguments == null)
			{
				throw new ArgumentNullException("typeArguments");
			}
			foreach (Type type2 in typeArguments)
			{
				if (type2 == null)
				{
					throw new ArgumentNullException("typeArguments");
				}
			}
			return new TypeBuilderInstantiation(type, typeArguments);
		}

		private TypeBuilderInstantiation(Type type, Type[] inst)
		{
			m_type = type;
			m_inst = inst;
			m_hashtable = new Hashtable();
		}

		public override string ToString()
		{
			return TypeNameBuilder.ToString(this, TypeNameBuilder.Format.ToString);
		}

		public override Type MakePointerType()
		{
			return SymbolType.FormCompoundType("*", this, 0);
		}

		public override Type MakeByRefType()
		{
			return SymbolType.FormCompoundType("&", this, 0);
		}

		public override Type MakeArrayType()
		{
			return SymbolType.FormCompoundType("[]", this, 0);
		}

		public override Type MakeArrayType(int rank)
		{
			if (rank <= 0)
			{
				throw new IndexOutOfRangeException();
			}
			string format = ((rank == 1) ? "[]" : ("[" + new string(',', rank - 1) + "]"));
			return SymbolType.FormCompoundType(format, this, 0);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
		{
			throw new NotSupportedException();
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2055:UnrecognizedReflectionPattern", Justification = "The entire TypeBuilderInstantiation is serving the MakeGenericType implementation. Currently this is not supported by linker. Once it is supported the outercall (Type.MakeGenericType)will validate that the types fullfill the necessary requirements of annotations on type parameters.As such the actual internals of the implementation are not interesting.")]
		private Type Substitute(Type[] substitutes)
		{
			Type[] genericArguments = GetGenericArguments();
			Type[] array = new Type[genericArguments.Length];
			for (int i = 0; i < array.Length; i++)
			{
				Type type = genericArguments[i];
				if (type is TypeBuilderInstantiation typeBuilderInstantiation)
				{
					array[i] = typeBuilderInstantiation.Substitute(substitutes);
				}
				else if (type is GenericTypeParameterBuilder)
				{
					array[i] = substitutes[type.GenericParameterPosition];
				}
				else
				{
					array[i] = type;
				}
			}
			return GetGenericTypeDefinition().MakeGenericType(array);
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
		public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
		public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo GetField(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)]
		public override FieldInfo[] GetFields(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2063:UnrecognizedReflectionPattern", Justification = "Linker doesn't recognize always throwing method. https://github.com/mono/linker/issues/2025")]
		[return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type GetInterface(string name, bool ignoreCase)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
		public override Type[] GetInterfaces()
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents)]
		public override EventInfo[] GetEvents()
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type[] GetNestedTypes(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes)]
		public override Type GetNestedType(string name, BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override EventInfo[] GetEvents(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.NonPublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.NonPublicEvents)]
		public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
		{
			throw new NotSupportedException();
		}

		protected override TypeAttributes GetAttributeFlagsImpl()
		{
			return m_type.Attributes;
		}

		protected override bool IsArrayImpl()
		{
			return false;
		}

		protected override bool IsByRefImpl()
		{
			return false;
		}

		protected override bool IsPointerImpl()
		{
			return false;
		}

		protected override bool IsPrimitiveImpl()
		{
			return false;
		}

		protected override bool IsCOMObjectImpl()
		{
			return false;
		}

		public override Type GetElementType()
		{
			throw new NotSupportedException();
		}

		protected override bool HasElementTypeImpl()
		{
			return false;
		}

		public override Type[] GetGenericArguments()
		{
			return m_inst;
		}

		protected override bool IsValueTypeImpl()
		{
			return m_type.IsValueType;
		}

		public override Type GetGenericTypeDefinition()
		{
			return m_type;
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public override Type MakeGenericType(params Type[] inst)
		{
			throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericTypeDefinition, this));
		}

		public override bool IsAssignableFrom([NotNullWhen(true)] Type c)
		{
			throw new NotSupportedException();
		}

		public override bool IsSubclassOf(Type c)
		{
			throw new NotSupportedException();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			throw new NotSupportedException();
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new NotSupportedException();
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new NotSupportedException();
		}
	}
	internal sealed class MethodOnTypeBuilderInstantiation : MethodInfo
	{
		internal MethodInfo m_method;

		private TypeBuilderInstantiation m_type;

		public override MemberTypes MemberType => m_method.MemberType;

		public override string Name => m_method.Name;

		public override Type DeclaringType => m_type;

		public override Type ReflectedType => m_type;

		public override Module Module => m_method.Module;

		public override RuntimeMethodHandle MethodHandle => m_method.MethodHandle;

		public override MethodAttributes Attributes => m_method.Attributes;

		public override CallingConventions CallingConvention => m_method.CallingConvention;

		public override bool IsGenericMethodDefinition => m_method.IsGenericMethodDefinition;

		public override bool ContainsGenericParameters => m_method.ContainsGenericParameters;

		public override bool IsGenericMethod => m_method.IsGenericMethod;

		public override Type ReturnType => m_method.ReturnType;

		public override ParameterInfo ReturnParameter
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override ICustomAttributeProvider ReturnTypeCustomAttributes
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		internal static MethodInfo GetMethod(MethodInfo method, TypeBuilderInstantiation type)
		{
			return new MethodOnTypeBuilderInstantiation(method, type);
		}

		internal MethodOnTypeBuilderInstantiation(MethodInfo method, TypeBuilderInstantiation type)
		{
			m_method = method;
			m_type = type;
		}

		internal override Type[] GetParameterTypes()
		{
			return m_method.GetParameterTypes();
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return m_method.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return m_method.GetCustomAttributes(attributeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return m_method.IsDefined(attributeType, inherit);
		}

		public override ParameterInfo[] GetParameters()
		{
			return m_method.GetParameters();
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			return m_method.GetMethodImplementationFlags();
		}

		public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			throw new NotSupportedException();
		}

		public override Type[] GetGenericArguments()
		{
			return m_method.GetGenericArguments();
		}

		public override MethodInfo GetGenericMethodDefinition()
		{
			return m_method;
		}

		[RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
		public override MethodInfo MakeGenericMethod(params Type[] typeArgs)
		{
			if (!IsGenericMethodDefinition)
			{
				throw new InvalidOperationException(SR.Format(SR.Arg_NotGenericMethodDefinition, this));
			}
			return MethodBuilderInstantiation.MakeGenericMethod(this, typeArgs);
		}

		public override MethodInfo GetBaseDefinition()
		{
			throw new NotSupportedException();
		}
	}
	internal sealed class ConstructorOnTypeBuilderInstantiation : ConstructorInfo
	{
		internal ConstructorInfo m_ctor;

		private TypeBuilderInstantiation m_type;

		public override MemberTypes MemberType => m_ctor.MemberType;

		public override string Name => m_ctor.Name;

		public override Type DeclaringType => m_type;

		public override Type ReflectedType => m_type;

		public override int MetadataToken
		{
			get
			{
				ConstructorBuilder constructorBuilder = m_ctor as ConstructorBuilder;
				if (constructorBuilder != null)
				{
					return constructorBuilder.MetadataToken;
				}
				return m_ctor.MetadataToken;
			}
		}

		public override Module Module => m_ctor.Module;

		public override RuntimeMethodHandle MethodHandle => m_ctor.MethodHandle;

		public override MethodAttributes Attributes => m_ctor.Attributes;

		public override CallingConventions CallingConvention => m_ctor.CallingConvention;

		public override bool IsGenericMethodDefinition => false;

		public override bool ContainsGenericParameters => false;

		public override bool IsGenericMethod => false;

		internal static ConstructorInfo GetConstructor(ConstructorInfo Constructor, TypeBuilderInstantiation type)
		{
			return new ConstructorOnTypeBuilderInstantiation(Constructor, type);
		}

		internal ConstructorOnTypeBuilderInstantiation(ConstructorInfo constructor, TypeBuilderInstantiation type)
		{
			m_ctor = constructor;
			m_type = type;
		}

		internal override Type[] GetParameterTypes()
		{
			return m_ctor.GetParameterTypes();
		}

		internal override Type GetReturnType()
		{
			return m_type;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return m_ctor.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return m_ctor.GetCustomAttributes(attributeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return m_ctor.IsDefined(attributeType, inherit);
		}

		public override ParameterInfo[] GetParameters()
		{
			return m_ctor.GetParameters();
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			return m_ctor.GetMethodImplementationFlags();
		}

		public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			throw new NotSupportedException();
		}

		public override Type[] GetGenericArguments()
		{
			return m_ctor.GetGenericArguments();
		}

		public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			throw new InvalidOperationException();
		}
	}
	internal sealed class FieldOnTypeBuilderInstantiation : FieldInfo
	{
		private FieldInfo m_field;

		private TypeBuilderInstantiation m_type;

		internal FieldInfo FieldInfo => m_field;

		public override MemberTypes MemberType => MemberTypes.Field;

		public override string Name => m_field.Name;

		public override Type DeclaringType => m_type;

		public override Type ReflectedType => m_type;

		public override int MetadataToken
		{
			get
			{
				FieldBuilder fieldBuilder = m_field as FieldBuilder;
				if (fieldBuilder != null)
				{
					return fieldBuilder.MetadataToken;
				}
				return m_field.MetadataToken;
			}
		}

		public override Module Module => m_field.Module;

		public override RuntimeFieldHandle FieldHandle
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public override Type FieldType
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public override FieldAttributes Attributes => m_field.Attributes;

		internal static FieldInfo GetField(FieldInfo Field, TypeBuilderInstantiation type)
		{
			FieldInfo fieldInfo;
			if (type.m_hashtable.Contains(Field))
			{
				fieldInfo = type.m_hashtable[Field] as FieldInfo;
			}
			else
			{
				fieldInfo = new FieldOnTypeBuilderInstantiation(Field, type);
				type.m_hashtable[Field] = fieldInfo;
			}
			return fieldInfo;
		}

		internal FieldOnTypeBuilderInstantiation(FieldInfo field, TypeBuilderInstantiation type)
		{
			m_field = field;
			m_type = type;
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			return m_field.GetCustomAttributes(inherit);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			return m_field.GetCustomAttributes(attributeType, inherit);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			return m_field.IsDefined(attributeType, inherit);
		}

		public override Type[] GetRequiredCustomModifiers()
		{
			return m_field.GetRequiredCustomModifiers();
		}

		public override Type[] GetOptionalCustomModifiers()
		{
			return m_field.GetOptionalCustomModifiers();
		}

		public override void SetValueDirect(TypedReference obj, object value)
		{
			throw new NotImplementedException();
		}

		public override object GetValueDirect(TypedReference obj)
		{
			throw new NotImplementedException();
		}

		public override object GetValue(object obj)
		{
			throw new InvalidOperationException();
		}

		public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
		{
			throw new InvalidOperationException();
		}
	}
	[Flags]
	public enum AssemblyBuilderAccess
	{
		Run = 1,
		RunAndCollect = 9
	}
	internal sealed class EmptyCAHolder : ICustomAttributeProvider
	{
		internal EmptyCAHolder()
		{
		}

		object[] ICustomAttributeProvider.GetCustomAttributes(Type attributeType, bool inherit)
		{
			return Array.Empty<object>();
		}

		object[] ICustomAttributeProvider.GetCustomAttributes(bool inherit)
		{
			return Array.Empty<object>();
		}

		bool ICustomAttributeProvider.IsDefined(Type attributeType, bool inherit)
		{
			return false;
		}
	}
	public enum FlowControl
	{
		Branch,
		Break,
		Call,
		Cond_Branch,
		Meta,
		Next,
		[Obsolete("FlowControl.Phi has been deprecated and is not supported.")]
		Phi,
		Return,
		Throw
	}
	public readonly struct Label : IEquatable<Label>
	{
		internal readonly int m_label;

		internal Label(int label)
		{
			m_label = label;
		}

		internal int GetLabelValue()
		{
			return m_label;
		}

		public override int GetHashCode()
		{
			return m_label;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is Label obj2)
			{
				return Equals(obj2);
			}
			return false;
		}

		public bool Equals(Label obj)
		{
			return obj.m_label == m_label;
		}

		public static bool operator ==(Label a, Label b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(Label a, Label b)
		{
			return !(a == b);
		}
	}
	public readonly struct OpCode : IEquatable<OpCode>
	{
		private readonly OpCodeValues m_value;

		private readonly int m_flags;

		private static volatile string[] g_nameCache;

		public OperandType OperandType => (OperandType)(m_flags & 0x1F);

		public FlowControl FlowControl => (FlowControl)((m_flags >> 5) & 0xF);

		public OpCodeType OpCodeType => (OpCodeType)((m_flags >> 9) & 7);

		public StackBehaviour StackBehaviourPop => (StackBehaviour)((m_flags >> 12) & 0x1F);

		public StackBehaviour StackBehaviourPush => (StackBehaviour)((m_flags >> 17) & 0x1F);

		public int Size => (m_flags >> 22) & 3;

		public short Value => (short)m_value;

		public string? Name
		{
			get
			{
				if (Size == 0)
				{
					return null;
				}
				string[] array = g_nameCache;
				if (array == null)
				{
					array = (g_nameCache = new string[287]);
				}
				OpCodeValues opCodeValues = (OpCodeValues)(ushort)Value;
				int num = (int)opCodeValues;
				if (num > 255)
				{
					if (num < 65024 || num > 65054)
					{
						return null;
					}
					num = 256 + (num - 65024);
				}
				string text = Volatile.Read(ref array[num]);
				if (text != null)
				{
					return text;
				}
				text = Enum.GetName(typeof(OpCodeValues), opCodeValues).ToLowerInvariant().Replace('_', '.');
				Volatile.Write(ref array[num], text);
				return text;
			}
		}

		internal OpCode(OpCodeValues value, int flags)
		{
			m_value = value;
			m_flags = flags;
		}

		internal bool EndsUncondJmpBlk()
		{
			return (m_flags & 0x1000000) != 0;
		}

		internal int StackChange()
		{
			return m_flags >> 28;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is OpCode obj2)
			{
				return Equals(obj2);
			}
			return false;
		}

		public bool Equals(OpCode obj)
		{
			return obj.Value == Value;
		}

		public static bool operator ==(OpCode a, OpCode b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(OpCode a, OpCode b)
		{
			return !(a == b);
		}

		public override int GetHashCode()
		{
			return Value;
		}

		public override string? ToString()
		{
			return Name;
		}
	}
	internal enum OpCodeValues
	{
		Nop = 0,
		Break = 1,
		Ldarg_0 = 2,
		Ldarg_1 = 3,
		Ldarg_2 = 4,
		Ldarg_3 = 5,
		Ldloc_0 = 6,
		Ldloc_1 = 7,
		Ldloc_2 = 8,
		Ldloc_3 = 9,
		Stloc_0 = 10,
		Stloc_1 = 11,
		Stloc_2 = 12,
		Stloc_3 = 13,
		Ldarg_S = 14,
		Ldarga_S = 15,
		Starg_S = 16,
		Ldloc_S = 17,
		Ldloca_S = 18,
		Stloc_S = 19,
		Ldnull = 20,
		Ldc_I4_M1 = 21,
		Ldc_I4_0 = 22,
		Ldc_I4_1 = 23,
		Ldc_I4_2 = 24,
		Ldc_I4_3 = 25,
		Ldc_I4_4 = 26,
		Ldc_I4_5 = 27,
		Ldc_I4_6 = 28,
		Ldc_I4_7 = 29,
		Ldc_I4_8 = 30,
		Ldc_I4_S = 31,
		Ldc_I4 = 32,
		Ldc_I8 = 33,
		Ldc_R4 = 34,
		Ldc_R8 = 35,
		Dup = 37,
		Pop = 38,
		Jmp = 39,
		Call = 40,
		Calli = 41,
		Ret = 42,
		Br_S = 43,
		Brfalse_S = 44,
		Brtrue_S = 45,
		Beq_S = 46,
		Bge_S = 47,
		Bgt_S = 48,
		Ble_S = 49,
		Blt_S = 50,
		Bne_Un_S = 51,
		Bge_Un_S = 52,
		Bgt_Un_S = 53,
		Ble_Un_S = 54,
		Blt_Un_S = 55,
		Br = 56,
		Brfalse = 57,
		Brtrue = 58,
		Beq = 59,
		Bge = 60,
		Bgt = 61,
		Ble = 62,
		Blt = 63,
		Bne_Un = 64,
		Bge_Un = 65,
		Bgt_Un = 66,
		Ble_Un = 67,
		Blt_Un = 68,
		Switch = 69,
		Ldind_I1 = 70,
		Ldind_U1 = 71,
		Ldind_I2 = 72,
		Ldind_U2 = 73,
		Ldind_I4 = 74,
		Ldind_U4 = 75,
		Ldind_I8 = 76,
		Ldind_I = 77,
		Ldind_R4 = 78,
		Ldind_R8 = 79,
		Ldind_Ref = 80,
		Stind_Ref = 81,
		Stind_I1 = 82,
		Stind_I2 = 83,
		Stind_I4 = 84,
		Stind_I8 = 85,
		Stind_R4 = 86,
		Stind_R8 = 87,
		Add = 88,
		Sub = 89,
		Mul = 90,
		Div = 91,
		Div_Un = 92,
		Rem = 93,
		Rem_Un = 94,
		And = 95,
		Or = 96,
		Xor = 97,
		Shl = 98,
		Shr = 99,
		Shr_Un = 100,
		Neg = 101,
		Not = 102,
		Conv_I1 = 103,
		Conv_I2 = 104,
		Conv_I4 = 105,
		Conv_I8 = 106,
		Conv_R4 = 107,
		Conv_R8 = 108,
		Conv_U4 = 109,
		Conv_U8 = 110,
		Callvirt = 111,
		Cpobj = 112,
		Ldobj = 113,
		Ldstr = 114,
		Newobj = 115,
		Castclass = 116,
		Isinst = 117,
		Conv_R_Un = 118,
		Unbox = 121,
		Throw = 122,
		Ldfld = 123,
		Ldflda = 124,
		Stfld = 125,
		Ldsfld = 126,
		Ldsflda = 127,
		Stsfld = 128,
		Stobj = 129,
		Conv_Ovf_I1_Un = 130,
		Conv_Ovf_I2_Un = 131,
		Conv_Ovf_I4_Un = 132,
		Conv_Ovf_I8_Un = 133,
		Conv_Ovf_U1_Un = 134,
		Conv_Ovf_U2_Un = 135,
		Conv_Ovf_U4_Un = 136,
		Conv_Ovf_U8_Un = 137,
		Conv_Ovf_I_Un = 138,
		Conv_Ovf_U_Un = 139,
		Box = 140,
		Newarr = 141,
		Ldlen = 142,
		Ldelema = 143,
		Ldelem_I1 = 144,
		Ldelem_U1 = 145,
		Ldelem_I2 = 146,
		Ldelem_U2 = 147,
		Ldelem_I4 = 148,
		Ldelem_U4 = 149,
		Ldelem_I8 = 150,
		Ldelem_I = 151,
		Ldelem_R4 = 152,
		Ldelem_R8 = 153,
		Ldelem_Ref = 154,
		Stelem_I = 155,
		Stelem_I1 = 156,
		Stelem_I2 = 157,
		Stelem_I4 = 158,
		Stelem_I8 = 159,
		Stelem_R4 = 160,
		Stelem_R8 = 161,
		Stelem_Ref = 162,
		Ldelem = 163,
		Stelem = 164,
		Unbox_Any = 165,
		Conv_Ovf_I1 = 179,
		Conv_Ovf_U1 = 180,
		Conv_Ovf_I2 = 181,
		Conv_Ovf_U2 = 182,
		Conv_Ovf_I4 = 183,
		Conv_Ovf_U4 = 184,
		Conv_Ovf_I8 = 185,
		Conv_Ovf_U8 = 186,
		Refanyval = 194,
		Ckfinite = 195,
		Mkrefany = 198,
		Ldtoken = 208,
		Conv_U2 = 209,
		Conv_U1 = 210,
		Conv_I = 211,
		Conv_Ovf_I = 212,
		Conv_Ovf_U = 213,
		Add_Ovf = 214,
		Add_Ovf_Un = 215,
		Mul_Ovf = 216,
		Mul_Ovf_Un = 217,
		Sub_Ovf = 218,
		Sub_Ovf_Un = 219,
		Endfinally = 220,
		Leave = 221,
		Leave_S = 222,
		Stind_I = 223,
		Conv_U = 224,
		Prefix7 = 248,
		Prefix6 = 249,
		Prefix5 = 250,
		Prefix4 = 251,
		Prefix3 = 252,
		Prefix2 = 253,
		Prefix1 = 254,
		Prefixref = 255,
		Arglist = 65024,
		Ceq = 65025,
		Cgt = 65026,
		Cgt_Un = 65027,
		Clt = 65028,
		Clt_Un = 65029,
		Ldftn = 65030,
		Ldvirtftn = 65031,
		Ldarg = 65033,
		Ldarga = 65034,
		Starg = 65035,
		Ldloc = 65036,
		Ldloca = 65037,
		Stloc = 65038,
		Localloc = 65039,
		Endfilter = 65041,
		Unaligned_ = 65042,
		Volatile_ = 65043,
		Tail_ = 65044,
		Initobj = 65045,
		Constrained_ = 65046,
		Cpblk = 65047,
		Initblk = 65048,
		Rethrow = 65050,
		Sizeof = 65052,
		Refanytype = 65053,
		Readonly_ = 65054
	}
	public class OpCodes
	{
		public static readonly OpCode Nop = new OpCode(OpCodeValues.Nop, 6556325);

		public static readonly OpCode Break = new OpCode(OpCodeValues.Break, 6556197);

		public static readonly OpCode Ldarg_0 = new OpCode(OpCodeValues.Ldarg_0, 275120805);

		public static readonly OpCode Ldarg_1 = new OpCode(OpCodeValues.Ldarg_1, 275120805);

		public static readonly OpCode Ldarg_2 = new OpCode(OpCodeValues.Ldarg_2, 275120805);

		public static readonly OpCode Ldarg_3 = new OpCode(OpCodeValues.Ldarg_3, 275120805);

		public static readonly OpCode Ldloc_0 = new OpCode(OpCodeValues.Ldloc_0, 275120805);

		public static readonly OpCode Ldloc_1 = new OpCode(OpCodeValues.Ldloc_1, 275120805);

		public static readonly OpCode Ldloc_2 = new OpCode(OpCodeValues.Ldloc_2, 275120805);

		public static readonly OpCode Ldloc_3 = new OpCode(OpCodeValues.Ldloc_3, 275120805);

		public static readonly OpCode Stloc_0 = new OpCode(OpCodeValues.Stloc_0, -261877083);

		public static readonly OpCode Stloc_1 = new OpCode(OpCodeValues.Stloc_1, -261877083);

		public static readonly OpCode Stloc_2 = new OpCode(OpCodeValues.Stloc_2, -261877083);

		public static readonly OpCode Stloc_3 = new OpCode(OpCodeValues.Stloc_3, -261877083);

		public static readonly OpCode Ldarg_S = new OpCode(OpCodeValues.Ldarg_S, 275120818);

		public static readonly OpCode Ldarga_S = new OpCode(OpCodeValues.Ldarga_S, 275382962);

		public static readonly OpCode Starg_S = new OpCode(OpCodeValues.Starg_S, -261877070);

		public static readonly OpCode Ldloc_S = new OpCode(OpCodeValues.Ldloc_S, 275120818);

		public static readonly OpCode Ldloca_S = new OpCode(OpCodeValues.Ldloca_S, 275382962);

		public static readonly OpCode Stloc_S = new OpCode(OpCodeValues.Stloc_S, -261877070);

		public static readonly OpCode Ldnull = new OpCode(OpCodeValues.Ldnull, 275909285);

		public static readonly OpCode Ldc_I4_M1 = new OpCode(OpCodeValues.Ldc_I4_M1, 275382949);

		public static readonly OpCode Ldc_I4_0 = new OpCode(OpCodeValues.Ldc_I4_0, 275382949);

		public static readonly OpCode Ldc_I4_1 = new OpCode(OpCodeValues.Ldc_I4_1, 275382949);

		public static readonly OpCode Ldc_I4_2 = new OpCode(OpCodeValues.Ldc_I4_2, 275382949);

		public static readonly OpCode Ldc_I4_3 = new OpCode(OpCodeValues.Ldc_I4_3, 275382949);

		public static readonly OpCode Ldc_I4_4 = new OpCode(OpCodeValues.Ldc_I4_4, 275382949);

		public static readonly OpCode Ldc_I4_5 = new OpCode(OpCodeValues.Ldc_I4_5, 275382949);

		public static readonly OpCode Ldc_I4_6 = new OpCode(OpCodeValues.Ldc_I4_6, 275382949);

		public static readonly OpCode Ldc_I4_7 = new OpCode(OpCodeValues.Ldc_I4_7, 275382949);

		public static readonly OpCode Ldc_I4_8 = new OpCode(OpCodeValues.Ldc_I4_8, 275382949);

		public static readonly OpCode Ldc_I4_S = new OpCode(OpCodeValues.Ldc_I4_S, 275382960);

		public static readonly OpCode Ldc_I4 = new OpCode(OpCodeValues.Ldc_I4, 275384994);

		public static readonly OpCode Ldc_I8 = new OpCode(OpCodeValues.Ldc_I8, 275516067);

		public static readonly OpCode Ldc_R4 = new OpCode(OpCodeValues.Ldc_R4, 275647153);

		public static readonly OpCode Ldc_R8 = new OpCode(OpCodeValues.Ldc_R8, 275778215);

		public static readonly OpCode Dup = new OpCode(OpCodeValues.Dup, 275258021);

		public static readonly OpCode Pop = new OpCode(OpCodeValues.Pop, -261875035);

		public static readonly OpCode Jmp = new OpCode(OpCodeValues.Jmp, 23333444);

		public static readonly OpCode Call = new OpCode(OpCodeValues.Call, 7842372);

		public static readonly OpCode Calli = new OpCode(OpCodeValues.Calli, 7842377);

		public static readonly OpCode Ret = new OpCode(OpCodeValues.Ret, 23440101);

		public static readonly OpCode Br_S = new OpCode(OpCodeValues.Br_S, 23331343);

		public static readonly OpCode Brfalse_S = new OpCode(OpCodeValues.Brfalse_S, -261868945);

		public static readonly OpCode Brtrue_S = new OpCode(OpCodeValues.Brtrue_S, -261868945);

		public static readonly OpCode Beq_S = new OpCode(OpCodeValues.Beq_S, -530308497);

		public static readonly OpCode Bge_S = new OpCode(OpCodeValues.Bge_S, -530308497);

		public static readonly OpCode Bgt_S = new OpCode(OpCodeValues.Bgt_S, -530308497);

		public static readonly OpCode Ble_S = new OpCode(OpCodeValues.Ble_S, -530308497);

		public static readonly OpCode Blt_S = new OpCode(OpCodeValues.Blt_S, -530308497);

		public static readonly OpCode Bne_Un_S = new OpCode(OpCodeValues.Bne_Un_S, -530308497);

		public static readonly OpCode Bge_Un_S = new OpCode(OpCodeValues.Bge_Un_S, -530308497);

		public static readonly OpCode Bgt_Un_S = new OpCode(OpCodeValues.Bgt_Un_S, -530308497);

		public static readonly OpCode Ble_Un_S = new OpCode(OpCodeValues.Ble_Un_S, -530308497);

		public static readonly OpCode Blt_Un_S = new OpCode(OpCodeValues.Blt_Un_S, -530308497);

		public static readonly OpCode Br = new OpCode(OpCodeValues.Br, 23333376);

		public static readonly OpCode Brfalse = new OpCode(OpCodeValues.Brfalse, -261866912);

		public static readonly OpCode Brtrue = new OpCode(OpCodeValues.Brtrue, -261866912);

		public static readonly OpCode Beq = new OpCode(OpCodeValues.Beq, -530308512);

		public static readonly OpCode Bge = new OpCode(OpCodeValues.Bge, -530308512);

		public static readonly OpCode Bgt = new OpCode(OpCodeValues.Bgt, -530308512);

		public static readonly OpCode Ble = new OpCode(OpCodeValues.Ble, -530308512);

		public static readonly OpCode Blt = new OpCode(OpCodeValues.Blt, -530308512);

		public static readonly OpCode Bne_Un = new OpCode(OpCodeValues.Bne_Un, -530308512);

		public static readonly OpCode Bge_Un = new OpCode(OpCodeValues.Bge_Un, -530308512);

		public static readonly OpCode Bgt_Un = new OpCode(OpCodeValues.Bgt_Un, -530308512);

		public static readonly OpCode Ble_Un = new OpCode(OpCodeValues.Ble_Un, -530308512);

		public static readonly OpCode Blt_Un = new OpCode(OpCodeValues.Blt_Un, -530308512);

		public static readonly OpCode Switch = new OpCode(OpCodeValues.Switch, -261866901);

		public static readonly OpCode Ldind_I1 = new OpCode(OpCodeValues.Ldind_I1, 6961829);

		public static readonly OpCode Ldind_U1 = new OpCode(OpCodeValues.Ldind_U1, 6961829);

		public static readonly OpCode Ldind_I2 = new OpCode(OpCodeValues.Ldind_I2, 6961829);

		public static readonly OpCode Ldind_U2 = new OpCode(OpCodeValues.Ldind_U2, 6961829);

		public static readonly OpCode Ldind_I4 = new OpCode(OpCodeValues.Ldind_I4, 6961829);

		public static readonly OpCode Ldind_U4 = new OpCode(OpCodeValues.Ldind_U4, 6961829);

		public static readonly OpCode Ldind_I8 = new OpCode(OpCodeValues.Ldind_I8, 7092901);

		public static readonly OpCode Ldind_I = new OpCode(OpCodeValues.Ldind_I, 6961829);

		public static readonly OpCode Ldind_R4 = new OpCode(OpCodeValues.Ldind_R4, 7223973);

		public static readonly OpCode Ldind_R8 = new OpCode(OpCodeValues.Ldind_R8, 7355045);

		public static readonly OpCode Ldind_Ref = new OpCode(OpCodeValues.Ldind_Ref, 7486117);

		public static readonly OpCode Stind_Ref = new OpCode(OpCodeValues.Stind_Ref, -530294107);

		public static readonly OpCode Stind_I1 = new OpCode(OpCodeValues.Stind_I1, -530294107);

		public static readonly OpCode Stind_I2 = new OpCode(OpCodeValues.Stind_I2, -530294107);

		public static readonly OpCode Stind_I4 = new OpCode(OpCodeValues.Stind_I4, -530294107);

		public static readonly OpCode Stind_I8 = new OpCode(OpCodeValues.Stind_I8, -530290011);

		public static readonly OpCode Stind_R4 = new OpCode(OpCodeValues.Stind_R4, -530281819);

		public static readonly OpCode Stind_R8 = new OpCode(OpCodeValues.Stind_R8, -530277723);

		public static readonly OpCode Add = new OpCode(OpCodeValues.Add, -261739867);

		public static readonly OpCode Sub = new OpCode(OpCodeValues.Sub, -261739867);

		public static readonly OpCode Mul = new OpCode(OpCodeValues.Mul, -261739867);

		public static readonly OpCode Div = new OpCode(OpCodeValues.Div, -261739867);

		public static readonly OpCode Div_Un = new OpCode(OpCodeValues.Div_Un, -261739867);

		public static readonly OpCode Rem = new OpCode(OpCodeValues.Rem, -261739867);

		public static readonly OpCode Rem_Un = new OpCode(OpCodeValues.Rem_Un, -261739867);

		public static readonly OpCode And = new OpCode(OpCodeValues.And, -261739867);

		public static readonly OpCode Or = new OpCode(OpCodeValues.Or, -261739867);

		public static readonly OpCode Xor = new OpCode(OpCodeValues.Xor, -261739867);

		public static readonly OpCode Shl = new OpCode(OpCodeValues.Shl, -261739867);

		public static readonly OpCode Shr = new OpCode(OpCodeValues.Shr, -261739867);

		public static readonly OpCode Shr_Un = new OpCode(OpCodeValues.Shr_Un, -261739867);

		public static readonly OpCode Neg = new OpCode(OpCodeValues.Neg, 6691493);

		public static readonly OpCode Not = new OpCode(OpCodeValues.Not, 6691493);

		public static readonly OpCode Conv_I1 = new OpCode(OpCodeValues.Conv_I1, 6953637);

		public static readonly OpCode Conv_I2 = new OpCode(OpCodeValues.Conv_I2, 6953637);

		public static readonly OpCode Conv_I4 = new OpCode(OpCodeValues.Conv_I4, 6953637);

		public static readonly OpCode Conv_I8 = new OpCode(OpCodeValues.Conv_I8, 7084709);

		public static readonly OpCode Conv_R4 = new OpCode(OpCodeValues.Conv_R4, 7215781);

		public static readonly OpCode Conv_R8 = new OpCode(OpCodeValues.Conv_R8, 7346853);

		public static readonly OpCode Conv_U4 = new OpCode(OpCodeValues.Conv_U4, 6953637);

		public static readonly OpCode Conv_U8 = new OpCode(OpCodeValues.Conv_U8, 7084709);

		public static readonly OpCode Callvirt = new OpCode(OpCodeValues.Callvirt, 7841348);

		public static readonly OpCode Cpobj = new OpCode(OpCodeValues.Cpobj, -530295123);

		public static readonly OpCode Ldobj = new OpCode(OpCodeValues.Ldobj, 6698669);

		public static readonly OpCode Ldstr = new OpCode(OpCodeValues.Ldstr, 275908266);

		public static readonly OpCode Newobj = new OpCode(OpCodeValues.Newobj, 276014660);

		public static readonly OpCode Castclass = new OpCode(OpCodeValues.Castclass, 7513773);

		public static readonly OpCode Isinst = new OpCode(OpCodeValues.Isinst, 6989485);

		public static readonly OpCode Conv_R_Un = new OpCode(OpCodeValues.Conv_R_Un, 7346853);

		public static readonly OpCode Unbox = new OpCode(OpCodeValues.Unbox, 6990509);

		public static readonly OpCode Throw = new OpCode(OpCodeValues.Throw, -245061883);

		public static readonly OpCode Ldfld = new OpCode(OpCodeValues.Ldfld, 6727329);

		public static readonly OpCode Ldflda = new OpCode(OpCodeValues.Ldflda, 6989473);

		public static readonly OpCode Stfld = new OpCode(OpCodeValues.Stfld, -530270559);

		public static readonly OpCode Ldsfld = new OpCode(OpCodeValues.Ldsfld, 275121825);

		public static readonly OpCode Ldsflda = new OpCode(OpCodeValues.Ldsflda, 275383969);

		public static readonly OpCode Stsfld = new OpCode(OpCodeValues.Stsfld, -261876063);

		public static readonly OpCode Stobj = new OpCode(OpCodeValues.Stobj, -530298195);

		public static readonly OpCode Conv_Ovf_I1_Un = new OpCode(OpCodeValues.Conv_Ovf_I1_Un, 6953637);

		public static readonly OpCode Conv_Ovf_I2_Un = new OpCode(OpCodeValues.Conv_Ovf_I2_Un, 6953637);

		public static readonly OpCode Conv_Ovf_I4_Un = new OpCode(OpCodeValues.Conv_Ovf_I4_Un, 6953637);

		public static readonly OpCode Conv_Ovf_I8_Un = new OpCode(OpCodeValues.Conv_Ovf_I8_Un, 7084709);

		public static readonly OpCode Conv_Ovf_U1_Un = new OpCode(OpCodeValues.Conv_Ovf_U1_Un, 6953637);

		public static readonly OpCode Conv_Ovf_U2_Un = new OpCode(OpCodeValues.Conv_Ovf_U2_Un, 6953637);

		public static readonly OpCode Conv_Ovf_U4_Un = new OpCode(OpCodeValues.Conv_Ovf_U4_Un, 6953637);

		public static readonly OpCode Conv_Ovf_U8_Un = new OpCode(OpCodeValues.Conv_Ovf_U8_Un, 7084709);

		public static readonly OpCode Conv_Ovf_I_Un = new OpCode(OpCodeValues.Conv_Ovf_I_Un, 6953637);

		public static readonly OpCode Conv_Ovf_U_Un = new OpCode(OpCodeValues.Conv_Ovf_U_Un, 6953637);

		public static readonly OpCode Box = new OpCode(OpCodeValues.Box, 7477933);

		public static readonly OpCode Newarr = new OpCode(OpCodeValues.Newarr, 7485101);

		public static readonly OpCode Ldlen = new OpCode(OpCodeValues.Ldlen, 6989477);

		public static readonly OpCode Ldelema = new OpCode(OpCodeValues.Ldelema, -261437779);

		public static readonly OpCode Ldelem_I1 = new OpCode(OpCodeValues.Ldelem_I1, -261437787);

		public static readonly OpCode Ldelem_U1 = new OpCode(OpCodeValues.Ldelem_U1, -261437787);

		public static readonly OpCode Ldelem_I2 = new OpCode(OpCodeValues.Ldelem_I2, -261437787);

		public static readonly OpCode Ldelem_U2 = new OpCode(OpCodeValues.Ldelem_U2, -261437787);

		public static readonly OpCode Ldelem_I4 = new OpCode(OpCodeValues.Ldelem_I4, -261437787);

		public static readonly OpCode Ldelem_U4 = new OpCode(OpCodeValues.Ldelem_U4, -261437787);

		public static readonly OpCode Ldelem_I8 = new OpCode(OpCodeValues.Ldelem_I8, -261306715);

		public static readonly OpCode Ldelem_I = new OpCode(OpCodeValues.Ldelem_I, -261437787);

		public static readonly OpCode Ldelem_R4 = new OpCode(OpCodeValues.Ldelem_R4, -261175643);

		public static readonly OpCode Ldelem_R8 = new OpCode(OpCodeValues.Ldelem_R8, -261044571);

		public static readonly OpCode Ldelem_Ref = new OpCode(OpCodeValues.Ldelem_Ref, -260913499);

		public static readonly OpCode Stelem_I = new OpCode(OpCodeValues.Stelem_I, -798697819);

		public static readonly OpCode Stelem_I1 = new OpCode(OpCodeValues.Stelem_I1, -798697819);

		public static readonly OpCode Stelem_I2 = new OpCode(OpCodeValues.Stelem_I2, -798697819);

		public static readonly OpCode Stelem_I4 = new OpCode(OpCodeValues.Stelem_I4, -798697819);

		public static readonly OpCode Stelem_I8 = new OpCode(OpCodeValues.Stelem_I8, -798693723);

		public static readonly OpCode Stelem_R4 = new OpCode(OpCodeValues.Stelem_R4, -798689627);

		public static readonly OpCode Stelem_R8 = new OpCode(OpCodeValues.Stelem_R8, -798685531);

		public static readonly OpCode Stelem_Ref = new OpCode(OpCodeValues.Stelem_Ref, -798681435);

		public static readonly OpCode Ldelem = new OpCode(OpCodeValues.Ldelem, -261699923);

		public static readonly OpCode Stelem = new OpCode(OpCodeValues.Stelem, -798636371);

		public static readonly OpCode Unbox_Any = new OpCode(OpCodeValues.Unbox_Any, 6727341);

		public static readonly OpCode Conv_Ovf_I1 = new OpCode(OpCodeValues.Conv_Ovf_I1, 6953637);

		public static readonly OpCode Conv_Ovf_U1 = new OpCode(OpCodeValues.Conv_Ovf_U1, 6953637);

		public static readonly OpCode Conv_Ovf_I2 = new OpCode(OpCodeValues.Conv_Ovf_I2, 6953637);

		public static readonly OpCode Conv_Ovf_U2 = new OpCode(OpCodeValues.Conv_Ovf_U2, 6953637);

		public static readonly OpCode Conv_Ovf_I4 = new OpCode(OpCodeValues.Conv_Ovf_I4, 6953637);

		public static readonly OpCode Conv_Ovf_U4 = new OpCode(OpCodeValues.Conv_Ovf_U4, 6953637);

		public static readonly OpCode Conv_Ovf_I8 = new OpCode(OpCodeValues.Conv_Ovf_I8, 7084709);

		public static readonly OpCode Conv_Ovf_U8 = new OpCode(OpCodeValues.Conv_Ovf_U8, 7084709);

		public static readonly OpCode Refanyval = new OpCode(OpCodeValues.Refanyval, 6953645);

		public static readonly OpCode Ckfinite = new OpCode(OpCodeValues.Ckfinite, 7346853);

		public static readonly OpCode Mkrefany = new OpCode(OpCodeValues.Mkrefany, 6699693);

		public static readonly OpCode Ldtoken = new OpCode(OpCodeValues.Ldtoken, 275385004);

		public static readonly OpCode Conv_U2 = new OpCode(OpCodeValues.Conv_U2, 6953637);

		public static readonly OpCode Conv_U1 = new OpCode(OpCodeValues.Conv_U1, 6953637);

		public static readonly OpCode Conv_I = new OpCode(OpCodeValues.Conv_I, 6953637);

		public static readonly OpCode Conv_Ovf_I = new OpCode(OpCodeValues.Conv_Ovf_I, 6953637);

		public static readonly OpCode Conv_Ovf_U = new OpCode(OpCodeValues.Conv_Ovf_U, 6953637);

		public static readonly OpCode Add_Ovf = new OpCode(OpCodeValues.Add_Ovf, -261739867);

		public static readonly OpCode Add_Ovf_Un = new OpCode(OpCodeValues.Add_Ovf_Un, -261739867);

		public static readonly OpCode Mul_Ovf = new OpCode(OpCodeValues.Mul_Ovf, -261739867);

		public static readonly OpCode Mul_Ovf_Un = new OpCode(OpCodeValues.Mul_Ovf_Un, -261739867);

		public static readonly OpCode Sub_Ovf = new OpCode(OpCodeValues.Sub_Ovf, -261739867);

		public static readonly OpCode Sub_Ovf_Un = new OpCode(OpCodeValues.Sub_Ovf_Un, -261739867);

		public static readonly OpCode Endfinally = new OpCode(OpCodeValues.Endfinally, 23333605);

		public static readonly OpCode Leave = new OpCode(OpCodeValues.Leave, 23333376);

		public static readonly OpCode Leave_S = new OpCode(OpCodeValues.Leave_S, 23333391);

		public static readonly OpCode Stind_I = new OpCode(OpCodeValues.Stind_I, -530294107);

		public static readonly OpCode Conv_U = new OpCode(OpCodeValues.Conv_U, 6953637);

		public static readonly OpCode Prefix7 = new OpCode(OpCodeValues.Prefix7, 6554757);

		public static readonly OpCode Prefix6 = new OpCode(OpCodeValues.Prefix6, 6554757);

		public static readonly OpCode Prefix5 = new OpCode(OpCodeValues.Prefix5, 6554757);

		public static readonly OpCode Prefix4 = new OpCode(OpCodeValues.Prefix4, 6554757);

		public static readonly OpCode Prefix3 = new OpCode(OpCodeValues.Prefix3, 6554757);

		public static readonly OpCode Prefix2 = new OpCode(OpCodeValues.Prefix2, 6554757);

		public static readonly OpCode Prefix1 = new OpCode(OpCodeValues.Prefix1, 6554757);

		public static readonly OpCode Prefixref = new OpCode(OpCodeValues.Prefixref, 6554757);

		public static readonly OpCode Arglist = new OpCode(OpCodeValues.Arglist, 279579301);

		public static readonly OpCode Ceq = new OpCode(OpCodeValues.Ceq, -257283419);

		public static readonly OpCode Cgt = new OpCode(OpCodeValues.Cgt, -257283419);

		public static readonly OpCode Cgt_Un = new OpCode(OpCodeValues.Cgt_Un, -257283419);

		public static readonly OpCode Clt = new OpCode(OpCodeValues.Clt, -257283419);

		public static readonly OpCode Clt_Un = new OpCode(OpCodeValues.Clt_Un, -257283419);

		public static readonly OpCode Ldftn = new OpCode(OpCodeValues.Ldftn, 279579300);

		public static readonly OpCode Ldvirtftn = new OpCode(OpCodeValues.Ldvirtftn, 11184804);

		public static readonly OpCode Ldarg = new OpCode(OpCodeValues.Ldarg, 279317166);

		public static readonly OpCode Ldarga = new OpCode(OpCodeValues.Ldarga, 279579310);

		public static readonly OpCode Starg = new OpCode(OpCodeValues.Starg, -257680722);

		public static readonly OpCode Ldloc = new OpCode(OpCodeValues.Ldloc, 279317166);

		public static readonly OpCode Ldloca = new OpCode(OpCodeValues.Ldloca, 279579310);

		public static readonly OpCode Stloc = new OpCode(OpCodeValues.Stloc, -257680722);

		public static readonly OpCode Localloc = new OpCode(OpCodeValues.Localloc, 11156133);

		public static readonly OpCode Endfilter = new OpCode(OpCodeValues.Endfilter, -240895259);

		public static readonly OpCode Unaligned = new OpCode(OpCodeValues.Unaligned_, 10750096);

		public static readonly OpCode Volatile = new OpCode(OpCodeValues.Volatile_, 10750085);

		public static readonly OpCode Tailcall = new OpCode(OpCodeValues.Tail_, 10750085);

		public static readonly OpCode Initobj = new OpCode(OpCodeValues.Initobj, -257673555);

		public static readonly OpCode Constrained = new OpCode(OpCodeValues.Constrained_, 10750093);

		public static readonly OpCode Cpblk = new OpCode(OpCodeValues.Cpblk, -794527067);

		public static readonly OpCode Initblk = new OpCode(OpCodeValues.Initblk, -794527067);

		public static readonly OpCode Rethrow = new OpCode(OpCodeValues.Rethrow, 27526917);

		public static readonly OpCode Sizeof = new OpCode(OpCodeValues.Sizeof, 279579309);

		public static readonly OpCode Refanytype = new OpCode(OpCodeValues.Refanytype, 11147941);

		public static readonly OpCode Readonly = new OpCode(OpCodeValues.Readonly_, 10750085);

		public static bool TakesSingleByteArgument(OpCode inst)
		{
			OperandType operandType = inst.OperandType;
			if ((uint)(operandType - 15) <= 1u || operandType == OperandType.ShortInlineVar)
			{
				return true;
			}
			return false;
		}
	}
	public enum OpCodeType
	{
		[Obsolete("OpCodeType.Annotation has been deprecated and is not supported.")]
		Annotation,
		Macro,
		Nternal,
		Objmodel,
		Prefix,
		Primitive
	}
	public enum OperandType
	{
		InlineBrTarget = 0,
		InlineField = 1,
		InlineI = 2,
		InlineI8 = 3,
		InlineMethod = 4,
		InlineNone = 5,
		[Obsolete("OperandType.InlinePhi has been deprecated and is not supported.")]
		InlinePhi = 6,
		InlineR = 7,
		InlineSig = 9,
		InlineString = 10,
		InlineSwitch = 11,
		InlineTok = 12,
		InlineType = 13,
		InlineVar = 14,
		ShortInlineBrTarget = 15,
		ShortInlineI = 16,
		ShortInlineR = 17,
		ShortInlineVar = 18
	}
	public enum PackingSize
	{
		Unspecified = 0,
		Size1 = 1,
		Size2 = 2,
		Size4 = 4,
		Size8 = 8,
		Size16 = 0x10,
		Size32 = 0x20,
		Size64 = 0x40,
		Size128 = 0x80
	}
	public enum PEFileKinds
	{
		Dll = 1,
		ConsoleApplication,
		WindowApplication
	}
	public enum StackBehaviour
	{
		Pop0,
		Pop1,
		Pop1_pop1,
		Popi,
		Popi_pop1,
		Popi_popi,
		Popi_popi8,
		Popi_popi_popi,
		Popi_popr4,
		Popi_popr8,
		Popref,
		Popref_pop1,
		Popref_popi,
		Popref_popi_popi,
		Popref_popi_popi8,
		Popref_popi_popr4,
		Popref_popi_popr8,
		Popref_popi_popref,
		Push0,
		Push1,
		Push1_push1,
		Pushi,
		Pushi8,
		Pushr4,
		Pushr8,
		Pushref,
		Varpop,
		Varpush,
		Popref_popi_pop1
	}
	internal sealed class TypeNameBuilder
	{
		internal enum Format
		{
			ToString,
			FullName,
			AssemblyQualifiedName
		}

		private StringBuilder _str = new StringBuilder();

		private int _instNesting;

		private bool _firstInstArg;

		private bool _nestedName;

		private bool _hasAssemblySpec;

		private bool _useAngleBracketsForGenerics;

		private List<int> _stack = new List<int>();

		private int _stackIdx;

		private TypeNameBuilder()
		{
		}

		private void OpenGenericArguments()
		{
			_instNesting++;
			_firstInstArg = true;
			if (_useAngleBracketsForGenerics)
			{
				Append('<');
			}
			else
			{
				Append('[');
			}
		}

		private void CloseGenericArguments()
		{
			_instNesting--;
			if (_firstInstArg)
			{
				_str.Remove(_str.Length - 1, 1);
			}
			else if (_useAngleBracketsForGenerics)
			{
				Append('>');
			}
			else
			{
				Append(']');
			}
		}

		private void OpenGenericArgument()
		{
			_nestedName = false;
			if (!_firstInstArg)
			{
				Append(',');
			}
			_firstInstArg = false;
			if (_useAngleBracketsForGenerics)
			{
				Append('<');
			}
			else
			{
				Append('[');
			}
			PushOpenGenericArgument();
		}

		private void CloseGenericArgument()
		{
			if (_hasAssemblySpec)
			{
				if (_useAngleBracketsForGenerics)
				{
					Append('>');
				}
				else
				{
					Append(']');
				}
			}
			PopOpenGenericArgument();
		}

		private void AddName(string name)
		{
			if (_nestedName)
			{
				Append('+');
			}
			_nestedName = true;
			EscapeName(name);
		}

		private void AddArray(int rank)
		{
			if (rank == 1)
			{
				Append("[*]");
				return;
			}
			if (rank > 64)
			{
				_str.Append('[').Append(rank).Append(']');
				return;
			}
			Append('[');
			for (int i = 1; i < rank; i++)
			{
				Append(',');
			}
			Append(']');
		}

		private void AddAssemblySpec(string assemblySpec)
		{
			if (assemblySpec != null && !assemblySpec.Equals(""))
			{
				Append(", ");
				if (_instNesting > 0)
				{
					EscapeEmbeddedAssemblyName(assemblySpec);
				}
				else
				{
					EscapeAssemblyName(assemblySpec);
				}
				_hasAssemblySpec = true;
			}
		}

		public override string ToString()
		{
			return _str.ToString();
		}

		private static bool ContainsReservedChar(string name)
		{
			foreach (char c in name)
			{
				if (c == '\0')
				{
					break;
				}
				if (IsTypeNameReservedChar(c))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsTypeNameReservedChar(char ch)
		{
			switch (ch)
			{
			case '&':
			case '*':
			case '+':
			case ',':
			case '[':
			case '\\':
			case ']':
				return true;
			default:
				return false;
			}
		}

		private void EscapeName(string name)
		{
			if (ContainsReservedChar(name))
			{
				foreach (char c in name)
				{
					if (c != 0)
					{
						if (IsTypeNameReservedChar(c))
						{
							_str.Append('\\');
						}
						_str.Append(c);
						continue;
					}
					break;
				}
			}
			else
			{
				Append(name);
			}
		}

		private void EscapeAssemblyName(string name)
		{
			Append(name);
		}

		private void EscapeEmbeddedAssemblyName(string name)
		{
			if (name.Contains(']'))
			{
				foreach (char c in name)
				{
					if (c == ']')
					{
						Append('\\');
					}
					Append(c);
				}
			}
			else
			{
				Append(name);
			}
		}

		private void PushOpenGenericArgument()
		{
			_stack.Add(_str.Length);
			_stackIdx++;
		}

		private void PopOpenGenericArgument()
		{
			int num = _stack[--_stackIdx];
			_stack.RemoveAt(_stackIdx);
			if (!_hasAssemblySpec)
			{
				_str.Remove(num - 1, 1);
			}
			_hasAssemblySpec = false;
		}

		private void Append(string pStr)
		{
			foreach (char c in pStr)
			{
				if (c != 0)
				{
					_str.Append(c);
					continue;
				}
				break;
			}
		}

		private void Append(char c)
		{
			_str.Append(c);
		}

		internal static string ToString(Type type, Format format)
		{
			if ((format == Format.FullName || format == Format.AssemblyQualifiedName) && !type.IsGenericTypeDefinition && type.ContainsGenericParameters)
			{
				return null;
			}
			TypeNameBuilder typeNameBuilder = new TypeNameBuilder();
			typeNameBuilder.AddAssemblyQualifiedName(type, format);
			return typeNameBuilder.ToString();
		}

		private void AddElementType(Type type)
		{
			if (type.HasElementType)
			{
				AddElementType(type.GetElementType());
				if (type.IsPointer)
				{
					Append('*');
				}
				else if (type.IsByRef)
				{
					Append('&');
				}
				else if (type.IsSZArray)
				{
					Append("[]");
				}
				else if (type.IsArray)
				{
					AddArray(type.GetArrayRank());
				}
			}
		}

		private void AddAssemblyQualifiedName(Type type, Format format)
		{
			Type type2 = type;
			while (type2.HasElementType)
			{
				type2 = type2.GetElementType();
			}
			List<Type> list = new List<Type>();
			Type type3 = type2;
			while (type3 != null)
			{
				list.Add(type3);
				type3 = (type3.IsGenericParameter ? null : type3.DeclaringType);
			}
			for (int num = list.Count - 1; num >= 0; num--)
			{
				Type type4 = list[num];
				string text = type4.Name;
				if (num == list.Count - 1 && type4.Namespace != null && type4.Namespace.Length != 0)
				{
					text = type4.Namespace + "." + text;
				}
				AddName(text);
			}
			if (type2.IsGenericType && (!type2.IsGenericTypeDefinition || format == Format.ToString))
			{
				Type[] genericArguments = type2.GetGenericArguments();
				OpenGenericArguments();
				for (int i = 0; i < genericArguments.Length; i++)
				{
					Format format2 = ((format == Format.FullName) ? Format.AssemblyQualifiedName : format);
					OpenGenericArgument();
					AddAssemblyQualifiedName(genericArguments[i], format2);
					CloseGenericArgument();
				}
				CloseGenericArguments();
			}
			AddElementType(type);
			if (format == Format.AssemblyQualifiedName)
			{
				AddAssemblySpec(type.Module.Assembly.FullName);
			}
		}
	}
}
namespace System.IO
{
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class FileLoadException : IOException
	{
		public override string Message => _message ?? (_message = FormatFileLoadExceptionMessage(FileName, base.HResult));

		public string? FileName { get; }

		public string? FusionLog { get; }

		private FileLoadException(string fileName, int hResult)
			: base(null)
		{
			base.HResult = hResult;
			FileName = fileName;
			_message = FormatFileLoadExceptionMessage(FileName, base.HResult);
		}

		internal static string FormatFileLoadExceptionMessage(string fileName, int hResult)
		{
			string s = null;
			GetFileLoadExceptionMessage(hResult, new StringHandleOnStack(ref s));
			string s2 = null;
			if (hResult == -2147024703)
			{
				s2 = SR.Arg_BadImageFormatException;
			}
			else
			{
				GetMessageForHR(hResult, new StringHandleOnStack(ref s2));
			}
			return string.Format(s, fileName, s2);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetFileLoadExceptionMessage(int hResult, StringHandleOnStack retString);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void GetMessageForHR(int hresult, StringHandleOnStack retString);

		public FileLoadException()
			: base(SR.IO_FileLoad)
		{
			base.HResult = -2146232799;
		}

		public FileLoadException(string? message)
			: base(message)
		{
			base.HResult = -2146232799;
		}

		public FileLoadException(string? message, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146232799;
		}

		public FileLoadException(string? message, string? fileName)
			: base(message)
		{
			base.HResult = -2146232799;
			FileName = fileName;
		}

		public FileLoadException(string? message, string? fileName, Exception? inner)
			: base(message, inner)
		{
			base.HResult = -2146232799;
			FileName = fileName;
		}

		public override string ToString()
		{
			string text = GetType().ToString() + ": " + Message;
			if (!string.IsNullOrEmpty(FileName))
			{
				text = text + "\r\n" + SR.Format(SR.IO_FileName_Name, FileName);
			}
			if (base.InnerException != null)
			{
				text = text + "\r\n ---> " + base.InnerException.ToString();
			}
			if (StackTrace != null)
			{
				text = text + "\r\n" + StackTrace;
			}
			if (FusionLog != null)
			{
				if (text == null)
				{
					text = " ";
				}
				text = text + "\r\n\r\n" + FusionLog;
			}
			return text;
		}

		protected FileLoadException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			FileName = info.GetString("FileLoad_FileName");
			FusionLog = info.GetString("FileLoad_FusionLog");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("FileLoad_FileName", FileName, typeof(string));
			info.AddValue("FileLoad_FusionLog", FusionLog, typeof(string));
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class FileNotFoundException : IOException
	{
		public override string Message
		{
			get
			{
				SetMessageField();
				return _message;
			}
		}

		public string? FileName { get; }

		public string? FusionLog { get; }

		private FileNotFoundException(string fileName, int hResult)
			: base(null)
		{
			base.HResult = hResult;
			FileName = fileName;
			SetMessageField();
		}

		public FileNotFoundException()
			: base(SR.IO_FileNotFound)
		{
			base.HResult = -2147024894;
		}

		public FileNotFoundException(string? message)
			: base(message)
		{
			base.HResult = -2147024894;
		}

		public FileNotFoundException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024894;
		}

		public FileNotFoundException(string? message, string? fileName)
			: base(message)
		{
			base.HResult = -2147024894;
			FileName = fileName;
		}

		public FileNotFoundException(string? message, string? fileName, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024894;
			FileName = fileName;
		}

		private void SetMessageField()
		{
			if (_message == null)
			{
				if (FileName == null && base.HResult == -2146233088)
				{
					_message = SR.IO_FileNotFound;
				}
				else if (FileName != null)
				{
					_message = FileLoadException.FormatFileLoadExceptionMessage(FileName, base.HResult);
				}
			}
		}

		public override string ToString()
		{
			string text = GetType().ToString() + ": " + Message;
			if (!string.IsNullOrEmpty(FileName))
			{
				text = text + "\r\n" + SR.Format(SR.IO_FileName_Name, FileName);
			}
			if (base.InnerException != null)
			{
				text = text + "\r\n ---> " + base.InnerException.ToString();
			}
			if (StackTrace != null)
			{
				text = text + "\r\n" + StackTrace;
			}
			if (FusionLog != null)
			{
				if (text == null)
				{
					text = " ";
				}
				text = text + "\r\n\r\n" + FusionLog;
			}
			return text;
		}

		protected FileNotFoundException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			FileName = info.GetString("FileNotFound_FileName");
			FusionLog = info.GetString("FileNotFound_FusionLog");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("FileNotFound_FileName", FileName, typeof(string));
			info.AddValue("FileNotFound_FusionLog", FusionLog, typeof(string));
		}
	}
	public abstract class Stream : MarshalByRefObject, IDisposable, IAsyncDisposable
	{
		private struct ReadWriteParameters
		{
			internal byte[] Buffer;

			internal int Offset;

			internal int Count;
		}

		private sealed class ReadWriteTask : Task<int>, ITaskCompletionAction
		{
			internal readonly bool _isRead;

			internal readonly bool _apm;

			internal bool _endCalled;

			internal Stream _stream;

			internal byte[] _buffer;

			internal readonly int _offset;

			internal readonly int _count;

			private AsyncCallback _callback;

			private ExecutionContext _context;

			private static ContextCallback s_invokeAsyncCallback;

			bool ITaskCompletionAction.InvokeMayRunArbitraryCode => true;

			internal void ClearBeginState()
			{
				_stream = null;
				_buffer = null;
			}

			public ReadWriteTask(bool isRead, bool apm, Func<object, int> function, object state, Stream stream, byte[] buffer, int offset, int count, AsyncCallback callback)
				: base(function, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach)
			{
				_isRead = isRead;
				_apm = apm;
				_stream = stream;
				_buffer = buffer;
				_offset = offset;
				_count = count;
				if (callback != null)
				{
					_callback = callback;
					_context = ExecutionContext.Capture();
					AddCompletionAction(this);
				}
			}

			private static void InvokeAsyncCallback(object completedTask)
			{
				ReadWriteTask readWriteTask = (ReadWriteTask)completedTask;
				AsyncCallback callback = readWriteTask._callback;
				readWriteTask._callback = null;
				callback(readWriteTask);
			}

			void ITaskCompletionAction.Invoke(Task completingTask)
			{
				ExecutionContext context = _context;
				if (context == null)
				{
					AsyncCallback callback = _callback;
					_callback = null;
					callback(completingTask);
				}
				else
				{
					_context = null;
					ContextCallback callback2 = InvokeAsyncCallback;
					ExecutionContext.RunInternal(context, callback2, this);
				}
			}
		}

		private sealed class NullStream : Stream
		{
			public override bool CanRead => true;

			public override bool CanWrite => true;

			public override bool CanSeek => true;

			public override long Length => 0L;

			public override long Position
			{
				get
				{
					return 0L;
				}
				set
				{
				}
			}

			internal NullStream()
			{
			}

			public override void CopyTo(Stream destination, int bufferSize)
			{
			}

			public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
			{
				if (!cancellationToken.IsCancellationRequested)
				{
					return Task.CompletedTask;
				}
				return Task.FromCanceled(cancellationToken);
			}

			protected override void Dispose(bool disposing)
			{
			}

			public override void Flush()
			{
			}

			public override Task FlushAsync(CancellationToken cancellationToken)
			{
				if (!cancellationToken.IsCancellationRequested)
				{
					return Task.CompletedTask;
				}
				return Task.FromCanceled(cancellationToken);
			}

			public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
			{
				return TaskToApm.Begin(Task<int>.s_defaultResultTask, callback, state);
			}

			public override int EndRead(IAsyncResult asyncResult)
			{
				return TaskToApm.End<int>(asyncResult);
			}

			public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
			{
				return TaskToApm.Begin(Task.CompletedTask, callback, state);
			}

			public override void EndWrite(IAsyncResult asyncResult)
			{
				TaskToApm.End(asyncResult);
			}

			public override int Read(byte[] buffer, int offset, int count)
			{
				return 0;
			}

			public override int Read(Span<byte> buffer)
			{
				return 0;
			}

			public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
			{
				if (!cancellationToken.IsCancellationRequested)
				{
					return Task.FromResult(0);
				}
				return Task.FromCanceled<int>(cancellationToken);
			}

			public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
			{
				if (!cancellationToken.IsCancellationRequested)
				{
					return default(ValueTask<int>);
				}
				return ValueTask.FromCanceled<int>(cancellationToken);
			}

			public override int ReadByte()
			{
				return -1;
			}

			public override void Write(byte[] buffer, int offset, int count)
			{
			}

			public override void Write(ReadOnlySpan<byte> buffer)
			{
			}

			public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
			{
				if (!cancellationToken.IsCancellationRequested)
				{
					return Task.CompletedTask;
				}
				return Task.FromCanceled(cancellationToken);
			}

			public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
			{
				if (!cancellationToken.IsCancellationRequested)
				{
					return default(ValueTask);
				}
				return ValueTask.FromCanceled(cancellationToken);
			}

			public override void WriteByte(byte value)
			{
			}

			public override long Seek(long offset, SeekOrigin origin)
			{
				return 0L;
			}

			public override void SetLength(long length)
			{
			}
		}

		private sealed class SyncStream : Stream, IDisposable
		{
			private readonly Stream _stream;

			public override bool CanRead => _stream.CanRead;

			public override bool CanWrite => _stream.CanWrite;

			public override bool CanSeek => _stream.CanSeek;

			public override bool CanTimeout => _stream.CanTimeout;

			public override long Length
			{
				get
				{
					lock (_stream)
					{
						return _stream.Length;
					}
				}
			}

			public override long Position
			{
				get
				{
					lock (_stream)
					{
						return _stream.Position;
					}
				}
				set
				{
					lock (_stream)
					{
						_stream.Position = value;
					}
				}
			}

			public override int ReadTimeout
			{
				get
				{
					return _stream.ReadTimeout;
				}
				set
				{
					_stream.ReadTimeout = value;
				}
			}

			public override int WriteTimeout
			{
				get
				{
					return _stream.WriteTimeout;
				}
				set
				{
					_stream.WriteTimeout = value;
				}
			}

			internal SyncStream(Stream stream)
			{
				_stream = stream ?? throw new ArgumentNullException("stream");
			}

			public override void Close()
			{
				lock (_stream)
				{
					try
					{
						_stream.Close();
					}
					finally
					{
						base.Dispose(disposing: true);
					}
				}
			}

			protected override void Dispose(bool disposing)
			{
				lock (_stream)
				{
					try
					{
						if (disposing)
						{
							((IDisposable)_stream).Dispose();
						}
					}
					finally
					{
						base.Dispose(disposing);
					}
				}
			}

			public override ValueTask DisposeAsync()
			{
				lock (_stream)
				{
					return _stream.DisposeAsync();
				}
			}

			public override void Flush()
			{
				lock (_stream)
				{
					_stream.Flush();
				}
			}

			public override int Read(byte[] bytes, int offset, int count)
			{
				lock (_stream)
				{
					return _stream.Read(bytes, offset, count);
				}
			}

			public override int Read(Span<byte> buffer)
			{
				lock (_stream)
				{
					return _stream.Read(buffer);
				}
			}

			public override int ReadByte()
			{
				lock (_stream)
				{
					return _stream.ReadByte();
				}
			}

			public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
			{
				bool flag = _stream.HasOverriddenBeginEndRead();
				lock (_stream)
				{
					IAsyncResult result;
					if (!flag)
					{
						IAsyncResult asyncResult = _stream.BeginReadInternal(buffer, offset, count, callback, state, serializeAsynchronously: true, apm: true);
						result = asyncResult;
					}
					else
					{
						result = _stream.BeginRead(buffer, offset, count, callback, state);
					}
					return result;
				}
			}

			public override int EndRead(IAsyncResult asyncResult)
			{
				if (asyncResult == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.asyncResult);
				}
				lock (_stream)
				{
					return _stream.EndRead(asyncResult);
				}
			}

			public override long Seek(long offset, SeekOrigin origin)
			{
				lock (_stream)
				{
					return _stream.Seek(offset, origin);
				}
			}

			public override void SetLength(long length)
			{
				lock (_stream)
				{
					_stream.SetLength(length);
				}
			}

			public override void Write(byte[] bytes, int offset, int count)
			{
				lock (_stream)
				{
					_stream.Write(bytes, offset, count);
				}
			}

			public override void Write(ReadOnlySpan<byte> buffer)
			{
				lock (_stream)
				{
					_stream.Write(buffer);
				}
			}

			public override void WriteByte(byte b)
			{
				lock (_stream)
				{
					_stream.WriteByte(b);
				}
			}

			public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
			{
				bool flag = _stream.HasOverriddenBeginEndWrite();
				lock (_stream)
				{
					IAsyncResult result;
					if (!flag)
					{
						IAsyncResult asyncResult = _stream.BeginWriteInternal(buffer, offset, count, callback, state, serializeAsynchronously: true, apm: true);
						result = asyncResult;
					}
					else
					{
						result = _stream.BeginWrite(buffer, offset, count, callback, state);
					}
					return result;
				}
			}

			public override void EndWrite(IAsyncResult asyncResult)
			{
				if (asyncResult == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.asyncResult);
				}
				lock (_stream)
				{
					_stream.EndWrite(asyncResult);
				}
			}
		}

		public static readonly Stream Null = new NullStream();

		private protected SemaphoreSlim _asyncActiveSemaphore;

		public abstract bool CanRead { get; }

		public abstract bool CanWrite { get; }

		public abstract bool CanSeek { get; }

		public virtual bool CanTimeout => false;

		public abstract long Length { get; }

		public abstract long Position { get; set; }

		public virtual int ReadTimeout
		{
			get
			{
				throw new InvalidOperationException(SR.InvalidOperation_TimeoutsNotSupported);
			}
			set
			{
				throw new InvalidOperationException(SR.InvalidOperation_TimeoutsNotSupported);
			}
		}

		public virtual int WriteTimeout
		{
			get
			{
				throw new InvalidOperationException(SR.InvalidOperation_TimeoutsNotSupported);
			}
			set
			{
				throw new InvalidOperationException(SR.InvalidOperation_TimeoutsNotSupported);
			}
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern bool HasOverriddenBeginEndRead();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private extern bool HasOverriddenBeginEndWrite();

		[MemberNotNull("_asyncActiveSemaphore")]
		private protected SemaphoreSlim EnsureAsyncActiveSemaphoreInitialized()
		{
			return Volatile.Read(ref _asyncActiveSemaphore) ?? Interlocked.CompareExchange(ref _asyncActiveSemaphore, new SemaphoreSlim(1, 1), null) ?? _asyncActiveSemaphore;
		}

		public void CopyTo(Stream destination)
		{
			CopyTo(destination, GetCopyBufferSize());
		}

		public virtual void CopyTo(Stream destination, int bufferSize)
		{
			ValidateCopyToArguments(destination, bufferSize);
			if (!CanRead)
			{
				if (CanWrite)
				{
					ThrowHelper.ThrowNotSupportedException_UnreadableStream();
				}
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(GetType().Name);
			}
			byte[] array = ArrayPool<byte>.Shared.Rent(bufferSize);
			try
			{
				int count;
				while ((count = Read(array, 0, array.Length)) != 0)
				{
					destination.Write(array, 0, count);
				}
			}
			finally
			{
				ArrayPool<byte>.Shared.Return(array);
			}
		}

		public Task CopyToAsync(Stream destination)
		{
			return CopyToAsync(destination, GetCopyBufferSize());
		}

		public Task CopyToAsync(Stream destination, int bufferSize)
		{
			return CopyToAsync(destination, bufferSize, CancellationToken.None);
		}

		public Task CopyToAsync(Stream destination, CancellationToken cancellationToken)
		{
			return CopyToAsync(destination, GetCopyBufferSize(), cancellationToken);
		}

		public virtual Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			ValidateCopyToArguments(destination, bufferSize);
			if (!CanRead)
			{
				if (CanWrite)
				{
					ThrowHelper.ThrowNotSupportedException_UnreadableStream();
				}
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(GetType().Name);
			}
			return Core(this, destination, bufferSize, cancellationToken);
			static async Task Core(Stream source, Stream destination, int bufferSize, CancellationToken cancellationToken)
			{
				byte[] buffer = ArrayPool<byte>.Shared.Rent(bufferSize);
				try
				{
					int length;
					while ((length = await source.ReadAsync(new Memory<byte>(buffer), cancellationToken).ConfigureAwait(continueOnCapturedContext: false)) != 0)
					{
						await destination.WriteAsync(new ReadOnlyMemory<byte>(buffer, 0, length), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					}
				}
				finally
				{
					ArrayPool<byte>.Shared.Return(buffer);
				}
			}
		}

		private int GetCopyBufferSize()
		{
			int num = 81920;
			if (CanSeek)
			{
				long length = Length;
				long position = Position;
				if (length <= position)
				{
					num = 1;
				}
				else
				{
					long num2 = length - position;
					if (num2 > 0)
					{
						num = (int)Math.Min(num, num2);
					}
				}
			}
			return num;
		}

		public void Dispose()
		{
			Close();
		}

		public virtual void Close()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
		}

		public virtual ValueTask DisposeAsync()
		{
			try
			{
				Dispose();
				return default(ValueTask);
			}
			catch (Exception exception)
			{
				return ValueTask.FromException(exception);
			}
		}

		public abstract void Flush();

		public Task FlushAsync()
		{
			return FlushAsync(CancellationToken.None);
		}

		public virtual Task FlushAsync(CancellationToken cancellationToken)
		{
			return Task.Factory.StartNew(delegate(object state)
			{
				((Stream)state).Flush();
			}, this, cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		[Obsolete("CreateWaitHandle has been deprecated. Use the ManualResetEvent(false) constructor instead.")]
		protected virtual WaitHandle CreateWaitHandle()
		{
			return new ManualResetEvent(initialState: false);
		}

		public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
		{
			return BeginReadInternal(buffer, offset, count, callback, state, serializeAsynchronously: false, apm: true);
		}

		internal Task<int> BeginReadInternal(byte[] buffer, int offset, int count, AsyncCallback callback, object state, bool serializeAsynchronously, bool apm)
		{
			ValidateBufferArguments(buffer, offset, count);
			if (!CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			SemaphoreSlim semaphoreSlim = EnsureAsyncActiveSemaphoreInitialized();
			Task task = null;
			if (serializeAsynchronously)
			{
				task = semaphoreSlim.WaitAsync();
			}
			else
			{
				semaphoreSlim.Wait();
			}
			ReadWriteTask readWriteTask = new ReadWriteTask(isRead: true, apm, delegate
			{
				ReadWriteTask readWriteTask2 = Task.InternalCurrent as ReadWriteTask;
				try
				{
					return readWriteTask2._stream.Read(readWriteTask2._buffer, readWriteTask2._offset, readWriteTask2._count);
				}
				finally
				{
					if (!readWriteTask2._apm)
					{
						readWriteTask2._stream.FinishTrackingAsyncOperation(readWriteTask2);
					}
					readWriteTask2.ClearBeginState();
				}
			}, state, this, buffer, offset, count, callback);
			if (task != null)
			{
				RunReadWriteTaskWhenReady(task, readWriteTask);
			}
			else
			{
				RunReadWriteTask(readWriteTask);
			}
			return readWriteTask;
		}

		public virtual int EndRead(IAsyncResult asyncResult)
		{
			if (asyncResult == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.asyncResult);
			}
			ReadWriteTask readWriteTask = asyncResult as ReadWriteTask;
			if (readWriteTask == null || !readWriteTask._isRead)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.InvalidOperation_WrongAsyncResultOrEndCalledMultiple);
			}
			else if (readWriteTask._endCalled)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_WrongAsyncResultOrEndCalledMultiple);
			}
			try
			{
				return readWriteTask.GetAwaiter().GetResult();
			}
			finally
			{
				FinishTrackingAsyncOperation(readWriteTask);
			}
		}

		public Task<int> ReadAsync(byte[] buffer, int offset, int count)
		{
			return ReadAsync(buffer, offset, count, CancellationToken.None);
		}

		public virtual Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				return BeginEndReadAsync(buffer, offset, count);
			}
			return Task.FromCanceled<int>(cancellationToken);
		}

		public virtual ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (MemoryMarshal.TryGetArray((ReadOnlyMemory<byte>)buffer, out ArraySegment<byte> segment))
			{
				return new ValueTask<int>(ReadAsync(segment.Array, segment.Offset, segment.Count, cancellationToken));
			}
			byte[] array = ArrayPool<byte>.Shared.Rent(buffer.Length);
			return FinishReadAsync(ReadAsync(array, 0, buffer.Length, cancellationToken), array, buffer);
			static async ValueTask<int> FinishReadAsync(Task<int> readTask, byte[] localBuffer, Memory<byte> localDestination)
			{
				try
				{
					int num = await readTask.ConfigureAwait(continueOnCapturedContext: false);
					new ReadOnlySpan<byte>(localBuffer, 0, num).CopyTo(localDestination.Span);
					return num;
				}
				finally
				{
					ArrayPool<byte>.Shared.Return(localBuffer);
				}
			}
		}

		private Task<int> BeginEndReadAsync(byte[] buffer, int offset, int count)
		{
			if (!HasOverriddenBeginEndRead())
			{
				return BeginReadInternal(buffer, offset, count, null, null, serializeAsynchronously: true, apm: false);
			}
			return TaskFactory<int>.FromAsyncTrim(this, new ReadWriteParameters
			{
				Buffer = buffer,
				Offset = offset,
				Count = count
			}, (Stream stream, ReadWriteParameters args, AsyncCallback callback, object state) => stream.BeginRead(args.Buffer, args.Offset, args.Count, callback, state), (Stream stream, IAsyncResult asyncResult) => stream.EndRead(asyncResult));
		}

		public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
		{
			return BeginWriteInternal(buffer, offset, count, callback, state, serializeAsynchronously: false, apm: true);
		}

		internal Task BeginWriteInternal(byte[] buffer, int offset, int count, AsyncCallback callback, object state, bool serializeAsynchronously, bool apm)
		{
			ValidateBufferArguments(buffer, offset, count);
			if (!CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
			SemaphoreSlim semaphoreSlim = EnsureAsyncActiveSemaphoreInitialized();
			Task task = null;
			if (serializeAsynchronously)
			{
				task = semaphoreSlim.WaitAsync();
			}
			else
			{
				semaphoreSlim.Wait();
			}
			ReadWriteTask readWriteTask = new ReadWriteTask(isRead: false, apm, delegate
			{
				ReadWriteTask readWriteTask2 = Task.InternalCurrent as ReadWriteTask;
				try
				{
					readWriteTask2._stream.Write(readWriteTask2._buffer, readWriteTask2._offset, readWriteTask2._count);
					return 0;
				}
				finally
				{
					if (!readWriteTask2._apm)
					{
						readWriteTask2._stream.FinishTrackingAsyncOperation(readWriteTask2);
					}
					readWriteTask2.ClearBeginState();
				}
			}, state, this, buffer, offset, count, callback);
			if (task != null)
			{
				RunReadWriteTaskWhenReady(task, readWriteTask);
			}
			else
			{
				RunReadWriteTask(readWriteTask);
			}
			return readWriteTask;
		}

		private static void RunReadWriteTaskWhenReady(Task asyncWaiter, ReadWriteTask readWriteTask)
		{
			if (asyncWaiter.IsCompleted)
			{
				RunReadWriteTask(readWriteTask);
				return;
			}
			asyncWaiter.ContinueWith(delegate(Task t, object state)
			{
				ReadWriteTask readWriteTask2 = (ReadWriteTask)state;
				RunReadWriteTask(readWriteTask2);
			}, readWriteTask, default(CancellationToken), TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
		}

		private static void RunReadWriteTask(ReadWriteTask readWriteTask)
		{
			readWriteTask.m_taskScheduler = TaskScheduler.Default;
			readWriteTask.ScheduleAndStart(needsProtection: false);
		}

		private void FinishTrackingAsyncOperation(ReadWriteTask task)
		{
			task._endCalled = true;
			_asyncActiveSemaphore.Release();
		}

		public virtual void EndWrite(IAsyncResult asyncResult)
		{
			if (asyncResult == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.asyncResult);
			}
			ReadWriteTask readWriteTask = asyncResult as ReadWriteTask;
			if (readWriteTask == null || readWriteTask._isRead)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.InvalidOperation_WrongAsyncResultOrEndCalledMultiple);
			}
			else if (readWriteTask._endCalled)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_WrongAsyncResultOrEndCalledMultiple);
			}
			try
			{
				readWriteTask.GetAwaiter().GetResult();
			}
			finally
			{
				FinishTrackingAsyncOperation(readWriteTask);
			}
		}

		public Task WriteAsync(byte[] buffer, int offset, int count)
		{
			return WriteAsync(buffer, offset, count, CancellationToken.None);
		}

		public virtual Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				return BeginEndWriteAsync(buffer, offset, count);
			}
			return Task.FromCanceled(cancellationToken);
		}

		public virtual ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (MemoryMarshal.TryGetArray(buffer, out var segment))
			{
				return new ValueTask(WriteAsync(segment.Array, segment.Offset, segment.Count, cancellationToken));
			}
			byte[] array = ArrayPool<byte>.Shared.Rent(buffer.Length);
			buffer.Span.CopyTo(array);
			return new ValueTask(FinishWriteAsync(WriteAsync(array, 0, buffer.Length, cancellationToken), array));
		}

		private static async Task FinishWriteAsync(Task writeTask, byte[] localBuffer)
		{
			try
			{
				await writeTask.ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				ArrayPool<byte>.Shared.Return(localBuffer);
			}
		}

		private Task BeginEndWriteAsync(byte[] buffer, int offset, int count)
		{
			if (!HasOverriddenBeginEndWrite())
			{
				return BeginWriteInternal(buffer, offset, count, null, null, serializeAsynchronously: true, apm: false);
			}
			return TaskFactory<VoidTaskResult>.FromAsyncTrim(this, new ReadWriteParameters
			{
				Buffer = buffer,
				Offset = offset,
				Count = count
			}, (Stream stream, ReadWriteParameters args, AsyncCallback callback, object state) => stream.BeginWrite(args.Buffer, args.Offset, args.Count, callback, state), delegate(Stream stream, IAsyncResult asyncResult)
			{
				stream.EndWrite(asyncResult);
				return default(VoidTaskResult);
			});
		}

		public abstract long Seek(long offset, SeekOrigin origin);

		public abstract void SetLength(long value);

		public abstract int Read(byte[] buffer, int offset, int count);

		public virtual int Read(Span<byte> buffer)
		{
			byte[] array = ArrayPool<byte>.Shared.Rent(buffer.Length);
			try
			{
				int num = Read(array, 0, buffer.Length);
				if ((uint)num > (uint)buffer.Length)
				{
					throw new IOException(SR.IO_StreamTooLong);
				}
				new ReadOnlySpan<byte>(array, 0, num).CopyTo(buffer);
				return num;
			}
			finally
			{
				ArrayPool<byte>.Shared.Return(array);
			}
		}

		public virtual int ReadByte()
		{
			byte[] array = new byte[1];
			if (Read(array, 0, 1) != 0)
			{
				return array[0];
			}
			return -1;
		}

		public abstract void Write(byte[] buffer, int offset, int count);

		public virtual void Write(ReadOnlySpan<byte> buffer)
		{
			byte[] array = ArrayPool<byte>.Shared.Rent(buffer.Length);
			try
			{
				buffer.CopyTo(array);
				Write(array, 0, buffer.Length);
			}
			finally
			{
				ArrayPool<byte>.Shared.Return(array);
			}
		}

		public virtual void WriteByte(byte value)
		{
			Write(new byte[1] { value }, 0, 1);
		}

		public static Stream Synchronized(Stream stream)
		{
			if (stream != null)
			{
				if (!(stream is SyncStream))
				{
					return new SyncStream(stream);
				}
				return stream;
			}
			throw new ArgumentNullException("stream");
		}

		[Obsolete("Do not call or override this method.")]
		protected virtual void ObjectInvariant()
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected static void ValidateBufferArguments(byte[] buffer, int offset, int count)
		{
			if (buffer == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.buffer);
			}
			if (offset < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.offset, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if ((uint)count > buffer.Length - offset)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.Argument_InvalidOffLen);
			}
		}

		protected static void ValidateCopyToArguments(Stream destination, int bufferSize)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			if (bufferSize <= 0)
			{
				throw new ArgumentOutOfRangeException("bufferSize", bufferSize, SR.ArgumentOutOfRange_NeedPosNum);
			}
			if (!destination.CanWrite)
			{
				if (destination.CanRead)
				{
					ThrowHelper.ThrowNotSupportedException_UnwritableStream();
				}
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(destination.GetType().Name);
			}
		}
	}
	public class BinaryReader : IDisposable
	{
		private readonly Stream _stream;

		private readonly byte[] _buffer;

		private readonly Decoder _decoder;

		private byte[] _charBytes;

		private char[] _charBuffer;

		private readonly int _maxCharsSize;

		private readonly bool _2BytesPerChar;

		private readonly bool _isMemoryStream;

		private readonly bool _leaveOpen;

		private bool _disposed;

		public virtual Stream BaseStream => _stream;

		public BinaryReader(Stream input)
			: this(input, Encoding.UTF8, leaveOpen: false)
		{
		}

		public BinaryReader(Stream input, Encoding encoding)
			: this(input, encoding, leaveOpen: false)
		{
		}

		public BinaryReader(Stream input, Encoding encoding, bool leaveOpen)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (!input.CanRead)
			{
				throw new ArgumentException(SR.Argument_StreamNotReadable);
			}
			_stream = input;
			_decoder = encoding.GetDecoder();
			_maxCharsSize = encoding.GetMaxCharCount(128);
			int num = encoding.GetMaxByteCount(1);
			if (num < 16)
			{
				num = 16;
			}
			_buffer = new byte[num];
			_2BytesPerChar = encoding is UnicodeEncoding;
			_isMemoryStream = _stream.GetType() == typeof(MemoryStream);
			_leaveOpen = leaveOpen;
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				if (disposing && !_leaveOpen)
				{
					_stream.Close();
				}
				_disposed = true;
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
		}

		public virtual void Close()
		{
			Dispose(disposing: true);
		}

		private void ThrowIfDisposed()
		{
			if (_disposed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
		}

		public virtual int PeekChar()
		{
			ThrowIfDisposed();
			if (!_stream.CanSeek)
			{
				return -1;
			}
			long position = _stream.Position;
			int result = Read();
			_stream.Position = position;
			return result;
		}

		public virtual int Read()
		{
			ThrowIfDisposed();
			int num = 0;
			long num2 = 0L;
			if (_stream.CanSeek)
			{
				num2 = _stream.Position;
			}
			if (_charBytes == null)
			{
				_charBytes = new byte[128];
			}
			Span<char> chars = stackalloc char[1];
			while (num == 0)
			{
				int num3 = ((!_2BytesPerChar) ? 1 : 2);
				int num4 = _stream.ReadByte();
				_charBytes[0] = (byte)num4;
				if (num4 == -1)
				{
					num3 = 0;
				}
				if (num3 == 2)
				{
					num4 = _stream.ReadByte();
					_charBytes[1] = (byte)num4;
					if (num4 == -1)
					{
						num3 = 1;
					}
				}
				if (num3 == 0)
				{
					return -1;
				}
				try
				{
					num = _decoder.GetChars(new ReadOnlySpan<byte>(_charBytes, 0, num3), chars, flush: false);
				}
				catch
				{
					if (_stream.CanSeek)
					{
						_stream.Seek(num2 - _stream.Position, SeekOrigin.Current);
					}
					throw;
				}
			}
			return chars[0];
		}

		public virtual byte ReadByte()
		{
			return InternalReadByte();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private byte InternalReadByte()
		{
			ThrowIfDisposed();
			int num = _stream.ReadByte();
			if (num == -1)
			{
				ThrowHelper.ThrowEndOfFileException();
			}
			return (byte)num;
		}

		[CLSCompliant(false)]
		public virtual sbyte ReadSByte()
		{
			return (sbyte)InternalReadByte();
		}

		public virtual bool ReadBoolean()
		{
			return InternalReadByte() != 0;
		}

		public virtual char ReadChar()
		{
			int num = Read();
			if (num == -1)
			{
				ThrowHelper.ThrowEndOfFileException();
			}
			return (char)num;
		}

		public virtual short ReadInt16()
		{
			return BinaryPrimitives.ReadInt16LittleEndian(InternalRead(2));
		}

		[CLSCompliant(false)]
		public virtual ushort ReadUInt16()
		{
			return BinaryPrimitives.ReadUInt16LittleEndian(InternalRead(2));
		}

		public virtual int ReadInt32()
		{
			return BinaryPrimitives.ReadInt32LittleEndian(InternalRead(4));
		}

		[CLSCompliant(false)]
		public virtual uint ReadUInt32()
		{
			return BinaryPrimitives.ReadUInt32LittleEndian(InternalRead(4));
		}

		public virtual long ReadInt64()
		{
			return BinaryPrimitives.ReadInt64LittleEndian(InternalRead(8));
		}

		[CLSCompliant(false)]
		public virtual ulong ReadUInt64()
		{
			return BinaryPrimitives.ReadUInt64LittleEndian(InternalRead(8));
		}

		public virtual Half ReadHalf()
		{
			return BitConverter.Int16BitsToHalf(BinaryPrimitives.ReadInt16LittleEndian(InternalRead(2)));
		}

		public virtual float ReadSingle()
		{
			return BitConverter.Int32BitsToSingle(BinaryPrimitives.ReadInt32LittleEndian(InternalRead(4)));
		}

		public virtual double ReadDouble()
		{
			return BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(InternalRead(8)));
		}

		public virtual decimal ReadDecimal()
		{
			ReadOnlySpan<byte> span = InternalRead(16);
			try
			{
				return decimal.ToDecimal(span);
			}
			catch (ArgumentException innerException)
			{
				throw new IOException(SR.Arg_DecBitCtor, innerException);
			}
		}

		public virtual string ReadString()
		{
			ThrowIfDisposed();
			int num = 0;
			int num2 = Read7BitEncodedInt();
			if (num2 < 0)
			{
				throw new IOException(SR.Format(SR.IO_InvalidStringLen_Len, num2));
			}
			if (num2 == 0)
			{
				return string.Empty;
			}
			if (_charBytes == null)
			{
				_charBytes = new byte[128];
			}
			if (_charBuffer == null)
			{
				_charBuffer = new char[_maxCharsSize];
			}
			StringBuilder stringBuilder = null;
			do
			{
				int count = ((num2 - num > 128) ? 128 : (num2 - num));
				int num3 = _stream.Read(_charBytes, 0, count);
				if (num3 == 0)
				{
					ThrowHelper.ThrowEndOfFileException();
				}
				int chars = _decoder.GetChars(_charBytes, 0, num3, _charBuffer, 0);
				if (num == 0 && num3 == num2)
				{
					return new string(_charBuffer, 0, chars);
				}
				if (stringBuilder == null)
				{
					stringBuilder = StringBuilderCache.Acquire(Math.Min(num2, 360));
				}
				stringBuilder.Append(_charBuffer, 0, chars);
				num += num3;
			}
			while (num < num2);
			return StringBuilderCache.GetStringAndRelease(stringBuilder);
		}

		public virtual int Read(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			ThrowIfDisposed();
			return InternalReadChars(new Span<char>(buffer, index, count));
		}

		public virtual int Read(Span<char> buffer)
		{
			ThrowIfDisposed();
			return InternalReadChars(buffer);
		}

		private int InternalReadChars(Span<char> buffer)
		{
			int num = 0;
			while (!buffer.IsEmpty)
			{
				int num2 = buffer.Length;
				if (_2BytesPerChar)
				{
					num2 <<= 1;
				}
				if (num2 > 1 && (!(_decoder is DecoderNLS decoderNLS) || decoderNLS.HasState))
				{
					num2--;
					if (_2BytesPerChar && num2 > 2)
					{
						num2 -= 2;
					}
				}
				ReadOnlySpan<byte> bytes;
				if (_isMemoryStream)
				{
					MemoryStream memoryStream = (MemoryStream)_stream;
					int start = memoryStream.InternalGetPosition();
					num2 = memoryStream.InternalEmulateRead(num2);
					bytes = new ReadOnlySpan<byte>(memoryStream.InternalGetBuffer(), start, num2);
				}
				else
				{
					if (_charBytes == null)
					{
						_charBytes = new byte[128];
					}
					if (num2 > 128)
					{
						num2 = 128;
					}
					num2 = _stream.Read(_charBytes, 0, num2);
					bytes = new ReadOnlySpan<byte>(_charBytes, 0, num2);
				}
				if (bytes.IsEmpty)
				{
					break;
				}
				int chars = _decoder.GetChars(bytes, buffer, flush: false);
				buffer = buffer.Slice(chars);
				num += chars;
			}
			return num;
		}

		public virtual char[] ReadChars(int count)
		{
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			ThrowIfDisposed();
			if (count == 0)
			{
				return Array.Empty<char>();
			}
			char[] array = new char[count];
			int num = InternalReadChars(new Span<char>(array));
			if (num != count)
			{
				char[] array2 = new char[num];
				Buffer.BlockCopy(array, 0, array2, 0, 2 * num);
				array = array2;
			}
			return array;
		}

		public virtual int Read(byte[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			ThrowIfDisposed();
			return _stream.Read(buffer, index, count);
		}

		public virtual int Read(Span<byte> buffer)
		{
			ThrowIfDisposed();
			return _stream.Read(buffer);
		}

		public virtual byte[] ReadBytes(int count)
		{
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			ThrowIfDisposed();
			if (count == 0)
			{
				return Array.Empty<byte>();
			}
			byte[] array = new byte[count];
			int num = 0;
			do
			{
				int num2 = _stream.Read(array, num, count);
				if (num2 == 0)
				{
					break;
				}
				num += num2;
				count -= num2;
			}
			while (count > 0);
			if (num != array.Length)
			{
				byte[] array2 = new byte[num];
				Buffer.BlockCopy(array, 0, array2, 0, num);
				array = array2;
			}
			return array;
		}

		private ReadOnlySpan<byte> InternalRead(int numBytes)
		{
			if (_isMemoryStream)
			{
				return ((MemoryStream)_stream).InternalReadSpan(numBytes);
			}
			ThrowIfDisposed();
			int num = 0;
			do
			{
				int num2 = _stream.Read(_buffer, num, numBytes - num);
				if (num2 == 0)
				{
					ThrowHelper.ThrowEndOfFileException();
				}
				num += num2;
			}
			while (num < numBytes);
			return _buffer;
		}

		protected virtual void FillBuffer(int numBytes)
		{
			if (numBytes < 0 || numBytes > _buffer.Length)
			{
				throw new ArgumentOutOfRangeException("numBytes", SR.ArgumentOutOfRange_BinaryReaderFillBuffer);
			}
			int num = 0;
			int num2 = 0;
			ThrowIfDisposed();
			if (numBytes == 1)
			{
				num2 = _stream.ReadByte();
				if (num2 == -1)
				{
					ThrowHelper.ThrowEndOfFileException();
				}
				_buffer[0] = (byte)num2;
				return;
			}
			do
			{
				num2 = _stream.Read(_buffer, num, numBytes - num);
				if (num2 == 0)
				{
					ThrowHelper.ThrowEndOfFileException();
				}
				num += num2;
			}
			while (num < numBytes);
		}

		public int Read7BitEncodedInt()
		{
			uint num = 0u;
			byte b;
			for (int i = 0; i < 28; i += 7)
			{
				b = ReadByte();
				num |= (uint)((b & 0x7F) << i);
				if ((uint)b <= 127u)
				{
					return (int)num;
				}
			}
			b = ReadByte();
			if ((uint)b > 15u)
			{
				throw new FormatException(SR.Format_Bad7BitInt);
			}
			return (int)num | (b << 28);
		}

		public long Read7BitEncodedInt64()
		{
			ulong num = 0uL;
			byte b;
			for (int i = 0; i < 63; i += 7)
			{
				b = ReadByte();
				num |= ((ulong)b & 0x7FuL) << i;
				if ((uint)b <= 127u)
				{
					return (long)num;
				}
			}
			b = ReadByte();
			if ((uint)b > 1u)
			{
				throw new FormatException(SR.Format_Bad7BitInt);
			}
			return (long)(num | ((ulong)b << 63));
		}
	}
	public class BinaryWriter : IDisposable, IAsyncDisposable
	{
		public static readonly BinaryWriter Null = new BinaryWriter();

		protected Stream OutStream;

		private readonly Encoding _encoding;

		private readonly bool _leaveOpen;

		private readonly bool _useFastUtf8;

		public virtual Stream BaseStream
		{
			get
			{
				Flush();
				return OutStream;
			}
		}

		protected BinaryWriter()
		{
			OutStream = Stream.Null;
			_encoding = Encoding.UTF8;
			_useFastUtf8 = true;
		}

		public BinaryWriter(Stream output)
			: this(output, Encoding.UTF8, leaveOpen: false)
		{
		}

		public BinaryWriter(Stream output, Encoding encoding)
			: this(output, encoding, leaveOpen: false)
		{
		}

		public BinaryWriter(Stream output, Encoding encoding, bool leaveOpen)
		{
			if (output == null)
			{
				throw new ArgumentNullException("output");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (!output.CanWrite)
			{
				throw new ArgumentException(SR.Argument_StreamNotWritable);
			}
			OutStream = output;
			_encoding = encoding;
			_leaveOpen = leaveOpen;
			_useFastUtf8 = encoding.IsUTF8CodePage && encoding.EncoderFallback.MaxCharCount <= 1;
		}

		public virtual void Close()
		{
			Dispose(disposing: true);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				if (_leaveOpen)
				{
					OutStream.Flush();
				}
				else
				{
					OutStream.Close();
				}
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
		}

		public virtual ValueTask DisposeAsync()
		{
			try
			{
				if (GetType() == typeof(BinaryWriter))
				{
					if (_leaveOpen)
					{
						return new ValueTask(OutStream.FlushAsync());
					}
					OutStream.Close();
				}
				else
				{
					Dispose();
				}
				return default(ValueTask);
			}
			catch (Exception exception)
			{
				return ValueTask.FromException(exception);
			}
		}

		public virtual void Flush()
		{
			OutStream.Flush();
		}

		public virtual long Seek(int offset, SeekOrigin origin)
		{
			return OutStream.Seek(offset, origin);
		}

		public virtual void Write(bool value)
		{
			OutStream.WriteByte((byte)(value ? 1u : 0u));
		}

		public virtual void Write(byte value)
		{
			OutStream.WriteByte(value);
		}

		[CLSCompliant(false)]
		public virtual void Write(sbyte value)
		{
			OutStream.WriteByte((byte)value);
		}

		public virtual void Write(byte[] buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			OutStream.Write(buffer, 0, buffer.Length);
		}

		public virtual void Write(byte[] buffer, int index, int count)
		{
			OutStream.Write(buffer, index, count);
		}

		public virtual void Write(char ch)
		{
			if (!Rune.TryCreate(ch, out var result))
			{
				throw new ArgumentException(SR.Arg_SurrogatesNotAllowedAsSingleChar);
			}
			Span<byte> span = stackalloc byte[8];
			if (_useFastUtf8)
			{
				int length = result.EncodeToUtf8(span);
				OutStream.Write(span.Slice(0, length));
				return;
			}
			byte[] array = null;
			int maxByteCount = _encoding.GetMaxByteCount(1);
			if (maxByteCount > span.Length)
			{
				array = ArrayPool<byte>.Shared.Rent(maxByteCount);
				span = array;
			}
			int bytes = _encoding.GetBytes(MemoryMarshal.CreateReadOnlySpan(ref ch, 1), span);
			OutStream.Write(span.Slice(0, bytes));
			if (array != null)
			{
				ArrayPool<byte>.Shared.Return(array);
			}
		}

		public virtual void Write(char[] chars)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars");
			}
			WriteCharsCommonWithoutLengthPrefix(chars, useThisWriteOverride: false);
		}

		public virtual void Write(char[] chars, int index, int count)
		{
			if (chars == null)
			{
				throw new ArgumentNullException("chars");
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (index > chars.Length - count)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_IndexCount);
			}
			WriteCharsCommonWithoutLengthPrefix(chars.AsSpan(index, count), useThisWriteOverride: false);
		}

		public virtual void Write(double value)
		{
			Span<byte> span = stackalloc byte[8];
			BinaryPrimitives.WriteDoubleLittleEndian(span, value);
			OutStream.Write(span);
		}

		public virtual void Write(decimal value)
		{
			Span<byte> span = stackalloc byte[16];
			decimal.GetBytes(in value, span);
			OutStream.Write(span);
		}

		public virtual void Write(short value)
		{
			Span<byte> span = stackalloc byte[2];
			BinaryPrimitives.WriteInt16LittleEndian(span, value);
			OutStream.Write(span);
		}

		[CLSCompliant(false)]
		public virtual void Write(ushort value)
		{
			Span<byte> span = stackalloc byte[2];
			BinaryPrimitives.WriteUInt16LittleEndian(span, value);
			OutStream.Write(span);
		}

		public virtual void Write(int value)
		{
			Span<byte> span = stackalloc byte[4];
			BinaryPrimitives.WriteInt32LittleEndian(span, value);
			OutStream.Write(span);
		}

		[CLSCompliant(false)]
		public virtual void Write(uint value)
		{
			Span<byte> span = stackalloc byte[4];
			BinaryPrimitives.WriteUInt32LittleEndian(span, value);
			OutStream.Write(span);
		}

		public virtual void Write(long value)
		{
			Span<byte> span = stackalloc byte[8];
			BinaryPrimitives.WriteInt64LittleEndian(span, value);
			OutStream.Write(span);
		}

		[CLSCompliant(false)]
		public virtual void Write(ulong value)
		{
			Span<byte> span = stackalloc byte[8];
			BinaryPrimitives.WriteUInt64LittleEndian(span, value);
			OutStream.Write(span);
		}

		public virtual void Write(float value)
		{
			Span<byte> span = stackalloc byte[4];
			BinaryPrimitives.WriteSingleLittleEndian(span, value);
			OutStream.Write(span);
		}

		public virtual void Write(Half value)
		{
			Span<byte> span = stackalloc byte[2];
			BinaryPrimitives.WriteHalfLittleEndian(span, value);
			OutStream.Write(span);
		}

		public virtual void Write(string value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (_useFastUtf8)
			{
				if (value.Length <= 42)
				{
					Span<byte> span = stackalloc byte[128];
					int bytes = _encoding.GetBytes(value, span.Slice(1));
					span[0] = (byte)bytes;
					OutStream.Write(span.Slice(0, bytes + 1));
					return;
				}
				if (value.Length <= 21845)
				{
					byte[] array = ArrayPool<byte>.Shared.Rent(value.Length * 3);
					int bytes2 = _encoding.GetBytes(value, array);
					Write7BitEncodedInt(bytes2);
					OutStream.Write(array, 0, bytes2);
					ArrayPool<byte>.Shared.Return(array);
					return;
				}
			}
			int byteCount = _encoding.GetByteCount(value);
			Write7BitEncodedInt(byteCount);
			WriteCharsCommonWithoutLengthPrefix(value, useThisWriteOverride: false);
		}

		public virtual void Write(ReadOnlySpan<byte> buffer)
		{
			if (GetType() == typeof(BinaryWriter))
			{
				OutStream.Write(buffer);
				return;
			}
			byte[] array = ArrayPool<byte>.Shared.Rent(buffer.Length);
			try
			{
				buffer.CopyTo(array);
				Write(array, 0, buffer.Length);
			}
			finally
			{
				ArrayPool<byte>.Shared.Return(array);
			}
		}

		public virtual void Write(ReadOnlySpan<char> chars)
		{
			WriteCharsCommonWithoutLengthPrefix(chars, useThisWriteOverride: true);
		}

		private void WriteCharsCommonWithoutLengthPrefix(ReadOnlySpan<char> chars, bool useThisWriteOverride)
		{
			byte[] array;
			if (chars.Length <= 65536)
			{
				int maxByteCount = _encoding.GetMaxByteCount(chars.Length);
				if (maxByteCount <= 65536)
				{
					array = ArrayPool<byte>.Shared.Rent(maxByteCount);
					int bytes = _encoding.GetBytes(chars, array);
					WriteToOutStream(array, 0, bytes, useThisWriteOverride);
					ArrayPool<byte>.Shared.Return(array);
					return;
				}
			}
			array = ArrayPool<byte>.Shared.Rent(65536);
			Encoder encoder = _encoding.GetEncoder();
			bool completed;
			do
			{
				encoder.Convert(chars, array, flush: true, out var charsUsed, out var bytesUsed, out completed);
				if (bytesUsed != 0)
				{
					WriteToOutStream(array, 0, bytesUsed, useThisWriteOverride);
				}
				chars = chars.Slice(charsUsed);
			}
			while (!completed);
			ArrayPool<byte>.Shared.Return(array);
			void WriteToOutStream(byte[] buffer, int offset, int count, bool useThisWriteOverride)
			{
				if (useThisWriteOverride)
				{
					Write(buffer, offset, count);
				}
				else
				{
					OutStream.Write(buffer, offset, count);
				}
			}
		}

		public void Write7BitEncodedInt(int value)
		{
			uint num;
			for (num = (uint)value; num > 127; num >>= 7)
			{
				Write((byte)(num | 0xFFFFFF80u));
			}
			Write((byte)num);
		}

		public void Write7BitEncodedInt64(long value)
		{
			ulong num;
			for (num = (ulong)value; num > 127; num >>= 7)
			{
				Write((byte)((uint)(int)num | 0xFFFFFF80u));
			}
			Write((byte)num);
		}
	}
	public sealed class BufferedStream : Stream
	{
		private Stream _stream;

		private byte[] _buffer;

		private readonly int _bufferSize;

		private int _readPos;

		private int _readLen;

		private int _writePos;

		private Task<int> _lastSyncCompletedReadTask;

		public Stream UnderlyingStream => _stream;

		public int BufferSize => _bufferSize;

		public override bool CanRead
		{
			get
			{
				if (_stream != null)
				{
					return _stream.CanRead;
				}
				return false;
			}
		}

		public override bool CanWrite
		{
			get
			{
				if (_stream != null)
				{
					return _stream.CanWrite;
				}
				return false;
			}
		}

		public override bool CanSeek
		{
			get
			{
				if (_stream != null)
				{
					return _stream.CanSeek;
				}
				return false;
			}
		}

		public override long Length
		{
			get
			{
				EnsureNotClosed();
				if (_writePos > 0)
				{
					FlushWrite();
				}
				return _stream.Length;
			}
		}

		public override long Position
		{
			get
			{
				EnsureNotClosed();
				EnsureCanSeek();
				return _stream.Position + (_readPos - _readLen + _writePos);
			}
			set
			{
				if (value < 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
				}
				Seek(value, SeekOrigin.Begin);
			}
		}

		public BufferedStream(Stream stream)
			: this(stream, 4096)
		{
		}

		public BufferedStream(Stream stream, int bufferSize)
		{
			if (stream == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stream);
			}
			if (bufferSize <= 0)
			{
				throw new ArgumentOutOfRangeException("bufferSize", SR.Format(SR.ArgumentOutOfRange_MustBePositive, "bufferSize"));
			}
			_stream = stream;
			_bufferSize = bufferSize;
			if (!_stream.CanRead && !_stream.CanWrite)
			{
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(null);
			}
		}

		private void EnsureNotClosed()
		{
			if (_stream == null)
			{
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(null);
			}
		}

		private void EnsureCanSeek()
		{
			if (!_stream.CanSeek)
			{
				ThrowHelper.ThrowNotSupportedException_UnseekableStream();
			}
		}

		private void EnsureCanRead()
		{
			if (!_stream.CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
		}

		private void EnsureCanWrite()
		{
			if (!_stream.CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
		}

		private void EnsureShadowBufferAllocated()
		{
			if (_buffer.Length == _bufferSize && _bufferSize < 81920)
			{
				byte[] array = new byte[Math.Min(_bufferSize + _bufferSize, 81920)];
				Buffer.BlockCopy(_buffer, 0, array, 0, _writePos);
				_buffer = array;
			}
		}

		private void EnsureBufferAllocated()
		{
			if (_buffer == null)
			{
				_buffer = new byte[_bufferSize];
			}
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing && _stream != null)
				{
					try
					{
						Flush();
						return;
					}
					finally
					{
						_stream.Dispose();
					}
				}
			}
			finally
			{
				_stream = null;
				_buffer = null;
				_writePos = 0;
				base.Dispose(disposing);
			}
		}

		public override async ValueTask DisposeAsync()
		{
			_ = 1;
			try
			{
				if (_stream != null)
				{
					try
					{
						await FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
					}
					finally
					{
						await _stream.DisposeAsync().ConfigureAwait(continueOnCapturedContext: false);
					}
				}
			}
			finally
			{
				_stream = null;
				_buffer = null;
				_writePos = 0;
			}
		}

		public override void Flush()
		{
			EnsureNotClosed();
			if (_writePos > 0)
			{
				FlushWrite();
			}
			else if (_readPos < _readLen)
			{
				if (_stream.CanSeek)
				{
					FlushRead();
				}
				if (_stream.CanWrite)
				{
					_stream.Flush();
				}
			}
			else
			{
				if (_stream.CanWrite)
				{
					_stream.Flush();
				}
				_writePos = (_readPos = (_readLen = 0));
			}
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<int>(cancellationToken);
			}
			EnsureNotClosed();
			return FlushAsyncInternal(cancellationToken);
		}

		private async Task FlushAsyncInternal(CancellationToken cancellationToken)
		{
			await EnsureAsyncActiveSemaphoreInitialized().WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				if (_writePos > 0)
				{
					await FlushWriteAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
				else if (_readPos < _readLen)
				{
					if (_stream.CanSeek)
					{
						FlushRead();
					}
					if (_stream.CanWrite)
					{
						await _stream.FlushAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					}
				}
				else if (_stream.CanWrite)
				{
					await _stream.FlushAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			finally
			{
				_asyncActiveSemaphore.Release();
			}
		}

		private void FlushRead()
		{
			if (_readPos - _readLen != 0)
			{
				_stream.Seek(_readPos - _readLen, SeekOrigin.Current);
			}
			_readPos = 0;
			_readLen = 0;
		}

		private void ClearReadBufferBeforeWrite()
		{
			if (_readPos == _readLen)
			{
				_readPos = (_readLen = 0);
				return;
			}
			if (!_stream.CanSeek)
			{
				throw new NotSupportedException(SR.NotSupported_CannotWriteToBufferedStreamIfReadBufferCannotBeFlushed);
			}
			FlushRead();
		}

		private void FlushWrite()
		{
			_stream.Write(_buffer, 0, _writePos);
			_writePos = 0;
			_stream.Flush();
		}

		private async ValueTask FlushWriteAsync(CancellationToken cancellationToken)
		{
			await _stream.WriteAsync(new ReadOnlyMemory<byte>(_buffer, 0, _writePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			_writePos = 0;
			await _stream.FlushAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}

		private int ReadFromBuffer(byte[] buffer, int offset, int count)
		{
			int num = _readLen - _readPos;
			if (num == 0)
			{
				return 0;
			}
			if (num > count)
			{
				num = count;
			}
			Buffer.BlockCopy(_buffer, _readPos, buffer, offset, num);
			_readPos += num;
			return num;
		}

		private int ReadFromBuffer(Span<byte> destination)
		{
			int num = Math.Min(_readLen - _readPos, destination.Length);
			if (num > 0)
			{
				new ReadOnlySpan<byte>(_buffer, _readPos, num).CopyTo(destination);
				_readPos += num;
			}
			return num;
		}

		private int ReadFromBuffer(byte[] buffer, int offset, int count, out Exception error)
		{
			try
			{
				error = null;
				return ReadFromBuffer(buffer, offset, count);
			}
			catch (Exception ex)
			{
				error = ex;
				return 0;
			}
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			EnsureNotClosed();
			EnsureCanRead();
			int num = ReadFromBuffer(buffer, offset, count);
			if (num == count)
			{
				return num;
			}
			int num2 = num;
			if (num > 0)
			{
				count -= num;
				offset += num;
			}
			_readPos = (_readLen = 0);
			if (_writePos > 0)
			{
				FlushWrite();
			}
			if (count >= _bufferSize)
			{
				return _stream.Read(buffer, offset, count) + num2;
			}
			EnsureBufferAllocated();
			_readLen = _stream.Read(_buffer, 0, _bufferSize);
			num = ReadFromBuffer(buffer, offset, count);
			return num + num2;
		}

		public override int Read(Span<byte> destination)
		{
			EnsureNotClosed();
			EnsureCanRead();
			int num = ReadFromBuffer(destination);
			if (num == destination.Length)
			{
				return num;
			}
			if (num > 0)
			{
				destination = destination.Slice(num);
			}
			_readPos = (_readLen = 0);
			if (_writePos > 0)
			{
				FlushWrite();
			}
			if (destination.Length >= _bufferSize)
			{
				return _stream.Read(destination) + num;
			}
			EnsureBufferAllocated();
			_readLen = _stream.Read(_buffer, 0, _bufferSize);
			return ReadFromBuffer(destination) + num;
		}

		private Task<int> LastSyncCompletedReadTask(int val)
		{
			Task<int> lastSyncCompletedReadTask = _lastSyncCompletedReadTask;
			if (lastSyncCompletedReadTask != null && lastSyncCompletedReadTask.Result == val)
			{
				return lastSyncCompletedReadTask;
			}
			return _lastSyncCompletedReadTask = Task.FromResult(val);
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<int>(cancellationToken);
			}
			EnsureNotClosed();
			EnsureCanRead();
			int num = 0;
			SemaphoreSlim semaphoreSlim = EnsureAsyncActiveSemaphoreInitialized();
			Task task = semaphoreSlim.WaitAsync(cancellationToken);
			if (task.IsCompletedSuccessfully)
			{
				bool flag = true;
				try
				{
					num = ReadFromBuffer(buffer, offset, count, out var error);
					flag = num == count || error != null;
					if (flag)
					{
						return (error == null) ? LastSyncCompletedReadTask(num) : Task.FromException<int>(error);
					}
				}
				finally
				{
					if (flag)
					{
						semaphoreSlim.Release();
					}
				}
			}
			return ReadFromUnderlyingStreamAsync(new Memory<byte>(buffer, offset + num, count - num), cancellationToken, num, task).AsTask();
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			EnsureNotClosed();
			EnsureCanRead();
			int num = 0;
			SemaphoreSlim semaphoreSlim = EnsureAsyncActiveSemaphoreInitialized();
			Task task = semaphoreSlim.WaitAsync(cancellationToken);
			if (task.IsCompletedSuccessfully)
			{
				bool flag = true;
				try
				{
					num = ReadFromBuffer(buffer.Span);
					flag = num == buffer.Length;
					if (flag)
					{
						return new ValueTask<int>(num);
					}
				}
				finally
				{
					if (flag)
					{
						semaphoreSlim.Release();
					}
				}
			}
			return ReadFromUnderlyingStreamAsync(buffer.Slice(num), cancellationToken, num, task);
		}

		private async ValueTask<int> ReadFromUnderlyingStreamAsync(Memory<byte> buffer, CancellationToken cancellationToken, int bytesAlreadySatisfied, Task semaphoreLockTask)
		{
			await semaphoreLockTask.ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				int num = ReadFromBuffer(buffer.Span);
				if (num == buffer.Length)
				{
					return bytesAlreadySatisfied + num;
				}
				if (num > 0)
				{
					buffer = buffer.Slice(num);
					bytesAlreadySatisfied += num;
				}
				_readPos = (_readLen = 0);
				if (_writePos > 0)
				{
					await FlushWriteAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
				if (buffer.Length >= _bufferSize)
				{
					return await _stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(continueOnCapturedContext: false) + bytesAlreadySatisfied;
				}
				EnsureBufferAllocated();
				_readLen = await _stream.ReadAsync(new Memory<byte>(_buffer, 0, _bufferSize), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				num = ReadFromBuffer(buffer.Span);
				return bytesAlreadySatisfied + num;
			}
			finally
			{
				_asyncActiveSemaphore.Release();
			}
		}

		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
		{
			return TaskToApm.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state);
		}

		public override int EndRead(IAsyncResult asyncResult)
		{
			return TaskToApm.End<int>(asyncResult);
		}

		public override int ReadByte()
		{
			if (_readPos == _readLen)
			{
				return ReadByteSlow();
			}
			return _buffer[_readPos++];
		}

		private int ReadByteSlow()
		{
			EnsureNotClosed();
			EnsureCanRead();
			if (_writePos > 0)
			{
				FlushWrite();
			}
			EnsureBufferAllocated();
			_readLen = _stream.Read(_buffer, 0, _bufferSize);
			_readPos = 0;
			if (_readLen == 0)
			{
				return -1;
			}
			return _buffer[_readPos++];
		}

		private void WriteToBuffer(byte[] buffer, ref int offset, ref int count)
		{
			int num = Math.Min(_bufferSize - _writePos, count);
			if (num > 0)
			{
				EnsureBufferAllocated();
				Buffer.BlockCopy(buffer, offset, _buffer, _writePos, num);
				_writePos += num;
				count -= num;
				offset += num;
			}
		}

		private int WriteToBuffer(ReadOnlySpan<byte> buffer)
		{
			int num = Math.Min(_bufferSize - _writePos, buffer.Length);
			if (num > 0)
			{
				EnsureBufferAllocated();
				buffer.Slice(0, num).CopyTo(new Span<byte>(_buffer, _writePos, num));
				_writePos += num;
			}
			return num;
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			EnsureNotClosed();
			EnsureCanWrite();
			if (_writePos == 0)
			{
				ClearReadBufferBeforeWrite();
			}
			int num;
			checked
			{
				num = _writePos + count;
				if ((uint)num + count < _bufferSize + _bufferSize)
				{
					WriteToBuffer(buffer, ref offset, ref count);
					if (_writePos >= _bufferSize)
					{
						_stream.Write(_buffer, 0, _writePos);
						_writePos = 0;
						WriteToBuffer(buffer, ref offset, ref count);
					}
					return;
				}
			}
			if (_writePos > 0)
			{
				if (num <= _bufferSize + _bufferSize && num <= 81920)
				{
					EnsureShadowBufferAllocated();
					Buffer.BlockCopy(buffer, offset, _buffer, _writePos, count);
					_stream.Write(_buffer, 0, num);
					_writePos = 0;
					return;
				}
				_stream.Write(_buffer, 0, _writePos);
				_writePos = 0;
			}
			_stream.Write(buffer, offset, count);
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			EnsureNotClosed();
			EnsureCanWrite();
			if (_writePos == 0)
			{
				ClearReadBufferBeforeWrite();
			}
			int num;
			checked
			{
				num = _writePos + buffer.Length;
				if ((uint)num + buffer.Length < _bufferSize + _bufferSize)
				{
					int start = WriteToBuffer(buffer);
					if (_writePos >= _bufferSize)
					{
						buffer = buffer.Slice(start);
						_stream.Write(_buffer, 0, _writePos);
						_writePos = 0;
						start = WriteToBuffer(buffer);
					}
					return;
				}
			}
			if (_writePos > 0)
			{
				if (num <= _bufferSize + _bufferSize && num <= 81920)
				{
					EnsureShadowBufferAllocated();
					buffer.CopyTo(new Span<byte>(_buffer, _writePos, buffer.Length));
					_stream.Write(_buffer, 0, num);
					_writePos = 0;
					return;
				}
				_stream.Write(_buffer, 0, _writePos);
				_writePos = 0;
			}
			_stream.Write(buffer);
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			return WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled(cancellationToken);
			}
			EnsureNotClosed();
			EnsureCanWrite();
			SemaphoreSlim semaphoreSlim = EnsureAsyncActiveSemaphoreInitialized();
			Task task = semaphoreSlim.WaitAsync(cancellationToken);
			if (task.IsCompletedSuccessfully)
			{
				bool flag = true;
				try
				{
					if (_writePos == 0)
					{
						ClearReadBufferBeforeWrite();
					}
					flag = buffer.Length < _bufferSize - _writePos;
					if (flag)
					{
						int num = WriteToBuffer(buffer.Span);
						return default(ValueTask);
					}
				}
				finally
				{
					if (flag)
					{
						semaphoreSlim.Release();
					}
				}
			}
			return WriteToUnderlyingStreamAsync(buffer, cancellationToken, task);
		}

		private async ValueTask WriteToUnderlyingStreamAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken, Task semaphoreLockTask)
		{
			await semaphoreLockTask.ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				if (_writePos == 0)
				{
					ClearReadBufferBeforeWrite();
				}
				int num;
				checked
				{
					num = _writePos + buffer.Length;
					if (num + buffer.Length < _bufferSize + _bufferSize)
					{
						buffer = buffer.Slice(WriteToBuffer(buffer.Span));
						if (_writePos >= _bufferSize)
						{
							await _stream.WriteAsync(new ReadOnlyMemory<byte>(_buffer, 0, _writePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
							_writePos = 0;
							WriteToBuffer(buffer.Span);
						}
						return;
					}
				}
				if (_writePos > 0)
				{
					if (num <= _bufferSize + _bufferSize && num <= 81920)
					{
						EnsureShadowBufferAllocated();
						buffer.Span.CopyTo(new Span<byte>(_buffer, _writePos, buffer.Length));
						await _stream.WriteAsync(new ReadOnlyMemory<byte>(_buffer, 0, num), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
						_writePos = 0;
						return;
					}
					await _stream.WriteAsync(new ReadOnlyMemory<byte>(_buffer, 0, _writePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					_writePos = 0;
				}
				await _stream.WriteAsync(buffer, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				_asyncActiveSemaphore.Release();
			}
		}

		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
		{
			return TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);
		}

		public override void EndWrite(IAsyncResult asyncResult)
		{
			TaskToApm.End(asyncResult);
		}

		public override void WriteByte(byte value)
		{
			if (_writePos > 0 && _writePos < _bufferSize - 1)
			{
				_buffer[_writePos++] = value;
			}
			else
			{
				WriteByteSlow(value);
			}
		}

		private void WriteByteSlow(byte value)
		{
			EnsureNotClosed();
			if (_writePos == 0)
			{
				EnsureCanWrite();
				ClearReadBufferBeforeWrite();
				EnsureBufferAllocated();
			}
			if (_writePos >= _bufferSize - 1)
			{
				FlushWrite();
			}
			_buffer[_writePos++] = value;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			EnsureNotClosed();
			EnsureCanSeek();
			if (_writePos > 0)
			{
				FlushWrite();
				return _stream.Seek(offset, origin);
			}
			if (_readLen - _readPos > 0 && origin == SeekOrigin.Current)
			{
				offset -= _readLen - _readPos;
			}
			long position = Position;
			long num = _stream.Seek(offset, origin);
			long num2 = num - (position - _readPos);
			if (0 <= num2 && num2 < _readLen)
			{
				_readPos = (int)num2;
				_stream.Seek(_readLen - _readPos, SeekOrigin.Current);
			}
			else
			{
				_readPos = (_readLen = 0);
			}
			return num;
		}

		public override void SetLength(long value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			EnsureNotClosed();
			EnsureCanSeek();
			EnsureCanWrite();
			Flush();
			_stream.SetLength(value);
		}

		public override void CopyTo(Stream destination, int bufferSize)
		{
			Stream.ValidateCopyToArguments(destination, bufferSize);
			EnsureNotClosed();
			EnsureCanRead();
			int num = _readLen - _readPos;
			if (num > 0)
			{
				destination.Write(_buffer, _readPos, num);
				_readPos = (_readLen = 0);
			}
			else if (_writePos > 0)
			{
				FlushWrite();
			}
			_stream.CopyTo(destination, bufferSize);
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			Stream.ValidateCopyToArguments(destination, bufferSize);
			EnsureNotClosed();
			EnsureCanRead();
			if (!cancellationToken.IsCancellationRequested)
			{
				return CopyToAsyncCore(destination, bufferSize, cancellationToken);
			}
			return Task.FromCanceled<int>(cancellationToken);
		}

		private async Task CopyToAsyncCore(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			await EnsureAsyncActiveSemaphoreInitialized().WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				int num = _readLen - _readPos;
				if (num > 0)
				{
					await destination.WriteAsync(new ReadOnlyMemory<byte>(_buffer, _readPos, num), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					_readPos = (_readLen = 0);
				}
				else if (_writePos > 0)
				{
					await FlushWriteAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
				await _stream.CopyToAsync(destination, bufferSize, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				_asyncActiveSemaphore.Release();
			}
		}
	}
	public static class Directory
	{
		public static DirectoryInfo? GetParent(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_PathEmpty, "path");
			}
			string fullPath = Path.GetFullPath(path);
			string directoryName = Path.GetDirectoryName(fullPath);
			if (directoryName == null)
			{
				return null;
			}
			return new DirectoryInfo(directoryName);
		}

		public static DirectoryInfo CreateDirectory(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_PathEmpty, "path");
			}
			string fullPath = Path.GetFullPath(path);
			FileSystem.CreateDirectory(fullPath);
			return new DirectoryInfo(path, fullPath, null, isNormalized: true);
		}

		public static bool Exists([NotNullWhen(true)] string? path)
		{
			try
			{
				if (path == null)
				{
					return false;
				}
				if (path.Length == 0)
				{
					return false;
				}
				string fullPath = Path.GetFullPath(path);
				return FileSystem.DirectoryExists(fullPath);
			}
			catch (ArgumentException)
			{
			}
			catch (IOException)
			{
			}
			catch (UnauthorizedAccessException)
			{
			}
			return false;
		}

		public static void SetCreationTime(string path, DateTime creationTime)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetCreationTime(fullPath, creationTime, asDirectory: true);
		}

		public static void SetCreationTimeUtc(string path, DateTime creationTimeUtc)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetCreationTime(fullPath, File.GetUtcDateTimeOffset(creationTimeUtc), asDirectory: true);
		}

		public static DateTime GetCreationTime(string path)
		{
			return File.GetCreationTime(path);
		}

		public static DateTime GetCreationTimeUtc(string path)
		{
			return File.GetCreationTimeUtc(path);
		}

		public static void SetLastWriteTime(string path, DateTime lastWriteTime)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetLastWriteTime(fullPath, lastWriteTime, asDirectory: true);
		}

		public static void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetLastWriteTime(fullPath, File.GetUtcDateTimeOffset(lastWriteTimeUtc), asDirectory: true);
		}

		public static DateTime GetLastWriteTime(string path)
		{
			return File.GetLastWriteTime(path);
		}

		public static DateTime GetLastWriteTimeUtc(string path)
		{
			return File.GetLastWriteTimeUtc(path);
		}

		public static void SetLastAccessTime(string path, DateTime lastAccessTime)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetLastAccessTime(fullPath, lastAccessTime, asDirectory: true);
		}

		public static void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetLastAccessTime(fullPath, File.GetUtcDateTimeOffset(lastAccessTimeUtc), asDirectory: true);
		}

		public static DateTime GetLastAccessTime(string path)
		{
			return File.GetLastAccessTime(path);
		}

		public static DateTime GetLastAccessTimeUtc(string path)
		{
			return File.GetLastAccessTimeUtc(path);
		}

		public static string[] GetFiles(string path)
		{
			return GetFiles(path, "*", EnumerationOptions.Compatible);
		}

		public static string[] GetFiles(string path, string searchPattern)
		{
			return GetFiles(path, searchPattern, EnumerationOptions.Compatible);
		}

		public static string[] GetFiles(string path, string searchPattern, SearchOption searchOption)
		{
			return GetFiles(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public static string[] GetFiles(string path, string searchPattern, EnumerationOptions enumerationOptions)
		{
			return new List<string>(InternalEnumeratePaths(path, searchPattern, SearchTarget.Files, enumerationOptions)).ToArray();
		}

		public static string[] GetDirectories(string path)
		{
			return GetDirectories(path, "*", EnumerationOptions.Compatible);
		}

		public static string[] GetDirectories(string path, string searchPattern)
		{
			return GetDirectories(path, searchPattern, EnumerationOptions.Compatible);
		}

		public static string[] GetDirectories(string path, string searchPattern, SearchOption searchOption)
		{
			return GetDirectories(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public static string[] GetDirectories(string path, string searchPattern, EnumerationOptions enumerationOptions)
		{
			return new List<string>(InternalEnumeratePaths(path, searchPattern, SearchTarget.Directories, enumerationOptions)).ToArray();
		}

		public static string[] GetFileSystemEntries(string path)
		{
			return GetFileSystemEntries(path, "*", EnumerationOptions.Compatible);
		}

		public static string[] GetFileSystemEntries(string path, string searchPattern)
		{
			return GetFileSystemEntries(path, searchPattern, EnumerationOptions.Compatible);
		}

		public static string[] GetFileSystemEntries(string path, string searchPattern, SearchOption searchOption)
		{
			return GetFileSystemEntries(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public static string[] GetFileSystemEntries(string path, string searchPattern, EnumerationOptions enumerationOptions)
		{
			return new List<string>(InternalEnumeratePaths(path, searchPattern, SearchTarget.Both, enumerationOptions)).ToArray();
		}

		internal static IEnumerable<string> InternalEnumeratePaths(string path, string searchPattern, SearchTarget searchTarget, EnumerationOptions options)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (searchPattern == null)
			{
				throw new ArgumentNullException("searchPattern");
			}
			FileSystemEnumerableFactory.NormalizeInputs(ref path, ref searchPattern, options.MatchType);
			return searchTarget switch
			{
				SearchTarget.Files => FileSystemEnumerableFactory.UserFiles(path, searchPattern, options), 
				SearchTarget.Directories => FileSystemEnumerableFactory.UserDirectories(path, searchPattern, options), 
				SearchTarget.Both => FileSystemEnumerableFactory.UserEntries(path, searchPattern, options), 
				_ => throw new ArgumentOutOfRangeException("searchTarget"), 
			};
		}

		public static IEnumerable<string> EnumerateDirectories(string path)
		{
			return EnumerateDirectories(path, "*", EnumerationOptions.Compatible);
		}

		public static IEnumerable<string> EnumerateDirectories(string path, string searchPattern)
		{
			return EnumerateDirectories(path, searchPattern, EnumerationOptions.Compatible);
		}

		public static IEnumerable<string> EnumerateDirectories(string path, string searchPattern, SearchOption searchOption)
		{
			return EnumerateDirectories(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public static IEnumerable<string> EnumerateDirectories(string path, string searchPattern, EnumerationOptions enumerationOptions)
		{
			return InternalEnumeratePaths(path, searchPattern, SearchTarget.Directories, enumerationOptions);
		}

		public static IEnumerable<string> EnumerateFiles(string path)
		{
			return EnumerateFiles(path, "*", EnumerationOptions.Compatible);
		}

		public static IEnumerable<string> EnumerateFiles(string path, string searchPattern)
		{
			return EnumerateFiles(path, searchPattern, EnumerationOptions.Compatible);
		}

		public static IEnumerable<string> EnumerateFiles(string path, string searchPattern, SearchOption searchOption)
		{
			return EnumerateFiles(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public static IEnumerable<string> EnumerateFiles(string path, string searchPattern, EnumerationOptions enumerationOptions)
		{
			return InternalEnumeratePaths(path, searchPattern, SearchTarget.Files, enumerationOptions);
		}

		public static IEnumerable<string> EnumerateFileSystemEntries(string path)
		{
			return EnumerateFileSystemEntries(path, "*", EnumerationOptions.Compatible);
		}

		public static IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern)
		{
			return EnumerateFileSystemEntries(path, searchPattern, EnumerationOptions.Compatible);
		}

		public static IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, SearchOption searchOption)
		{
			return EnumerateFileSystemEntries(path, searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public static IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, EnumerationOptions enumerationOptions)
		{
			return InternalEnumeratePaths(path, searchPattern, SearchTarget.Both, enumerationOptions);
		}

		public static string GetDirectoryRoot(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			string fullPath = Path.GetFullPath(path);
			return Path.GetPathRoot(fullPath);
		}

		public static string GetCurrentDirectory()
		{
			return Environment.CurrentDirectory;
		}

		public static void SetCurrentDirectory(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_PathEmpty, "path");
			}
			Environment.CurrentDirectory = Path.GetFullPath(path);
		}

		public static void Move(string sourceDirName, string destDirName)
		{
			if (sourceDirName == null)
			{
				throw new ArgumentNullException("sourceDirName");
			}
			if (sourceDirName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "sourceDirName");
			}
			if (destDirName == null)
			{
				throw new ArgumentNullException("destDirName");
			}
			if (destDirName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "destDirName");
			}
			string fullPath = Path.GetFullPath(sourceDirName);
			string text = PathInternal.EnsureTrailingSeparator(fullPath);
			string fullPath2 = Path.GetFullPath(destDirName);
			string text2 = PathInternal.EnsureTrailingSeparator(fullPath2);
			ReadOnlySpan<char> fileName = Path.GetFileName(fullPath.AsSpan());
			ReadOnlySpan<char> fileName2 = Path.GetFileName(fullPath2.AsSpan());
			StringComparison stringComparison = PathInternal.StringComparison;
			bool flag = !fileName.SequenceEqual(fileName2) && MemoryExtensions.Equals(fileName, fileName2, StringComparison.OrdinalIgnoreCase) && MemoryExtensions.Equals(fileName2, fileName, stringComparison);
			if (!flag && string.Equals(text, text2, stringComparison))
			{
				throw new IOException(SR.IO_SourceDestMustBeDifferent);
			}
			ReadOnlySpan<char> pathRoot = Path.GetPathRoot(text.AsSpan());
			ReadOnlySpan<char> pathRoot2 = Path.GetPathRoot(text2.AsSpan());
			if (!MemoryExtensions.Equals(pathRoot, pathRoot2, StringComparison.OrdinalIgnoreCase))
			{
				throw new IOException(SR.IO_SourceDestMustHaveSameRoot);
			}
			if (!FileSystem.DirectoryExists(fullPath) && !FileSystem.FileExists(fullPath))
			{
				throw new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, fullPath));
			}
			if (!flag && FileSystem.DirectoryExists(fullPath2))
			{
				throw new IOException(SR.Format(SR.IO_AlreadyExists_Name, fullPath2));
			}
			if (!flag && Exists(fullPath2))
			{
				throw new IOException(SR.Format(SR.IO_AlreadyExists_Name, fullPath2));
			}
			FileSystem.MoveDirectory(fullPath, fullPath2);
		}

		public static void Delete(string path)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.RemoveDirectory(fullPath, recursive: false);
		}

		public static void Delete(string path, bool recursive)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.RemoveDirectory(fullPath, recursive);
		}

		public static string[] GetLogicalDrives()
		{
			return FileSystem.GetLogicalDrives();
		}

		public static FileSystemInfo CreateSymbolicLink(string path, string pathToTarget)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.VerifyValidPath(pathToTarget, "pathToTarget");
			FileSystem.CreateSymbolicLink(path, pathToTarget, isDirectory: true);
			return new DirectoryInfo(path, fullPath, null, isNormalized: true);
		}

		public static FileSystemInfo? ResolveLinkTarget(string linkPath, bool returnFinalTarget)
		{
			FileSystem.VerifyValidPath(linkPath, "linkPath");
			return FileSystem.ResolveLinkTarget(linkPath, returnFinalTarget, isDirectory: true);
		}
	}
	public sealed class DirectoryInfo : FileSystemInfo
	{
		private bool _isNormalized;

		public DirectoryInfo? Parent
		{
			get
			{
				string directoryName = Path.GetDirectoryName(PathInternal.IsRoot(FullPath.AsSpan()) ? FullPath : Path.TrimEndingDirectorySeparator(FullPath));
				if (directoryName == null)
				{
					return null;
				}
				return new DirectoryInfo(directoryName, null, null, isNormalized: true);
			}
		}

		public DirectoryInfo Root => new DirectoryInfo(Path.GetPathRoot(FullPath));

		public DirectoryInfo(string path)
		{
			Init(path, Path.GetFullPath(path), null, isNormalized: true);
		}

		internal DirectoryInfo(string originalPath, string fullPath = null, string fileName = null, bool isNormalized = false)
		{
			Init(originalPath, fullPath, fileName, isNormalized);
		}

		private void Init(string originalPath, string fullPath = null, string fileName = null, bool isNormalized = false)
		{
			OriginalPath = originalPath ?? throw new ArgumentNullException("originalPath");
			fullPath = fullPath ?? originalPath;
			fullPath = (isNormalized ? fullPath : Path.GetFullPath(fullPath));
			_name = fileName ?? (PathInternal.IsRoot(fullPath.AsSpan()) ? fullPath.AsSpan() : Path.GetFileName(Path.TrimEndingDirectorySeparator(fullPath.AsSpan()))).ToString();
			FullPath = fullPath;
			_isNormalized = isNormalized;
		}

		public DirectoryInfo CreateSubdirectory(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (PathInternal.IsEffectivelyEmpty(path.AsSpan()))
			{
				throw new ArgumentException(SR.Argument_PathEmpty, "path");
			}
			if (Path.IsPathRooted(path))
			{
				throw new ArgumentException(SR.Arg_Path2IsRooted, "path");
			}
			string fullPath = Path.GetFullPath(Path.Combine(FullPath, path));
			ReadOnlySpan<char> span = Path.TrimEndingDirectorySeparator(fullPath.AsSpan());
			ReadOnlySpan<char> value = Path.TrimEndingDirectorySeparator(FullPath.AsSpan());
			if (span.StartsWith(value, PathInternal.StringComparison) && (span.Length == value.Length || PathInternal.IsDirectorySeparator(fullPath[value.Length])))
			{
				FileSystem.CreateDirectory(fullPath);
				return new DirectoryInfo(fullPath);
			}
			throw new ArgumentException(SR.Format(SR.Argument_InvalidSubPath, path, FullPath), "path");
		}

		public void Create()
		{
			FileSystem.CreateDirectory(FullPath);
			Invalidate();
		}

		public FileInfo[] GetFiles()
		{
			return GetFiles("*", EnumerationOptions.Compatible);
		}

		public FileInfo[] GetFiles(string searchPattern)
		{
			return GetFiles(searchPattern, EnumerationOptions.Compatible);
		}

		public FileInfo[] GetFiles(string searchPattern, SearchOption searchOption)
		{
			return GetFiles(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public FileInfo[] GetFiles(string searchPattern, EnumerationOptions enumerationOptions)
		{
			return new List<FileInfo>((IEnumerable<FileInfo>)InternalEnumerateInfos(FullPath, searchPattern, SearchTarget.Files, enumerationOptions)).ToArray();
		}

		public FileSystemInfo[] GetFileSystemInfos()
		{
			return GetFileSystemInfos("*", EnumerationOptions.Compatible);
		}

		public FileSystemInfo[] GetFileSystemInfos(string searchPattern)
		{
			return GetFileSystemInfos(searchPattern, EnumerationOptions.Compatible);
		}

		public FileSystemInfo[] GetFileSystemInfos(string searchPattern, SearchOption searchOption)
		{
			return GetFileSystemInfos(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public FileSystemInfo[] GetFileSystemInfos(string searchPattern, EnumerationOptions enumerationOptions)
		{
			return new List<FileSystemInfo>(InternalEnumerateInfos(FullPath, searchPattern, SearchTarget.Both, enumerationOptions)).ToArray();
		}

		public DirectoryInfo[] GetDirectories()
		{
			return GetDirectories("*", EnumerationOptions.Compatible);
		}

		public DirectoryInfo[] GetDirectories(string searchPattern)
		{
			return GetDirectories(searchPattern, EnumerationOptions.Compatible);
		}

		public DirectoryInfo[] GetDirectories(string searchPattern, SearchOption searchOption)
		{
			return GetDirectories(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public DirectoryInfo[] GetDirectories(string searchPattern, EnumerationOptions enumerationOptions)
		{
			return new List<DirectoryInfo>((IEnumerable<DirectoryInfo>)InternalEnumerateInfos(FullPath, searchPattern, SearchTarget.Directories, enumerationOptions)).ToArray();
		}

		public IEnumerable<DirectoryInfo> EnumerateDirectories()
		{
			return EnumerateDirectories("*", EnumerationOptions.Compatible);
		}

		public IEnumerable<DirectoryInfo> EnumerateDirectories(string searchPattern)
		{
			return EnumerateDirectories(searchPattern, EnumerationOptions.Compatible);
		}

		public IEnumerable<DirectoryInfo> EnumerateDirectories(string searchPattern, SearchOption searchOption)
		{
			return EnumerateDirectories(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public IEnumerable<DirectoryInfo> EnumerateDirectories(string searchPattern, EnumerationOptions enumerationOptions)
		{
			return (IEnumerable<DirectoryInfo>)InternalEnumerateInfos(FullPath, searchPattern, SearchTarget.Directories, enumerationOptions);
		}

		public IEnumerable<FileInfo> EnumerateFiles()
		{
			return EnumerateFiles("*", EnumerationOptions.Compatible);
		}

		public IEnumerable<FileInfo> EnumerateFiles(string searchPattern)
		{
			return EnumerateFiles(searchPattern, EnumerationOptions.Compatible);
		}

		public IEnumerable<FileInfo> EnumerateFiles(string searchPattern, SearchOption searchOption)
		{
			return EnumerateFiles(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public IEnumerable<FileInfo> EnumerateFiles(string searchPattern, EnumerationOptions enumerationOptions)
		{
			return (IEnumerable<FileInfo>)InternalEnumerateInfos(FullPath, searchPattern, SearchTarget.Files, enumerationOptions);
		}

		public IEnumerable<FileSystemInfo> EnumerateFileSystemInfos()
		{
			return EnumerateFileSystemInfos("*", EnumerationOptions.Compatible);
		}

		public IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(string searchPattern)
		{
			return EnumerateFileSystemInfos(searchPattern, EnumerationOptions.Compatible);
		}

		public IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(string searchPattern, SearchOption searchOption)
		{
			return EnumerateFileSystemInfos(searchPattern, EnumerationOptions.FromSearchOption(searchOption));
		}

		public IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(string searchPattern, EnumerationOptions enumerationOptions)
		{
			return InternalEnumerateInfos(FullPath, searchPattern, SearchTarget.Both, enumerationOptions);
		}

		private IEnumerable<FileSystemInfo> InternalEnumerateInfos(string path, string searchPattern, SearchTarget searchTarget, EnumerationOptions options)
		{
			if (searchPattern == null)
			{
				throw new ArgumentNullException("searchPattern");
			}
			_isNormalized &= FileSystemEnumerableFactory.NormalizeInputs(ref path, ref searchPattern, options.MatchType);
			return searchTarget switch
			{
				SearchTarget.Directories => FileSystemEnumerableFactory.DirectoryInfos(path, searchPattern, options, _isNormalized), 
				SearchTarget.Files => FileSystemEnumerableFactory.FileInfos(path, searchPattern, options, _isNormalized), 
				SearchTarget.Both => FileSystemEnumerableFactory.FileSystemInfos(path, searchPattern, options, _isNormalized), 
				_ => throw new ArgumentException(SR.ArgumentOutOfRange_Enum, "searchTarget"), 
			};
		}

		public void MoveTo(string destDirName)
		{
			if (destDirName == null)
			{
				throw new ArgumentNullException("destDirName");
			}
			if (destDirName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "destDirName");
			}
			string fullPath = Path.GetFullPath(destDirName);
			string text = PathInternal.EnsureTrailingSeparator(fullPath);
			string text2 = PathInternal.EnsureTrailingSeparator(FullPath);
			if (string.Equals(text2, text, PathInternal.StringComparison))
			{
				throw new IOException(SR.IO_SourceDestMustBeDifferent);
			}
			string pathRoot = Path.GetPathRoot(text2);
			string pathRoot2 = Path.GetPathRoot(text);
			if (!string.Equals(pathRoot, pathRoot2, PathInternal.StringComparison))
			{
				throw new IOException(SR.IO_SourceDestMustHaveSameRoot);
			}
			if (!Exists && !FileSystem.FileExists(FullPath))
			{
				throw new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, FullPath));
			}
			if (FileSystem.DirectoryExists(fullPath))
			{
				throw new IOException(SR.Format(SR.IO_AlreadyExists_Name, text));
			}
			FileSystem.MoveDirectory(FullPath, fullPath);
			Init(destDirName, text, null, isNormalized: true);
			Invalidate();
		}

		public override void Delete()
		{
			Delete(recursive: false);
		}

		public void Delete(bool recursive)
		{
			FileSystem.RemoveDirectory(FullPath, recursive);
			Invalidate();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class DirectoryNotFoundException : IOException
	{
		public DirectoryNotFoundException()
			: base(SR.Arg_DirectoryNotFoundException)
		{
			base.HResult = -2147024893;
		}

		public DirectoryNotFoundException(string? message)
			: base(message)
		{
			base.HResult = -2147024893;
		}

		public DirectoryNotFoundException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024893;
		}

		protected DirectoryNotFoundException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal static class EncodingCache
	{
		internal static readonly Encoding UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
	}
	public class EnumerationOptions
	{
		private int _maxRecursionDepth;

		internal static EnumerationOptions Compatible { get; } = new EnumerationOptions
		{
			MatchType = MatchType.Win32,
			AttributesToSkip = (FileAttributes)0,
			IgnoreInaccessible = false
		};


		private static EnumerationOptions CompatibleRecursive { get; } = new EnumerationOptions
		{
			RecurseSubdirectories = true,
			MatchType = MatchType.Win32,
			AttributesToSkip = (FileAttributes)0,
			IgnoreInaccessible = false
		};


		internal static EnumerationOptions Default { get; } = new EnumerationOptions();


		public bool RecurseSubdirectories { get; set; }

		public bool IgnoreInaccessible { get; set; }

		public int BufferSize { get; set; }

		public FileAttributes AttributesToSkip { get; set; }

		public MatchType MatchType { get; set; }

		public MatchCasing MatchCasing { get; set; }

		public int MaxRecursionDepth
		{
			get
			{
				return _maxRecursionDepth;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				_maxRecursionDepth = value;
			}
		}

		public bool ReturnSpecialDirectories { get; set; }

		public EnumerationOptions()
		{
			IgnoreInaccessible = true;
			AttributesToSkip = FileAttributes.Hidden | FileAttributes.System;
			MaxRecursionDepth = int.MaxValue;
		}

		internal static EnumerationOptions FromSearchOption(SearchOption searchOption)
		{
			if (searchOption != 0 && searchOption != SearchOption.AllDirectories)
			{
				throw new ArgumentOutOfRangeException("searchOption", SR.ArgumentOutOfRange_Enum);
			}
			if (searchOption != SearchOption.AllDirectories)
			{
				return Compatible;
			}
			return CompatibleRecursive;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class EndOfStreamException : IOException
	{
		public EndOfStreamException()
			: base(SR.Arg_EndOfStreamException)
		{
			base.HResult = -2147024858;
		}

		public EndOfStreamException(string? message)
			: base(message)
		{
			base.HResult = -2147024858;
		}

		public EndOfStreamException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024858;
		}

		protected EndOfStreamException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public static class File
	{
		private static Encoding s_UTF8NoBOM;

		private static Encoding UTF8NoBOM => s_UTF8NoBOM ?? (s_UTF8NoBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));

		public static StreamReader OpenText(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			return new StreamReader(path);
		}

		public static StreamWriter CreateText(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			return new StreamWriter(path, append: false);
		}

		public static StreamWriter AppendText(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			return new StreamWriter(path, append: true);
		}

		public static void Copy(string sourceFileName, string destFileName)
		{
			Copy(sourceFileName, destFileName, overwrite: false);
		}

		public static void Copy(string sourceFileName, string destFileName, bool overwrite)
		{
			if (sourceFileName == null)
			{
				throw new ArgumentNullException("sourceFileName", SR.ArgumentNull_FileName);
			}
			if (destFileName == null)
			{
				throw new ArgumentNullException("destFileName", SR.ArgumentNull_FileName);
			}
			if (sourceFileName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "sourceFileName");
			}
			if (destFileName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "destFileName");
			}
			FileSystem.CopyFile(Path.GetFullPath(sourceFileName), Path.GetFullPath(destFileName), overwrite);
		}

		public static FileStream Create(string path)
		{
			return Create(path, 4096);
		}

		public static FileStream Create(string path, int bufferSize)
		{
			return new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None, bufferSize);
		}

		public static FileStream Create(string path, int bufferSize, FileOptions options)
		{
			return new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None, bufferSize, options);
		}

		public static void Delete(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			FileSystem.DeleteFile(Path.GetFullPath(path));
		}

		public static bool Exists([NotNullWhen(true)] string? path)
		{
			try
			{
				if (path == null)
				{
					return false;
				}
				if (path.Length == 0)
				{
					return false;
				}
				path = Path.GetFullPath(path);
				if (path.Length > 0 && PathInternal.IsDirectorySeparator(path[path.Length - 1]))
				{
					return false;
				}
				return FileSystem.FileExists(path);
			}
			catch (ArgumentException)
			{
			}
			catch (IOException)
			{
			}
			catch (UnauthorizedAccessException)
			{
			}
			return false;
		}

		public static FileStream Open(string path, FileMode mode)
		{
			return Open(path, mode, (mode == FileMode.Append) ? FileAccess.Write : FileAccess.ReadWrite, FileShare.None);
		}

		public static FileStream Open(string path, FileMode mode, FileAccess access)
		{
			return Open(path, mode, access, FileShare.None);
		}

		public static FileStream Open(string path, FileMode mode, FileAccess access, FileShare share)
		{
			return new FileStream(path, mode, access, share);
		}

		internal static DateTimeOffset GetUtcDateTimeOffset(DateTime dateTime)
		{
			if (dateTime.Kind == DateTimeKind.Unspecified)
			{
				return DateTime.SpecifyKind(dateTime, DateTimeKind.Utc);
			}
			return dateTime.ToUniversalTime();
		}

		public static void SetCreationTime(string path, DateTime creationTime)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetCreationTime(fullPath, creationTime, asDirectory: false);
		}

		public static void SetCreationTimeUtc(string path, DateTime creationTimeUtc)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetCreationTime(fullPath, GetUtcDateTimeOffset(creationTimeUtc), asDirectory: false);
		}

		public static DateTime GetCreationTime(string path)
		{
			string fullPath = Path.GetFullPath(path);
			return FileSystem.GetCreationTime(fullPath).LocalDateTime;
		}

		public static DateTime GetCreationTimeUtc(string path)
		{
			string fullPath = Path.GetFullPath(path);
			return FileSystem.GetCreationTime(fullPath).UtcDateTime;
		}

		public static void SetLastAccessTime(string path, DateTime lastAccessTime)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetLastAccessTime(fullPath, lastAccessTime, asDirectory: false);
		}

		public static void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetLastAccessTime(fullPath, GetUtcDateTimeOffset(lastAccessTimeUtc), asDirectory: false);
		}

		public static DateTime GetLastAccessTime(string path)
		{
			string fullPath = Path.GetFullPath(path);
			return FileSystem.GetLastAccessTime(fullPath).LocalDateTime;
		}

		public static DateTime GetLastAccessTimeUtc(string path)
		{
			string fullPath = Path.GetFullPath(path);
			return FileSystem.GetLastAccessTime(fullPath).UtcDateTime;
		}

		public static void SetLastWriteTime(string path, DateTime lastWriteTime)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetLastWriteTime(fullPath, lastWriteTime, asDirectory: false);
		}

		public static void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetLastWriteTime(fullPath, GetUtcDateTimeOffset(lastWriteTimeUtc), asDirectory: false);
		}

		public static DateTime GetLastWriteTime(string path)
		{
			string fullPath = Path.GetFullPath(path);
			return FileSystem.GetLastWriteTime(fullPath).LocalDateTime;
		}

		public static DateTime GetLastWriteTimeUtc(string path)
		{
			string fullPath = Path.GetFullPath(path);
			return FileSystem.GetLastWriteTime(fullPath).UtcDateTime;
		}

		public static FileAttributes GetAttributes(string path)
		{
			string fullPath = Path.GetFullPath(path);
			return FileSystem.GetAttributes(fullPath);
		}

		public static void SetAttributes(string path, FileAttributes fileAttributes)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.SetAttributes(fullPath, fileAttributes);
		}

		public static FileStream OpenRead(string path)
		{
			return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
		}

		public static FileStream OpenWrite(string path)
		{
			return new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
		}

		public static string ReadAllText(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			return InternalReadAllText(path, Encoding.UTF8);
		}

		public static string ReadAllText(string path, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			return InternalReadAllText(path, encoding);
		}

		private static string InternalReadAllText(string path, Encoding encoding)
		{
			using StreamReader streamReader = new StreamReader(path, encoding, detectEncodingFromByteOrderMarks: true);
			return streamReader.ReadToEnd();
		}

		public static void WriteAllText(string path, string? contents)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			using StreamWriter streamWriter = new StreamWriter(path);
			streamWriter.Write(contents);
		}

		public static void WriteAllText(string path, string? contents, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			using StreamWriter streamWriter = new StreamWriter(path, append: false, encoding);
			streamWriter.Write(contents);
		}

		public static byte[] ReadAllBytes(string path)
		{
			using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 1, FileOptions.SequentialScan);
			long num = 0L;
			if (fileStream.CanSeek && (num = fileStream.Length) > int.MaxValue)
			{
				throw new IOException(SR.IO_FileTooLong2GB);
			}
			if (num == 0L)
			{
				return ReadAllBytesUnknownLength(fileStream);
			}
			int num2 = 0;
			int num3 = (int)num;
			byte[] array = new byte[num3];
			while (num3 > 0)
			{
				int num4 = fileStream.Read(array, num2, num3);
				if (num4 == 0)
				{
					ThrowHelper.ThrowEndOfFileException();
				}
				num2 += num4;
				num3 -= num4;
			}
			return array;
		}

		public static void WriteAllBytes(string path, byte[] bytes)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path", SR.ArgumentNull_Path);
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes");
			}
			using SafeFileHandle handle = OpenHandle(path, FileMode.Create, FileAccess.Write, FileShare.Read, FileOptions.None, 0L);
			RandomAccess.WriteAtOffset(handle, bytes, 0L);
		}

		public static string[] ReadAllLines(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			return InternalReadAllLines(path, Encoding.UTF8);
		}

		public static string[] ReadAllLines(string path, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			return InternalReadAllLines(path, encoding);
		}

		private static string[] InternalReadAllLines(string path, Encoding encoding)
		{
			List<string> list = new List<string>();
			using (StreamReader streamReader = new StreamReader(path, encoding))
			{
				string item;
				while ((item = streamReader.ReadLine()) != null)
				{
					list.Add(item);
				}
			}
			return list.ToArray();
		}

		public static IEnumerable<string> ReadLines(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			return ReadLinesIterator.CreateIterator(path, Encoding.UTF8);
		}

		public static IEnumerable<string> ReadLines(string path, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			return ReadLinesIterator.CreateIterator(path, encoding);
		}

		public static void WriteAllLines(string path, string[] contents)
		{
			WriteAllLines(path, (IEnumerable<string>)contents);
		}

		public static void WriteAllLines(string path, IEnumerable<string> contents)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (contents == null)
			{
				throw new ArgumentNullException("contents");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			InternalWriteAllLines(new StreamWriter(path), contents);
		}

		public static void WriteAllLines(string path, string[] contents, Encoding encoding)
		{
			WriteAllLines(path, (IEnumerable<string>)contents, encoding);
		}

		public static void WriteAllLines(string path, IEnumerable<string> contents, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (contents == null)
			{
				throw new ArgumentNullException("contents");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			InternalWriteAllLines(new StreamWriter(path, append: false, encoding), contents);
		}

		private static void InternalWriteAllLines(TextWriter writer, IEnumerable<string> contents)
		{
			using (writer)
			{
				foreach (string content in contents)
				{
					writer.WriteLine(content);
				}
			}
		}

		public static void AppendAllText(string path, string? contents)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			using StreamWriter streamWriter = new StreamWriter(path, append: true);
			streamWriter.Write(contents);
		}

		public static void AppendAllText(string path, string? contents, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			using StreamWriter streamWriter = new StreamWriter(path, append: true, encoding);
			streamWriter.Write(contents);
		}

		public static void AppendAllLines(string path, IEnumerable<string> contents)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (contents == null)
			{
				throw new ArgumentNullException("contents");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			InternalWriteAllLines(new StreamWriter(path, append: true), contents);
		}

		public static void AppendAllLines(string path, IEnumerable<string> contents, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (contents == null)
			{
				throw new ArgumentNullException("contents");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			InternalWriteAllLines(new StreamWriter(path, append: true, encoding), contents);
		}

		public static void Replace(string sourceFileName, string destinationFileName, string? destinationBackupFileName)
		{
			Replace(sourceFileName, destinationFileName, destinationBackupFileName, ignoreMetadataErrors: false);
		}

		public static void Replace(string sourceFileName, string destinationFileName, string? destinationBackupFileName, bool ignoreMetadataErrors)
		{
			if (sourceFileName == null)
			{
				throw new ArgumentNullException("sourceFileName");
			}
			if (destinationFileName == null)
			{
				throw new ArgumentNullException("destinationFileName");
			}
			FileSystem.ReplaceFile(Path.GetFullPath(sourceFileName), Path.GetFullPath(destinationFileName), (destinationBackupFileName != null) ? Path.GetFullPath(destinationBackupFileName) : null, ignoreMetadataErrors);
		}

		public static void Move(string sourceFileName, string destFileName)
		{
			Move(sourceFileName, destFileName, overwrite: false);
		}

		public static void Move(string sourceFileName, string destFileName, bool overwrite)
		{
			if (sourceFileName == null)
			{
				throw new ArgumentNullException("sourceFileName", SR.ArgumentNull_FileName);
			}
			if (destFileName == null)
			{
				throw new ArgumentNullException("destFileName", SR.ArgumentNull_FileName);
			}
			if (sourceFileName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "sourceFileName");
			}
			if (destFileName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "destFileName");
			}
			string fullPath = Path.GetFullPath(sourceFileName);
			string fullPath2 = Path.GetFullPath(destFileName);
			if (!FileSystem.FileExists(fullPath))
			{
				throw new FileNotFoundException(SR.Format(SR.IO_FileNotFound_FileName, fullPath), fullPath);
			}
			FileSystem.MoveFile(fullPath, fullPath2, overwrite);
		}

		[SupportedOSPlatform("windows")]
		public static void Encrypt(string path)
		{
			FileSystem.Encrypt(path ?? throw new ArgumentNullException("path"));
		}

		[SupportedOSPlatform("windows")]
		public static void Decrypt(string path)
		{
			FileSystem.Decrypt(path ?? throw new ArgumentNullException("path"));
		}

		private static StreamReader AsyncStreamReader(string path, Encoding encoding)
		{
			FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.Asynchronous | FileOptions.SequentialScan);
			return new StreamReader(stream, encoding, detectEncodingFromByteOrderMarks: true);
		}

		private static StreamWriter AsyncStreamWriter(string path, Encoding encoding, bool append)
		{
			FileStream stream = new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read, 4096, FileOptions.Asynchronous | FileOptions.SequentialScan);
			return new StreamWriter(stream, encoding);
		}

		public static Task<string> ReadAllTextAsync(string path, CancellationToken cancellationToken = default(CancellationToken))
		{
			return ReadAllTextAsync(path, Encoding.UTF8, cancellationToken);
		}

		public static Task<string> ReadAllTextAsync(string path, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (!cancellationToken.IsCancellationRequested)
			{
				return InternalReadAllTextAsync(path, encoding, cancellationToken);
			}
			return Task.FromCanceled<string>(cancellationToken);
		}

		private static async Task<string> InternalReadAllTextAsync(string path, Encoding encoding, CancellationToken cancellationToken)
		{
			char[] buffer = null;
			StreamReader sr = AsyncStreamReader(path, encoding);
			try
			{
				cancellationToken.ThrowIfCancellationRequested();
				buffer = ArrayPool<char>.Shared.Rent(sr.CurrentEncoding.GetMaxCharCount(4096));
				StringBuilder sb = new StringBuilder();
				while (true)
				{
					int num = await sr.ReadAsync(new Memory<char>(buffer), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					if (num == 0)
					{
						break;
					}
					sb.Append(buffer, 0, num);
				}
				return sb.ToString();
			}
			finally
			{
				sr.Dispose();
				if (buffer != null)
				{
					ArrayPool<char>.Shared.Return(buffer);
				}
			}
		}

		public static Task WriteAllTextAsync(string path, string? contents, CancellationToken cancellationToken = default(CancellationToken))
		{
			return WriteAllTextAsync(path, contents, UTF8NoBOM, cancellationToken);
		}

		public static Task WriteAllTextAsync(string path, string? contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			if (string.IsNullOrEmpty(contents))
			{
				new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read).Dispose();
				return Task.CompletedTask;
			}
			return InternalWriteAllTextAsync(AsyncStreamWriter(path, encoding, append: false), contents, cancellationToken);
		}

		public static Task<byte[]> ReadAllBytesAsync(string path, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<byte[]>(cancellationToken);
			}
			FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 1, FileOptions.Asynchronous | FileOptions.SequentialScan);
			bool flag = false;
			try
			{
				long num = 0L;
				if (fileStream.CanSeek && (num = fileStream.Length) > int.MaxValue)
				{
					IOException ex = new IOException(SR.IO_FileTooLong2GB);
					ExceptionDispatchInfo.SetCurrentStackTrace(ex);
					return Task.FromException<byte[]>(ex);
				}
				flag = true;
				return (num > 0) ? InternalReadAllBytesAsync(fileStream, (int)num, cancellationToken) : InternalReadAllBytesUnknownLengthAsync(fileStream, cancellationToken);
			}
			finally
			{
				if (!flag)
				{
					fileStream.Dispose();
				}
			}
		}

		private static async Task<byte[]> InternalReadAllBytesAsync(FileStream fs, int count, CancellationToken cancellationToken)
		{
			using (fs)
			{
				int index = 0;
				byte[] bytes = new byte[count];
				do
				{
					int num = await fs.ReadAsync(new Memory<byte>(bytes, index, count - index), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					if (num == 0)
					{
						ThrowHelper.ThrowEndOfFileException();
					}
					index += num;
				}
				while (index < count);
				return bytes;
			}
		}

		private static async Task<byte[]> InternalReadAllBytesUnknownLengthAsync(FileStream fs, CancellationToken cancellationToken)
		{
			byte[] rentedArray = ArrayPool<byte>.Shared.Rent(512);
			try
			{
				int bytesRead = 0;
				while (true)
				{
					if (bytesRead == rentedArray.Length)
					{
						uint num = (uint)(rentedArray.Length * 2);
						if (num > 2147483591)
						{
							num = (uint)Math.Max(2147483591, rentedArray.Length + 1);
						}
						byte[] array = ArrayPool<byte>.Shared.Rent((int)num);
						Buffer.BlockCopy(rentedArray, 0, array, 0, bytesRead);
						byte[] array2 = rentedArray;
						rentedArray = array;
						ArrayPool<byte>.Shared.Return(array2);
					}
					int num2 = await fs.ReadAsync(rentedArray.AsMemory(bytesRead), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					if (num2 == 0)
					{
						break;
					}
					bytesRead += num2;
				}
				return rentedArray.AsSpan(0, bytesRead).ToArray();
			}
			finally
			{
				fs.Dispose();
				ArrayPool<byte>.Shared.Return(rentedArray);
			}
		}

		public static Task WriteAllBytesAsync(string path, byte[] bytes, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (path == null)
			{
				throw new ArgumentNullException("path", SR.ArgumentNull_Path);
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (bytes == null)
			{
				throw new ArgumentNullException("bytes");
			}
			if (!cancellationToken.IsCancellationRequested)
			{
				return Core(path, bytes, cancellationToken);
			}
			return Task.FromCanceled(cancellationToken);
			static async Task Core(string path, byte[] bytes, CancellationToken cancellationToken)
			{
				using SafeFileHandle sfh = OpenHandle(path, FileMode.Create, FileAccess.Write, FileShare.Read, FileOptions.Asynchronous | FileOptions.SequentialScan, 0L);
				await RandomAccess.WriteAtOffsetAsync(sfh, bytes, 0L, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		public static Task<string[]> ReadAllLinesAsync(string path, CancellationToken cancellationToken = default(CancellationToken))
		{
			return ReadAllLinesAsync(path, Encoding.UTF8, cancellationToken);
		}

		public static Task<string[]> ReadAllLinesAsync(string path, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (!cancellationToken.IsCancellationRequested)
			{
				return InternalReadAllLinesAsync(path, encoding, cancellationToken);
			}
			return Task.FromCanceled<string[]>(cancellationToken);
		}

		private static async Task<string[]> InternalReadAllLinesAsync(string path, Encoding encoding, CancellationToken cancellationToken)
		{
			using StreamReader sr = AsyncStreamReader(path, encoding);
			cancellationToken.ThrowIfCancellationRequested();
			List<string> lines = new List<string>();
			string item;
			while ((item = await sr.ReadLineAsync().ConfigureAwait(continueOnCapturedContext: false)) != null)
			{
				lines.Add(item);
				cancellationToken.ThrowIfCancellationRequested();
			}
			return lines.ToArray();
		}

		public static Task WriteAllLinesAsync(string path, IEnumerable<string> contents, CancellationToken cancellationToken = default(CancellationToken))
		{
			return WriteAllLinesAsync(path, contents, UTF8NoBOM, cancellationToken);
		}

		public static Task WriteAllLinesAsync(string path, IEnumerable<string> contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (contents == null)
			{
				throw new ArgumentNullException("contents");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (!cancellationToken.IsCancellationRequested)
			{
				return InternalWriteAllLinesAsync(AsyncStreamWriter(path, encoding, append: false), contents, cancellationToken);
			}
			return Task.FromCanceled(cancellationToken);
		}

		private static async Task InternalWriteAllLinesAsync(TextWriter writer, IEnumerable<string> contents, CancellationToken cancellationToken)
		{
			using (writer)
			{
				foreach (string content in contents)
				{
					cancellationToken.ThrowIfCancellationRequested();
					await writer.WriteLineAsync(content).ConfigureAwait(continueOnCapturedContext: false);
				}
				cancellationToken.ThrowIfCancellationRequested();
				await writer.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		private static async Task InternalWriteAllTextAsync(StreamWriter sw, string contents, CancellationToken cancellationToken)
		{
			using (sw)
			{
				await sw.WriteAsync(contents.AsMemory(), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				await sw.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		public static Task AppendAllTextAsync(string path, string? contents, CancellationToken cancellationToken = default(CancellationToken))
		{
			return AppendAllTextAsync(path, contents, UTF8NoBOM, cancellationToken);
		}

		public static Task AppendAllTextAsync(string path, string? contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			if (string.IsNullOrEmpty(contents))
			{
				new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.Read).Dispose();
				return Task.CompletedTask;
			}
			return InternalWriteAllTextAsync(AsyncStreamWriter(path, encoding, append: true), contents, cancellationToken);
		}

		public static Task AppendAllLinesAsync(string path, IEnumerable<string> contents, CancellationToken cancellationToken = default(CancellationToken))
		{
			return AppendAllLinesAsync(path, contents, UTF8NoBOM, cancellationToken);
		}

		public static Task AppendAllLinesAsync(string path, IEnumerable<string> contents, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (contents == null)
			{
				throw new ArgumentNullException("contents");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (!cancellationToken.IsCancellationRequested)
			{
				return InternalWriteAllLinesAsync(AsyncStreamWriter(path, encoding, append: true), contents, cancellationToken);
			}
			return Task.FromCanceled(cancellationToken);
		}

		public static FileSystemInfo CreateSymbolicLink(string path, string pathToTarget)
		{
			string fullPath = Path.GetFullPath(path);
			FileSystem.VerifyValidPath(pathToTarget, "pathToTarget");
			FileSystem.CreateSymbolicLink(path, pathToTarget, isDirectory: false);
			return new FileInfo(path, fullPath, null, isNormalized: true);
		}

		public static FileSystemInfo? ResolveLinkTarget(string linkPath, bool returnFinalTarget)
		{
			FileSystem.VerifyValidPath(linkPath, "linkPath");
			return FileSystem.ResolveLinkTarget(linkPath, returnFinalTarget, isDirectory: false);
		}

		public static FileStream Open(string path, FileStreamOptions options)
		{
			return new FileStream(path, options);
		}

		public static SafeFileHandle OpenHandle(string path, FileMode mode = FileMode.Open, FileAccess access = FileAccess.Read, FileShare share = FileShare.Read, FileOptions options = FileOptions.None, long preallocationSize = 0L)
		{
			FileStreamHelpers.ValidateArguments(path, mode, access, share, 0, options, preallocationSize);
			return SafeFileHandle.Open(Path.GetFullPath(path), mode, access, share, options, preallocationSize);
		}

		private static byte[] ReadAllBytesUnknownLength(FileStream fs)
		{
			byte[] array = null;
			Span<byte> span = stackalloc byte[512];
			try
			{
				int num = 0;
				while (true)
				{
					if (num == span.Length)
					{
						uint num2 = (uint)(span.Length * 2);
						if (num2 > Array.MaxLength)
						{
							num2 = (uint)Math.Max(Array.MaxLength, span.Length + 1);
						}
						byte[] array2 = ArrayPool<byte>.Shared.Rent((int)num2);
						span.CopyTo(array2);
						byte[] array3 = array;
						span = (array = array2);
						if (array3 != null)
						{
							ArrayPool<byte>.Shared.Return(array3);
						}
					}
					int num3 = fs.Read(span.Slice(num));
					if (num3 == 0)
					{
						break;
					}
					num += num3;
				}
				return span.Slice(0, num).ToArray();
			}
			finally
			{
				if (array != null)
				{
					ArrayPool<byte>.Shared.Return(array);
				}
			}
		}
	}
	[Flags]
	public enum FileAccess
	{
		Read = 1,
		Write = 2,
		ReadWrite = 3
	}
	[Flags]
	public enum FileAttributes
	{
		ReadOnly = 1,
		Hidden = 2,
		System = 4,
		Directory = 0x10,
		Archive = 0x20,
		Device = 0x40,
		Normal = 0x80,
		Temporary = 0x100,
		SparseFile = 0x200,
		ReparsePoint = 0x400,
		Compressed = 0x800,
		Offline = 0x1000,
		NotContentIndexed = 0x2000,
		Encrypted = 0x4000,
		IntegrityStream = 0x8000,
		NoScrubData = 0x20000
	}
	public sealed class FileInfo : FileSystemInfo
	{
		public long Length
		{
			get
			{
				if ((base.Attributes & FileAttributes.Directory) == FileAttributes.Directory)
				{
					throw new FileNotFoundException(SR.Format(SR.IO_FileNotFound_FileName, FullPath), FullPath);
				}
				return base.LengthCore;
			}
		}

		public string? DirectoryName => Path.GetDirectoryName(FullPath);

		public DirectoryInfo? Directory
		{
			get
			{
				string directoryName = DirectoryName;
				if (directoryName == null)
				{
					return null;
				}
				return new DirectoryInfo(directoryName);
			}
		}

		public bool IsReadOnly
		{
			get
			{
				return (base.Attributes & FileAttributes.ReadOnly) != 0;
			}
			set
			{
				if (value)
				{
					base.Attributes |= FileAttributes.ReadOnly;
				}
				else
				{
					base.Attributes &= ~FileAttributes.ReadOnly;
				}
			}
		}

		public FileInfo(string fileName)
			: this(fileName, null, null, isNormalized: false)
		{
		}

		internal FileInfo(string originalPath, string fullPath = null, string fileName = null, bool isNormalized = false)
		{
			OriginalPath = originalPath ?? throw new ArgumentNullException("fileName");
			fullPath = fullPath ?? originalPath;
			FullPath = (isNormalized ? (fullPath ?? originalPath) : Path.GetFullPath(fullPath));
			_name = fileName ?? Path.GetFileName(originalPath);
		}

		public StreamReader OpenText()
		{
			return new StreamReader(base.NormalizedPath, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);
		}

		public StreamWriter CreateText()
		{
			return new StreamWriter(base.NormalizedPath, append: false);
		}

		public StreamWriter AppendText()
		{
			return new StreamWriter(base.NormalizedPath, append: true);
		}

		public FileInfo CopyTo(string destFileName)
		{
			return CopyTo(destFileName, overwrite: false);
		}

		public FileInfo CopyTo(string destFileName, bool overwrite)
		{
			if (destFileName == null)
			{
				throw new ArgumentNullException("destFileName", SR.ArgumentNull_FileName);
			}
			if (destFileName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "destFileName");
			}
			string fullPath = Path.GetFullPath(destFileName);
			FileSystem.CopyFile(FullPath, fullPath, overwrite);
			return new FileInfo(fullPath, null, null, isNormalized: true);
		}

		public FileStream Create()
		{
			FileStream result = File.Create(base.NormalizedPath);
			Invalidate();
			return result;
		}

		public override void Delete()
		{
			FileSystem.DeleteFile(FullPath);
			Invalidate();
		}

		public FileStream Open(FileMode mode)
		{
			return Open(mode, (mode == FileMode.Append) ? FileAccess.Write : FileAccess.ReadWrite, FileShare.None);
		}

		public FileStream Open(FileMode mode, FileAccess access)
		{
			return Open(mode, access, FileShare.None);
		}

		public FileStream Open(FileMode mode, FileAccess access, FileShare share)
		{
			return new FileStream(base.NormalizedPath, mode, access, share);
		}

		public FileStream OpenRead()
		{
			return new FileStream(base.NormalizedPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, useAsync: false);
		}

		public FileStream OpenWrite()
		{
			return new FileStream(base.NormalizedPath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
		}

		public void MoveTo(string destFileName)
		{
			MoveTo(destFileName, overwrite: false);
		}

		public void MoveTo(string destFileName, bool overwrite)
		{
			if (destFileName == null)
			{
				throw new ArgumentNullException("destFileName");
			}
			if (destFileName.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyFileName, "destFileName");
			}
			string fullPath = Path.GetFullPath(destFileName);
			if (!new DirectoryInfo(Path.GetDirectoryName(FullName)).Exists)
			{
				throw new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, FullName));
			}
			if (!Exists)
			{
				throw new FileNotFoundException(SR.Format(SR.IO_FileNotFound_FileName, FullName), FullName);
			}
			FileSystem.MoveFile(FullPath, fullPath, overwrite);
			FullPath = fullPath;
			OriginalPath = destFileName;
			_name = Path.GetFileName(fullPath);
			Invalidate();
		}

		public FileInfo Replace(string destinationFileName, string? destinationBackupFileName)
		{
			return Replace(destinationFileName, destinationBackupFileName, ignoreMetadataErrors: false);
		}

		public FileInfo Replace(string destinationFileName, string? destinationBackupFileName, bool ignoreMetadataErrors)
		{
			if (destinationFileName == null)
			{
				throw new ArgumentNullException("destinationFileName");
			}
			FileSystem.ReplaceFile(FullPath, Path.GetFullPath(destinationFileName), (destinationBackupFileName != null) ? Path.GetFullPath(destinationBackupFileName) : null, ignoreMetadataErrors);
			return new FileInfo(destinationFileName);
		}

		[SupportedOSPlatform("windows")]
		public void Decrypt()
		{
			File.Decrypt(FullPath);
		}

		[SupportedOSPlatform("windows")]
		public void Encrypt()
		{
			File.Encrypt(FullPath);
		}

		public FileStream Open(FileStreamOptions options)
		{
			return File.Open(base.NormalizedPath, options);
		}
	}
	public enum FileMode
	{
		CreateNew = 1,
		Create,
		Open,
		OpenOrCreate,
		Truncate,
		Append
	}
	[Flags]
	public enum FileOptions
	{
		None = 0,
		WriteThrough = int.MinValue,
		Asynchronous = 0x40000000,
		RandomAccess = 0x10000000,
		DeleteOnClose = 0x4000000,
		SequentialScan = 0x8000000,
		Encrypted = 0x4000
	}
	[Flags]
	public enum FileShare
	{
		None = 0,
		Read = 1,
		Write = 2,
		ReadWrite = 3,
		Delete = 4,
		Inheritable = 0x10
	}
	public class FileStream : Stream
	{
		private readonly FileStreamStrategy _strategy;

		[Obsolete("FileStream.Handle has been deprecated. Use FileStream's SafeFileHandle property instead.")]
		public virtual IntPtr Handle => _strategy.Handle;

		public override bool CanRead => _strategy.CanRead;

		public override bool CanWrite => _strategy.CanWrite;

		public virtual SafeFileHandle SafeFileHandle => _strategy.SafeFileHandle;

		public virtual string Name => _strategy.Name;

		public virtual bool IsAsync => _strategy.IsAsync;

		public override long Length
		{
			get
			{
				if (_strategy.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				else if (!CanSeek)
				{
					ThrowHelper.ThrowNotSupportedException_UnseekableStream();
				}
				return _strategy.Length;
			}
		}

		public override long Position
		{
			get
			{
				if (_strategy.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				else if (!CanSeek)
				{
					ThrowHelper.ThrowNotSupportedException_UnseekableStream();
				}
				return _strategy.Position;
			}
			set
			{
				if (value < 0)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
				}
				_strategy.Seek(value, SeekOrigin.Begin);
			}
		}

		public override bool CanSeek => _strategy.CanSeek;

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) instead.")]
		public FileStream(IntPtr handle, FileAccess access)
			: this(handle, access, ownsHandle: true, 4096, isAsync: false)
		{
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
		public FileStream(IntPtr handle, FileAccess access, bool ownsHandle)
			: this(handle, access, ownsHandle, 4096, isAsync: false)
		{
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
		public FileStream(IntPtr handle, FileAccess access, bool ownsHandle, int bufferSize)
			: this(handle, access, ownsHandle, bufferSize, isAsync: false)
		{
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("This constructor has been deprecated. Use FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync) and optionally make a new SafeFileHandle with ownsHandle=false if needed instead.")]
		public FileStream(IntPtr handle, FileAccess access, bool ownsHandle, int bufferSize, bool isAsync)
		{
			SafeFileHandle safeFileHandle = new SafeFileHandle(handle, ownsHandle);
			try
			{
				ValidateHandle(safeFileHandle, access, bufferSize, isAsync);
				_strategy = FileStreamHelpers.ChooseStrategy(this, safeFileHandle, access, bufferSize, isAsync);
			}
			catch
			{
				GC.SuppressFinalize(safeFileHandle);
				throw;
			}
		}

		private static void ValidateHandle(SafeFileHandle handle, FileAccess access, int bufferSize)
		{
			if (handle.IsInvalid)
			{
				throw new ArgumentException(SR.Arg_InvalidHandle, "handle");
			}
			if (access < FileAccess.Read || access > FileAccess.ReadWrite)
			{
				throw new ArgumentOutOfRangeException("access", SR.ArgumentOutOfRange_Enum);
			}
			if (bufferSize < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum("bufferSize");
			}
			else if (handle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
		}

		private static void ValidateHandle(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync)
		{
			ValidateHandle(handle, access, bufferSize);
			if (isAsync && !handle.IsAsync)
			{
				ThrowHelper.ThrowArgumentException_HandleNotAsync("handle");
			}
			else if (!isAsync && handle.IsAsync)
			{
				ThrowHelper.ThrowArgumentException_HandleNotSync("handle");
			}
		}

		public FileStream(SafeFileHandle handle, FileAccess access)
			: this(handle, access, 4096)
		{
		}

		public FileStream(SafeFileHandle handle, FileAccess access, int bufferSize)
		{
			ValidateHandle(handle, access, bufferSize);
			_strategy = FileStreamHelpers.ChooseStrategy(this, handle, access, bufferSize, handle.IsAsync);
		}

		public FileStream(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync)
		{
			ValidateHandle(handle, access, bufferSize, isAsync);
			_strategy = FileStreamHelpers.ChooseStrategy(this, handle, access, bufferSize, isAsync);
		}

		public FileStream(string path, FileMode mode)
			: this(path, mode, (mode == FileMode.Append) ? FileAccess.Write : FileAccess.ReadWrite, FileShare.Read, 4096, useAsync: false)
		{
		}

		public FileStream(string path, FileMode mode, FileAccess access)
			: this(path, mode, access, FileShare.Read, 4096, useAsync: false)
		{
		}

		public FileStream(string path, FileMode mode, FileAccess access, FileShare share)
			: this(path, mode, access, share, 4096, useAsync: false)
		{
		}

		public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize)
			: this(path, mode, access, share, bufferSize, useAsync: false)
		{
		}

		public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, bool useAsync)
			: this(path, mode, access, share, bufferSize, useAsync ? FileOptions.Asynchronous : FileOptions.None)
		{
		}

		public FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options)
			: this(path, mode, access, share, bufferSize, options, 0L)
		{
		}

		public FileStream(string path, FileStreamOptions options)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path", SR.ArgumentNull_Path);
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			if ((options.Access & FileAccess.Read) != 0 && options.Mode == FileMode.Append)
			{
				throw new ArgumentException(SR.Argument_InvalidAppendMode, "options");
			}
			if ((options.Access & FileAccess.Write) == 0 && (options.Mode == FileMode.Truncate || options.Mode == FileMode.CreateNew || options.Mode == FileMode.Create || options.Mode == FileMode.Append))
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, options.Mode, options.Access), "options");
			}
			if (options.PreallocationSize > 0)
			{
				FileStreamHelpers.ValidateArgumentsForPreallocation(options.Mode, options.Access);
			}
			FileStreamHelpers.SerializationGuard(options.Access);
			_strategy = FileStreamHelpers.ChooseStrategy(this, path, options.Mode, options.Access, options.Share, options.BufferSize, options.Options, options.PreallocationSize);
		}

		private FileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
		{
			FileStreamHelpers.ValidateArguments(path, mode, access, share, bufferSize, options, preallocationSize);
			_strategy = FileStreamHelpers.ChooseStrategy(this, path, mode, access, share, bufferSize, options, preallocationSize);
		}

		[UnsupportedOSPlatform("ios")]
		[UnsupportedOSPlatform("macos")]
		[UnsupportedOSPlatform("tvos")]
		public virtual void Lock(long position, long length)
		{
			if (position < 0 || length < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum((position < 0) ? "position" : "length");
			}
			else if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			_strategy.Lock(position, length);
		}

		[UnsupportedOSPlatform("ios")]
		[UnsupportedOSPlatform("macos")]
		[UnsupportedOSPlatform("tvos")]
		public virtual void Unlock(long position, long length)
		{
			if (position < 0 || length < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum((position < 0) ? "position" : "length");
			}
			else if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			_strategy.Unlock(position, length);
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			return _strategy.FlushAsync(cancellationToken);
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			ValidateReadWriteArgs(buffer, offset, count);
			return _strategy.Read(buffer, offset, count);
		}

		public override int Read(Span<byte> buffer)
		{
			return _strategy.Read(buffer);
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<int>(cancellationToken);
			}
			if (!_strategy.CanRead)
			{
				if (_strategy.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			return _strategy.ReadAsync(buffer, offset, count, cancellationToken);
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			if (!_strategy.CanRead)
			{
				if (_strategy.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			return _strategy.ReadAsync(buffer, cancellationToken);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			ValidateReadWriteArgs(buffer, offset, count);
			_strategy.Write(buffer, offset, count);
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			_strategy.Write(buffer);
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			if (!_strategy.CanWrite)
			{
				if (_strategy.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
			return _strategy.WriteAsync(buffer, offset, count, cancellationToken);
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled(cancellationToken);
			}
			if (!_strategy.CanWrite)
			{
				if (_strategy.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
			return _strategy.WriteAsync(buffer, cancellationToken);
		}

		public override void Flush()
		{
			Flush(flushToDisk: false);
		}

		public virtual void Flush(bool flushToDisk)
		{
			if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			_strategy.Flush(flushToDisk);
		}

		private void ValidateReadWriteArgs(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
		}

		public override void SetLength(long value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			else if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			else if (!CanSeek)
			{
				ThrowHelper.ThrowNotSupportedException_UnseekableStream();
			}
			else if (!CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
			_strategy.SetLength(value);
		}

		public override int ReadByte()
		{
			return _strategy.ReadByte();
		}

		public override void WriteByte(byte value)
		{
			_strategy.WriteByte(value);
		}

		protected override void Dispose(bool disposing)
		{
			_strategy.DisposeInternal(disposing);
		}

		internal void DisposeInternal(bool disposing)
		{
			Dispose(disposing);
		}

		public override ValueTask DisposeAsync()
		{
			return _strategy.DisposeAsync();
		}

		public override void CopyTo(Stream destination, int bufferSize)
		{
			Stream.ValidateCopyToArguments(destination, bufferSize);
			_strategy.CopyTo(destination, bufferSize);
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			Stream.ValidateCopyToArguments(destination, bufferSize);
			return _strategy.CopyToAsync(destination, bufferSize, cancellationToken);
		}

		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			else if (!CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			return _strategy.BeginRead(buffer, offset, count, callback, state);
		}

		public override int EndRead(IAsyncResult asyncResult)
		{
			if (asyncResult == null)
			{
				throw new ArgumentNullException("asyncResult");
			}
			return _strategy.EndRead(asyncResult);
		}

		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback? callback, object? state)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			else if (!CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
			return _strategy.BeginWrite(buffer, offset, count, callback, state);
		}

		public override void EndWrite(IAsyncResult asyncResult)
		{
			if (asyncResult == null)
			{
				throw new ArgumentNullException("asyncResult");
			}
			_strategy.EndWrite(asyncResult);
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			return _strategy.Seek(offset, origin);
		}

		internal Task BaseFlushAsync(CancellationToken cancellationToken)
		{
			return base.FlushAsync(cancellationToken);
		}

		internal int BaseRead(Span<byte> buffer)
		{
			return base.Read(buffer);
		}

		internal Task<int> BaseReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return base.ReadAsync(buffer, offset, count, cancellationToken);
		}

		internal ValueTask<int> BaseReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			return base.ReadAsync(buffer, cancellationToken);
		}

		internal void BaseWrite(ReadOnlySpan<byte> buffer)
		{
			base.Write(buffer);
		}

		internal Task BaseWriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return base.WriteAsync(buffer, offset, count, cancellationToken);
		}

		internal ValueTask BaseWriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			return base.WriteAsync(buffer, cancellationToken);
		}

		internal ValueTask BaseDisposeAsync()
		{
			return base.DisposeAsync();
		}

		internal Task BaseCopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			return base.CopyToAsync(destination, bufferSize, cancellationToken);
		}

		internal IAsyncResult BaseBeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return base.BeginRead(buffer, offset, count, callback, state);
		}

		internal int BaseEndRead(IAsyncResult asyncResult)
		{
			return base.EndRead(asyncResult);
		}

		internal IAsyncResult BaseBeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return base.BeginWrite(buffer, offset, count, callback, state);
		}

		internal void BaseEndWrite(IAsyncResult asyncResult)
		{
			base.EndWrite(asyncResult);
		}
	}
	public sealed class FileStreamOptions
	{
		private FileMode _mode = FileMode.Open;

		private FileAccess _access = FileAccess.Read;

		private FileShare _share = FileShare.Read;

		private FileOptions _options;

		private long _preallocationSize;

		private int _bufferSize = 4096;

		public FileMode Mode
		{
			get
			{
				return _mode;
			}
			set
			{
				if (value < FileMode.CreateNew || value > FileMode.Append)
				{
					ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
				}
				_mode = value;
			}
		}

		public FileAccess Access
		{
			get
			{
				return _access;
			}
			set
			{
				if (value < FileAccess.Read || value > FileAccess.ReadWrite)
				{
					ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
				}
				_access = value;
			}
		}

		public FileShare Share
		{
			get
			{
				return _share;
			}
			set
			{
				FileShare fileShare = value & ~FileShare.Inheritable;
				if ((fileShare < FileShare.None) || fileShare > (FileShare.ReadWrite | FileShare.Delete))
				{
					ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
				}
				_share = value;
			}
		}

		public FileOptions Options
		{
			get
			{
				return _options;
			}
			set
			{
				if (value != 0 && (value & (FileOptions)67092479) != 0)
				{
					ThrowHelper.ArgumentOutOfRangeException_Enum_Value();
				}
				_options = value;
			}
		}

		public long PreallocationSize
		{
			get
			{
				return _preallocationSize;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				_preallocationSize = value;
			}
		}

		public int BufferSize
		{
			get
			{
				return _bufferSize;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				_bufferSize = value;
			}
		}
	}
	internal static class FileSystem
	{
		internal static void VerifyValidPath(string path, string argName)
		{
			if (path == null)
			{
				throw new ArgumentNullException(argName);
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Arg_PathEmpty, argName);
			}
			if (path.Contains('\0'))
			{
				throw new ArgumentException(SR.Argument_InvalidPathChars, argName);
			}
		}

		public static bool DirectoryExists(string fullPath)
		{
			int lastError;
			return DirectoryExists(fullPath, out lastError);
		}

		private static bool DirectoryExists(string path, out int lastError)
		{
			Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default(Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA);
			lastError = FillAttributeInfo(path, ref data, returnErrorOnNotFound: true);
			if (lastError == 0 && data.dwFileAttributes != -1)
			{
				return (data.dwFileAttributes & 0x10) != 0;
			}
			return false;
		}

		public static bool FileExists(string fullPath)
		{
			Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default(Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA);
			if (FillAttributeInfo(fullPath, ref data, returnErrorOnNotFound: true) == 0 && data.dwFileAttributes != -1)
			{
				return (data.dwFileAttributes & 0x10) == 0;
			}
			return false;
		}

		internal static int FillAttributeInfo(string path, ref Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data, bool returnErrorOnNotFound)
		{
			int num = 0;
			path = PathInternal.TrimEndingDirectorySeparator(path);
			using (DisableMediaInsertionPrompt.Create())
			{
				if (!Interop.Kernel32.GetFileAttributesEx(path, Interop.Kernel32.GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, ref data))
				{
					num = Marshal.GetLastWin32Error();
					if (!IsPathUnreachableError(num))
					{
						Interop.Kernel32.WIN32_FIND_DATA data2 = default(Interop.Kernel32.WIN32_FIND_DATA);
						using SafeFindHandle safeFindHandle = Interop.Kernel32.FindFirstFile(path, ref data2);
						if (safeFindHandle.IsInvalid)
						{
							num = Marshal.GetLastWin32Error();
						}
						else
						{
							num = 0;
							data.PopulateFrom(ref data2);
						}
					}
				}
			}
			if (num != 0 && !returnErrorOnNotFound && ((uint)(num - 2) <= 1u || num == 21))
			{
				data.dwFileAttributes = -1;
				return 0;
			}
			return num;
		}

		internal static bool IsPathUnreachableError(int errorCode)
		{
			switch (errorCode)
			{
			case 2:
			case 3:
			case 6:
			case 21:
			case 53:
			case 65:
			case 67:
			case 87:
			case 123:
			case 161:
			case 206:
			case 1231:
				return true;
			default:
				return false;
			}
		}

		public unsafe static void CreateDirectory(string fullPath, byte[] securityDescriptor = null)
		{
			if (DirectoryExists(fullPath))
			{
				return;
			}
			List<string> list = new List<string>();
			bool flag = false;
			int num = fullPath.Length;
			if (num >= 2 && PathInternal.EndsInDirectorySeparator(fullPath.AsSpan()))
			{
				num--;
			}
			int rootLength = PathInternal.GetRootLength(fullPath.AsSpan());
			if (num > rootLength)
			{
				int num2 = num - 1;
				while (num2 >= rootLength && !flag)
				{
					string text = fullPath.Substring(0, num2 + 1);
					if (!DirectoryExists(text))
					{
						list.Add(text);
					}
					else
					{
						flag = true;
					}
					while (num2 > rootLength && !PathInternal.IsDirectorySeparator(fullPath[num2]))
					{
						num2--;
					}
					num2--;
				}
			}
			int count = list.Count;
			bool flag2 = true;
			int num3 = 0;
			string path = fullPath;
			fixed (byte* ptr = securityDescriptor)
			{
				Interop.Kernel32.SECURITY_ATTRIBUTES sECURITY_ATTRIBUTES = default(Interop.Kernel32.SECURITY_ATTRIBUTES);
				sECURITY_ATTRIBUTES.nLength = (uint)sizeof(Interop.Kernel32.SECURITY_ATTRIBUTES);
				sECURITY_ATTRIBUTES.lpSecurityDescriptor = (IntPtr)ptr;
				Interop.Kernel32.SECURITY_ATTRIBUTES lpSecurityAttributes = sECURITY_ATTRIBUTES;
				while (list.Count > 0)
				{
					string text2 = list[list.Count - 1];
					list.RemoveAt(list.Count - 1);
					flag2 = Interop.Kernel32.CreateDirectory(text2, ref lpSecurityAttributes);
					if (!flag2 && num3 == 0)
					{
						int lastError = Marshal.GetLastWin32Error();
						if (lastError != 183)
						{
							num3 = lastError;
						}
						else if (FileExists(text2) || (!DirectoryExists(text2, out lastError) && lastError == 5))
						{
							num3 = lastError;
							path = text2;
						}
					}
				}
			}
			if (count == 0 && !flag)
			{
				string pathRoot = Path.GetPathRoot(fullPath);
				if (!DirectoryExists(pathRoot))
				{
					throw Win32Marshal.GetExceptionForWin32Error(3, pathRoot);
				}
			}
			else if (!flag2 && num3 != 0)
			{
				throw Win32Marshal.GetExceptionForWin32Error(num3, path);
			}
		}

		public static void Encrypt(string path)
		{
			string fullPath = Path.GetFullPath(path);
			if (!Interop.Advapi32.EncryptFile(fullPath))
			{
				ThrowExceptionEncryptDecryptFail(fullPath);
			}
		}

		public static void Decrypt(string path)
		{
			string fullPath = Path.GetFullPath(path);
			if (!Interop.Advapi32.DecryptFile(fullPath))
			{
				ThrowExceptionEncryptDecryptFail(fullPath);
			}
		}

		private unsafe static void ThrowExceptionEncryptDecryptFail(string fullPath)
		{
			int lastWin32Error = Marshal.GetLastWin32Error();
			if (lastWin32Error == 5)
			{
				string text = DriveInfoInternal.NormalizeDriveName(Path.GetPathRoot(fullPath));
				using (DisableMediaInsertionPrompt.Create())
				{
					if (!Interop.Kernel32.GetVolumeInformation(text, null, 0, null, null, out var fileSystemFlags, null, 0))
					{
						lastWin32Error = Marshal.GetLastWin32Error();
						throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, text);
					}
					if (((ulong)fileSystemFlags & 0x20000uL) == 0L)
					{
						throw new NotSupportedException(SR.PlatformNotSupported_FileEncryption);
					}
				}
			}
			throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, fullPath);
		}

		public static void CopyFile(string sourceFullPath, string destFullPath, bool overwrite)
		{
			int num = Interop.Kernel32.CopyFile(sourceFullPath, destFullPath, !overwrite);
			if (num == 0)
			{
				return;
			}
			string path = destFullPath;
			if (num != 80)
			{
				using (SafeFileHandle safeFileHandle = Interop.Kernel32.CreateFile(sourceFullPath, int.MinValue, FileShare.Read, FileMode.Open, 0))
				{
					if (safeFileHandle.IsInvalid)
					{
						path = sourceFullPath;
					}
				}
				if (num == 5 && DirectoryExists(destFullPath))
				{
					throw new IOException(SR.Format(SR.Arg_FileIsDirectory_Name, destFullPath), 5);
				}
			}
			throw Win32Marshal.GetExceptionForWin32Error(num, path);
		}

		public static void ReplaceFile(string sourceFullPath, string destFullPath, string destBackupFullPath, bool ignoreMetadataErrors)
		{
			int dwReplaceFlags = (ignoreMetadataErrors ? 2 : 0);
			if (!Interop.Kernel32.ReplaceFile(destFullPath, sourceFullPath, destBackupFullPath, dwReplaceFlags, IntPtr.Zero, IntPtr.Zero))
			{
				throw Win32Marshal.GetExceptionForWin32Error(Marshal.GetLastWin32Error());
			}
		}

		public static void DeleteFile(string fullPath)
		{
			if (!Interop.Kernel32.DeleteFile(fullPath))
			{
				int lastWin32Error = Marshal.GetLastWin32Error();
				if (lastWin32Error != 2)
				{
					throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, fullPath);
				}
			}
		}

		public static FileAttributes GetAttributes(string fullPath)
		{
			Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default(Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA);
			int num = FillAttributeInfo(fullPath, ref data, returnErrorOnNotFound: true);
			if (num != 0)
			{
				throw Win32Marshal.GetExceptionForWin32Error(num, fullPath);
			}
			return (FileAttributes)data.dwFileAttributes;
		}

		public static DateTimeOffset GetCreationTime(string fullPath)
		{
			Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default(Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA);
			int num = FillAttributeInfo(fullPath, ref data, returnErrorOnNotFound: false);
			if (num != 0)
			{
				throw Win32Marshal.GetExceptionForWin32Error(num, fullPath);
			}
			return data.ftCreationTime.ToDateTimeOffset();
		}

		public static DateTimeOffset GetLastAccessTime(string fullPath)
		{
			Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default(Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA);
			int num = FillAttributeInfo(fullPath, ref data, returnErrorOnNotFound: false);
			if (num != 0)
			{
				throw Win32Marshal.GetExceptionForWin32Error(num, fullPath);
			}
			return data.ftLastAccessTime.ToDateTimeOffset();
		}

		public static DateTimeOffset GetLastWriteTime(string fullPath)
		{
			Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default(Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA);
			int num = FillAttributeInfo(fullPath, ref data, returnErrorOnNotFound: false);
			if (num != 0)
			{
				throw Win32Marshal.GetExceptionForWin32Error(num, fullPath);
			}
			return data.ftLastWriteTime.ToDateTimeOffset();
		}

		public static void MoveDirectory(string sourceFullPath, string destFullPath)
		{
			if (!Interop.Kernel32.MoveFile(sourceFullPath, destFullPath, overwrite: false))
			{
				int lastWin32Error = Marshal.GetLastWin32Error();
				switch (lastWin32Error)
				{
				case 2:
					throw Win32Marshal.GetExceptionForWin32Error(3, sourceFullPath);
				case 183:
					throw Win32Marshal.GetExceptionForWin32Error(183, destFullPath);
				case 5:
					throw new IOException(SR.Format(SR.UnauthorizedAccess_IODenied_Path, sourceFullPath), Win32Marshal.MakeHRFromErrorCode(lastWin32Error));
				default:
					throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error);
				}
			}
		}

		public static void MoveFile(string sourceFullPath, string destFullPath, bool overwrite)
		{
			if (!Interop.Kernel32.MoveFile(sourceFullPath, destFullPath, overwrite))
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
		}

		private static SafeFileHandle OpenHandleToWriteAttributes(string fullPath, bool asDirectory)
		{
			if (fullPath.Length == PathInternal.GetRootLength(fullPath.AsSpan()) && fullPath[1] == Path.VolumeSeparatorChar)
			{
				throw new ArgumentException(SR.Arg_PathIsVolume, "path");
			}
			SafeFileHandle safeFileHandle = Interop.Kernel32.CreateFile(fullPath, 256, FileShare.ReadWrite | FileShare.Delete, FileMode.Open, asDirectory ? 33554432 : 0);
			if (safeFileHandle.IsInvalid)
			{
				int num = Marshal.GetLastWin32Error();
				if (!asDirectory && num == 3 && fullPath.Equals(Directory.GetDirectoryRoot(fullPath)))
				{
					num = 5;
				}
				throw Win32Marshal.GetExceptionForWin32Error(num, fullPath);
			}
			return safeFileHandle;
		}

		public static void RemoveDirectory(string fullPath, bool recursive)
		{
			if (!recursive)
			{
				RemoveDirectoryInternal(fullPath, topLevel: true);
				return;
			}
			Interop.Kernel32.WIN32_FIND_DATA findData = default(Interop.Kernel32.WIN32_FIND_DATA);
			GetFindData(fullPath, isDirectory: true, ignoreAccessDenied: true, ref findData);
			if (IsNameSurrogateReparsePoint(ref findData))
			{
				RemoveDirectoryInternal(fullPath, topLevel: true);
				return;
			}
			fullPath = PathInternal.EnsureExtendedPrefix(fullPath);
			RemoveDirectoryRecursive(fullPath, ref findData, topLevel: true);
		}

		private static void GetFindData(string fullPath, bool isDirectory, bool ignoreAccessDenied, ref Interop.Kernel32.WIN32_FIND_DATA findData)
		{
			using SafeFindHandle safeFindHandle = Interop.Kernel32.FindFirstFile(Path.TrimEndingDirectorySeparator(fullPath), ref findData);
			if (safeFindHandle.IsInvalid)
			{
				int num = Marshal.GetLastWin32Error();
				if (isDirectory && num == 2)
				{
					num = 3;
				}
				if (!(isDirectory && num == 5 && ignoreAccessDenied))
				{
					throw Win32Marshal.GetExceptionForWin32Error(num, fullPath);
				}
			}
		}

		private static bool IsNameSurrogateReparsePoint(ref Interop.Kernel32.WIN32_FIND_DATA data)
		{
			if ((data.dwFileAttributes & 0x400u) != 0)
			{
				return (data.dwReserved0 & 0x20000000) != 0;
			}
			return false;
		}

		private static void RemoveDirectoryRecursive(string fullPath, ref Interop.Kernel32.WIN32_FIND_DATA findData, bool topLevel)
		{
			Exception ex = null;
			using (SafeFindHandle safeFindHandle = Interop.Kernel32.FindFirstFile(Path.Join(fullPath, "*"), ref findData))
			{
				if (safeFindHandle.IsInvalid)
				{
					throw Win32Marshal.GetExceptionForLastWin32Error(fullPath);
				}
				int lastWin32Error;
				do
				{
					if ((findData.dwFileAttributes & 0x10) == 0)
					{
						string stringFromFixedBuffer = findData.cFileName.GetStringFromFixedBuffer();
						if (!Interop.Kernel32.DeleteFile(Path.Combine(fullPath, stringFromFixedBuffer)) && ex == null)
						{
							lastWin32Error = Marshal.GetLastWin32Error();
							if (lastWin32Error != 2)
							{
								ex = Win32Marshal.GetExceptionForWin32Error(lastWin32Error, stringFromFixedBuffer);
							}
						}
					}
					else
					{
						if (findData.cFileName.FixedBufferEqualsString(".") || findData.cFileName.FixedBufferEqualsString(".."))
						{
							continue;
						}
						string stringFromFixedBuffer2 = findData.cFileName.GetStringFromFixedBuffer();
						if (!IsNameSurrogateReparsePoint(ref findData))
						{
							try
							{
								RemoveDirectoryRecursive(Path.Combine(fullPath, stringFromFixedBuffer2), ref findData, topLevel: false);
							}
							catch (Exception ex2)
							{
								if (ex == null)
								{
									ex = ex2;
								}
							}
							continue;
						}
						if (findData.dwReserved0 == 2684354563u)
						{
							string mountPoint = Path.Join(fullPath, stringFromFixedBuffer2, "\\");
							if (!Interop.Kernel32.DeleteVolumeMountPoint(mountPoint) && ex == null)
							{
								lastWin32Error = Marshal.GetLastWin32Error();
								if (lastWin32Error != 0 && lastWin32Error != 3)
								{
									ex = Win32Marshal.GetExceptionForWin32Error(lastWin32Error, stringFromFixedBuffer2);
								}
							}
						}
						if (!Interop.Kernel32.RemoveDirectory(Path.Combine(fullPath, stringFromFixedBuffer2)) && ex == null)
						{
							lastWin32Error = Marshal.GetLastWin32Error();
							if (lastWin32Error != 3)
							{
								ex = Win32Marshal.GetExceptionForWin32Error(lastWin32Error, stringFromFixedBuffer2);
							}
						}
					}
				}
				while (Interop.Kernel32.FindNextFile(safeFindHandle, ref findData));
				if (ex != null)
				{
					throw ex;
				}
				lastWin32Error = Marshal.GetLastWin32Error();
				if (lastWin32Error != 0 && lastWin32Error != 18)
				{
					throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, fullPath);
				}
			}
			RemoveDirectoryInternal(fullPath, topLevel, allowDirectoryNotEmpty: true);
		}

		private static void RemoveDirectoryInternal(string fullPath, bool topLevel, bool allowDirectoryNotEmpty = false)
		{
			if (Interop.Kernel32.RemoveDirectory(fullPath))
			{
				return;
			}
			int num = Marshal.GetLastWin32Error();
			switch (num)
			{
			case 2:
				num = 3;
				goto case 3;
			case 3:
				if (!topLevel)
				{
					return;
				}
				break;
			case 145:
				if (allowDirectoryNotEmpty)
				{
					return;
				}
				break;
			case 5:
				throw new IOException(SR.Format(SR.UnauthorizedAccess_IODenied_Path, fullPath));
			}
			throw Win32Marshal.GetExceptionForWin32Error(num, fullPath);
		}

		public static void SetAttributes(string fullPath, FileAttributes attributes)
		{
			if (!Interop.Kernel32.SetFileAttributes(fullPath, (int)attributes))
			{
				int lastWin32Error = Marshal.GetLastWin32Error();
				if (lastWin32Error == 87)
				{
					throw new ArgumentException(SR.Arg_InvalidFileAttrs, "attributes");
				}
				throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, fullPath);
			}
		}

		private unsafe static void SetFileTime(string fullPath, bool asDirectory, long creationTime = -1L, long lastAccessTime = -1L, long lastWriteTime = -1L, long changeTime = -1L, uint fileAttributes = 0u)
		{
			using SafeFileHandle hFile = OpenHandleToWriteAttributes(fullPath, asDirectory);
			Interop.Kernel32.FILE_BASIC_INFO fILE_BASIC_INFO = default(Interop.Kernel32.FILE_BASIC_INFO);
			fILE_BASIC_INFO.CreationTime = creationTime;
			fILE_BASIC_INFO.LastAccessTime = lastAccessTime;
			fILE_BASIC_INFO.LastWriteTime = lastWriteTime;
			fILE_BASIC_INFO.ChangeTime = changeTime;
			fILE_BASIC_INFO.FileAttributes = fileAttributes;
			Interop.Kernel32.FILE_BASIC_INFO fILE_BASIC_INFO2 = fILE_BASIC_INFO;
			if (!Interop.Kernel32.SetFileInformationByHandle(hFile, 0, &fILE_BASIC_INFO2, (uint)sizeof(Interop.Kernel32.FILE_BASIC_INFO)))
			{
				throw Win32Marshal.GetExceptionForLastWin32Error(fullPath);
			}
		}

		public static void SetCreationTime(string fullPath, DateTimeOffset time, bool asDirectory)
		{
			SetFileTime(fullPath, asDirectory, time.ToFileTime(), -1L, -1L, -1L);
		}

		public static void SetLastAccessTime(string fullPath, DateTimeOffset time, bool asDirectory)
		{
			SetFileTime(fullPath, asDirectory, -1L, time.ToFileTime(), -1L, -1L);
		}

		public static void SetLastWriteTime(string fullPath, DateTimeOffset time, bool asDirectory)
		{
			SetFileTime(fullPath, asDirectory, -1L, -1L, time.ToFileTime(), -1L);
		}

		public static string[] GetLogicalDrives()
		{
			return DriveInfoInternal.GetLogicalDrives();
		}

		internal static void CreateSymbolicLink(string path, string pathToTarget, bool isDirectory)
		{
			string linkTargetFullPath = PathInternal.GetLinkTargetFullPath(path, pathToTarget);
			Interop.Kernel32.CreateSymbolicLink(path, pathToTarget, isDirectory);
		}

		internal static FileSystemInfo ResolveLinkTarget(string linkPath, bool returnFinalTarget, bool isDirectory)
		{
			string text = (returnFinalTarget ? GetFinalLinkTarget(linkPath, isDirectory) : GetImmediateLinkTarget(linkPath, isDirectory, throwOnError: true, returnFullPath: true));
			if (text != null)
			{
				if (!isDirectory)
				{
					return new FileInfo(text);
				}
				return new DirectoryInfo(text);
			}
			return null;
		}

		internal static string GetLinkTarget(string linkPath, bool isDirectory)
		{
			return GetImmediateLinkTarget(linkPath, isDirectory, throwOnError: false, returnFullPath: false);
		}

		internal unsafe static string GetImmediateLinkTarget(string linkPath, bool isDirectory, bool throwOnError, bool returnFullPath)
		{
			using (SafeFileHandle safeFileHandle = OpenSafeFileHandle(linkPath, 35651584))
			{
				if (safeFileHandle.IsInvalid)
				{
					if (!throwOnError)
					{
						return null;
					}
					int num = Marshal.GetLastWin32Error();
					if (isDirectory && num == 2)
					{
						num = 3;
					}
					throw Win32Marshal.GetExceptionForWin32Error(num, linkPath);
				}
				byte[] array = ArrayPool<byte>.Shared.Rent(16384);
				try
				{
					if (!Interop.Kernel32.DeviceIoControl(safeFileHandle, 589992u, IntPtr.Zero, 0u, array, 16384u, out var _, IntPtr.Zero))
					{
						if (!throwOnError)
						{
							return null;
						}
						int lastWin32Error = Marshal.GetLastWin32Error();
						if (lastWin32Error == 4390)
						{
							return null;
						}
						throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, linkPath);
					}
					Span<byte> span = new Span<byte>(array);
					bool flag = MemoryMarshal.TryRead<Interop.Kernel32.SymbolicLinkReparseBuffer>(span, out var value);
					if (value.ReparseTag == 2684354572u)
					{
						int start = sizeof(Interop.Kernel32.SymbolicLinkReparseBuffer) + value.SubstituteNameOffset;
						int substituteNameLength = value.SubstituteNameLength;
						Span<char> span2 = MemoryMarshal.Cast<byte, char>(span.Slice(start, substituteNameLength));
						if ((value.Flags & 1) == 0)
						{
							if (span2.StartsWith("\\??\\UNC\\".AsSpan()))
							{
								return Path.Join("\\\\".AsSpan(), span2.Slice("\\??\\UNC\\".Length));
							}
							return GetTargetPathWithoutNTPrefix(span2);
						}
						if (returnFullPath)
						{
							return Path.Join(Path.GetDirectoryName(linkPath.AsSpan()), span2);
						}
						return span2.ToString();
					}
					if (value.ReparseTag == 2684354563u)
					{
						flag = MemoryMarshal.TryRead<Interop.Kernel32.MountPointReparseBuffer>(span, out var value2);
						int start2 = sizeof(Interop.Kernel32.MountPointReparseBuffer) + value2.SubstituteNameOffset;
						int substituteNameLength2 = value2.SubstituteNameLength;
						Span<char> span3 = MemoryMarshal.Cast<byte, char>(span.Slice(start2, substituteNameLength2));
						return GetTargetPathWithoutNTPrefix(span3);
					}
					return null;
				}
				finally
				{
					ArrayPool<byte>.Shared.Return(array);
				}
			}
			static string GetTargetPathWithoutNTPrefix(ReadOnlySpan<char> targetPath)
			{
				return targetPath.Slice("\\??\\".Length).ToString();
			}
		}

		private static string GetFinalLinkTarget(string linkPath, bool isDirectory)
		{
			Interop.Kernel32.WIN32_FIND_DATA findData = default(Interop.Kernel32.WIN32_FIND_DATA);
			GetFindData(linkPath, isDirectory, ignoreAccessDenied: false, ref findData);
			if ((findData.dwFileAttributes & 0x400) == 0 || (findData.dwReserved0 != 2684354572u && findData.dwReserved0 != 2684354563u))
			{
				return null;
			}
			using (SafeFileHandle safeFileHandle = OpenSafeFileHandle(linkPath, 33554435))
			{
				if (safeFileHandle.IsInvalid)
				{
					int lastWin32Error = Marshal.GetLastWin32Error();
					if (IsPathUnreachableError(lastWin32Error))
					{
						return GetFinalLinkTargetSlow(linkPath);
					}
					throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, linkPath);
				}
				char[] array = ArrayPool<char>.Shared.Rent(4096);
				try
				{
					uint num = GetFinalPathNameByHandle(safeFileHandle, array);
					if (num > array.Length)
					{
						char[] array2 = array;
						array = ArrayPool<char>.Shared.Rent((int)num);
						ArrayPool<char>.Shared.Return(array2);
						num = GetFinalPathNameByHandle(safeFileHandle, array);
					}
					if (num == 0)
					{
						throw Win32Marshal.GetExceptionForLastWin32Error(linkPath);
					}
					int num2 = ((!PathInternal.IsExtended(linkPath.AsSpan())) ? 4 : 0);
					return new string(array, num2, (int)num - num2);
				}
				finally
				{
					ArrayPool<char>.Shared.Return(array);
				}
			}
			string GetFinalLinkTargetSlow(string linkPath)
			{
				string immediateLinkTarget = GetImmediateLinkTarget(linkPath, isDirectory, throwOnError: false, returnFullPath: true);
				string result = null;
				while (immediateLinkTarget != null)
				{
					result = immediateLinkTarget;
					immediateLinkTarget = GetImmediateLinkTarget(immediateLinkTarget, isDirectory, throwOnError: false, returnFullPath: true);
				}
				return result;
			}
			unsafe static uint GetFinalPathNameByHandle(SafeFileHandle handle, char[] buffer)
			{
				fixed (char* lpszFilePath = buffer)
				{
					return Interop.Kernel32.GetFinalPathNameByHandle(handle, lpszFilePath, (uint)buffer.Length, 0u);
				}
			}
		}

		private unsafe static SafeFileHandle OpenSafeFileHandle(string path, int flags)
		{
			return Interop.Kernel32.CreateFile(path, 0, FileShare.ReadWrite | FileShare.Delete, (Interop.Kernel32.SECURITY_ATTRIBUTES*)(void*)IntPtr.Zero, FileMode.Open, flags, IntPtr.Zero);
		}
	}
	public abstract class FileSystemInfo : MarshalByRefObject, ISerializable
	{
		protected string FullPath;

		protected string OriginalPath;

		internal string _name;

		private string _linkTarget;

		private bool _linkTargetIsValid;

		private Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA _data;

		private int _dataInitialized = -1;

		public virtual string FullName => FullPath;

		public string Extension
		{
			get
			{
				int length = FullPath.Length;
				int num = length;
				while (--num >= 0)
				{
					char c = FullPath[num];
					if (c == '.')
					{
						return FullPath.Substring(num, length - num);
					}
					if (PathInternal.IsDirectorySeparator(c) || c == Path.VolumeSeparatorChar)
					{
						break;
					}
				}
				return string.Empty;
			}
		}

		public virtual string Name => _name;

		public virtual bool Exists
		{
			get
			{
				try
				{
					return ExistsCore;
				}
				catch
				{
					return false;
				}
			}
		}

		public DateTime CreationTime
		{
			get
			{
				return CreationTimeUtc.ToLocalTime();
			}
			set
			{
				CreationTimeUtc = value.ToUniversalTime();
			}
		}

		public DateTime CreationTimeUtc
		{
			get
			{
				return CreationTimeCore.UtcDateTime;
			}
			set
			{
				CreationTimeCore = File.GetUtcDateTimeOffset(value);
			}
		}

		public DateTime LastAccessTime
		{
			get
			{
				return LastAccessTimeUtc.ToLocalTime();
			}
			set
			{
				LastAccessTimeUtc = value.ToUniversalTime();
			}
		}

		public DateTime LastAccessTimeUtc
		{
			get
			{
				return LastAccessTimeCore.UtcDateTime;
			}
			set
			{
				LastAccessTimeCore = File.GetUtcDateTimeOffset(value);
			}
		}

		public DateTime LastWriteTime
		{
			get
			{
				return LastWriteTimeUtc.ToLocalTime();
			}
			set
			{
				LastWriteTimeUtc = value.ToUniversalTime();
			}
		}

		public DateTime LastWriteTimeUtc
		{
			get
			{
				return LastWriteTimeCore.UtcDateTime;
			}
			set
			{
				LastWriteTimeCore = File.GetUtcDateTimeOffset(value);
			}
		}

		public string? LinkTarget
		{
			get
			{
				if (_linkTargetIsValid)
				{
					return _linkTarget;
				}
				_linkTarget = FileSystem.GetLinkTarget(FullPath, this is DirectoryInfo);
				_linkTargetIsValid = true;
				return _linkTarget;
			}
		}

		public FileAttributes Attributes
		{
			get
			{
				EnsureDataInitialized();
				return (FileAttributes)_data.dwFileAttributes;
			}
			set
			{
				FileSystem.SetAttributes(FullPath, value);
				_dataInitialized = -1;
			}
		}

		internal bool ExistsCore
		{
			get
			{
				if (_dataInitialized == -1)
				{
					RefreshCore();
				}
				if (_dataInitialized != 0)
				{
					return false;
				}
				if (_data.dwFileAttributes != -1)
				{
					return this is DirectoryInfo == ((_data.dwFileAttributes & 0x10) == 16);
				}
				return false;
			}
		}

		internal DateTimeOffset CreationTimeCore
		{
			get
			{
				EnsureDataInitialized();
				return _data.ftCreationTime.ToDateTimeOffset();
			}
			set
			{
				FileSystem.SetCreationTime(FullPath, value, this is DirectoryInfo);
				_dataInitialized = -1;
			}
		}

		internal DateTimeOffset LastAccessTimeCore
		{
			get
			{
				EnsureDataInitialized();
				return _data.ftLastAccessTime.ToDateTimeOffset();
			}
			set
			{
				FileSystem.SetLastAccessTime(FullPath, value, this is DirectoryInfo);
				_dataInitialized = -1;
			}
		}

		internal DateTimeOffset LastWriteTimeCore
		{
			get
			{
				EnsureDataInitialized();
				return _data.ftLastWriteTime.ToDateTimeOffset();
			}
			set
			{
				FileSystem.SetLastWriteTime(FullPath, value, this is DirectoryInfo);
				_dataInitialized = -1;
			}
		}

		internal long LengthCore
		{
			get
			{
				EnsureDataInitialized();
				return (long)((ulong)_data.nFileSizeHigh << 32) | ((long)_data.nFileSizeLow & 0xFFFFFFFFL);
			}
		}

		internal string NormalizedPath
		{
			get
			{
				if (!PathInternal.EndsWithPeriodOrSpace(FullPath))
				{
					return FullPath;
				}
				return PathInternal.EnsureExtendedPrefix(FullPath);
			}
		}

		protected FileSystemInfo(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		internal void Invalidate()
		{
			_linkTargetIsValid = false;
			InvalidateCore();
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			throw new PlatformNotSupportedException();
		}

		public abstract void Delete();

		public void CreateAsSymbolicLink(string pathToTarget)
		{
			FileSystem.VerifyValidPath(pathToTarget, "pathToTarget");
			FileSystem.CreateSymbolicLink(OriginalPath, pathToTarget, this is DirectoryInfo);
			Invalidate();
		}

		public FileSystemInfo? ResolveLinkTarget(bool returnFinalTarget)
		{
			return FileSystem.ResolveLinkTarget(FullPath, returnFinalTarget, this is DirectoryInfo);
		}

		public override string ToString()
		{
			return OriginalPath ?? string.Empty;
		}

		protected FileSystemInfo()
		{
		}

		internal unsafe static FileSystemInfo Create(string fullPath, ref FileSystemEntry findData)
		{
			FileSystemInfo fileSystemInfo = (findData.IsDirectory ? ((FileSystemInfo)new DirectoryInfo(fullPath, null, findData.FileName.ToString(), isNormalized: true)) : ((FileSystemInfo)new FileInfo(fullPath, null, findData.FileName.ToString(), isNormalized: true)));
			fileSystemInfo.Init(findData._info);
			return fileSystemInfo;
		}

		internal void InvalidateCore()
		{
			_dataInitialized = -1;
		}

		internal unsafe void Init(Interop.NtDll.FILE_FULL_DIR_INFORMATION* info)
		{
			_data.dwFileAttributes = (int)info->FileAttributes;
			_data.ftCreationTime = *(Interop.Kernel32.FILE_TIME*)(&info->CreationTime);
			_data.ftLastAccessTime = *(Interop.Kernel32.FILE_TIME*)(&info->LastAccessTime);
			_data.ftLastWriteTime = *(Interop.Kernel32.FILE_TIME*)(&info->LastWriteTime);
			_data.nFileSizeHigh = (uint)(info->EndOfFile >> 32);
			_data.nFileSizeLow = (uint)info->EndOfFile;
			_dataInitialized = 0;
		}

		private void EnsureDataInitialized()
		{
			if (_dataInitialized == -1)
			{
				_data = default(Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA);
				RefreshCore();
			}
			if (_dataInitialized != 0)
			{
				throw Win32Marshal.GetExceptionForWin32Error(_dataInitialized, FullPath);
			}
		}

		public void Refresh()
		{
			_linkTargetIsValid = false;
			RefreshCore();
		}

		private void RefreshCore()
		{
			_dataInitialized = FileSystem.FillAttributeInfo(FullPath, ref _data, returnErrorOnNotFound: false);
		}
	}
	public enum HandleInheritability
	{
		None,
		Inheritable
	}
	[Serializable]
	[TypeForwardedFrom("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class InvalidDataException : SystemException
	{
		public InvalidDataException()
			: base(SR.GenericInvalidData)
		{
		}

		public InvalidDataException(string? message)
			: base(message)
		{
		}

		public InvalidDataException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		private InvalidDataException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class IOException : SystemException
	{
		public IOException()
			: base(SR.Arg_IOException)
		{
			base.HResult = -2146232800;
		}

		public IOException(string? message)
			: base(message)
		{
			base.HResult = -2146232800;
		}

		public IOException(string? message, int hresult)
			: base(message)
		{
			base.HResult = hresult;
		}

		public IOException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146232800;
		}

		protected IOException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal abstract class Iterator<TSource> : IEnumerable<TSource>, System.Collections.IEnumerable, IEnumerator<TSource>, IDisposable, System.Collections.IEnumerator
	{
		private readonly int _threadId;

		internal int state;

		internal TSource current;

		public TSource Current => current;

		object System.Collections.IEnumerator.Current => Current;

		public Iterator()
		{
			_threadId = Environment.CurrentManagedThreadId;
		}

		protected abstract Iterator<TSource> Clone();

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			current = default(TSource);
			state = -1;
		}

		public IEnumerator<TSource> GetEnumerator()
		{
			if (state == 0 && _threadId == Environment.CurrentManagedThreadId)
			{
				state = 1;
				return this;
			}
			Iterator<TSource> iterator = Clone();
			iterator.state = 1;
			return iterator;
		}

		public abstract bool MoveNext();

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void System.Collections.IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}
	public enum MatchCasing
	{
		PlatformDefault,
		CaseSensitive,
		CaseInsensitive
	}
	public enum MatchType
	{
		Simple,
		Win32
	}
	public class MemoryStream : Stream
	{
		private byte[] _buffer;

		private readonly int _origin;

		private int _position;

		private int _length;

		private int _capacity;

		private bool _expandable;

		private bool _writable;

		private readonly bool _exposable;

		private bool _isOpen;

		private Task<int> _lastReadTask;

		public override bool CanRead => _isOpen;

		public override bool CanSeek => _isOpen;

		public override bool CanWrite => _writable;

		public virtual int Capacity
		{
			get
			{
				EnsureNotClosed();
				return _capacity - _origin;
			}
			set
			{
				if (value < Length)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_SmallCapacity);
				}
				EnsureNotClosed();
				if (!_expandable && value != Capacity)
				{
					throw new NotSupportedException(SR.NotSupported_MemStreamNotExpandable);
				}
				if (!_expandable || value == _capacity)
				{
					return;
				}
				if (value > 0)
				{
					byte[] array = new byte[value];
					if (_length > 0)
					{
						Buffer.BlockCopy(_buffer, 0, array, 0, _length);
					}
					_buffer = array;
				}
				else
				{
					_buffer = Array.Empty<byte>();
				}
				_capacity = value;
			}
		}

		public override long Length
		{
			get
			{
				EnsureNotClosed();
				return _length - _origin;
			}
		}

		public override long Position
		{
			get
			{
				EnsureNotClosed();
				return _position - _origin;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				EnsureNotClosed();
				if (value > int.MaxValue)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_StreamLength);
				}
				_position = _origin + (int)value;
			}
		}

		public MemoryStream()
			: this(0)
		{
		}

		public MemoryStream(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_NegativeCapacity);
			}
			_buffer = ((capacity != 0) ? new byte[capacity] : Array.Empty<byte>());
			_capacity = capacity;
			_expandable = true;
			_writable = true;
			_exposable = true;
			_isOpen = true;
		}

		public MemoryStream(byte[] buffer)
			: this(buffer, writable: true)
		{
		}

		public MemoryStream(byte[] buffer, bool writable)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			_buffer = buffer;
			_length = (_capacity = buffer.Length);
			_writable = writable;
			_isOpen = true;
		}

		public MemoryStream(byte[] buffer, int index, int count)
			: this(buffer, index, count, writable: true, publiclyVisible: false)
		{
		}

		public MemoryStream(byte[] buffer, int index, int count, bool writable)
			: this(buffer, index, count, writable, publiclyVisible: false)
		{
		}

		public MemoryStream(byte[] buffer, int index, int count, bool writable, bool publiclyVisible)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			_buffer = buffer;
			_origin = (_position = index);
			_length = (_capacity = index + count);
			_writable = writable;
			_exposable = publiclyVisible;
			_isOpen = true;
		}

		private void EnsureNotClosed()
		{
			if (!_isOpen)
			{
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(null);
			}
		}

		private void EnsureWriteable()
		{
			if (!CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing)
				{
					_isOpen = false;
					_writable = false;
					_expandable = false;
					_lastReadTask = null;
				}
			}
			finally
			{
				base.Dispose(disposing);
			}
		}

		private bool EnsureCapacity(int value)
		{
			if (value < 0)
			{
				throw new IOException(SR.IO_StreamTooLong);
			}
			if (value > _capacity)
			{
				int num = Math.Max(value, 256);
				if (num < _capacity * 2)
				{
					num = _capacity * 2;
				}
				if ((uint)(_capacity * 2) > Array.MaxLength)
				{
					num = Math.Max(value, Array.MaxLength);
				}
				Capacity = num;
				return true;
			}
			return false;
		}

		public override void Flush()
		{
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			try
			{
				Flush();
				return Task.CompletedTask;
			}
			catch (Exception exception)
			{
				return Task.FromException(exception);
			}
		}

		public virtual byte[] GetBuffer()
		{
			if (!_exposable)
			{
				throw new UnauthorizedAccessException(SR.UnauthorizedAccess_MemStreamBuffer);
			}
			return _buffer;
		}

		public virtual bool TryGetBuffer(out ArraySegment<byte> buffer)
		{
			if (!_exposable)
			{
				buffer = default(ArraySegment<byte>);
				return false;
			}
			buffer = new ArraySegment<byte>(_buffer, _origin, _length - _origin);
			return true;
		}

		internal byte[] InternalGetBuffer()
		{
			return _buffer;
		}

		internal int InternalGetPosition()
		{
			return _position;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ReadOnlySpan<byte> InternalReadSpan(int count)
		{
			EnsureNotClosed();
			int position = _position;
			int num = position + count;
			if ((uint)num > (uint)_length)
			{
				_position = _length;
				ThrowHelper.ThrowEndOfFileException();
			}
			ReadOnlySpan<byte> result = new ReadOnlySpan<byte>(_buffer, position, count);
			_position = num;
			return result;
		}

		internal int InternalEmulateRead(int count)
		{
			EnsureNotClosed();
			int num = _length - _position;
			if (num > count)
			{
				num = count;
			}
			if (num < 0)
			{
				num = 0;
			}
			_position += num;
			return num;
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			EnsureNotClosed();
			int num = _length - _position;
			if (num > count)
			{
				num = count;
			}
			if (num <= 0)
			{
				return 0;
			}
			if (num <= 8)
			{
				int num2 = num;
				while (--num2 >= 0)
				{
					buffer[offset + num2] = _buffer[_position + num2];
				}
			}
			else
			{
				Buffer.BlockCopy(_buffer, _position, buffer, offset, num);
			}
			_position += num;
			return num;
		}

		public override int Read(Span<byte> buffer)
		{
			if (GetType() != typeof(MemoryStream))
			{
				return base.Read(buffer);
			}
			EnsureNotClosed();
			int num = Math.Min(_length - _position, buffer.Length);
			if (num <= 0)
			{
				return 0;
			}
			new Span<byte>(_buffer, _position, num).CopyTo(buffer);
			_position += num;
			return num;
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<int>(cancellationToken);
			}
			try
			{
				int num = Read(buffer, offset, count);
				Task<int> lastReadTask = _lastReadTask;
				return (lastReadTask != null && lastReadTask.Result == num) ? lastReadTask : (_lastReadTask = Task.FromResult(num));
			}
			catch (OperationCanceledException exception)
			{
				return Task.FromCanceled<int>(exception);
			}
			catch (Exception exception2)
			{
				return Task.FromException<int>(exception2);
			}
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			try
			{
				ArraySegment<byte> segment;
				return new ValueTask<int>(MemoryMarshal.TryGetArray((ReadOnlyMemory<byte>)buffer, out segment) ? Read(segment.Array, segment.Offset, segment.Count) : Read(buffer.Span));
			}
			catch (OperationCanceledException exception)
			{
				return new ValueTask<int>(Task.FromCanceled<int>(exception));
			}
			catch (Exception exception2)
			{
				return ValueTask.FromException<int>(exception2);
			}
		}

		public override int ReadByte()
		{
			EnsureNotClosed();
			if (_position >= _length)
			{
				return -1;
			}
			return _buffer[_position++];
		}

		public override void CopyTo(Stream destination, int bufferSize)
		{
			if (GetType() != typeof(MemoryStream))
			{
				base.CopyTo(destination, bufferSize);
				return;
			}
			Stream.ValidateCopyToArguments(destination, bufferSize);
			EnsureNotClosed();
			int position = _position;
			int num = InternalEmulateRead(_length - position);
			if (num > 0)
			{
				destination.Write(_buffer, position, num);
			}
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			Stream.ValidateCopyToArguments(destination, bufferSize);
			EnsureNotClosed();
			if (GetType() != typeof(MemoryStream))
			{
				return base.CopyToAsync(destination, bufferSize, cancellationToken);
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			int position = _position;
			int num = InternalEmulateRead(_length - _position);
			if (num == 0)
			{
				return Task.CompletedTask;
			}
			if (!(destination is MemoryStream memoryStream))
			{
				return destination.WriteAsync(_buffer, position, num, cancellationToken);
			}
			try
			{
				memoryStream.Write(_buffer, position, num);
				return Task.CompletedTask;
			}
			catch (Exception exception)
			{
				return Task.FromException(exception);
			}
		}

		public override long Seek(long offset, SeekOrigin loc)
		{
			EnsureNotClosed();
			if (offset > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_StreamLength);
			}
			switch (loc)
			{
			case SeekOrigin.Begin:
			{
				int num3 = _origin + (int)offset;
				if (offset < 0 || num3 < _origin)
				{
					throw new IOException(SR.IO_SeekBeforeBegin);
				}
				_position = num3;
				break;
			}
			case SeekOrigin.Current:
			{
				int num2 = _position + (int)offset;
				if (_position + offset < _origin || num2 < _origin)
				{
					throw new IOException(SR.IO_SeekBeforeBegin);
				}
				_position = num2;
				break;
			}
			case SeekOrigin.End:
			{
				int num = _length + (int)offset;
				if (_length + offset < _origin || num < _origin)
				{
					throw new IOException(SR.IO_SeekBeforeBegin);
				}
				_position = num;
				break;
			}
			default:
				throw new ArgumentException(SR.Argument_InvalidSeekOrigin);
			}
			return _position;
		}

		public override void SetLength(long value)
		{
			if (value < 0 || value > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_StreamLength);
			}
			EnsureWriteable();
			if (value > int.MaxValue - _origin)
			{
				throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_StreamLength);
			}
			int num = _origin + (int)value;
			if (!EnsureCapacity(num) && num > _length)
			{
				Array.Clear(_buffer, _length, num - _length);
			}
			_length = num;
			if (_position > num)
			{
				_position = num;
			}
		}

		public virtual byte[] ToArray()
		{
			int num = _length - _origin;
			if (num == 0)
			{
				return Array.Empty<byte>();
			}
			byte[] array = GC.AllocateUninitializedArray<byte>(num);
			_buffer.AsSpan(_origin, num).CopyTo(array);
			return array;
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			EnsureNotClosed();
			EnsureWriteable();
			int num = _position + count;
			if (num < 0)
			{
				throw new IOException(SR.IO_StreamTooLong);
			}
			if (num > _length)
			{
				bool flag = _position > _length;
				if (num > _capacity && EnsureCapacity(num))
				{
					flag = false;
				}
				if (flag)
				{
					Array.Clear(_buffer, _length, num - _length);
				}
				_length = num;
			}
			if (count <= 8 && buffer != _buffer)
			{
				int num2 = count;
				while (--num2 >= 0)
				{
					_buffer[_position + num2] = buffer[offset + num2];
				}
			}
			else
			{
				Buffer.BlockCopy(buffer, offset, _buffer, _position, count);
			}
			_position = num;
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			if (GetType() != typeof(MemoryStream))
			{
				base.Write(buffer);
				return;
			}
			EnsureNotClosed();
			EnsureWriteable();
			int num = _position + buffer.Length;
			if (num < 0)
			{
				throw new IOException(SR.IO_StreamTooLong);
			}
			if (num > _length)
			{
				bool flag = _position > _length;
				if (num > _capacity && EnsureCapacity(num))
				{
					flag = false;
				}
				if (flag)
				{
					Array.Clear(_buffer, _length, num - _length);
				}
				_length = num;
			}
			buffer.CopyTo(new Span<byte>(_buffer, _position, buffer.Length));
			_position = num;
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			try
			{
				Write(buffer, offset, count);
				return Task.CompletedTask;
			}
			catch (OperationCanceledException exception)
			{
				return Task.FromCanceled(exception);
			}
			catch (Exception exception2)
			{
				return Task.FromException(exception2);
			}
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled(cancellationToken);
			}
			try
			{
				if (MemoryMarshal.TryGetArray(buffer, out var segment))
				{
					Write(segment.Array, segment.Offset, segment.Count);
				}
				else
				{
					Write(buffer.Span);
				}
				return default(ValueTask);
			}
			catch (OperationCanceledException exception)
			{
				return new ValueTask(Task.FromCanceled(exception));
			}
			catch (Exception exception2)
			{
				return ValueTask.FromException(exception2);
			}
		}

		public override void WriteByte(byte value)
		{
			EnsureNotClosed();
			EnsureWriteable();
			if (_position >= _length)
			{
				int num = _position + 1;
				bool flag = _position > _length;
				if (num >= _capacity && EnsureCapacity(num))
				{
					flag = false;
				}
				if (flag)
				{
					Array.Clear(_buffer, _length, _position - _length);
				}
				_length = num;
			}
			_buffer[_position++] = value;
		}

		public virtual void WriteTo(Stream stream)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream", SR.ArgumentNull_Stream);
			}
			EnsureNotClosed();
			stream.Write(_buffer, _origin, _length - _origin);
		}
	}
	public static class Path
	{
		private readonly struct Join3Payload
		{
			public unsafe readonly char* First;

			public readonly int FirstLength;

			public unsafe readonly char* Second;

			public readonly int SecondLength;

			public unsafe readonly char* Third;

			public readonly int ThirdLength;

			public readonly byte Separators;

			public unsafe Join3Payload(char* first, int firstLength, char* second, int secondLength, char* third, int thirdLength, byte separators)
			{
				First = first;
				FirstLength = firstLength;
				Second = second;
				SecondLength = secondLength;
				Third = third;
				ThirdLength = thirdLength;
				Separators = separators;
			}
		}

		private readonly struct Join4Payload
		{
			public unsafe readonly char* First;

			public readonly int FirstLength;

			public unsafe readonly char* Second;

			public readonly int SecondLength;

			public unsafe readonly char* Third;

			public readonly int ThirdLength;

			public unsafe readonly char* Fourth;

			public readonly int FourthLength;

			public readonly byte Separators;

			public unsafe Join4Payload(char* first, int firstLength, char* second, int secondLength, char* third, int thirdLength, char* fourth, int fourthLength, byte separators)
			{
				First = first;
				FirstLength = firstLength;
				Second = second;
				SecondLength = secondLength;
				Third = third;
				ThirdLength = thirdLength;
				Fourth = fourth;
				FourthLength = fourthLength;
				Separators = separators;
			}
		}

		public static readonly char DirectorySeparatorChar = '\\';

		public static readonly char AltDirectorySeparatorChar = '/';

		public static readonly char VolumeSeparatorChar = ':';

		public static readonly char PathSeparator = ';';

		[Obsolete("Path.InvalidPathChars has been deprecated. Use GetInvalidPathChars or GetInvalidFileNameChars instead.")]
		public static readonly char[] InvalidPathChars = GetInvalidPathChars();

		private static ReadOnlySpan<byte> Base32Char => "abcdefghijklmnopqrstuvwxyz012345"u8;

		[return: NotNullIfNotNull("path")]
		public static string? ChangeExtension(string? path, string? extension)
		{
			if (path == null)
			{
				return null;
			}
			int num = path.Length;
			if (num == 0)
			{
				return string.Empty;
			}
			for (int num2 = path.Length - 1; num2 >= 0; num2--)
			{
				char c = path[num2];
				if (c == '.')
				{
					num = num2;
					break;
				}
				if (PathInternal.IsDirectorySeparator(c))
				{
					break;
				}
			}
			if (extension == null)
			{
				return path.Substring(0, num);
			}
			ReadOnlySpan<char> readOnlySpan = path.AsSpan(0, num);
			if (!extension.StartsWith('.'))
			{
				return string.Concat(readOnlySpan, ".", extension);
			}
			return string.Concat(readOnlySpan, extension);
		}

		public static string? GetDirectoryName(string? path)
		{
			if (path == null || PathInternal.IsEffectivelyEmpty(path.AsSpan()))
			{
				return null;
			}
			int directoryNameOffset = GetDirectoryNameOffset(path.AsSpan());
			if (directoryNameOffset < 0)
			{
				return null;
			}
			return PathInternal.NormalizeDirectorySeparators(path.Substring(0, directoryNameOffset));
		}

		public static ReadOnlySpan<char> GetDirectoryName(ReadOnlySpan<char> path)
		{
			if (PathInternal.IsEffectivelyEmpty(path))
			{
				return ReadOnlySpan<char>.Empty;
			}
			int directoryNameOffset = GetDirectoryNameOffset(path);
			if (directoryNameOffset < 0)
			{
				return ReadOnlySpan<char>.Empty;
			}
			return path.Slice(0, directoryNameOffset);
		}

		internal static int GetDirectoryNameOffset(ReadOnlySpan<char> path)
		{
			int rootLength = PathInternal.GetRootLength(path);
			int num = path.Length;
			if (num <= rootLength)
			{
				return -1;
			}
			while (num > rootLength && !PathInternal.IsDirectorySeparator(path[--num]))
			{
			}
			while (num > rootLength && PathInternal.IsDirectorySeparator(path[num - 1]))
			{
				num--;
			}
			return num;
		}

		[return: NotNullIfNotNull("path")]
		public static string? GetExtension(string? path)
		{
			if (path == null)
			{
				return null;
			}
			return GetExtension(path.AsSpan()).ToString();
		}

		public static ReadOnlySpan<char> GetExtension(ReadOnlySpan<char> path)
		{
			int length = path.Length;
			for (int num = length - 1; num >= 0; num--)
			{
				char c = path[num];
				if (c == '.')
				{
					if (num != length - 1)
					{
						return path.Slice(num, length - num);
					}
					return ReadOnlySpan<char>.Empty;
				}
				if (PathInternal.IsDirectorySeparator(c))
				{
					break;
				}
			}
			return ReadOnlySpan<char>.Empty;
		}

		[return: NotNullIfNotNull("path")]
		public static string? GetFileName(string? path)
		{
			if (path == null)
			{
				return null;
			}
			ReadOnlySpan<char> fileName = GetFileName(path.AsSpan());
			if (path.Length == fileName.Length)
			{
				return path;
			}
			return fileName.ToString();
		}

		public static ReadOnlySpan<char> GetFileName(ReadOnlySpan<char> path)
		{
			int length = GetPathRoot(path).Length;
			int num = path.Length;
			while (--num >= 0)
			{
				if (num < length || PathInternal.IsDirectorySeparator(path[num]))
				{
					return path.Slice(num + 1, path.Length - num - 1);
				}
			}
			return path;
		}

		[return: NotNullIfNotNull("path")]
		public static string? GetFileNameWithoutExtension(string? path)
		{
			if (path == null)
			{
				return null;
			}
			ReadOnlySpan<char> fileNameWithoutExtension = GetFileNameWithoutExtension(path.AsSpan());
			if (path.Length == fileNameWithoutExtension.Length)
			{
				return path;
			}
			return fileNameWithoutExtension.ToString();
		}

		public static ReadOnlySpan<char> GetFileNameWithoutExtension(ReadOnlySpan<char> path)
		{
			ReadOnlySpan<char> fileName = GetFileName(path);
			int num = fileName.LastIndexOf('.');
			if (num != -1)
			{
				return fileName.Slice(0, num);
			}
			return fileName;
		}

		public unsafe static string GetRandomFileName()
		{
			byte* ptr = stackalloc byte[8];
			Interop.GetRandomBytes(ptr, 8);
			return string.Create(12, (IntPtr)ptr, delegate(Span<char> span, IntPtr key)
			{
				Populate83FileNameFromRandomBytes((byte*)(void*)key, 8, span);
			});
		}

		public static bool IsPathFullyQualified(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			return IsPathFullyQualified(path.AsSpan());
		}

		public static bool IsPathFullyQualified(ReadOnlySpan<char> path)
		{
			return !PathInternal.IsPartiallyQualified(path);
		}

		public static bool HasExtension([NotNullWhen(true)] string? path)
		{
			if (path != null)
			{
				return HasExtension(path.AsSpan());
			}
			return false;
		}

		public static bool HasExtension(ReadOnlySpan<char> path)
		{
			for (int num = path.Length - 1; num >= 0; num--)
			{
				char c = path[num];
				if (c == '.')
				{
					return num != path.Length - 1;
				}
				if (PathInternal.IsDirectorySeparator(c))
				{
					break;
				}
			}
			return false;
		}

		public static string Combine(string path1, string path2)
		{
			if (path1 == null || path2 == null)
			{
				throw new ArgumentNullException((path1 == null) ? "path1" : "path2");
			}
			return CombineInternal(path1, path2);
		}

		public static string Combine(string path1, string path2, string path3)
		{
			if (path1 == null || path2 == null || path3 == null)
			{
				throw new ArgumentNullException((path1 == null) ? "path1" : ((path2 == null) ? "path2" : "path3"));
			}
			return CombineInternal(path1, path2, path3);
		}

		public static string Combine(string path1, string path2, string path3, string path4)
		{
			if (path1 == null || path2 == null || path3 == null || path4 == null)
			{
				throw new ArgumentNullException((path1 == null) ? "path1" : ((path2 == null) ? "path2" : ((path3 == null) ? "path3" : "path4")));
			}
			return CombineInternal(path1, path2, path3, path4);
		}

		public static string Combine(params string[] paths)
		{
			if (paths == null)
			{
				throw new ArgumentNullException("paths");
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < paths.Length; i++)
			{
				if (paths[i] == null)
				{
					throw new ArgumentNullException("paths");
				}
				if (paths[i].Length != 0)
				{
					if (IsPathRooted(paths[i]))
					{
						num2 = i;
						num = paths[i].Length;
					}
					else
					{
						num += paths[i].Length;
					}
					char c = paths[i][paths[i].Length - 1];
					if (!PathInternal.IsDirectorySeparator(c))
					{
						num++;
					}
				}
			}
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.EnsureCapacity(num);
			for (int j = num2; j < paths.Length; j++)
			{
				if (paths[j].Length == 0)
				{
					continue;
				}
				if (valueStringBuilder.Length == 0)
				{
					valueStringBuilder.Append(paths[j]);
					continue;
				}
				char c2 = valueStringBuilder[valueStringBuilder.Length - 1];
				if (!PathInternal.IsDirectorySeparator(c2))
				{
					valueStringBuilder.Append('\\');
				}
				valueStringBuilder.Append(paths[j]);
			}
			return valueStringBuilder.ToString();
		}

		public static string Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2)
		{
			if (path1.Length == 0)
			{
				return path2.ToString();
			}
			if (path2.Length == 0)
			{
				return path1.ToString();
			}
			return JoinInternal(path1, path2);
		}

		public static string Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3)
		{
			if (path1.Length == 0)
			{
				return Join(path2, path3);
			}
			if (path2.Length == 0)
			{
				return Join(path1, path3);
			}
			if (path3.Length == 0)
			{
				return Join(path1, path2);
			}
			return JoinInternal(path1, path2, path3);
		}

		public static string Join(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, ReadOnlySpan<char> path4)
		{
			if (path1.Length == 0)
			{
				return Join(path2, path3, path4);
			}
			if (path2.Length == 0)
			{
				return Join(path1, path3, path4);
			}
			if (path3.Length == 0)
			{
				return Join(path1, path2, path4);
			}
			if (path4.Length == 0)
			{
				return Join(path1, path2, path3);
			}
			return JoinInternal(path1, path2, path3, path4);
		}

		public static string Join(string? path1, string? path2)
		{
			return Join(path1.AsSpan(), path2.AsSpan());
		}

		public static string Join(string? path1, string? path2, string? path3)
		{
			return Join(path1.AsSpan(), path2.AsSpan(), path3.AsSpan());
		}

		public static string Join(string? path1, string? path2, string? path3, string? path4)
		{
			return Join(path1.AsSpan(), path2.AsSpan(), path3.AsSpan(), path4.AsSpan());
		}

		public static string Join(params string?[] paths)
		{
			if (paths == null)
			{
				throw new ArgumentNullException("paths");
			}
			if (paths.Length == 0)
			{
				return string.Empty;
			}
			int num = 0;
			for (int i = 0; i < paths.Length; i++)
			{
				num += paths[i]?.Length ?? 0;
			}
			num += paths.Length - 1;
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.EnsureCapacity(num);
			foreach (string text in paths)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				if (valueStringBuilder.Length == 0)
				{
					valueStringBuilder.Append(text);
					continue;
				}
				if (!PathInternal.IsDirectorySeparator(valueStringBuilder[valueStringBuilder.Length - 1]) && !PathInternal.IsDirectorySeparator(text[0]))
				{
					valueStringBuilder.Append('\\');
				}
				valueStringBuilder.Append(text);
			}
			return valueStringBuilder.ToString();
		}

		public static bool TryJoin(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, Span<char> destination, out int charsWritten)
		{
			charsWritten = 0;
			if (path1.Length == 0 && path2.Length == 0)
			{
				return true;
			}
			if (path1.Length == 0 || path2.Length == 0)
			{
				ref ReadOnlySpan<char> reference = ref path1.Length == 0 ? ref path2 : ref path1;
				if (destination.Length < reference.Length)
				{
					return false;
				}
				reference.CopyTo(destination);
				charsWritten = reference.Length;
				return true;
			}
			bool flag = !EndsInDirectorySeparator(path1) && !PathInternal.StartsWithDirectorySeparator(path2);
			int num = path1.Length + path2.Length + (flag ? 1 : 0);
			if (destination.Length < num)
			{
				return false;
			}
			path1.CopyTo(destination);
			if (flag)
			{
				destination[path1.Length] = DirectorySeparatorChar;
			}
			path2.CopyTo(destination.Slice(path1.Length + (flag ? 1 : 0)));
			charsWritten = num;
			return true;
		}

		public static bool TryJoin(ReadOnlySpan<char> path1, ReadOnlySpan<char> path2, ReadOnlySpan<char> path3, Span<char> destination, out int charsWritten)
		{
			charsWritten = 0;
			if (path1.Length == 0 && path2.Length == 0 && path3.Length == 0)
			{
				return true;
			}
			if (path1.Length == 0)
			{
				return TryJoin(path2, path3, destination, out charsWritten);
			}
			if (path2.Length == 0)
			{
				return TryJoin(path1, path3, destination, out charsWritten);
			}
			if (path3.Length == 0)
			{
				return TryJoin(path1, path2, destination, out charsWritten);
			}
			int num = ((!EndsInDirectorySeparator(path1) && !PathInternal.StartsWithDirectorySeparator(path2)) ? 1 : 0);
			bool flag = !EndsInDirectorySeparator(path2) && !PathInternal.StartsWithDirectorySeparator(path3);
			if (flag)
			{
				num++;
			}
			int num2 = path1.Length + path2.Length + path3.Length + num;
			if (destination.Length < num2)
			{
				return false;
			}
			bool flag2 = TryJoin(path1, path2, destination, out charsWritten);
			if (flag)
			{
				destination[charsWritten++] = DirectorySeparatorChar;
			}
			path3.CopyTo(destination.Slice(charsWritten));
			charsWritten += path3.Length;
			return true;
		}

		private static string CombineInternal(string first, string second)
		{
			if (string.IsNullOrEmpty(first))
			{
				return second;
			}
			if (string.IsNullOrEmpty(second))
			{
				return first;
			}
			if (IsPathRooted(second.AsSpan()))
			{
				return second;
			}
			return JoinInternal(first.AsSpan(), second.AsSpan());
		}

		private static string CombineInternal(string first, string second, string third)
		{
			if (string.IsNullOrEmpty(first))
			{
				return CombineInternal(second, third);
			}
			if (string.IsNullOrEmpty(second))
			{
				return CombineInternal(first, third);
			}
			if (string.IsNullOrEmpty(third))
			{
				return CombineInternal(first, second);
			}
			if (IsPathRooted(third.AsSpan()))
			{
				return third;
			}
			if (IsPathRooted(second.AsSpan()))
			{
				return CombineInternal(second, third);
			}
			return JoinInternal(first.AsSpan(), second.AsSpan(), third.AsSpan());
		}

		private static string CombineInternal(string first, string second, string third, string fourth)
		{
			if (string.IsNullOrEmpty(first))
			{
				return CombineInternal(second, third, fourth);
			}
			if (string.IsNullOrEmpty(second))
			{
				return CombineInternal(first, third, fourth);
			}
			if (string.IsNullOrEmpty(third))
			{
				return CombineInternal(first, second, fourth);
			}
			if (string.IsNullOrEmpty(fourth))
			{
				return CombineInternal(first, second, third);
			}
			if (IsPathRooted(fourth.AsSpan()))
			{
				return fourth;
			}
			if (IsPathRooted(third.AsSpan()))
			{
				return CombineInternal(third, fourth);
			}
			if (IsPathRooted(second.AsSpan()))
			{
				return CombineInternal(second, third, fourth);
			}
			return JoinInternal(first.AsSpan(), second.AsSpan(), third.AsSpan(), fourth.AsSpan());
		}

		private static string JoinInternal(ReadOnlySpan<char> first, ReadOnlySpan<char> second)
		{
			if (!PathInternal.IsDirectorySeparator(first[first.Length - 1]) && !PathInternal.IsDirectorySeparator(second[0]))
			{
				return string.Concat(first, "\\", second);
			}
			return string.Concat(first, second);
		}

		private unsafe static string JoinInternal(ReadOnlySpan<char> first, ReadOnlySpan<char> second, ReadOnlySpan<char> third)
		{
			byte b = (byte)((!PathInternal.IsDirectorySeparator(first[first.Length - 1]) && !PathInternal.IsDirectorySeparator(second[0])) ? 1 : 0);
			byte b2 = (byte)((!PathInternal.IsDirectorySeparator(second[second.Length - 1]) && !PathInternal.IsDirectorySeparator(third[0])) ? 1 : 0);
			fixed (char* first2 = &MemoryMarshal.GetReference(first))
			{
				fixed (char* second2 = &MemoryMarshal.GetReference(second))
				{
					fixed (char* third2 = &MemoryMarshal.GetReference(third))
					{
						Join3Payload join3Payload = new Join3Payload(first2, first.Length, second2, second.Length, third2, third.Length, (byte)(b | (b2 << 1)));
						return string.Create(first.Length + second.Length + third.Length + b + b2, (IntPtr)(&join3Payload), delegate(Span<char> destination, IntPtr statePtr)
						{
							ref Join3Payload reference = ref *(Join3Payload*)(void*)statePtr;
							new Span<char>(reference.First, reference.FirstLength).CopyTo(destination);
							if (((uint)reference.Separators & (true ? 1u : 0u)) != 0)
							{
								destination[reference.FirstLength] = '\\';
							}
							new Span<char>(reference.Second, reference.SecondLength).CopyTo(destination.Slice(reference.FirstLength + (reference.Separators & 1)));
							if ((reference.Separators & 2u) != 0)
							{
								destination[destination.Length - reference.ThirdLength - 1] = '\\';
							}
							new Span<char>(reference.Third, reference.ThirdLength).CopyTo(destination.Slice(destination.Length - reference.ThirdLength));
						});
					}
				}
			}
		}

		private unsafe static string JoinInternal(ReadOnlySpan<char> first, ReadOnlySpan<char> second, ReadOnlySpan<char> third, ReadOnlySpan<char> fourth)
		{
			byte b = (byte)((!PathInternal.IsDirectorySeparator(first[first.Length - 1]) && !PathInternal.IsDirectorySeparator(second[0])) ? 1 : 0);
			byte b2 = (byte)((!PathInternal.IsDirectorySeparator(second[second.Length - 1]) && !PathInternal.IsDirectorySeparator(third[0])) ? 1 : 0);
			byte b3 = (byte)((!PathInternal.IsDirectorySeparator(third[third.Length - 1]) && !PathInternal.IsDirectorySeparator(fourth[0])) ? 1 : 0);
			fixed (char* first2 = &MemoryMarshal.GetReference(first))
			{
				fixed (char* second2 = &MemoryMarshal.GetReference(second))
				{
					fixed (char* third2 = &MemoryMarshal.GetReference(third))
					{
						fixed (char* fourth2 = &MemoryMarshal.GetReference(fourth))
						{
							Join4Payload join4Payload = new Join4Payload(first2, first.Length, second2, second.Length, third2, third.Length, fourth2, fourth.Length, (byte)(b | (b2 << 1) | (b3 << 2)));
							return string.Create(first.Length + second.Length + third.Length + fourth.Length + b + b2 + b3, (IntPtr)(&join4Payload), delegate(Span<char> destination, IntPtr statePtr)
							{
								ref Join4Payload reference = ref *(Join4Payload*)(void*)statePtr;
								new Span<char>(reference.First, reference.FirstLength).CopyTo(destination);
								int firstLength = reference.FirstLength;
								if (((uint)reference.Separators & (true ? 1u : 0u)) != 0)
								{
									destination[firstLength++] = '\\';
								}
								new Span<char>(reference.Second, reference.SecondLength).CopyTo(destination.Slice(firstLength));
								firstLength += reference.SecondLength;
								if ((reference.Separators & 2u) != 0)
								{
									destination[firstLength++] = '\\';
								}
								new Span<char>(reference.Third, reference.ThirdLength).CopyTo(destination.Slice(firstLength));
								firstLength += reference.ThirdLength;
								if ((reference.Separators & 4u) != 0)
								{
									destination[firstLength++] = '\\';
								}
								new Span<char>(reference.Fourth, reference.FourthLength).CopyTo(destination.Slice(firstLength));
							});
						}
					}
				}
			}
		}

		private unsafe static void Populate83FileNameFromRandomBytes(byte* bytes, int byteCount, Span<char> chars)
		{
			byte b = *bytes;
			byte b2 = bytes[1];
			byte b3 = bytes[2];
			byte b4 = bytes[3];
			byte b5 = bytes[4];
			chars[11] = (char)Base32Char[bytes[7] & 0x1F];
			chars[0] = (char)Base32Char[b & 0x1F];
			chars[1] = (char)Base32Char[b2 & 0x1F];
			chars[2] = (char)Base32Char[b3 & 0x1F];
			chars[3] = (char)Base32Char[b4 & 0x1F];
			chars[4] = (char)Base32Char[b5 & 0x1F];
			chars[5] = (char)Base32Char[((b & 0xE0) >> 5) | ((b4 & 0x60) >> 2)];
			chars[6] = (char)Base32Char[((b2 & 0xE0) >> 5) | ((b5 & 0x60) >> 2)];
			b3 >>= 5;
			if ((b4 & 0x80u) != 0)
			{
				b3 = (byte)(b3 | 8u);
			}
			if ((b5 & 0x80u) != 0)
			{
				b3 = (byte)(b3 | 0x10u);
			}
			chars[7] = (char)Base32Char[b3];
			chars[8] = '.';
			chars[9] = (char)Base32Char[bytes[5] & 0x1F];
			chars[10] = (char)Base32Char[bytes[6] & 0x1F];
		}

		public static string GetRelativePath(string relativeTo, string path)
		{
			return GetRelativePath(relativeTo, path, PathInternal.StringComparison);
		}

		private static string GetRelativePath(string relativeTo, string path, StringComparison comparisonType)
		{
			if (relativeTo == null)
			{
				throw new ArgumentNullException("relativeTo");
			}
			if (PathInternal.IsEffectivelyEmpty(relativeTo.AsSpan()))
			{
				throw new ArgumentException(SR.Arg_PathEmpty, "relativeTo");
			}
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (PathInternal.IsEffectivelyEmpty(path.AsSpan()))
			{
				throw new ArgumentException(SR.Arg_PathEmpty, "path");
			}
			relativeTo = GetFullPath(relativeTo);
			path = GetFullPath(path);
			if (!PathInternal.AreRootsEqual(relativeTo, path, comparisonType))
			{
				return path;
			}
			int num = PathInternal.GetCommonPathLength(relativeTo, path, comparisonType == StringComparison.OrdinalIgnoreCase);
			if (num == 0)
			{
				return path;
			}
			int num2 = relativeTo.Length;
			if (EndsInDirectorySeparator(relativeTo.AsSpan()))
			{
				num2--;
			}
			bool flag = EndsInDirectorySeparator(path.AsSpan());
			int num3 = path.Length;
			if (flag)
			{
				num3--;
			}
			if (num2 == num3 && num >= num2)
			{
				return ".";
			}
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			valueStringBuilder.EnsureCapacity(Math.Max(relativeTo.Length, path.Length));
			if (num < num2)
			{
				valueStringBuilder.Append("..");
				for (int i = num + 1; i < num2; i++)
				{
					if (PathInternal.IsDirectorySeparator(relativeTo[i]))
					{
						valueStringBuilder.Append(DirectorySeparatorChar);
						valueStringBuilder.Append("..");
					}
				}
			}
			else if (PathInternal.IsDirectorySeparator(path[num]))
			{
				num++;
			}
			int num4 = num3 - num;
			if (flag)
			{
				num4++;
			}
			if (num4 > 0)
			{
				if (valueStringBuilder.Length > 0)
				{
					valueStringBuilder.Append(DirectorySeparatorChar);
				}
				valueStringBuilder.Append(path.AsSpan(num, num4));
			}
			return valueStringBuilder.ToString();
		}

		public static string TrimEndingDirectorySeparator(string path)
		{
			return PathInternal.TrimEndingDirectorySeparator(path);
		}

		public static ReadOnlySpan<char> TrimEndingDirectorySeparator(ReadOnlySpan<char> path)
		{
			return PathInternal.TrimEndingDirectorySeparator(path);
		}

		public static bool EndsInDirectorySeparator(ReadOnlySpan<char> path)
		{
			return PathInternal.EndsInDirectorySeparator(path);
		}

		public static bool EndsInDirectorySeparator(string path)
		{
			return PathInternal.EndsInDirectorySeparator(path);
		}

		public static char[] GetInvalidFileNameChars()
		{
			return new char[41]
			{
				'"', '<', '>', '|', '\0', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005',
				'\u0006', '\a', '\b', '\t', '\n', '\v', '\f', '\r', '\u000e', '\u000f',
				'\u0010', '\u0011', '\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017', '\u0018', '\u0019',
				'\u001a', '\u001b', '\u001c', '\u001d', '\u001e', '\u001f', ':', '*', '?', '\\',
				'/'
			};
		}

		public static char[] GetInvalidPathChars()
		{
			return new char[33]
			{
				'|', '\0', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005', '\u0006', '\a', '\b',
				'\t', '\n', '\v', '\f', '\r', '\u000e', '\u000f', '\u0010', '\u0011', '\u0012',
				'\u0013', '\u0014', '\u0015', '\u0016', '\u0017', '\u0018', '\u0019', '\u001a', '\u001b', '\u001c',
				'\u001d', '\u001e', '\u001f'
			};
		}

		public static string GetFullPath(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (PathInternal.IsEffectivelyEmpty(path.AsSpan()))
			{
				throw new ArgumentException(SR.Arg_PathEmpty, "path");
			}
			if (path.Contains('\0'))
			{
				throw new ArgumentException(SR.Argument_InvalidPathChars, "path");
			}
			return GetFullPathInternal(path);
		}

		public static string GetFullPath(string path, string basePath)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (basePath == null)
			{
				throw new ArgumentNullException("basePath");
			}
			if (!IsPathFullyQualified(basePath))
			{
				throw new ArgumentException(SR.Arg_BasePathNotFullyQualified, "basePath");
			}
			if (basePath.Contains('\0') || path.Contains('\0'))
			{
				throw new ArgumentException(SR.Argument_InvalidPathChars);
			}
			if (IsPathFullyQualified(path))
			{
				return GetFullPathInternal(path);
			}
			if (PathInternal.IsEffectivelyEmpty(path.AsSpan()))
			{
				return basePath;
			}
			int length = path.Length;
			string text = ((length >= 1 && PathInternal.IsDirectorySeparator(path[0])) ? Join(GetPathRoot(basePath.AsSpan()), path.AsSpan(1)) : ((length < 2 || !PathInternal.IsValidDriveChar(path[0]) || path[1] != ':') ? JoinInternal(basePath.AsSpan(), path.AsSpan()) : ((!GetVolumeName(path.AsSpan()).EqualsOrdinal(GetVolumeName(basePath.AsSpan()))) ? ((!PathInternal.IsDevice(basePath.AsSpan())) ? path.Insert(2, "\\") : ((length == 2) ? JoinInternal(basePath.AsSpan(0, 4), path.AsSpan(), "\\".AsSpan()) : JoinInternal(basePath.AsSpan(0, 4), path.AsSpan(0, 2), "\\".AsSpan(), path.AsSpan(2)))) : Join(basePath.AsSpan(), path.AsSpan(2)))));
			if (!PathInternal.IsDevice(text.AsSpan()))
			{
				return GetFullPathInternal(text);
			}
			return PathInternal.RemoveRelativeSegments(text, PathInternal.GetRootLength(text.AsSpan()));
		}

		private static string GetFullPathInternal(string path)
		{
			if (PathInternal.IsExtended(path.AsSpan()))
			{
				return path;
			}
			return PathHelper.Normalize(path);
		}

		public static string GetTempPath()
		{
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder builder = new ValueStringBuilder(initialBuffer);
			GetTempPath(ref builder);
			string result = PathHelper.Normalize(ref builder);
			builder.Dispose();
			return result;
		}

		private static void GetTempPath(ref ValueStringBuilder builder)
		{
			uint tempPathW;
			while ((tempPathW = Interop.Kernel32.GetTempPathW(builder.Capacity, ref builder.GetPinnableReference())) > builder.Capacity)
			{
				builder.EnsureCapacity(checked((int)tempPathW));
			}
			if (tempPathW == 0)
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
			builder.Length = (int)tempPathW;
		}

		public static string GetTempFileName()
		{
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder builder = new ValueStringBuilder(initialBuffer);
			GetTempPath(ref builder);
			initialBuffer = stackalloc char[260];
			ValueStringBuilder path = new ValueStringBuilder(initialBuffer);
			uint tempFileNameW = Interop.Kernel32.GetTempFileNameW(ref builder.GetPinnableReference(), "tmp", 0u, ref path.GetPinnableReference());
			builder.Dispose();
			if (tempFileNameW == 0)
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
			path.Length = path.RawChars.IndexOf('\0');
			string result = PathHelper.Normalize(ref path);
			path.Dispose();
			return result;
		}

		public static bool IsPathRooted([NotNullWhen(true)] string? path)
		{
			if (path != null)
			{
				return IsPathRooted(path.AsSpan());
			}
			return false;
		}

		public static bool IsPathRooted(ReadOnlySpan<char> path)
		{
			int length = path.Length;
			if (length < 1 || !PathInternal.IsDirectorySeparator(path[0]))
			{
				if (length >= 2 && PathInternal.IsValidDriveChar(path[0]))
				{
					return path[1] == ':';
				}
				return false;
			}
			return true;
		}

		public static string? GetPathRoot(string? path)
		{
			if (PathInternal.IsEffectivelyEmpty(path.AsSpan()))
			{
				return null;
			}
			ReadOnlySpan<char> pathRoot = GetPathRoot(path.AsSpan());
			if (path.Length == pathRoot.Length)
			{
				return PathInternal.NormalizeDirectorySeparators(path);
			}
			return PathInternal.NormalizeDirectorySeparators(pathRoot.ToString());
		}

		public static ReadOnlySpan<char> GetPathRoot(ReadOnlySpan<char> path)
		{
			if (PathInternal.IsEffectivelyEmpty(path))
			{
				return ReadOnlySpan<char>.Empty;
			}
			int rootLength = PathInternal.GetRootLength(path);
			if (rootLength > 0)
			{
				return path.Slice(0, rootLength);
			}
			return ReadOnlySpan<char>.Empty;
		}

		internal static ReadOnlySpan<char> GetVolumeName(ReadOnlySpan<char> path)
		{
			ReadOnlySpan<char> pathRoot = GetPathRoot(path);
			if (pathRoot.Length == 0)
			{
				return pathRoot;
			}
			int num = GetUncRootLength(path);
			if (num == -1)
			{
				num = (PathInternal.IsDevice(path) ? 4 : 0);
			}
			ReadOnlySpan<char> readOnlySpan = pathRoot.Slice(num);
			if (!EndsInDirectorySeparator(readOnlySpan))
			{
				return readOnlySpan;
			}
			return readOnlySpan.Slice(0, readOnlySpan.Length - 1);
		}

		internal static int GetUncRootLength(ReadOnlySpan<char> path)
		{
			bool flag = PathInternal.IsDevice(path);
			if (!flag && path.Slice(0, 2).EqualsOrdinal("\\\\".AsSpan()))
			{
				return 2;
			}
			if (flag && path.Length >= 8 && (path.Slice(0, 8).EqualsOrdinal("\\\\?\\UNC\\".AsSpan()) || path.Slice(5, 4).EqualsOrdinal("UNC\\".AsSpan())))
			{
				return 8;
			}
			return -1;
		}
	}
	internal static class PathInternal
	{
		internal static StringComparison StringComparison
		{
			get
			{
				_ = IsCaseSensitive;
				return StringComparison.OrdinalIgnoreCase;
			}
		}

		internal static bool IsCaseSensitive
		{
			get
			{
				if (!OperatingSystem.IsWindows())
				{
				}
				return false;
			}
		}

		internal static bool StartsWithDirectorySeparator(ReadOnlySpan<char> path)
		{
			if (path.Length > 0)
			{
				return IsDirectorySeparator(path[0]);
			}
			return false;
		}

		internal static string EnsureTrailingSeparator(string path)
		{
			if (!EndsInDirectorySeparator(path.AsSpan()))
			{
				return path + "\\";
			}
			return path;
		}

		internal static bool IsRoot(ReadOnlySpan<char> path)
		{
			return path.Length == GetRootLength(path);
		}

		internal static int GetCommonPathLength(string first, string second, bool ignoreCase)
		{
			int num = EqualStartingCharacterCount(first, second, ignoreCase);
			if (num == 0)
			{
				return num;
			}
			if (num == first.Length && (num == second.Length || IsDirectorySeparator(second[num])))
			{
				return num;
			}
			if (num == second.Length && IsDirectorySeparator(first[num]))
			{
				return num;
			}
			while (num > 0 && !IsDirectorySeparator(first[num - 1]))
			{
				num--;
			}
			return num;
		}

		internal unsafe static int EqualStartingCharacterCount(string first, string second, bool ignoreCase)
		{
			//The blocks IL_0037, IL_005c, IL_006c, IL_0072, IL_0078, IL_0080, IL_0083 are reachable both inside and outside the pinned region starting at IL_0032. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			if (string.IsNullOrEmpty(first) || string.IsNullOrEmpty(second))
			{
				return 0;
			}
			int num = 0;
			fixed (char* ptr2 = first)
			{
				char* intPtr;
				if (second == null)
				{
					char* ptr;
					intPtr = (ptr = null);
					char* ptr3 = ptr2;
					char* ptr4 = ptr;
					char* ptr5 = ptr3 + first.Length;
					char* ptr6 = ptr4 + second.Length;
					while (ptr3 != ptr5 && ptr4 != ptr6 && (*ptr3 == *ptr4 || (ignoreCase && char.ToUpperInvariant(*ptr3) == char.ToUpperInvariant(*ptr4))))
					{
						num++;
						ptr3++;
						ptr4++;
					}
				}
				else
				{
					fixed (char* ptr7 = &second.GetPinnableReference())
					{
						char* ptr;
						intPtr = (ptr = ptr7);
						char* ptr3 = ptr2;
						char* ptr4 = ptr;
						char* ptr5 = ptr3 + first.Length;
						char* ptr6 = ptr4 + second.Length;
						while (ptr3 != ptr5 && ptr4 != ptr6 && (*ptr3 == *ptr4 || (ignoreCase && char.ToUpperInvariant(*ptr3) == char.ToUpperInvariant(*ptr4))))
						{
							num++;
							ptr3++;
							ptr4++;
						}
					}
				}
			}
			return num;
		}

		internal static bool AreRootsEqual(string first, string second, StringComparison comparisonType)
		{
			int rootLength = GetRootLength(first.AsSpan());
			int rootLength2 = GetRootLength(second.AsSpan());
			if (rootLength == rootLength2)
			{
				return string.Compare(first, 0, second, 0, rootLength, comparisonType) == 0;
			}
			return false;
		}

		internal static string RemoveRelativeSegments(string path, int rootLength)
		{
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder sb = new ValueStringBuilder(initialBuffer);
			if (RemoveRelativeSegments(path.AsSpan(), rootLength, ref sb))
			{
				path = sb.ToString();
			}
			sb.Dispose();
			return path;
		}

		internal static bool RemoveRelativeSegments(ReadOnlySpan<char> path, int rootLength, ref ValueStringBuilder sb)
		{
			bool flag = false;
			int num = rootLength;
			if (IsDirectorySeparator(path[num - 1]))
			{
				num--;
			}
			if (num > 0)
			{
				sb.Append(path.Slice(0, num));
			}
			for (int i = num; i < path.Length; i++)
			{
				char c = path[i];
				if (IsDirectorySeparator(c) && i + 1 < path.Length)
				{
					if (IsDirectorySeparator(path[i + 1]))
					{
						continue;
					}
					if ((i + 2 == path.Length || IsDirectorySeparator(path[i + 2])) && path[i + 1] == '.')
					{
						i++;
						continue;
					}
					if (i + 2 < path.Length && (i + 3 == path.Length || IsDirectorySeparator(path[i + 3])) && path[i + 1] == '.' && path[i + 2] == '.')
					{
						int num2;
						for (num2 = sb.Length - 1; num2 >= num; num2--)
						{
							if (IsDirectorySeparator(sb[num2]))
							{
								sb.Length = ((i + 3 >= path.Length && num2 == num) ? (num2 + 1) : num2);
								break;
							}
						}
						if (num2 < num)
						{
							sb.Length = num;
						}
						i += 2;
						continue;
					}
				}
				if (c != '\\' && c == '/')
				{
					c = '\\';
					flag = true;
				}
				sb.Append(c);
			}
			if (!flag && sb.Length == path.Length)
			{
				return false;
			}
			if (num != rootLength && sb.Length < rootLength)
			{
				sb.Append(path[rootLength - 1]);
			}
			return true;
		}

		[return: NotNullIfNotNull("path")]
		internal static string TrimEndingDirectorySeparator(string path)
		{
			if (!EndsInDirectorySeparator(path) || IsRoot(path.AsSpan()))
			{
				return path;
			}
			return path.Substring(0, path.Length - 1);
		}

		internal static bool EndsInDirectorySeparator(string path)
		{
			if (!string.IsNullOrEmpty(path))
			{
				return IsDirectorySeparator(path[path.Length - 1]);
			}
			return false;
		}

		internal static ReadOnlySpan<char> TrimEndingDirectorySeparator(ReadOnlySpan<char> path)
		{
			if (!EndsInDirectorySeparator(path) || IsRoot(path))
			{
				return path;
			}
			return path.Slice(0, path.Length - 1);
		}

		internal static bool EndsInDirectorySeparator(ReadOnlySpan<char> path)
		{
			if (path.Length > 0)
			{
				return IsDirectorySeparator(path[path.Length - 1]);
			}
			return false;
		}

		internal static string GetLinkTargetFullPath(string path, string pathToTarget)
		{
			if (!IsPartiallyQualified(pathToTarget.AsSpan()))
			{
				return pathToTarget;
			}
			return Path.Join(Path.GetDirectoryName(path.AsSpan()), pathToTarget.AsSpan());
		}

		internal static bool IsValidDriveChar(char value)
		{
			if (value < 'A' || value > 'Z')
			{
				if (value >= 'a')
				{
					return value <= 'z';
				}
				return false;
			}
			return true;
		}

		internal static bool EndsWithPeriodOrSpace(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return false;
			}
			char c = path[path.Length - 1];
			if (c != ' ')
			{
				return c == '.';
			}
			return true;
		}

		[return: NotNullIfNotNull("path")]
		internal static string EnsureExtendedPrefixIfNeeded(string path)
		{
			if (path != null && (path.Length >= 260 || EndsWithPeriodOrSpace(path)))
			{
				return EnsureExtendedPrefix(path);
			}
			return path;
		}

		internal static string EnsureExtendedPrefix(string path)
		{
			if (IsPartiallyQualified(path.AsSpan()) || IsDevice(path.AsSpan()))
			{
				return path;
			}
			if (path.StartsWith("\\\\", StringComparison.OrdinalIgnoreCase))
			{
				return path.Insert(2, "?\\UNC\\");
			}
			return "\\\\?\\" + path;
		}

		internal static bool IsDevice(ReadOnlySpan<char> path)
		{
			if (!IsExtended(path))
			{
				if (path.Length >= 4 && IsDirectorySeparator(path[0]) && IsDirectorySeparator(path[1]) && (path[2] == '.' || path[2] == '?'))
				{
					return IsDirectorySeparator(path[3]);
				}
				return false;
			}
			return true;
		}

		internal static bool IsDeviceUNC(ReadOnlySpan<char> path)
		{
			if (path.Length >= 8 && IsDevice(path) && IsDirectorySeparator(path[7]) && path[4] == 'U' && path[5] == 'N')
			{
				return path[6] == 'C';
			}
			return false;
		}

		internal static bool IsExtended(ReadOnlySpan<char> path)
		{
			if (path.Length >= 4 && path[0] == '\\' && (path[1] == '\\' || path[1] == '?') && path[2] == '?')
			{
				return path[3] == '\\';
			}
			return false;
		}

		internal static int GetRootLength(ReadOnlySpan<char> path)
		{
			int length = path.Length;
			int i = 0;
			bool flag = IsDevice(path);
			bool flag2 = flag && IsDeviceUNC(path);
			if ((!flag || flag2) && length > 0 && IsDirectorySeparator(path[0]))
			{
				if (flag2 || (length > 1 && IsDirectorySeparator(path[1])))
				{
					i = (flag2 ? 8 : 2);
					int num = 2;
					for (; i < length; i++)
					{
						if (IsDirectorySeparator(path[i]) && --num <= 0)
						{
							break;
						}
					}
				}
				else
				{
					i = 1;
				}
			}
			else if (flag)
			{
				for (i = 4; i < length && !IsDirectorySeparator(path[i]); i++)
				{
				}
				if (i < length && i > 4 && IsDirectorySeparator(path[i]))
				{
					i++;
				}
			}
			else if (length >= 2 && path[1] == ':' && IsValidDriveChar(path[0]))
			{
				i = 2;
				if (length > 2 && IsDirectorySeparator(path[2]))
				{
					i++;
				}
			}
			return i;
		}

		internal static bool IsPartiallyQualified(ReadOnlySpan<char> path)
		{
			if (path.Length < 2)
			{
				return true;
			}
			if (IsDirectorySeparator(path[0]))
			{
				if (path[1] != '?')
				{
					return !IsDirectorySeparator(path[1]);
				}
				return false;
			}
			if (path.Length >= 3 && path[1] == ':' && IsDirectorySeparator(path[2]))
			{
				return !IsValidDriveChar(path[0]);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsDirectorySeparator(char c)
		{
			if (c != '\\')
			{
				return c == '/';
			}
			return true;
		}

		[return: NotNullIfNotNull("path")]
		internal static string NormalizeDirectorySeparators(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return path;
			}
			bool flag = true;
			for (int i = 0; i < path.Length; i++)
			{
				char c = path[i];
				if (IsDirectorySeparator(c) && (c != '\\' || (i > 0 && i + 1 < path.Length && IsDirectorySeparator(path[i + 1]))))
				{
					flag = false;
					break;
				}
			}
			if (flag)
			{
				return path;
			}
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			int num = 0;
			if (IsDirectorySeparator(path[num]))
			{
				num++;
				valueStringBuilder.Append('\\');
			}
			for (int j = num; j < path.Length; j++)
			{
				char c = path[j];
				if (IsDirectorySeparator(c))
				{
					if (j + 1 < path.Length && IsDirectorySeparator(path[j + 1]))
					{
						continue;
					}
					c = '\\';
				}
				valueStringBuilder.Append(c);
			}
			return valueStringBuilder.ToString();
		}

		internal static bool IsEffectivelyEmpty(ReadOnlySpan<char> path)
		{
			if (path.IsEmpty)
			{
				return true;
			}
			ReadOnlySpan<char> readOnlySpan = path;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				char c = readOnlySpan[i];
				if (c != ' ')
				{
					return false;
				}
			}
			return true;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class PathTooLongException : IOException
	{
		public PathTooLongException()
			: base(SR.IO_PathTooLong)
		{
			base.HResult = -2147024690;
		}

		public PathTooLongException(string? message)
			: base(message)
		{
			base.HResult = -2147024690;
		}

		public PathTooLongException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2147024690;
		}

		protected PathTooLongException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal sealed class PinnedBufferMemoryStream : UnmanagedMemoryStream
	{
		private readonly byte[] _array;

		private GCHandle _pinningHandle;

		internal unsafe PinnedBufferMemoryStream(byte[] array)
		{
			_array = array;
			_pinningHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
			int num = array.Length;
			fixed (byte* pointer = &MemoryMarshal.GetReference<byte>(array))
			{
				Initialize(pointer, num, num, FileAccess.Read);
			}
		}

		public override int Read(Span<byte> buffer)
		{
			return ReadCore(buffer);
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			WriteCore(buffer);
		}

		~PinnedBufferMemoryStream()
		{
			Dispose(disposing: false);
		}

		protected override void Dispose(bool disposing)
		{
			if (_pinningHandle.IsAllocated)
			{
				_pinningHandle.Free();
			}
			base.Dispose(disposing);
		}
	}
	public static class RandomAccess
	{
		private sealed class CallbackResetEvent : EventWaitHandle
		{
			private readonly ThreadPoolBoundHandle _threadPoolBoundHandle;

			private int _freeWhenZero = 2;

			internal CallbackResetEvent(ThreadPoolBoundHandle threadPoolBoundHandle)
				: base(initialState: false, EventResetMode.ManualReset)
			{
				_threadPoolBoundHandle = threadPoolBoundHandle;
			}

			internal unsafe void ReleaseRefCount(NativeOverlapped* pOverlapped)
			{
				if (Interlocked.Decrement(ref _freeWhenZero) == 0)
				{
					_threadPoolBoundHandle.FreeNativeOverlapped(pOverlapped);
				}
			}
		}

		private interface IMemoryHandler<T>
		{
			int GetLength(in T memory);

			MemoryHandle Pin(in T memory);
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private readonly struct MemoryHandler : IMemoryHandler<Memory<byte>>
		{
			public int GetLength(in Memory<byte> memory)
			{
				return memory.Length;
			}

			public MemoryHandle Pin(in Memory<byte> memory)
			{
				return memory.Pin();
			}

			int IMemoryHandler<Memory<byte>>.GetLength(in Memory<byte> memory)
			{
				return GetLength(in memory);
			}

			MemoryHandle IMemoryHandler<Memory<byte>>.Pin(in Memory<byte> memory)
			{
				return Pin(in memory);
			}
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private readonly struct ReadOnlyMemoryHandler : IMemoryHandler<ReadOnlyMemory<byte>>
		{
			public int GetLength(in ReadOnlyMemory<byte> memory)
			{
				return memory.Length;
			}

			public MemoryHandle Pin(in ReadOnlyMemory<byte> memory)
			{
				return memory.Pin();
			}

			int IMemoryHandler<ReadOnlyMemory<byte>>.GetLength(in ReadOnlyMemory<byte> memory)
			{
				return GetLength(in memory);
			}

			MemoryHandle IMemoryHandler<ReadOnlyMemory<byte>>.Pin(in ReadOnlyMemory<byte> memory)
			{
				return Pin(in memory);
			}
		}

		private static readonly IOCompletionCallback s_callback = AllocateCallback();

		private static readonly int s_cachedPageSize = Environment.SystemPageSize;

		public static long GetLength(SafeFileHandle handle)
		{
			ValidateInput(handle, 0L);
			return GetFileLength(handle);
		}

		public static int Read(SafeFileHandle handle, Span<byte> buffer, long fileOffset)
		{
			ValidateInput(handle, fileOffset);
			return ReadAtOffset(handle, buffer, fileOffset);
		}

		public static long Read(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset)
		{
			ValidateInput(handle, fileOffset);
			ValidateBuffers(buffers);
			return ReadScatterAtOffset(handle, buffers, fileOffset);
		}

		public static ValueTask<int> ReadAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken = default(CancellationToken))
		{
			ValidateInput(handle, fileOffset);
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			return ReadAtOffsetAsync(handle, buffer, fileOffset, cancellationToken);
		}

		public static ValueTask<long> ReadAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset, CancellationToken cancellationToken = default(CancellationToken))
		{
			ValidateInput(handle, fileOffset);
			ValidateBuffers(buffers);
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<long>(cancellationToken);
			}
			return ReadScatterAtOffsetAsync(handle, buffers, fileOffset, cancellationToken);
		}

		public static void Write(SafeFileHandle handle, ReadOnlySpan<byte> buffer, long fileOffset)
		{
			ValidateInput(handle, fileOffset);
			WriteAtOffset(handle, buffer, fileOffset);
		}

		public static void Write(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset)
		{
			ValidateInput(handle, fileOffset);
			ValidateBuffers(buffers);
			WriteGatherAtOffset(handle, buffers, fileOffset);
		}

		public static ValueTask WriteAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken = default(CancellationToken))
		{
			ValidateInput(handle, fileOffset);
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled(cancellationToken);
			}
			return WriteAtOffsetAsync(handle, buffer, fileOffset, cancellationToken);
		}

		public static ValueTask WriteAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset, CancellationToken cancellationToken = default(CancellationToken))
		{
			ValidateInput(handle, fileOffset);
			ValidateBuffers(buffers);
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled(cancellationToken);
			}
			return WriteGatherAtOffsetAsync(handle, buffers, fileOffset, cancellationToken);
		}

		private static void ValidateInput(SafeFileHandle handle, long fileOffset)
		{
			if (handle == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.handle);
			}
			else if (handle.IsInvalid)
			{
				ThrowHelper.ThrowArgumentException_InvalidHandle("handle");
			}
			else if (!handle.CanSeek)
			{
				if (handle.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				ThrowHelper.ThrowNotSupportedException_UnseekableStream();
			}
			else if (fileOffset < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum("fileOffset");
			}
		}

		private static void ValidateBuffers<T>(IReadOnlyList<T> buffers)
		{
			if (buffers == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.buffers);
			}
		}

		private static ValueTask<int> ScheduleSyncReadAtOffsetAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy strategy)
		{
			return handle.GetThreadPoolValueTaskSource().QueueRead(buffer, fileOffset, cancellationToken, strategy);
		}

		private static ValueTask<long> ScheduleSyncReadScatterAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset, CancellationToken cancellationToken)
		{
			return handle.GetThreadPoolValueTaskSource().QueueReadScatter(buffers, fileOffset, cancellationToken);
		}

		private static ValueTask ScheduleSyncWriteAtOffsetAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy strategy)
		{
			return handle.GetThreadPoolValueTaskSource().QueueWrite(buffer, fileOffset, cancellationToken, strategy);
		}

		private static ValueTask ScheduleSyncWriteGatherAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset, CancellationToken cancellationToken)
		{
			return handle.GetThreadPoolValueTaskSource().QueueWriteGather(buffers, fileOffset, cancellationToken);
		}

		internal unsafe static long GetFileLength(SafeFileHandle handle)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.Kernel32.FILE_STANDARD_INFO fILE_STANDARD_INFO);
			if (!Interop.Kernel32.GetFileInformationByHandleEx(handle, 1, &fILE_STANDARD_INFO, (uint)sizeof(Interop.Kernel32.FILE_STANDARD_INFO)))
			{
				throw Win32Marshal.GetExceptionForLastWin32Error(handle.Path);
			}
			return fILE_STANDARD_INFO.EndOfFile;
		}

		internal unsafe static int ReadAtOffset(SafeFileHandle handle, Span<byte> buffer, long fileOffset)
		{
			if (handle.IsAsync)
			{
				return ReadSyncUsingAsyncHandle(handle, buffer, fileOffset);
			}
			NativeOverlapped nativeOverlappedForSyncHandle = GetNativeOverlappedForSyncHandle(handle, fileOffset);
			fixed (byte* bytes = &MemoryMarshal.GetReference(buffer))
			{
				if (Interop.Kernel32.ReadFile(handle, bytes, buffer.Length, out var numBytesRead, &nativeOverlappedForSyncHandle) != 0)
				{
					return numBytesRead;
				}
				int lastWin32ErrorAndDisposeHandleIfInvalid = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
				return lastWin32ErrorAndDisposeHandleIfInvalid switch
				{
					38 => numBytesRead, 
					109 => 0, 
					_ => throw Win32Marshal.GetExceptionForWin32Error(lastWin32ErrorAndDisposeHandleIfInvalid, handle.Path), 
				};
			}
		}

		private unsafe static int ReadSyncUsingAsyncHandle(SafeFileHandle handle, Span<byte> buffer, long fileOffset)
		{
			handle.EnsureThreadPoolBindingInitialized();
			CallbackResetEvent callbackResetEvent = new CallbackResetEvent(handle.ThreadPoolBinding);
			NativeOverlapped* ptr = null;
			try
			{
				ptr = GetNativeOverlappedForAsyncHandle(handle, fileOffset, callbackResetEvent);
				fixed (byte* bytes = &MemoryMarshal.GetReference(buffer))
				{
					Interop.Kernel32.ReadFile(handle, bytes, buffer.Length, IntPtr.Zero, ptr);
					int num = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					if (num == 997)
					{
						callbackResetEvent.WaitOne();
						num = 0;
					}
					if (num == 0)
					{
						int lpNumberOfBytesTransferred = 0;
						if (Interop.Kernel32.GetOverlappedResult(handle, ptr, ref lpNumberOfBytesTransferred, bWait: false))
						{
							return lpNumberOfBytesTransferred;
						}
						num = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					}
					else
					{
						callbackResetEvent.ReleaseRefCount(ptr);
					}
					if (num == 38 || num == 109)
					{
						ptr->InternalLow = IntPtr.Zero;
						return 0;
					}
					throw Win32Marshal.GetExceptionForWin32Error(num, handle.Path);
				}
			}
			finally
			{
				if (ptr != null)
				{
					callbackResetEvent.ReleaseRefCount(ptr);
				}
				callbackResetEvent.Dispose();
			}
		}

		internal unsafe static void WriteAtOffset(SafeFileHandle handle, ReadOnlySpan<byte> buffer, long fileOffset)
		{
			if (buffer.IsEmpty)
			{
				return;
			}
			if (handle.IsAsync)
			{
				WriteSyncUsingAsyncHandle(handle, buffer, fileOffset);
				return;
			}
			NativeOverlapped nativeOverlappedForSyncHandle = GetNativeOverlappedForSyncHandle(handle, fileOffset);
			fixed (byte* bytes = &MemoryMarshal.GetReference(buffer))
			{
				if (Interop.Kernel32.WriteFile(handle, bytes, buffer.Length, out var _, &nativeOverlappedForSyncHandle) == 0)
				{
					int lastWin32ErrorAndDisposeHandleIfInvalid = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					if (lastWin32ErrorAndDisposeHandleIfInvalid != 232)
					{
						throw Win32Marshal.GetExceptionForWin32Error(lastWin32ErrorAndDisposeHandleIfInvalid, handle.Path);
					}
				}
			}
		}

		private unsafe static void WriteSyncUsingAsyncHandle(SafeFileHandle handle, ReadOnlySpan<byte> buffer, long fileOffset)
		{
			if (buffer.IsEmpty)
			{
				return;
			}
			handle.EnsureThreadPoolBindingInitialized();
			CallbackResetEvent callbackResetEvent = new CallbackResetEvent(handle.ThreadPoolBinding);
			NativeOverlapped* ptr = null;
			try
			{
				ptr = GetNativeOverlappedForAsyncHandle(handle, fileOffset, callbackResetEvent);
				fixed (byte* bytes = &MemoryMarshal.GetReference(buffer))
				{
					Interop.Kernel32.WriteFile(handle, bytes, buffer.Length, IntPtr.Zero, ptr);
					int num = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					if (num == 997)
					{
						callbackResetEvent.WaitOne();
						num = 0;
					}
					if (num == 0)
					{
						int lpNumberOfBytesTransferred = 0;
						if (Interop.Kernel32.GetOverlappedResult(handle, ptr, ref lpNumberOfBytesTransferred, bWait: false))
						{
							return;
						}
						num = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					}
					else
					{
						callbackResetEvent.ReleaseRefCount(ptr);
					}
					switch (num)
					{
					case 232:
						break;
					case 87:
						throw new IOException(SR.IO_FileTooLong);
					default:
						throw Win32Marshal.GetExceptionForWin32Error(num, handle.Path);
					}
				}
			}
			finally
			{
				if (ptr != null)
				{
					callbackResetEvent.ReleaseRefCount(ptr);
				}
				callbackResetEvent.Dispose();
			}
		}

		internal static ValueTask<int> ReadAtOffsetAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy strategy = null)
		{
			if (handle.IsAsync)
			{
				var (overlappedValueTaskSource, num) = QueueAsyncReadFile(handle, buffer, fileOffset, cancellationToken, strategy);
				if (overlappedValueTaskSource != null)
				{
					return new ValueTask<int>(overlappedValueTaskSource, overlappedValueTaskSource.Version);
				}
				if (num == 0)
				{
					return ValueTask.FromResult(0);
				}
				return ValueTask.FromException<int>(Win32Marshal.GetExceptionForWin32Error(num, handle.Path));
			}
			return ScheduleSyncReadAtOffsetAsync(handle, buffer, fileOffset, cancellationToken, strategy);
		}

		private unsafe static (SafeFileHandle.OverlappedValueTaskSource vts, int errorCode) QueueAsyncReadFile(SafeFileHandle handle, Memory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy strategy)
		{
			handle.EnsureThreadPoolBindingInitialized();
			SafeFileHandle.OverlappedValueTaskSource overlappedValueTaskSource = handle.GetOverlappedValueTaskSource();
			int num = 0;
			try
			{
				NativeOverlapped* ptr = overlappedValueTaskSource.PrepareForOperation(buffer, fileOffset, strategy);
				if (Interop.Kernel32.ReadFile(handle, (byte*)overlappedValueTaskSource._memoryHandle.Pointer, buffer.Length, IntPtr.Zero, ptr) == 0)
				{
					num = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					switch (num)
					{
					case 997:
						overlappedValueTaskSource.RegisterForCancellation(cancellationToken);
						break;
					case 38:
					case 109:
						ptr->InternalLow = IntPtr.Zero;
						overlappedValueTaskSource.Dispose();
						return (null, 0);
					default:
						overlappedValueTaskSource.Dispose();
						return (null, num);
					}
				}
			}
			catch
			{
				overlappedValueTaskSource.Dispose();
				throw;
			}
			finally
			{
				if (num != 997 && num != 0)
				{
					strategy?.OnIncompleteOperation(buffer.Length, 0);
				}
			}
			overlappedValueTaskSource.FinishedScheduling();
			return (overlappedValueTaskSource, -1);
		}

		internal static ValueTask WriteAtOffsetAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy strategy = null)
		{
			if (handle.IsAsync)
			{
				var (overlappedValueTaskSource, num) = QueueAsyncWriteFile(handle, buffer, fileOffset, cancellationToken, strategy);
				if (overlappedValueTaskSource != null)
				{
					return new ValueTask(overlappedValueTaskSource, overlappedValueTaskSource.Version);
				}
				if (num == 0)
				{
					return ValueTask.CompletedTask;
				}
				return ValueTask.FromException(Win32Marshal.GetExceptionForWin32Error(num, handle.Path));
			}
			return ScheduleSyncWriteAtOffsetAsync(handle, buffer, fileOffset, cancellationToken, strategy);
		}

		private unsafe static (SafeFileHandle.OverlappedValueTaskSource vts, int errorCode) QueueAsyncWriteFile(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy strategy)
		{
			handle.EnsureThreadPoolBindingInitialized();
			SafeFileHandle.OverlappedValueTaskSource overlappedValueTaskSource = handle.GetOverlappedValueTaskSource();
			int num = 0;
			try
			{
				NativeOverlapped* lpOverlapped = overlappedValueTaskSource.PrepareForOperation(buffer, fileOffset, strategy);
				if (Interop.Kernel32.WriteFile(handle, (byte*)overlappedValueTaskSource._memoryHandle.Pointer, buffer.Length, IntPtr.Zero, lpOverlapped) == 0)
				{
					num = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					switch (num)
					{
					case 997:
						overlappedValueTaskSource.RegisterForCancellation(cancellationToken);
						break;
					case 232:
						overlappedValueTaskSource.Dispose();
						return (null, 0);
					default:
						overlappedValueTaskSource.Dispose();
						return (null, num);
					}
				}
			}
			catch
			{
				overlappedValueTaskSource.Dispose();
				throw;
			}
			finally
			{
				if (num != 997 && num != 0)
				{
					strategy?.OnIncompleteOperation(buffer.Length, 0);
				}
			}
			overlappedValueTaskSource.FinishedScheduling();
			return (overlappedValueTaskSource, -1);
		}

		internal static long ReadScatterAtOffset(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset)
		{
			long num = 0L;
			int count = buffers.Count;
			for (int i = 0; i < count; i++)
			{
				Span<byte> span = buffers[i].Span;
				int num2 = ReadAtOffset(handle, span, fileOffset + num);
				num += num2;
				if (num2 != span.Length)
				{
					break;
				}
			}
			return num;
		}

		internal static void WriteGatherAtOffset(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset)
		{
			int num = 0;
			int count = buffers.Count;
			for (int i = 0; i < count; i++)
			{
				ReadOnlySpan<byte> span = buffers[i].Span;
				WriteAtOffset(handle, span, fileOffset + num);
				num += span.Length;
			}
		}

		private static bool CanUseScatterGatherWindowsAPIs(SafeFileHandle handle)
		{
			if (handle.IsAsync)
			{
				return (handle.GetFileOptions() & (FileOptions)536870912) != 0;
			}
			return false;
		}

		private unsafe static bool TryPrepareScatterGatherBuffers<T, THandler>(IReadOnlyList<T> buffers, THandler handler, [NotNullWhen(true)] out MemoryHandle[] handlesToDispose, out IntPtr segmentsPtr, out int totalBytes) where THandler : struct, IMemoryHandler<T>
		{
			int num = s_cachedPageSize;
			long num2 = num - 1;
			int count = buffers.Count;
			handlesToDispose = null;
			segmentsPtr = IntPtr.Zero;
			totalBytes = 0;
			long* ptr = null;
			bool flag = false;
			try
			{
				long num3 = 0L;
				for (int i = 0; i < count; i++)
				{
					T memory = buffers[i];
					int length = handler.GetLength(in memory);
					num3 += length;
					if (length != num || num3 > int.MaxValue)
					{
						return false;
					}
					MemoryHandle memoryHandle = handler.Pin(in memory);
					long num4 = (long)memoryHandle.Pointer;
					if ((num4 & num2) != 0L)
					{
						memoryHandle.Dispose();
						return false;
					}
					(handlesToDispose ?? (handlesToDispose = new MemoryHandle[count]))[i] = memoryHandle;
					if (ptr == null)
					{
						ptr = (long*)NativeMemory.Alloc((nuint)count + (nuint)1u, 8u);
						ptr[count] = 0L;
					}
					ptr[i] = num4;
				}
				segmentsPtr = (IntPtr)ptr;
				totalBytes = (int)num3;
				flag = true;
				return handlesToDispose != null;
			}
			finally
			{
				if (!flag)
				{
					CleanupScatterGatherBuffers(handlesToDispose, (IntPtr)ptr);
				}
			}
		}

		private unsafe static void CleanupScatterGatherBuffers(MemoryHandle[] handlesToDispose, IntPtr segmentsPtr)
		{
			if (handlesToDispose != null)
			{
				foreach (MemoryHandle memoryHandle in handlesToDispose)
				{
					memoryHandle.Dispose();
				}
			}
			if (segmentsPtr != IntPtr.Zero)
			{
				NativeMemory.Free((void*)segmentsPtr);
			}
		}

		private static ValueTask<long> ReadScatterAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset, CancellationToken cancellationToken)
		{
			if (!handle.IsAsync)
			{
				return ScheduleSyncReadScatterAtOffsetAsync(handle, buffers, fileOffset, cancellationToken);
			}
			if (CanUseScatterGatherWindowsAPIs(handle) && TryPrepareScatterGatherBuffers(buffers, default(MemoryHandler), out var handlesToDispose, out var segmentsPtr, out var totalBytes))
			{
				return ReadScatterAtOffsetSingleSyscallAsync(handle, handlesToDispose, segmentsPtr, fileOffset, totalBytes, cancellationToken);
			}
			return ReadScatterAtOffsetMultipleSyscallsAsync(handle, buffers, fileOffset, cancellationToken);
		}

		private static async ValueTask<long> ReadScatterAtOffsetSingleSyscallAsync(SafeFileHandle handle, MemoryHandle[] handlesToDispose, IntPtr segmentsPtr, long fileOffset, int totalBytes, CancellationToken cancellationToken)
		{
			try
			{
				return await ReadFileScatterAsync(handle, segmentsPtr, totalBytes, fileOffset, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				CleanupScatterGatherBuffers(handlesToDispose, segmentsPtr);
			}
		}

		private unsafe static ValueTask<int> ReadFileScatterAsync(SafeFileHandle handle, IntPtr segmentsPtr, int bytesToRead, long fileOffset, CancellationToken cancellationToken)
		{
			handle.EnsureThreadPoolBindingInitialized();
			SafeFileHandle.OverlappedValueTaskSource overlappedValueTaskSource = handle.GetOverlappedValueTaskSource();
			try
			{
				NativeOverlapped* ptr = overlappedValueTaskSource.PrepareForOperation(Memory<byte>.Empty, fileOffset);
				if (Interop.Kernel32.ReadFileScatter(handle, (long*)(void*)segmentsPtr, bytesToRead, IntPtr.Zero, ptr) == 0)
				{
					int lastWin32ErrorAndDisposeHandleIfInvalid = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					switch (lastWin32ErrorAndDisposeHandleIfInvalid)
					{
					case 997:
						overlappedValueTaskSource.RegisterForCancellation(cancellationToken);
						break;
					case 38:
					case 109:
						ptr->InternalLow = IntPtr.Zero;
						overlappedValueTaskSource.Dispose();
						return ValueTask.FromResult(0);
					default:
						overlappedValueTaskSource.Dispose();
						return ValueTask.FromException<int>(Win32Marshal.GetExceptionForWin32Error(lastWin32ErrorAndDisposeHandleIfInvalid, handle.Path));
					}
				}
			}
			catch
			{
				overlappedValueTaskSource.Dispose();
				throw;
			}
			overlappedValueTaskSource.FinishedScheduling();
			return new ValueTask<int>(overlappedValueTaskSource, overlappedValueTaskSource.Version);
		}

		private static async ValueTask<long> ReadScatterAtOffsetMultipleSyscallsAsync(SafeFileHandle handle, IReadOnlyList<Memory<byte>> buffers, long fileOffset, CancellationToken cancellationToken)
		{
			long total = 0L;
			int buffersCount = buffers.Count;
			for (int i = 0; i < buffersCount; i++)
			{
				Memory<byte> buffer = buffers[i];
				int num = await ReadAtOffsetAsync(handle, buffer, fileOffset + total, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				total += num;
				if (num != buffer.Length)
				{
					break;
				}
			}
			return total;
		}

		private static ValueTask WriteGatherAtOffsetAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset, CancellationToken cancellationToken)
		{
			if (!handle.IsAsync)
			{
				return ScheduleSyncWriteGatherAtOffsetAsync(handle, buffers, fileOffset, cancellationToken);
			}
			if (CanUseScatterGatherWindowsAPIs(handle) && TryPrepareScatterGatherBuffers(buffers, default(ReadOnlyMemoryHandler), out var handlesToDispose, out var segmentsPtr, out var totalBytes))
			{
				return WriteGatherAtOffsetSingleSyscallAsync(handle, handlesToDispose, segmentsPtr, fileOffset, totalBytes, cancellationToken);
			}
			return WriteGatherAtOffsetMultipleSyscallsAsync(handle, buffers, fileOffset, cancellationToken);
		}

		private static async ValueTask WriteGatherAtOffsetSingleSyscallAsync(SafeFileHandle handle, MemoryHandle[] handlesToDispose, IntPtr segmentsPtr, long fileOffset, int totalBytes, CancellationToken cancellationToken)
		{
			try
			{
				await WriteFileGatherAsync(handle, segmentsPtr, totalBytes, fileOffset, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				CleanupScatterGatherBuffers(handlesToDispose, segmentsPtr);
			}
		}

		private unsafe static ValueTask WriteFileGatherAsync(SafeFileHandle handle, IntPtr segmentsPtr, int bytesToWrite, long fileOffset, CancellationToken cancellationToken)
		{
			handle.EnsureThreadPoolBindingInitialized();
			SafeFileHandle.OverlappedValueTaskSource overlappedValueTaskSource = handle.GetOverlappedValueTaskSource();
			try
			{
				NativeOverlapped* lpOverlapped = overlappedValueTaskSource.PrepareForOperation(ReadOnlyMemory<byte>.Empty, fileOffset);
				if (Interop.Kernel32.WriteFileGather(handle, (long*)(void*)segmentsPtr, bytesToWrite, IntPtr.Zero, lpOverlapped) == 0)
				{
					int lastWin32ErrorAndDisposeHandleIfInvalid = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
					if (lastWin32ErrorAndDisposeHandleIfInvalid != 997)
					{
						overlappedValueTaskSource.Dispose();
						return (lastWin32ErrorAndDisposeHandleIfInvalid == 232) ? ValueTask.CompletedTask : ValueTask.FromException(SafeFileHandle.OverlappedValueTaskSource.GetIOError(lastWin32ErrorAndDisposeHandleIfInvalid, null));
					}
					overlappedValueTaskSource.RegisterForCancellation(cancellationToken);
				}
			}
			catch
			{
				overlappedValueTaskSource.Dispose();
				throw;
			}
			overlappedValueTaskSource.FinishedScheduling();
			return new ValueTask(overlappedValueTaskSource, overlappedValueTaskSource.Version);
		}

		private static async ValueTask WriteGatherAtOffsetMultipleSyscallsAsync(SafeFileHandle handle, IReadOnlyList<ReadOnlyMemory<byte>> buffers, long fileOffset, CancellationToken cancellationToken)
		{
			int buffersCount = buffers.Count;
			for (int i = 0; i < buffersCount; i++)
			{
				ReadOnlyMemory<byte> rom = buffers[i];
				await WriteAtOffsetAsync(handle, rom, fileOffset, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				fileOffset += rom.Length;
			}
		}

		private unsafe static NativeOverlapped* GetNativeOverlappedForAsyncHandle(SafeFileHandle handle, long fileOffset, CallbackResetEvent resetEvent)
		{
			NativeOverlapped* ptr = handle.ThreadPoolBinding.UnsafeAllocateNativeOverlapped(s_callback, resetEvent, null);
			if (handle.CanSeek)
			{
				ptr->OffsetLow = (int)fileOffset;
				ptr->OffsetHigh = (int)(fileOffset >> 32);
			}
			ptr->EventHandle = resetEvent.SafeWaitHandle.DangerousGetHandle();
			return ptr;
		}

		private static NativeOverlapped GetNativeOverlappedForSyncHandle(SafeFileHandle handle, long fileOffset)
		{
			NativeOverlapped result = default(NativeOverlapped);
			if (handle.CanSeek)
			{
				result.OffsetLow = (int)fileOffset;
				result.OffsetHigh = (int)(fileOffset >> 32);
			}
			return result;
		}

		private unsafe static IOCompletionCallback AllocateCallback()
		{
			return Callback;
			unsafe static void Callback(uint errorCode, uint numBytes, NativeOverlapped* pOverlapped)
			{
				CallbackResetEvent callbackResetEvent = (CallbackResetEvent)ThreadPoolBoundHandle.GetNativeOverlappedState(pOverlapped);
				callbackResetEvent.ReleaseRefCount(pOverlapped);
			}
		}
	}
	internal sealed class ReadLinesIterator : Iterator<string>
	{
		private readonly string _path;

		private readonly Encoding _encoding;

		private StreamReader _reader;

		private ReadLinesIterator(string path, Encoding encoding, StreamReader reader)
		{
			_path = path;
			_encoding = encoding;
			_reader = reader;
		}

		public override bool MoveNext()
		{
			if (_reader != null)
			{
				current = _reader.ReadLine();
				if (current != null)
				{
					return true;
				}
				Dispose();
			}
			return false;
		}

		protected override Iterator<string> Clone()
		{
			return CreateIterator(_path, _encoding, _reader);
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing && _reader != null)
				{
					_reader.Dispose();
				}
			}
			finally
			{
				_reader = null;
				base.Dispose(disposing);
			}
		}

		internal static ReadLinesIterator CreateIterator(string path, Encoding encoding)
		{
			return CreateIterator(path, encoding, null);
		}

		private static ReadLinesIterator CreateIterator(string path, Encoding encoding, StreamReader reader)
		{
			return new ReadLinesIterator(path, encoding, reader ?? new StreamReader(path, encoding));
		}
	}
	public enum SearchOption
	{
		TopDirectoryOnly,
		AllDirectories
	}
	internal enum SearchTarget
	{
		Files = 1,
		Directories,
		Both
	}
	public enum SeekOrigin
	{
		Begin,
		Current,
		End
	}
	public class StreamReader : TextReader
	{
		private sealed class NullStreamReader : StreamReader
		{
			public override Encoding CurrentEncoding => Encoding.Unicode;

			protected override void Dispose(bool disposing)
			{
			}

			public override int Peek()
			{
				return -1;
			}

			public override int Read()
			{
				return -1;
			}

			public override int Read(char[] buffer, int index, int count)
			{
				return 0;
			}

			public override string ReadLine()
			{
				return null;
			}

			public override string ReadToEnd()
			{
				return string.Empty;
			}

			internal override int ReadBuffer()
			{
				return 0;
			}
		}

		public new static readonly StreamReader Null = new NullStreamReader();

		private readonly Stream _stream;

		private Encoding _encoding;

		private Decoder _decoder;

		private readonly byte[] _byteBuffer;

		private char[] _charBuffer;

		private int _charPos;

		private int _charLen;

		private int _byteLen;

		private int _bytePos;

		private int _maxCharsPerBuffer;

		private bool _disposed;

		private bool _detectEncoding;

		private bool _checkPreamble;

		private bool _isBlocked;

		private readonly bool _closable;

		private Task _asyncReadTask = Task.CompletedTask;

		public virtual Encoding CurrentEncoding => _encoding;

		public virtual Stream BaseStream => _stream;

		public bool EndOfStream
		{
			get
			{
				ThrowIfDisposed();
				CheckAsyncTaskInProgress();
				if (_charPos < _charLen)
				{
					return false;
				}
				int num = ReadBuffer();
				return num == 0;
			}
		}

		private void CheckAsyncTaskInProgress()
		{
			if (!_asyncReadTask.IsCompleted)
			{
				ThrowAsyncIOInProgress();
			}
		}

		[DoesNotReturn]
		private static void ThrowAsyncIOInProgress()
		{
			throw new InvalidOperationException(SR.InvalidOperation_AsyncIOInProgress);
		}

		private StreamReader()
		{
			_stream = Stream.Null;
			_closable = true;
		}

		public StreamReader(Stream stream)
			: this(stream, detectEncodingFromByteOrderMarks: true)
		{
		}

		public StreamReader(Stream stream, bool detectEncodingFromByteOrderMarks)
			: this(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks, 1024, leaveOpen: false)
		{
		}

		public StreamReader(Stream stream, Encoding encoding)
			: this(stream, encoding, detectEncodingFromByteOrderMarks: true, 1024, leaveOpen: false)
		{
		}

		public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks)
			: this(stream, encoding, detectEncodingFromByteOrderMarks, 1024, leaveOpen: false)
		{
		}

		public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize)
			: this(stream, encoding, detectEncodingFromByteOrderMarks, bufferSize, leaveOpen: false)
		{
		}

		public StreamReader(Stream stream, Encoding? encoding = null, bool detectEncodingFromByteOrderMarks = true, int bufferSize = -1, bool leaveOpen = false)
		{
			if (stream == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stream);
			}
			if (encoding == null)
			{
				encoding = Encoding.UTF8;
			}
			if (!stream.CanRead)
			{
				throw new ArgumentException(SR.Argument_StreamNotReadable);
			}
			if (bufferSize == -1)
			{
				bufferSize = 1024;
			}
			else if (bufferSize <= 0)
			{
				throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedPosNum);
			}
			_stream = stream;
			_encoding = encoding;
			_decoder = encoding.GetDecoder();
			if (bufferSize < 128)
			{
				bufferSize = 128;
			}
			_byteBuffer = new byte[bufferSize];
			_maxCharsPerBuffer = encoding.GetMaxCharCount(bufferSize);
			_charBuffer = new char[_maxCharsPerBuffer];
			_detectEncoding = detectEncodingFromByteOrderMarks;
			_checkPreamble = encoding.Preamble.Length > 0;
			_closable = !leaveOpen;
		}

		public StreamReader(string path)
			: this(path, detectEncodingFromByteOrderMarks: true)
		{
		}

		public StreamReader(string path, bool detectEncodingFromByteOrderMarks)
			: this(path, Encoding.UTF8, detectEncodingFromByteOrderMarks, 1024)
		{
		}

		public StreamReader(string path, Encoding encoding)
			: this(path, encoding, detectEncodingFromByteOrderMarks: true, 1024)
		{
		}

		public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks)
			: this(path, encoding, detectEncodingFromByteOrderMarks, 1024)
		{
		}

		public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize)
			: this(ValidateArgsAndOpenPath(path, encoding, bufferSize), encoding, detectEncodingFromByteOrderMarks, bufferSize, leaveOpen: false)
		{
		}

		public StreamReader(string path, FileStreamOptions options)
			: this(path, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, options)
		{
		}

		public StreamReader(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, FileStreamOptions options)
			: this(ValidateArgsAndOpenPath(path, encoding, options), encoding, detectEncodingFromByteOrderMarks, 1024)
		{
		}

		private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options)
		{
			ValidateArgs(path, encoding);
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			if ((options.Access & FileAccess.Read) == 0)
			{
				throw new ArgumentException(SR.Argument_StreamNotReadable, "options");
			}
			return new FileStream(path, options);
		}

		private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, int bufferSize)
		{
			ValidateArgs(path, encoding);
			if (bufferSize <= 0)
			{
				throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedPosNum);
			}
			return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 4096);
		}

		private static void ValidateArgs(string path, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath);
			}
		}

		public override void Close()
		{
			Dispose(disposing: true);
		}

		protected override void Dispose(bool disposing)
		{
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			if (!_closable)
			{
				return;
			}
			try
			{
				if (disposing)
				{
					_stream.Close();
				}
			}
			finally
			{
				_charPos = 0;
				_charLen = 0;
				base.Dispose(disposing);
			}
		}

		public void DiscardBufferedData()
		{
			CheckAsyncTaskInProgress();
			_byteLen = 0;
			_charLen = 0;
			_charPos = 0;
			if (_encoding != null)
			{
				_decoder = _encoding.GetDecoder();
			}
			_isBlocked = false;
		}

		public override int Peek()
		{
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			if (_charPos == _charLen && (_isBlocked || ReadBuffer() == 0))
			{
				return -1;
			}
			return _charBuffer[_charPos];
		}

		public override int Read()
		{
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			if (_charPos == _charLen && ReadBuffer() == 0)
			{
				return -1;
			}
			int result = _charBuffer[_charPos];
			_charPos++;
			return result;
		}

		public override int Read(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			return ReadSpan(new Span<char>(buffer, index, count));
		}

		public override int Read(Span<char> buffer)
		{
			if (!(GetType() == typeof(StreamReader)))
			{
				return base.Read(buffer);
			}
			return ReadSpan(buffer);
		}

		private int ReadSpan(Span<char> buffer)
		{
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			int num = 0;
			bool readToUserBuffer = false;
			int num2 = buffer.Length;
			while (num2 > 0)
			{
				int num3 = _charLen - _charPos;
				if (num3 == 0)
				{
					num3 = ReadBuffer(buffer.Slice(num), out readToUserBuffer);
				}
				if (num3 == 0)
				{
					break;
				}
				if (num3 > num2)
				{
					num3 = num2;
				}
				if (!readToUserBuffer)
				{
					new Span<char>(_charBuffer, _charPos, num3).CopyTo(buffer.Slice(num));
					_charPos += num3;
				}
				num += num3;
				num2 -= num3;
				if (_isBlocked)
				{
					break;
				}
			}
			return num;
		}

		public override string ReadToEnd()
		{
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			StringBuilder stringBuilder = new StringBuilder(_charLen - _charPos);
			do
			{
				stringBuilder.Append(_charBuffer, _charPos, _charLen - _charPos);
				_charPos = _charLen;
				ReadBuffer();
			}
			while (_charLen > 0);
			return stringBuilder.ToString();
		}

		public override int ReadBlock(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return base.ReadBlock(buffer, index, count);
		}

		public override int ReadBlock(Span<char> buffer)
		{
			if (GetType() != typeof(StreamReader))
			{
				return base.ReadBlock(buffer);
			}
			int num = 0;
			int num2;
			do
			{
				num2 = ReadSpan(buffer.Slice(num));
				num += num2;
			}
			while (num2 > 0 && num < buffer.Length);
			return num;
		}

		private void CompressBuffer(int n)
		{
			Buffer.BlockCopy(_byteBuffer, n, _byteBuffer, 0, _byteLen - n);
			_byteLen -= n;
		}

		private void DetectEncoding()
		{
			if (_byteLen < 2)
			{
				return;
			}
			_detectEncoding = false;
			bool flag = false;
			if (_byteBuffer[0] == 254 && _byteBuffer[1] == byte.MaxValue)
			{
				_encoding = Encoding.BigEndianUnicode;
				CompressBuffer(2);
				flag = true;
			}
			else if (_byteBuffer[0] == byte.MaxValue && _byteBuffer[1] == 254)
			{
				if (_byteLen < 4 || _byteBuffer[2] != 0 || _byteBuffer[3] != 0)
				{
					_encoding = Encoding.Unicode;
					CompressBuffer(2);
					flag = true;
				}
				else
				{
					_encoding = Encoding.UTF32;
					CompressBuffer(4);
					flag = true;
				}
			}
			else if (_byteLen >= 3 && _byteBuffer[0] == 239 && _byteBuffer[1] == 187 && _byteBuffer[2] == 191)
			{
				_encoding = Encoding.UTF8;
				CompressBuffer(3);
				flag = true;
			}
			else if (_byteLen >= 4 && _byteBuffer[0] == 0 && _byteBuffer[1] == 0 && _byteBuffer[2] == 254 && _byteBuffer[3] == byte.MaxValue)
			{
				_encoding = new UTF32Encoding(bigEndian: true, byteOrderMark: true);
				CompressBuffer(4);
				flag = true;
			}
			else if (_byteLen == 2)
			{
				_detectEncoding = true;
			}
			if (flag)
			{
				_decoder = _encoding.GetDecoder();
				int maxCharCount = _encoding.GetMaxCharCount(_byteBuffer.Length);
				if (maxCharCount > _maxCharsPerBuffer)
				{
					_charBuffer = new char[maxCharCount];
				}
				_maxCharsPerBuffer = maxCharCount;
			}
		}

		private bool IsPreamble()
		{
			if (!_checkPreamble)
			{
				return _checkPreamble;
			}
			ReadOnlySpan<byte> preamble = _encoding.Preamble;
			int num = ((_byteLen >= preamble.Length) ? (preamble.Length - _bytePos) : (_byteLen - _bytePos));
			int num2 = 0;
			while (num2 < num)
			{
				if (_byteBuffer[_bytePos] != preamble[_bytePos])
				{
					_bytePos = 0;
					_checkPreamble = false;
					break;
				}
				num2++;
				_bytePos++;
			}
			if (_checkPreamble && _bytePos == preamble.Length)
			{
				CompressBuffer(preamble.Length);
				_bytePos = 0;
				_checkPreamble = false;
				_detectEncoding = false;
			}
			return _checkPreamble;
		}

		internal virtual int ReadBuffer()
		{
			_charLen = 0;
			_charPos = 0;
			if (!_checkPreamble)
			{
				_byteLen = 0;
			}
			do
			{
				if (_checkPreamble)
				{
					int num = _stream.Read(_byteBuffer, _bytePos, _byteBuffer.Length - _bytePos);
					if (num == 0)
					{
						if (_byteLen > 0)
						{
							_charLen += _decoder.GetChars(_byteBuffer, 0, _byteLen, _charBuffer, _charLen);
							_bytePos = (_byteLen = 0);
						}
						return _charLen;
					}
					_byteLen += num;
				}
				else
				{
					_byteLen = _stream.Read(_byteBuffer, 0, _byteBuffer.Length);
					if (_byteLen == 0)
					{
						return _charLen;
					}
				}
				_isBlocked = _byteLen < _byteBuffer.Length;
				if (!IsPreamble())
				{
					if (_detectEncoding && _byteLen >= 2)
					{
						DetectEncoding();
					}
					_charLen += _decoder.GetChars(_byteBuffer, 0, _byteLen, _charBuffer, _charLen);
				}
			}
			while (_charLen == 0);
			return _charLen;
		}

		private int ReadBuffer(Span<char> userBuffer, out bool readToUserBuffer)
		{
			_charLen = 0;
			_charPos = 0;
			if (!_checkPreamble)
			{
				_byteLen = 0;
			}
			int num = 0;
			readToUserBuffer = userBuffer.Length >= _maxCharsPerBuffer;
			do
			{
				if (_checkPreamble)
				{
					int num2 = _stream.Read(_byteBuffer, _bytePos, _byteBuffer.Length - _bytePos);
					if (num2 == 0)
					{
						if (_byteLen > 0)
						{
							if (readToUserBuffer)
							{
								num = _decoder.GetChars(new ReadOnlySpan<byte>(_byteBuffer, 0, _byteLen), userBuffer.Slice(num), flush: false);
								_charLen = 0;
							}
							else
							{
								num = _decoder.GetChars(_byteBuffer, 0, _byteLen, _charBuffer, num);
								_charLen += num;
							}
						}
						return num;
					}
					_byteLen += num2;
				}
				else
				{
					_byteLen = _stream.Read(_byteBuffer, 0, _byteBuffer.Length);
					if (_byteLen == 0)
					{
						break;
					}
				}
				_isBlocked = _byteLen < _byteBuffer.Length;
				if (!IsPreamble())
				{
					if (_detectEncoding && _byteLen >= 2)
					{
						DetectEncoding();
						readToUserBuffer = userBuffer.Length >= _maxCharsPerBuffer;
					}
					_charPos = 0;
					if (readToUserBuffer)
					{
						num += _decoder.GetChars(new ReadOnlySpan<byte>(_byteBuffer, 0, _byteLen), userBuffer.Slice(num), flush: false);
						_charLen = 0;
					}
					else
					{
						num = _decoder.GetChars(_byteBuffer, 0, _byteLen, _charBuffer, num);
						_charLen += num;
					}
				}
			}
			while (num == 0);
			_isBlocked &= num < userBuffer.Length;
			return num;
		}

		public override string? ReadLine()
		{
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			if (_charPos == _charLen && ReadBuffer() == 0)
			{
				return null;
			}
			StringBuilder stringBuilder = null;
			do
			{
				int num = _charPos;
				do
				{
					char c = _charBuffer[num];
					if (c == '\r' || c == '\n')
					{
						string result;
						if (stringBuilder != null)
						{
							stringBuilder.Append(_charBuffer, _charPos, num - _charPos);
							result = stringBuilder.ToString();
						}
						else
						{
							result = new string(_charBuffer, _charPos, num - _charPos);
						}
						_charPos = num + 1;
						if (c == '\r' && (_charPos < _charLen || ReadBuffer() > 0) && _charBuffer[_charPos] == '\n')
						{
							_charPos++;
						}
						return result;
					}
					num++;
				}
				while (num < _charLen);
				num = _charLen - _charPos;
				if (stringBuilder == null)
				{
					stringBuilder = new StringBuilder(num + 80);
				}
				stringBuilder.Append(_charBuffer, _charPos, num);
			}
			while (ReadBuffer() > 0);
			return stringBuilder.ToString();
		}

		public override Task<string?> ReadLineAsync()
		{
			if (GetType() != typeof(StreamReader))
			{
				return base.ReadLineAsync();
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return (Task<string?>)(_asyncReadTask = ReadLineAsyncInternal());
		}

		private async Task<string> ReadLineAsyncInternal()
		{
			bool flag = _charPos == _charLen;
			bool flag2 = flag;
			if (flag2)
			{
				flag2 = await ReadBufferAsync(CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false) == 0;
			}
			if (flag2)
			{
				return null;
			}
			StringBuilder sb = null;
			do
			{
				char[] charBuffer = _charBuffer;
				int charLen = _charLen;
				int charPos = _charPos;
				int num = charPos;
				do
				{
					char c = charBuffer[num];
					if (c == '\r' || c == '\n')
					{
						string s;
						if (sb != null)
						{
							sb.Append(charBuffer, charPos, num - charPos);
							s = sb.ToString();
						}
						else
						{
							s = new string(charBuffer, charPos, num - charPos);
						}
						charPos = (_charPos = num + 1);
						bool flag3 = c == '\r';
						bool flag4 = flag3;
						if (flag4)
						{
							bool flag5 = charPos < charLen;
							bool flag6 = flag5;
							if (!flag6)
							{
								flag6 = await ReadBufferAsync(CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false) > 0;
							}
							flag4 = flag6;
						}
						if (flag4)
						{
							charPos = _charPos;
							if (_charBuffer[charPos] == '\n')
							{
								_charPos = charPos + 1;
							}
						}
						return s;
					}
					num++;
				}
				while (num < charLen);
				num = charLen - charPos;
				if (sb == null)
				{
					sb = new StringBuilder(num + 80);
				}
				sb.Append(charBuffer, charPos, num);
			}
			while (await ReadBufferAsync(CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false) > 0);
			return sb.ToString();
		}

		public override Task<string> ReadToEndAsync()
		{
			if (GetType() != typeof(StreamReader))
			{
				return base.ReadToEndAsync();
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return (Task<string>)(_asyncReadTask = ReadToEndAsyncInternal());
		}

		private async Task<string> ReadToEndAsyncInternal()
		{
			StringBuilder sb = new StringBuilder(_charLen - _charPos);
			do
			{
				int charPos = _charPos;
				sb.Append(_charBuffer, charPos, _charLen - charPos);
				_charPos = _charLen;
				await ReadBufferAsync(CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
			}
			while (_charLen > 0);
			return sb.ToString();
		}

		public override Task<int> ReadAsync(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (GetType() != typeof(StreamReader))
			{
				return base.ReadAsync(buffer, index, count);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return (Task<int>)(_asyncReadTask = ReadAsyncInternal(new Memory<char>(buffer, index, count), CancellationToken.None).AsTask());
		}

		public override ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (GetType() != typeof(StreamReader))
			{
				return base.ReadAsync(buffer, cancellationToken);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			return ReadAsyncInternal(buffer, cancellationToken);
		}

		internal override async ValueTask<int> ReadAsyncInternal(Memory<char> buffer, CancellationToken cancellationToken)
		{
			bool flag = _charPos == _charLen;
			bool flag2 = flag;
			if (flag2)
			{
				flag2 = await ReadBufferAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false) == 0;
			}
			if (flag2)
			{
				return 0;
			}
			int charsRead = 0;
			bool readToUserBuffer = false;
			byte[] tmpByteBuffer = _byteBuffer;
			Stream tmpStream = _stream;
			int count = buffer.Length;
			while (count > 0)
			{
				int i = _charLen - _charPos;
				if (i == 0)
				{
					_charLen = 0;
					_charPos = 0;
					if (!_checkPreamble)
					{
						_byteLen = 0;
					}
					readToUserBuffer = count >= _maxCharsPerBuffer;
					do
					{
						if (_checkPreamble)
						{
							int bytePos = _bytePos;
							int num = await tmpStream.ReadAsync(new Memory<byte>(tmpByteBuffer, bytePos, tmpByteBuffer.Length - bytePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
							if (num == 0)
							{
								if (_byteLen > 0)
								{
									if (readToUserBuffer)
									{
										i = _decoder.GetChars(new ReadOnlySpan<byte>(tmpByteBuffer, 0, _byteLen), buffer.Span.Slice(charsRead), flush: false);
										_charLen = 0;
									}
									else
									{
										i = _decoder.GetChars(tmpByteBuffer, 0, _byteLen, _charBuffer, 0);
										_charLen += i;
									}
								}
								_isBlocked = true;
								break;
							}
							_byteLen += num;
						}
						else
						{
							_byteLen = await tmpStream.ReadAsync(new Memory<byte>(tmpByteBuffer), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
							if (_byteLen == 0)
							{
								_isBlocked = true;
								break;
							}
						}
						_isBlocked = _byteLen < tmpByteBuffer.Length;
						if (!IsPreamble())
						{
							if (_detectEncoding && _byteLen >= 2)
							{
								DetectEncoding();
								readToUserBuffer = count >= _maxCharsPerBuffer;
							}
							_charPos = 0;
							if (readToUserBuffer)
							{
								i += _decoder.GetChars(new ReadOnlySpan<byte>(tmpByteBuffer, 0, _byteLen), buffer.Span.Slice(charsRead), flush: false);
								_charLen = 0;
							}
							else
							{
								i = _decoder.GetChars(tmpByteBuffer, 0, _byteLen, _charBuffer, 0);
								_charLen += i;
							}
						}
					}
					while (i == 0);
					if (i == 0)
					{
						break;
					}
				}
				if (i > count)
				{
					i = count;
				}
				if (!readToUserBuffer)
				{
					new Span<char>(_charBuffer, _charPos, i).CopyTo(buffer.Span.Slice(charsRead));
					_charPos += i;
				}
				charsRead += i;
				count -= i;
				if (_isBlocked)
				{
					break;
				}
			}
			return charsRead;
		}

		public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (GetType() != typeof(StreamReader))
			{
				return base.ReadBlockAsync(buffer, index, count);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return (Task<int>)(_asyncReadTask = base.ReadBlockAsync(buffer, index, count));
		}

		public override ValueTask<int> ReadBlockAsync(Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (GetType() != typeof(StreamReader))
			{
				return base.ReadBlockAsync(buffer, cancellationToken);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			ValueTask<int> result = ReadBlockAsyncInternal(buffer, cancellationToken);
			if (result.IsCompletedSuccessfully)
			{
				return result;
			}
			return new ValueTask<int>((Task<int>)(_asyncReadTask = result.AsTask()));
		}

		private async ValueTask<int> ReadBufferAsync(CancellationToken cancellationToken)
		{
			_charLen = 0;
			_charPos = 0;
			byte[] tmpByteBuffer = _byteBuffer;
			Stream tmpStream = _stream;
			if (!_checkPreamble)
			{
				_byteLen = 0;
			}
			do
			{
				if (_checkPreamble)
				{
					int bytePos = _bytePos;
					int num = await tmpStream.ReadAsync(new Memory<byte>(tmpByteBuffer, bytePos, tmpByteBuffer.Length - bytePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					if (num == 0)
					{
						if (_byteLen > 0)
						{
							_charLen += _decoder.GetChars(tmpByteBuffer, 0, _byteLen, _charBuffer, _charLen);
							_bytePos = 0;
							_byteLen = 0;
						}
						return _charLen;
					}
					_byteLen += num;
				}
				else
				{
					_byteLen = await tmpStream.ReadAsync(new Memory<byte>(tmpByteBuffer), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					if (_byteLen == 0)
					{
						return _charLen;
					}
				}
				_isBlocked = _byteLen < tmpByteBuffer.Length;
				if (!IsPreamble())
				{
					if (_detectEncoding && _byteLen >= 2)
					{
						DetectEncoding();
					}
					_charLen += _decoder.GetChars(tmpByteBuffer, 0, _byteLen, _charBuffer, _charLen);
				}
			}
			while (_charLen == 0);
			return _charLen;
		}

		private void ThrowIfDisposed()
		{
			if (_disposed)
			{
				ThrowObjectDisposedException();
			}
			void ThrowObjectDisposedException()
			{
				throw new ObjectDisposedException(GetType().Name, SR.ObjectDisposed_ReaderClosed);
			}
		}
	}
	public class StreamWriter : TextWriter
	{
		public new static readonly StreamWriter Null = new StreamWriter(Stream.Null, UTF8NoBOM, 128, leaveOpen: true);

		private readonly Stream _stream;

		private readonly Encoding _encoding;

		private readonly Encoder _encoder;

		private byte[] _byteBuffer;

		private readonly char[] _charBuffer;

		private int _charPos;

		private int _charLen;

		private bool _autoFlush;

		private bool _haveWrittenPreamble;

		private readonly bool _closable;

		private bool _disposed;

		private Task _asyncWriteTask = Task.CompletedTask;

		private static Encoding UTF8NoBOM => EncodingCache.UTF8NoBOM;

		public virtual bool AutoFlush
		{
			get
			{
				return _autoFlush;
			}
			set
			{
				CheckAsyncTaskInProgress();
				_autoFlush = value;
				if (value)
				{
					Flush(flushStream: true, flushEncoder: false);
				}
			}
		}

		public virtual Stream BaseStream => _stream;

		public override Encoding Encoding => _encoding;

		private void CheckAsyncTaskInProgress()
		{
			if (!_asyncWriteTask.IsCompleted)
			{
				ThrowAsyncIOInProgress();
			}
		}

		[DoesNotReturn]
		private static void ThrowAsyncIOInProgress()
		{
			throw new InvalidOperationException(SR.InvalidOperation_AsyncIOInProgress);
		}

		public StreamWriter(Stream stream)
			: this(stream, UTF8NoBOM, 1024, leaveOpen: false)
		{
		}

		public StreamWriter(Stream stream, Encoding encoding)
			: this(stream, encoding, 1024, leaveOpen: false)
		{
		}

		public StreamWriter(Stream stream, Encoding encoding, int bufferSize)
			: this(stream, encoding, bufferSize, leaveOpen: false)
		{
		}

		public StreamWriter(Stream stream, Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false)
			: base(null)
		{
			if (stream == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stream);
			}
			if (encoding == null)
			{
				encoding = UTF8NoBOM;
			}
			if (!stream.CanWrite)
			{
				throw new ArgumentException(SR.Argument_StreamNotWritable);
			}
			if (bufferSize == -1)
			{
				bufferSize = 1024;
			}
			else if (bufferSize <= 0)
			{
				throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedPosNum);
			}
			_stream = stream;
			_encoding = encoding;
			_encoder = _encoding.GetEncoder();
			if (bufferSize < 128)
			{
				bufferSize = 128;
			}
			_charBuffer = new char[bufferSize];
			_charLen = bufferSize;
			if (_stream.CanSeek && _stream.Position > 0)
			{
				_haveWrittenPreamble = true;
			}
			_closable = !leaveOpen;
		}

		public StreamWriter(string path)
			: this(path, append: false, UTF8NoBOM, 1024)
		{
		}

		public StreamWriter(string path, bool append)
			: this(path, append, UTF8NoBOM, 1024)
		{
		}

		public StreamWriter(string path, bool append, Encoding encoding)
			: this(path, append, encoding, 1024)
		{
		}

		public StreamWriter(string path, bool append, Encoding encoding, int bufferSize)
			: this(ValidateArgsAndOpenPath(path, append, encoding, bufferSize), encoding, bufferSize, leaveOpen: false)
		{
		}

		public StreamWriter(string path, FileStreamOptions options)
			: this(path, UTF8NoBOM, options)
		{
		}

		public StreamWriter(string path, Encoding encoding, FileStreamOptions options)
			: this(ValidateArgsAndOpenPath(path, encoding, options), encoding, 4096)
		{
		}

		private static Stream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options)
		{
			ValidateArgs(path, encoding);
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			if ((options.Access & FileAccess.Write) == 0)
			{
				throw new ArgumentException(SR.Argument_StreamNotWritable, "options");
			}
			return new FileStream(path, options);
		}

		private static Stream ValidateArgsAndOpenPath(string path, bool append, Encoding encoding, int bufferSize)
		{
			ValidateArgs(path, encoding);
			if (bufferSize <= 0)
			{
				throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedPosNum);
			}
			return new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read, 4096);
		}

		private static void ValidateArgs(string path, Encoding encoding)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			if (encoding == null)
			{
				throw new ArgumentNullException("encoding");
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath);
			}
		}

		public override void Close()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (!_disposed && disposing)
				{
					CheckAsyncTaskInProgress();
					Flush(flushStream: true, flushEncoder: true);
				}
			}
			finally
			{
				CloseStreamFromDispose(disposing);
			}
		}

		private void CloseStreamFromDispose(bool disposing)
		{
			if (!_closable || _disposed)
			{
				return;
			}
			try
			{
				if (disposing)
				{
					_stream.Close();
				}
			}
			finally
			{
				_disposed = true;
				_charLen = 0;
				base.Dispose(disposing);
			}
		}

		public override ValueTask DisposeAsync()
		{
			if (!(GetType() != typeof(StreamWriter)))
			{
				return DisposeAsyncCore();
			}
			return base.DisposeAsync();
		}

		private async ValueTask DisposeAsyncCore()
		{
			try
			{
				if (!_disposed)
				{
					await FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			finally
			{
				CloseStreamFromDispose(disposing: true);
			}
			GC.SuppressFinalize(this);
		}

		public override void Flush()
		{
			CheckAsyncTaskInProgress();
			Flush(flushStream: true, flushEncoder: true);
		}

		private void Flush(bool flushStream, bool flushEncoder)
		{
			ThrowIfDisposed();
			if (_charPos == 0 && !flushStream && !flushEncoder)
			{
				return;
			}
			if (!_haveWrittenPreamble)
			{
				_haveWrittenPreamble = true;
				ReadOnlySpan<byte> preamble = _encoding.Preamble;
				if (preamble.Length > 0)
				{
					_stream.Write(preamble);
				}
			}
			Span<byte> span = default(Span<byte>);
			if (_byteBuffer != null)
			{
				span = _byteBuffer;
			}
			else
			{
				int maxByteCount = _encoding.GetMaxByteCount(_charPos);
				Span<byte> span2 = ((maxByteCount > 1024) ? ((Span<byte>)(_byteBuffer = new byte[_encoding.GetMaxByteCount(_charBuffer.Length)])) : stackalloc byte[1024]);
				span = span2;
			}
			int bytes = _encoder.GetBytes(new ReadOnlySpan<char>(_charBuffer, 0, _charPos), span, flushEncoder);
			_charPos = 0;
			if (bytes > 0)
			{
				_stream.Write(span.Slice(0, bytes));
			}
			if (flushStream)
			{
				_stream.Flush();
			}
		}

		public override void Write(char value)
		{
			CheckAsyncTaskInProgress();
			if (_charPos == _charLen)
			{
				Flush(flushStream: false, flushEncoder: false);
			}
			_charBuffer[_charPos] = value;
			_charPos++;
			if (_autoFlush)
			{
				Flush(flushStream: true, flushEncoder: false);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override void Write(char[]? buffer)
		{
			WriteSpan(buffer, appendNewLine: false);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override void Write(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			WriteSpan(buffer.AsSpan(index, count), appendNewLine: false);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override void Write(ReadOnlySpan<char> buffer)
		{
			if (GetType() == typeof(StreamWriter))
			{
				WriteSpan(buffer, appendNewLine: false);
			}
			else
			{
				base.Write(buffer);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe void WriteSpan(ReadOnlySpan<char> buffer, bool appendNewLine)
		{
			CheckAsyncTaskInProgress();
			if (buffer.Length <= 4 && buffer.Length <= _charLen - _charPos)
			{
				for (int i = 0; i < buffer.Length; i++)
				{
					_charBuffer[_charPos++] = buffer[i];
				}
			}
			else
			{
				ThrowIfDisposed();
				char[] charBuffer = _charBuffer;
				fixed (char* ptr = &MemoryMarshal.GetReference(buffer))
				{
					fixed (char* ptr3 = &charBuffer[0])
					{
						char* ptr2 = ptr;
						int num = buffer.Length;
						int num2 = _charPos;
						while (num > 0)
						{
							if (num2 == charBuffer.Length)
							{
								Flush(flushStream: false, flushEncoder: false);
								num2 = 0;
							}
							int num3 = Math.Min(charBuffer.Length - num2, num);
							int num4 = num3 * 2;
							Buffer.MemoryCopy(ptr2, ptr3 + num2, num4, num4);
							_charPos += num3;
							num2 += num3;
							ptr2 += num3;
							num -= num3;
						}
					}
				}
			}
			if (appendNewLine)
			{
				char[] coreNewLine = CoreNewLine;
				for (int j = 0; j < coreNewLine.Length; j++)
				{
					if (_charPos == _charLen)
					{
						Flush(flushStream: false, flushEncoder: false);
					}
					_charBuffer[_charPos] = coreNewLine[j];
					_charPos++;
				}
			}
			if (_autoFlush)
			{
				Flush(flushStream: true, flushEncoder: false);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override void Write(string? value)
		{
			WriteSpan(value, appendNewLine: false);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override void WriteLine(string? value)
		{
			CheckAsyncTaskInProgress();
			WriteSpan(value, appendNewLine: true);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public override void WriteLine(ReadOnlySpan<char> buffer)
		{
			if (GetType() == typeof(StreamWriter))
			{
				CheckAsyncTaskInProgress();
				WriteSpan(buffer, appendNewLine: true);
			}
			else
			{
				base.WriteLine(buffer);
			}
		}

		private void WriteFormatHelper(string format, ParamsArray args, bool appendNewLine)
		{
			StringBuilder stringBuilder = StringBuilderCache.Acquire((format?.Length ?? 0) + args.Length * 8).AppendFormatHelper(null, format, args);
			StringBuilder.ChunkEnumerator chunks = stringBuilder.GetChunks();
			bool flag = chunks.MoveNext();
			while (flag)
			{
				ReadOnlySpan<char> span = chunks.Current.Span;
				flag = chunks.MoveNext();
				WriteSpan(span, !flag && appendNewLine);
			}
			StringBuilderCache.Release(stringBuilder);
		}

		public override void Write(string format, object? arg0)
		{
			if (GetType() == typeof(StreamWriter))
			{
				WriteFormatHelper(format, new ParamsArray(arg0), appendNewLine: false);
			}
			else
			{
				base.Write(format, arg0);
			}
		}

		public override void Write(string format, object? arg0, object? arg1)
		{
			if (GetType() == typeof(StreamWriter))
			{
				WriteFormatHelper(format, new ParamsArray(arg0, arg1), appendNewLine: false);
			}
			else
			{
				base.Write(format, arg0, arg1);
			}
		}

		public override void Write(string format, object? arg0, object? arg1, object? arg2)
		{
			if (GetType() == typeof(StreamWriter))
			{
				WriteFormatHelper(format, new ParamsArray(arg0, arg1, arg2), appendNewLine: false);
			}
			else
			{
				base.Write(format, arg0, arg1, arg2);
			}
		}

		public override void Write(string format, params object?[] arg)
		{
			if (GetType() == typeof(StreamWriter))
			{
				if (arg == null)
				{
					throw new ArgumentNullException((format == null) ? "format" : "arg");
				}
				WriteFormatHelper(format, new ParamsArray(arg), appendNewLine: false);
			}
			else
			{
				base.Write(format, arg);
			}
		}

		public override void WriteLine(string format, object? arg0)
		{
			if (GetType() == typeof(StreamWriter))
			{
				WriteFormatHelper(format, new ParamsArray(arg0), appendNewLine: true);
			}
			else
			{
				base.WriteLine(format, arg0);
			}
		}

		public override void WriteLine(string format, object? arg0, object? arg1)
		{
			if (GetType() == typeof(StreamWriter))
			{
				WriteFormatHelper(format, new ParamsArray(arg0, arg1), appendNewLine: true);
			}
			else
			{
				base.WriteLine(format, arg0, arg1);
			}
		}

		public override void WriteLine(string format, object? arg0, object? arg1, object? arg2)
		{
			if (GetType() == typeof(StreamWriter))
			{
				WriteFormatHelper(format, new ParamsArray(arg0, arg1, arg2), appendNewLine: true);
			}
			else
			{
				base.WriteLine(format, arg0, arg1, arg2);
			}
		}

		public override void WriteLine(string format, params object?[] arg)
		{
			if (GetType() == typeof(StreamWriter))
			{
				if (arg == null)
				{
					throw new ArgumentNullException("arg");
				}
				WriteFormatHelper(format, new ParamsArray(arg), appendNewLine: true);
			}
			else
			{
				base.WriteLine(format, arg);
			}
		}

		public override Task WriteAsync(char value)
		{
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteAsync(value);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return _asyncWriteTask = WriteAsyncInternal(value, appendNewLine: false);
		}

		private async Task WriteAsyncInternal(char value, bool appendNewLine)
		{
			if (_charPos == _charLen)
			{
				await FlushAsyncInternal(flushStream: false, flushEncoder: false).ConfigureAwait(continueOnCapturedContext: false);
			}
			_charBuffer[_charPos++] = value;
			if (appendNewLine)
			{
				for (int i = 0; i < CoreNewLine.Length; i++)
				{
					if (_charPos == _charLen)
					{
						await FlushAsyncInternal(flushStream: false, flushEncoder: false).ConfigureAwait(continueOnCapturedContext: false);
					}
					_charBuffer[_charPos++] = CoreNewLine[i];
				}
			}
			if (_autoFlush)
			{
				await FlushAsyncInternal(flushStream: true, flushEncoder: false).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		public override Task WriteAsync(string? value)
		{
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteAsync(value);
			}
			if (value != null)
			{
				ThrowIfDisposed();
				CheckAsyncTaskInProgress();
				return _asyncWriteTask = WriteAsyncInternal(value.AsMemory(), appendNewLine: false, default(CancellationToken));
			}
			return Task.CompletedTask;
		}

		public override Task WriteAsync(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteAsync(buffer, index, count);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return _asyncWriteTask = WriteAsyncInternal(new ReadOnlyMemory<char>(buffer, index, count), appendNewLine: false, default(CancellationToken));
		}

		public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteAsync(buffer, cancellationToken);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			return _asyncWriteTask = WriteAsyncInternal(buffer, appendNewLine: false, cancellationToken);
		}

		private async Task WriteAsyncInternal(ReadOnlyMemory<char> source, bool appendNewLine, CancellationToken cancellationToken)
		{
			int num;
			for (int copied = 0; copied < source.Length; copied += num)
			{
				if (_charPos == _charLen)
				{
					await FlushAsyncInternal(flushStream: false, flushEncoder: false, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
				num = Math.Min(_charLen - _charPos, source.Length - copied);
				ReadOnlySpan<char> readOnlySpan = source.Span;
				readOnlySpan = readOnlySpan.Slice(copied, num);
				readOnlySpan.CopyTo(new Span<char>(_charBuffer, _charPos, num));
				_charPos += num;
			}
			if (appendNewLine)
			{
				for (int i = 0; i < CoreNewLine.Length; i++)
				{
					if (_charPos == _charLen)
					{
						await FlushAsyncInternal(flushStream: false, flushEncoder: false, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					}
					_charBuffer[_charPos++] = CoreNewLine[i];
				}
			}
			if (_autoFlush)
			{
				await FlushAsyncInternal(flushStream: true, flushEncoder: false, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		public override Task WriteLineAsync()
		{
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteLineAsync();
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return _asyncWriteTask = WriteAsyncInternal(ReadOnlyMemory<char>.Empty, appendNewLine: true, default(CancellationToken));
		}

		public override Task WriteLineAsync(char value)
		{
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteLineAsync(value);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return _asyncWriteTask = WriteAsyncInternal(value, appendNewLine: true);
		}

		public override Task WriteLineAsync(string? value)
		{
			if (value == null)
			{
				return WriteLineAsync();
			}
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteLineAsync(value);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return _asyncWriteTask = WriteAsyncInternal(value.AsMemory(), appendNewLine: true, default(CancellationToken));
		}

		public override Task WriteLineAsync(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteLineAsync(buffer, index, count);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return _asyncWriteTask = WriteAsyncInternal(new ReadOnlyMemory<char>(buffer, index, count), appendNewLine: true, default(CancellationToken));
		}

		public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (GetType() != typeof(StreamWriter))
			{
				return base.WriteLineAsync(buffer, cancellationToken);
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			return _asyncWriteTask = WriteAsyncInternal(buffer, appendNewLine: true, cancellationToken);
		}

		public override Task FlushAsync()
		{
			if (GetType() != typeof(StreamWriter))
			{
				return base.FlushAsync();
			}
			ThrowIfDisposed();
			CheckAsyncTaskInProgress();
			return _asyncWriteTask = FlushAsyncInternal(flushStream: true, flushEncoder: true);
		}

		private Task FlushAsyncInternal(bool flushStream, bool flushEncoder, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			if (_charPos == 0 && !flushStream && !flushEncoder)
			{
				return Task.CompletedTask;
			}
			return Core(flushStream, flushEncoder, cancellationToken);
			async Task Core(bool flushStream, bool flushEncoder, CancellationToken cancellationToken)
			{
				if (!_haveWrittenPreamble)
				{
					_haveWrittenPreamble = true;
					byte[] preamble = _encoding.GetPreamble();
					if (preamble.Length != 0)
					{
						await _stream.WriteAsync(new ReadOnlyMemory<byte>(preamble), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					}
				}
				byte[] array = _byteBuffer ?? (_byteBuffer = new byte[_encoding.GetMaxByteCount(_charBuffer.Length)]);
				int bytes = _encoder.GetBytes(new ReadOnlySpan<char>(_charBuffer, 0, _charPos), array, flushEncoder);
				_charPos = 0;
				if (bytes > 0)
				{
					await _stream.WriteAsync(new ReadOnlyMemory<byte>(array, 0, bytes), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
				if (flushStream)
				{
					await _stream.FlushAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
		}

		private void ThrowIfDisposed()
		{
			if (_disposed)
			{
				ThrowObjectDisposedException();
			}
			void ThrowObjectDisposedException()
			{
				throw new ObjectDisposedException(GetType().Name, SR.ObjectDisposed_WriterClosed);
			}
		}
	}
	public class StringReader : TextReader
	{
		private string _s;

		private int _pos;

		private int _length;

		public StringReader(string s)
		{
			if (s == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
			}
			_s = s;
			_length = s.Length;
		}

		public override void Close()
		{
			Dispose(disposing: true);
		}

		protected override void Dispose(bool disposing)
		{
			_s = null;
			_pos = 0;
			_length = 0;
			base.Dispose(disposing);
		}

		public override int Peek()
		{
			if (_s == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ReaderClosed);
			}
			if (_pos == _length)
			{
				return -1;
			}
			return _s[_pos];
		}

		public override int Read()
		{
			if (_s == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ReaderClosed);
			}
			if (_pos == _length)
			{
				return -1;
			}
			return _s[_pos++];
		}

		public override int Read(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (_s == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ReaderClosed);
			}
			int num = _length - _pos;
			if (num > 0)
			{
				if (num > count)
				{
					num = count;
				}
				_s.CopyTo(_pos, buffer, index, num);
				_pos += num;
			}
			return num;
		}

		public override int Read(Span<char> buffer)
		{
			if (GetType() != typeof(StringReader))
			{
				return base.Read(buffer);
			}
			if (_s == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ReaderClosed);
			}
			int num = _length - _pos;
			if (num > 0)
			{
				if (num > buffer.Length)
				{
					num = buffer.Length;
				}
				_s.AsSpan(_pos, num).CopyTo(buffer);
				_pos += num;
			}
			return num;
		}

		public override int ReadBlock(Span<char> buffer)
		{
			return Read(buffer);
		}

		public override string ReadToEnd()
		{
			if (_s == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ReaderClosed);
			}
			string result = ((_pos != 0) ? _s.Substring(_pos, _length - _pos) : _s);
			_pos = _length;
			return result;
		}

		public override string? ReadLine()
		{
			if (_s == null)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_ReaderClosed);
			}
			int i;
			for (i = _pos; i < _length; i++)
			{
				char c = _s[i];
				if (c == '\r' || c == '\n')
				{
					string result = _s.Substring(_pos, i - _pos);
					_pos = i + 1;
					if (c == '\r' && _pos < _length && _s[_pos] == '\n')
					{
						_pos++;
					}
					return result;
				}
			}
			if (i > _pos)
			{
				string result2 = _s.Substring(_pos, i - _pos);
				_pos = i;
				return result2;
			}
			return null;
		}

		public override Task<string?> ReadLineAsync()
		{
			return Task.FromResult(ReadLine());
		}

		public override Task<string> ReadToEndAsync()
		{
			return Task.FromResult(ReadToEnd());
		}

		public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			return Task.FromResult(ReadBlock(buffer, index, count));
		}

		public override ValueTask<int> ReadBlockAsync(Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				return new ValueTask<int>(ReadBlock(buffer.Span));
			}
			return ValueTask.FromCanceled<int>(cancellationToken);
		}

		public override Task<int> ReadAsync(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			return Task.FromResult(Read(buffer, index, count));
		}

		public override ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				return new ValueTask<int>(Read(buffer.Span));
			}
			return ValueTask.FromCanceled<int>(cancellationToken);
		}
	}
	public class StringWriter : TextWriter
	{
		private static volatile UnicodeEncoding s_encoding;

		private readonly StringBuilder _sb;

		private bool _isOpen;

		public override Encoding Encoding
		{
			get
			{
				if (s_encoding == null)
				{
					s_encoding = new UnicodeEncoding(bigEndian: false, byteOrderMark: false);
				}
				return s_encoding;
			}
		}

		public StringWriter()
			: this(new StringBuilder(), CultureInfo.CurrentCulture)
		{
		}

		public StringWriter(IFormatProvider? formatProvider)
			: this(new StringBuilder(), formatProvider)
		{
		}

		public StringWriter(StringBuilder sb)
			: this(sb, CultureInfo.CurrentCulture)
		{
		}

		public StringWriter(StringBuilder sb, IFormatProvider? formatProvider)
			: base(formatProvider)
		{
			if (sb == null)
			{
				throw new ArgumentNullException("sb", SR.ArgumentNull_Buffer);
			}
			_sb = sb;
			_isOpen = true;
		}

		public override void Close()
		{
			Dispose(disposing: true);
		}

		protected override void Dispose(bool disposing)
		{
			_isOpen = false;
			base.Dispose(disposing);
		}

		public virtual StringBuilder GetStringBuilder()
		{
			return _sb;
		}

		public override void Write(char value)
		{
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			_sb.Append(value);
		}

		public override void Write(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			_sb.Append(buffer, index, count);
		}

		public override void Write(ReadOnlySpan<char> buffer)
		{
			if (GetType() != typeof(StringWriter))
			{
				base.Write(buffer);
				return;
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			_sb.Append(buffer);
		}

		public override void Write(string? value)
		{
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			if (value != null)
			{
				_sb.Append(value);
			}
		}

		public override void Write(StringBuilder? value)
		{
			if (GetType() != typeof(StringWriter))
			{
				base.Write(value);
				return;
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			_sb.Append(value);
		}

		public override void WriteLine(ReadOnlySpan<char> buffer)
		{
			if (GetType() != typeof(StringWriter))
			{
				base.WriteLine(buffer);
				return;
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			_sb.Append(buffer);
			WriteLine();
		}

		public override void WriteLine(StringBuilder? value)
		{
			if (GetType() != typeof(StringWriter))
			{
				base.WriteLine(value);
				return;
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			_sb.Append(value);
			WriteLine();
		}

		public override Task WriteAsync(char value)
		{
			Write(value);
			return Task.CompletedTask;
		}

		public override Task WriteAsync(string? value)
		{
			Write(value);
			return Task.CompletedTask;
		}

		public override Task WriteAsync(char[] buffer, int index, int count)
		{
			Write(buffer, index, count);
			return Task.CompletedTask;
		}

		public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			Write(buffer.Span);
			return Task.CompletedTask;
		}

		public override Task WriteAsync(StringBuilder? value, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (GetType() != typeof(StringWriter))
			{
				return base.WriteAsync(value, cancellationToken);
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			_sb.Append(value);
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(char value)
		{
			WriteLine(value);
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(string? value)
		{
			WriteLine(value);
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(StringBuilder? value, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (GetType() != typeof(StringWriter))
			{
				return base.WriteLineAsync(value, cancellationToken);
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException(null, SR.ObjectDisposed_WriterClosed);
			}
			_sb.Append(value);
			WriteLine();
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(char[] buffer, int index, int count)
		{
			WriteLine(buffer, index, count);
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			WriteLine(buffer.Span);
			return Task.CompletedTask;
		}

		public override Task FlushAsync()
		{
			return Task.CompletedTask;
		}

		public override string ToString()
		{
			return _sb.ToString();
		}
	}
	public abstract class TextReader : MarshalByRefObject, IDisposable
	{
		private sealed class NullTextReader : TextReader
		{
			public override int Read(char[] buffer, int index, int count)
			{
				return 0;
			}

			public override string ReadLine()
			{
				return null;
			}
		}

		internal sealed class SyncTextReader : TextReader
		{
			internal readonly TextReader _in;

			internal SyncTextReader(TextReader t)
			{
				_in = t;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Close()
			{
				_in.Close();
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			protected override void Dispose(bool disposing)
			{
				if (disposing)
				{
					((IDisposable)_in).Dispose();
				}
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override int Peek()
			{
				return _in.Peek();
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override int Read()
			{
				return _in.Read();
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override int Read(char[] buffer, int index, int count)
			{
				return _in.Read(buffer, index, count);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override int ReadBlock(char[] buffer, int index, int count)
			{
				return _in.ReadBlock(buffer, index, count);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override string ReadLine()
			{
				return _in.ReadLine();
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override string ReadToEnd()
			{
				return _in.ReadToEnd();
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task<string> ReadLineAsync()
			{
				return Task.FromResult(ReadLine());
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task<string> ReadToEndAsync()
			{
				return Task.FromResult(ReadToEnd());
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
			{
				if (buffer == null)
				{
					throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
				}
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (buffer.Length - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				return Task.FromResult(ReadBlock(buffer, index, count));
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task<int> ReadAsync(char[] buffer, int index, int count)
			{
				if (buffer == null)
				{
					throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
				}
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (buffer.Length - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				return Task.FromResult(Read(buffer, index, count));
			}
		}

		public static readonly TextReader Null = new NullTextReader();

		public virtual void Close()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
		}

		public virtual int Peek()
		{
			return -1;
		}

		public virtual int Read()
		{
			return -1;
		}

		public virtual int Read(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			int i;
			for (i = 0; i < count; i++)
			{
				int num = Read();
				if (num == -1)
				{
					break;
				}
				buffer[index + i] = (char)num;
			}
			return i;
		}

		public virtual int Read(Span<char> buffer)
		{
			char[] array = ArrayPool<char>.Shared.Rent(buffer.Length);
			try
			{
				int num = Read(array, 0, buffer.Length);
				if ((uint)num > (uint)buffer.Length)
				{
					throw new IOException(SR.IO_InvalidReadLength);
				}
				new Span<char>(array, 0, num).CopyTo(buffer);
				return num;
			}
			finally
			{
				ArrayPool<char>.Shared.Return(array);
			}
		}

		public virtual string ReadToEnd()
		{
			char[] array = new char[4096];
			StringBuilder stringBuilder = new StringBuilder(4096);
			int charCount;
			while ((charCount = Read(array, 0, array.Length)) != 0)
			{
				stringBuilder.Append(array, 0, charCount);
			}
			return stringBuilder.ToString();
		}

		public virtual int ReadBlock(char[] buffer, int index, int count)
		{
			int num = 0;
			int num2;
			do
			{
				num += (num2 = Read(buffer, index + num, count - num));
			}
			while (num2 > 0 && num < count);
			return num;
		}

		public virtual int ReadBlock(Span<char> buffer)
		{
			char[] array = ArrayPool<char>.Shared.Rent(buffer.Length);
			try
			{
				int num = ReadBlock(array, 0, buffer.Length);
				if ((uint)num > (uint)buffer.Length)
				{
					throw new IOException(SR.IO_InvalidReadLength);
				}
				new Span<char>(array, 0, num).CopyTo(buffer);
				return num;
			}
			finally
			{
				ArrayPool<char>.Shared.Return(array);
			}
		}

		public virtual string? ReadLine()
		{
			StringBuilder stringBuilder = new StringBuilder();
			while (true)
			{
				int num = Read();
				switch (num)
				{
				case 10:
				case 13:
					if (num == 13 && Peek() == 10)
					{
						Read();
					}
					return stringBuilder.ToString();
				case -1:
					if (stringBuilder.Length > 0)
					{
						return stringBuilder.ToString();
					}
					return null;
				}
				stringBuilder.Append((char)num);
			}
		}

		public virtual Task<string?> ReadLineAsync()
		{
			return Task<string>.Factory.StartNew((object state) => ((TextReader)state).ReadLine(), this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		public virtual async Task<string> ReadToEndAsync()
		{
			StringBuilder sb = new StringBuilder(4096);
			char[] chars = ArrayPool<char>.Shared.Rent(4096);
			try
			{
				int charCount;
				while ((charCount = await ReadAsyncInternal(chars, default(CancellationToken)).ConfigureAwait(continueOnCapturedContext: false)) != 0)
				{
					sb.Append(chars, 0, charCount);
				}
			}
			finally
			{
				ArrayPool<char>.Shared.Return(chars);
			}
			return sb.ToString();
		}

		public virtual Task<int> ReadAsync(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			return ReadAsyncInternal(new Memory<char>(buffer, index, count), default(CancellationToken)).AsTask();
		}

		public virtual ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			ArraySegment<char> segment;
			return new ValueTask<int>(MemoryMarshal.TryGetArray((ReadOnlyMemory<char>)buffer, out segment) ? ReadAsync(segment.Array, segment.Offset, segment.Count) : Task<int>.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextReader, Memory<char>> tupleSlim = (TupleSlim<TextReader, Memory<char>>)state;
				return tupleSlim.Item1.Read(tupleSlim.Item2.Span);
			}, new TupleSlim<TextReader, Memory<char>>(this, buffer), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
		}

		internal virtual ValueTask<int> ReadAsyncInternal(Memory<char> buffer, CancellationToken cancellationToken)
		{
			return new ValueTask<int>(Task<int>.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextReader, Memory<char>> tupleSlim = (TupleSlim<TextReader, Memory<char>>)state;
				return tupleSlim.Item1.Read(tupleSlim.Item2.Span);
			}, new TupleSlim<TextReader, Memory<char>>(this, buffer), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
		}

		public virtual Task<int> ReadBlockAsync(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			return ReadBlockAsyncInternal(new Memory<char>(buffer, index, count), default(CancellationToken)).AsTask();
		}

		public virtual ValueTask<int> ReadBlockAsync(Memory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			ArraySegment<char> segment;
			return new ValueTask<int>(MemoryMarshal.TryGetArray((ReadOnlyMemory<char>)buffer, out segment) ? ReadBlockAsync(segment.Array, segment.Offset, segment.Count) : Task<int>.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextReader, Memory<char>> tupleSlim = (TupleSlim<TextReader, Memory<char>>)state;
				return tupleSlim.Item1.ReadBlock(tupleSlim.Item2.Span);
			}, new TupleSlim<TextReader, Memory<char>>(this, buffer), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
		}

		internal async ValueTask<int> ReadBlockAsyncInternal(Memory<char> buffer, CancellationToken cancellationToken)
		{
			int i = 0;
			int num;
			do
			{
				num = await ReadAsyncInternal(buffer.Slice(i), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				i += num;
			}
			while (num > 0 && i < buffer.Length);
			return i;
		}

		public static TextReader Synchronized(TextReader reader)
		{
			if (reader == null)
			{
				throw new ArgumentNullException("reader");
			}
			if (!(reader is SyncTextReader))
			{
				return new SyncTextReader(reader);
			}
			return reader;
		}
	}
	public abstract class TextWriter : MarshalByRefObject, IDisposable, IAsyncDisposable
	{
		private sealed class NullTextWriter : TextWriter
		{
			public override IFormatProvider FormatProvider => CultureInfo.InvariantCulture;

			public override Encoding Encoding => Encoding.Unicode;

			internal NullTextWriter()
			{
			}

			public override void Write(char[] buffer, int index, int count)
			{
			}

			public override void Write(string value)
			{
			}

			public override void WriteLine()
			{
			}

			public override void WriteLine(string value)
			{
			}

			public override void WriteLine(object value)
			{
			}

			public override void Write(char value)
			{
			}
		}

		internal sealed class SyncTextWriter : TextWriter, IDisposable
		{
			private readonly TextWriter _out;

			public override Encoding Encoding => _out.Encoding;

			public override IFormatProvider FormatProvider => _out.FormatProvider;

			public override string NewLine
			{
				[MethodImpl(MethodImplOptions.Synchronized)]
				get
				{
					return _out.NewLine;
				}
				[MethodImpl(MethodImplOptions.Synchronized)]
				[param: AllowNull]
				set
				{
					_out.NewLine = value;
				}
			}

			internal SyncTextWriter(TextWriter t)
			{
				_out = t;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Close()
			{
				_out.Close();
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			protected override void Dispose(bool disposing)
			{
				if (disposing)
				{
					((IDisposable)_out).Dispose();
				}
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Flush()
			{
				_out.Flush();
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(char value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(char[] buffer)
			{
				_out.Write(buffer);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(char[] buffer, int index, int count)
			{
				_out.Write(buffer, index, count);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(ReadOnlySpan<char> buffer)
			{
				_out.Write(buffer);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(bool value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(int value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(uint value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(long value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(ulong value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(float value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(double value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(decimal value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(string value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(StringBuilder value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(object value)
			{
				_out.Write(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(string format, object arg0)
			{
				_out.Write(format, arg0);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(string format, object arg0, object arg1)
			{
				_out.Write(format, arg0, arg1);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(string format, object arg0, object arg1, object arg2)
			{
				_out.Write(format, arg0, arg1, arg2);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void Write(string format, params object[] arg)
			{
				_out.Write(format, arg);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine()
			{
				_out.WriteLine();
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(char value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(decimal value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(char[] buffer)
			{
				_out.WriteLine(buffer);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(char[] buffer, int index, int count)
			{
				_out.WriteLine(buffer, index, count);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(ReadOnlySpan<char> buffer)
			{
				_out.WriteLine(buffer);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(bool value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(int value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(uint value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(long value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(ulong value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(float value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(double value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(string value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(StringBuilder value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(object value)
			{
				_out.WriteLine(value);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(string format, object arg0)
			{
				_out.WriteLine(format, arg0);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(string format, object arg0, object arg1)
			{
				_out.WriteLine(format, arg0, arg1);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(string format, object arg0, object arg1, object arg2)
			{
				_out.WriteLine(format, arg0, arg1, arg2);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override void WriteLine(string format, params object[] arg)
			{
				_out.WriteLine(format, arg);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override ValueTask DisposeAsync()
			{
				Dispose();
				return default(ValueTask);
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteAsync(char value)
			{
				Write(value);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteAsync(string value)
			{
				Write(value);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken))
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return Task.FromCanceled(cancellationToken);
				}
				Write(value);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteAsync(char[] buffer, int index, int count)
			{
				Write(buffer, index, count);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return Task.FromCanceled(cancellationToken);
				}
				Write(buffer.Span);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return Task.FromCanceled(cancellationToken);
				}
				WriteLine(buffer.Span);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteLineAsync(char value)
			{
				WriteLine(value);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteLineAsync()
			{
				WriteLine();
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteLineAsync(string value)
			{
				WriteLine(value);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken))
			{
				if (cancellationToken.IsCancellationRequested)
				{
					return Task.FromCanceled(cancellationToken);
				}
				WriteLine(value);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task WriteLineAsync(char[] buffer, int index, int count)
			{
				WriteLine(buffer, index, count);
				return Task.CompletedTask;
			}

			[MethodImpl(MethodImplOptions.Synchronized)]
			public override Task FlushAsync()
			{
				Flush();
				return Task.CompletedTask;
			}
		}

		public static readonly TextWriter Null = new NullTextWriter();

		private static readonly char[] s_coreNewLine = "\r\n".ToCharArray();

		protected char[] CoreNewLine = s_coreNewLine;

		private string CoreNewLineStr = "\r\n";

		private readonly IFormatProvider _internalFormatProvider;

		public virtual IFormatProvider FormatProvider
		{
			get
			{
				if (_internalFormatProvider == null)
				{
					return CultureInfo.CurrentCulture;
				}
				return _internalFormatProvider;
			}
		}

		public abstract Encoding Encoding { get; }

		public virtual string NewLine
		{
			get
			{
				return CoreNewLineStr;
			}
			[param: AllowNull]
			set
			{
				if (value == null)
				{
					value = "\r\n";
				}
				CoreNewLineStr = value;
				CoreNewLine = value.ToCharArray();
			}
		}

		protected TextWriter()
		{
		}

		protected TextWriter(IFormatProvider? formatProvider)
		{
			_internalFormatProvider = formatProvider;
		}

		public virtual void Close()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public virtual ValueTask DisposeAsync()
		{
			try
			{
				Dispose();
				return default(ValueTask);
			}
			catch (Exception exception)
			{
				return ValueTask.FromException(exception);
			}
		}

		public virtual void Flush()
		{
		}

		public virtual void Write(char value)
		{
		}

		public virtual void Write(char[]? buffer)
		{
			if (buffer != null)
			{
				Write(buffer, 0, buffer.Length);
			}
		}

		public virtual void Write(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer", SR.ArgumentNull_Buffer);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			for (int i = 0; i < count; i++)
			{
				Write(buffer[index + i]);
			}
		}

		public virtual void Write(ReadOnlySpan<char> buffer)
		{
			char[] array = ArrayPool<char>.Shared.Rent(buffer.Length);
			try
			{
				buffer.CopyTo(new Span<char>(array));
				Write(array, 0, buffer.Length);
			}
			finally
			{
				ArrayPool<char>.Shared.Return(array);
			}
		}

		public virtual void Write(bool value)
		{
			Write(value ? "True" : "False");
		}

		public virtual void Write(int value)
		{
			Write(value.ToString(FormatProvider));
		}

		[CLSCompliant(false)]
		public virtual void Write(uint value)
		{
			Write(value.ToString(FormatProvider));
		}

		public virtual void Write(long value)
		{
			Write(value.ToString(FormatProvider));
		}

		[CLSCompliant(false)]
		public virtual void Write(ulong value)
		{
			Write(value.ToString(FormatProvider));
		}

		public virtual void Write(float value)
		{
			Write(value.ToString(FormatProvider));
		}

		public virtual void Write(double value)
		{
			Write(value.ToString(FormatProvider));
		}

		public virtual void Write(decimal value)
		{
			Write(value.ToString(FormatProvider));
		}

		public virtual void Write(string? value)
		{
			if (value != null)
			{
				Write(value.ToCharArray());
			}
		}

		public virtual void Write(object? value)
		{
			if (value != null)
			{
				if (value is IFormattable formattable)
				{
					Write(formattable.ToString(null, FormatProvider));
				}
				else
				{
					Write(value.ToString());
				}
			}
		}

		public virtual void Write(StringBuilder? value)
		{
			if (value != null)
			{
				StringBuilder.ChunkEnumerator enumerator = value.GetChunks().GetEnumerator();
				while (enumerator.MoveNext())
				{
					Write(enumerator.Current.Span);
				}
			}
		}

		public virtual void Write(string format, object? arg0)
		{
			Write(string.Format(FormatProvider, format, arg0));
		}

		public virtual void Write(string format, object? arg0, object? arg1)
		{
			Write(string.Format(FormatProvider, format, arg0, arg1));
		}

		public virtual void Write(string format, object? arg0, object? arg1, object? arg2)
		{
			Write(string.Format(FormatProvider, format, arg0, arg1, arg2));
		}

		public virtual void Write(string format, params object?[] arg)
		{
			Write(string.Format(FormatProvider, format, arg));
		}

		public virtual void WriteLine()
		{
			Write(CoreNewLine);
		}

		public virtual void WriteLine(char value)
		{
			Write(value);
			WriteLine();
		}

		public virtual void WriteLine(char[]? buffer)
		{
			Write(buffer);
			WriteLine();
		}

		public virtual void WriteLine(char[] buffer, int index, int count)
		{
			Write(buffer, index, count);
			WriteLine();
		}

		public virtual void WriteLine(ReadOnlySpan<char> buffer)
		{
			char[] array = ArrayPool<char>.Shared.Rent(buffer.Length);
			try
			{
				buffer.CopyTo(new Span<char>(array));
				WriteLine(array, 0, buffer.Length);
			}
			finally
			{
				ArrayPool<char>.Shared.Return(array);
			}
		}

		public virtual void WriteLine(bool value)
		{
			Write(value);
			WriteLine();
		}

		public virtual void WriteLine(int value)
		{
			Write(value);
			WriteLine();
		}

		[CLSCompliant(false)]
		public virtual void WriteLine(uint value)
		{
			Write(value);
			WriteLine();
		}

		public virtual void WriteLine(long value)
		{
			Write(value);
			WriteLine();
		}

		[CLSCompliant(false)]
		public virtual void WriteLine(ulong value)
		{
			Write(value);
			WriteLine();
		}

		public virtual void WriteLine(float value)
		{
			Write(value);
			WriteLine();
		}

		public virtual void WriteLine(double value)
		{
			Write(value);
			WriteLine();
		}

		public virtual void WriteLine(decimal value)
		{
			Write(value);
			WriteLine();
		}

		public virtual void WriteLine(string? value)
		{
			if (value != null)
			{
				Write(value);
			}
			Write(CoreNewLineStr);
		}

		public virtual void WriteLine(StringBuilder? value)
		{
			Write(value);
			WriteLine();
		}

		public virtual void WriteLine(object? value)
		{
			if (value == null)
			{
				WriteLine();
			}
			else if (value is IFormattable formattable)
			{
				WriteLine(formattable.ToString(null, FormatProvider));
			}
			else
			{
				WriteLine(value.ToString());
			}
		}

		public virtual void WriteLine(string format, object? arg0)
		{
			WriteLine(string.Format(FormatProvider, format, arg0));
		}

		public virtual void WriteLine(string format, object? arg0, object? arg1)
		{
			WriteLine(string.Format(FormatProvider, format, arg0, arg1));
		}

		public virtual void WriteLine(string format, object? arg0, object? arg1, object? arg2)
		{
			WriteLine(string.Format(FormatProvider, format, arg0, arg1, arg2));
		}

		public virtual void WriteLine(string format, params object?[] arg)
		{
			WriteLine(string.Format(FormatProvider, format, arg));
		}

		public virtual Task WriteAsync(char value)
		{
			return Task.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextWriter, char> tupleSlim = (TupleSlim<TextWriter, char>)state;
				tupleSlim.Item1.Write(tupleSlim.Item2);
			}, new TupleSlim<TextWriter, char>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		public virtual Task WriteAsync(string? value)
		{
			return Task.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextWriter, string> tupleSlim = (TupleSlim<TextWriter, string>)state;
				tupleSlim.Item1.Write(tupleSlim.Item2);
			}, new TupleSlim<TextWriter, string>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		public virtual Task WriteAsync(StringBuilder? value, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				if (value != null)
				{
					return WriteAsyncCore(value, cancellationToken);
				}
				return Task.CompletedTask;
			}
			return Task.FromCanceled(cancellationToken);
			async Task WriteAsyncCore(StringBuilder sb, CancellationToken ct)
			{
				StringBuilder.ChunkEnumerator enumerator = sb.GetChunks().GetEnumerator();
				while (enumerator.MoveNext())
				{
					ReadOnlyMemory<char> current = enumerator.Current;
					await WriteAsync(current, ct).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
		}

		public Task WriteAsync(char[]? buffer)
		{
			if (buffer == null)
			{
				return Task.CompletedTask;
			}
			return WriteAsync(buffer, 0, buffer.Length);
		}

		public virtual Task WriteAsync(char[] buffer, int index, int count)
		{
			return Task.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextWriter, char[], int, int> tupleSlim = (TupleSlim<TextWriter, char[], int, int>)state;
				tupleSlim.Item1.Write(tupleSlim.Item2, tupleSlim.Item3, tupleSlim.Item4);
			}, new TupleSlim<TextWriter, char[], int, int>(this, buffer, index, count), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		public virtual Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				if (!MemoryMarshal.TryGetArray(buffer, out var segment))
				{
					return Task.Factory.StartNew(delegate(object state)
					{
						TupleSlim<TextWriter, ReadOnlyMemory<char>> tupleSlim = (TupleSlim<TextWriter, ReadOnlyMemory<char>>)state;
						tupleSlim.Item1.Write(tupleSlim.Item2.Span);
					}, new TupleSlim<TextWriter, ReadOnlyMemory<char>>(this, buffer), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
				}
				return WriteAsync(segment.Array, segment.Offset, segment.Count);
			}
			return Task.FromCanceled(cancellationToken);
		}

		public virtual Task WriteLineAsync(char value)
		{
			return Task.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextWriter, char> tupleSlim = (TupleSlim<TextWriter, char>)state;
				tupleSlim.Item1.WriteLine(tupleSlim.Item2);
			}, new TupleSlim<TextWriter, char>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		public virtual Task WriteLineAsync(string? value)
		{
			return Task.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextWriter, string> tupleSlim = (TupleSlim<TextWriter, string>)state;
				tupleSlim.Item1.WriteLine(tupleSlim.Item2);
			}, new TupleSlim<TextWriter, string>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		public virtual Task WriteLineAsync(StringBuilder? value, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				if (value != null)
				{
					return WriteLineAsyncCore(value, cancellationToken);
				}
				return WriteAsync(CoreNewLine, cancellationToken);
			}
			return Task.FromCanceled(cancellationToken);
			async Task WriteLineAsyncCore(StringBuilder sb, CancellationToken ct)
			{
				StringBuilder.ChunkEnumerator enumerator = sb.GetChunks().GetEnumerator();
				while (enumerator.MoveNext())
				{
					ReadOnlyMemory<char> current = enumerator.Current;
					await WriteAsync(current, ct).ConfigureAwait(continueOnCapturedContext: false);
				}
				await WriteAsync(CoreNewLine, ct).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		public Task WriteLineAsync(char[]? buffer)
		{
			if (buffer == null)
			{
				return WriteLineAsync();
			}
			return WriteLineAsync(buffer, 0, buffer.Length);
		}

		public virtual Task WriteLineAsync(char[] buffer, int index, int count)
		{
			return Task.Factory.StartNew(delegate(object state)
			{
				TupleSlim<TextWriter, char[], int, int> tupleSlim = (TupleSlim<TextWriter, char[], int, int>)state;
				tupleSlim.Item1.WriteLine(tupleSlim.Item2, tupleSlim.Item3, tupleSlim.Item4);
			}, new TupleSlim<TextWriter, char[], int, int>(this, buffer, index, count), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		public virtual Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				if (!MemoryMarshal.TryGetArray(buffer, out var segment))
				{
					return Task.Factory.StartNew(delegate(object state)
					{
						TupleSlim<TextWriter, ReadOnlyMemory<char>> tupleSlim = (TupleSlim<TextWriter, ReadOnlyMemory<char>>)state;
						tupleSlim.Item1.WriteLine(tupleSlim.Item2.Span);
					}, new TupleSlim<TextWriter, ReadOnlyMemory<char>>(this, buffer), cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
				}
				return WriteLineAsync(segment.Array, segment.Offset, segment.Count);
			}
			return Task.FromCanceled(cancellationToken);
		}

		public virtual Task WriteLineAsync()
		{
			return WriteAsync(CoreNewLine);
		}

		public virtual Task FlushAsync()
		{
			return Task.Factory.StartNew(delegate(object state)
			{
				((TextWriter)state).Flush();
			}, this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
		}

		public static TextWriter Synchronized(TextWriter writer)
		{
			if (writer == null)
			{
				throw new ArgumentNullException("writer");
			}
			if (!(writer is SyncTextWriter))
			{
				return new SyncTextWriter(writer);
			}
			return writer;
		}
	}
	public class UnmanagedMemoryAccessor : IDisposable
	{
		private SafeBuffer _buffer;

		private long _offset;

		private long _capacity;

		private FileAccess _access;

		private bool _isOpen;

		private bool _canRead;

		private bool _canWrite;

		public long Capacity => _capacity;

		public bool CanRead
		{
			get
			{
				if (_isOpen)
				{
					return _canRead;
				}
				return false;
			}
		}

		public bool CanWrite
		{
			get
			{
				if (_isOpen)
				{
					return _canWrite;
				}
				return false;
			}
		}

		protected bool IsOpen => _isOpen;

		protected UnmanagedMemoryAccessor()
		{
		}

		public UnmanagedMemoryAccessor(SafeBuffer buffer, long offset, long capacity)
		{
			Initialize(buffer, offset, capacity, FileAccess.Read);
		}

		public UnmanagedMemoryAccessor(SafeBuffer buffer, long offset, long capacity, FileAccess access)
		{
			Initialize(buffer, offset, capacity, access);
		}

		protected unsafe void Initialize(SafeBuffer buffer, long offset, long capacity, FileAccess access)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.ByteLength < (ulong)(offset + capacity))
			{
				throw new ArgumentException(SR.Argument_OffsetAndCapacityOutOfBounds);
			}
			if (access < FileAccess.Read || access > FileAccess.ReadWrite)
			{
				throw new ArgumentOutOfRangeException("access");
			}
			if (_isOpen)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CalledTwice);
			}
			byte* pointer = null;
			try
			{
				buffer.AcquirePointer(ref pointer);
				if ((nuint)((long)pointer + offset + capacity) < (nuint)pointer)
				{
					throw new ArgumentException(SR.Argument_UnmanagedMemAccessorWrapAround);
				}
			}
			finally
			{
				if (pointer != null)
				{
					buffer.ReleasePointer();
				}
			}
			_offset = offset;
			_buffer = buffer;
			_capacity = capacity;
			_access = access;
			_isOpen = true;
			_canRead = (_access & FileAccess.Read) != 0;
			_canWrite = (_access & FileAccess.Write) != 0;
		}

		protected virtual void Dispose(bool disposing)
		{
			_isOpen = false;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public bool ReadBoolean(long position)
		{
			return ReadByte(position) != 0;
		}

		public unsafe byte ReadByte(long position)
		{
			EnsureSafeToRead(position, 1);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				return (pointer + _offset)[position];
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public char ReadChar(long position)
		{
			return (char)ReadInt16(position);
		}

		public unsafe short ReadInt16(long position)
		{
			EnsureSafeToRead(position, 2);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				return Unsafe.ReadUnaligned<short>(pointer + _offset + position);
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public unsafe int ReadInt32(long position)
		{
			EnsureSafeToRead(position, 4);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				return Unsafe.ReadUnaligned<int>(pointer + _offset + position);
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public unsafe long ReadInt64(long position)
		{
			EnsureSafeToRead(position, 8);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				return Unsafe.ReadUnaligned<long>(pointer + _offset + position);
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public unsafe decimal ReadDecimal(long position)
		{
			EnsureSafeToRead(position, 16);
			byte* pointer = null;
			int lo;
			int mid;
			int hi;
			int num;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				pointer += _offset + position;
				lo = Unsafe.ReadUnaligned<int>(pointer);
				mid = Unsafe.ReadUnaligned<int>(pointer + 4);
				hi = Unsafe.ReadUnaligned<int>(pointer + 8);
				num = Unsafe.ReadUnaligned<int>(pointer + 12);
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
			if (((uint)num & 0x7F00FFFFu) != 0 || (num & 0xFF0000) > 1835008)
			{
				throw new ArgumentException(SR.Arg_BadDecimal);
			}
			bool isNegative = (num & int.MinValue) != 0;
			byte scale = (byte)(num >> 16);
			return new decimal(lo, mid, hi, isNegative, scale);
		}

		public float ReadSingle(long position)
		{
			return BitConverter.Int32BitsToSingle(ReadInt32(position));
		}

		public double ReadDouble(long position)
		{
			return BitConverter.Int64BitsToDouble(ReadInt64(position));
		}

		[CLSCompliant(false)]
		public sbyte ReadSByte(long position)
		{
			return (sbyte)ReadByte(position);
		}

		[CLSCompliant(false)]
		public ushort ReadUInt16(long position)
		{
			return (ushort)ReadInt16(position);
		}

		[CLSCompliant(false)]
		public uint ReadUInt32(long position)
		{
			return (uint)ReadInt32(position);
		}

		[CLSCompliant(false)]
		public ulong ReadUInt64(long position)
		{
			return (ulong)ReadInt64(position);
		}

		public void Read<T>(long position, out T structure) where T : struct
		{
			if (position < 0)
			{
				throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException("UnmanagedMemoryAccessor", SR.ObjectDisposed_ViewAccessorClosed);
			}
			if (!_canRead)
			{
				throw new NotSupportedException(SR.NotSupported_Reading);
			}
			uint num = SafeBuffer.SizeOf<T>();
			if (position > _capacity - num)
			{
				if (position >= _capacity)
				{
					throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_PositionLessThanCapacityRequired);
				}
				throw new ArgumentException(SR.Format(SR.Argument_NotEnoughBytesToRead, typeof(T)), "position");
			}
			structure = _buffer.Read<T>((ulong)(_offset + position));
		}

		public int ReadArray<T>(long position, T[] array, int offset, int count) where T : struct
		{
			if (array == null)
			{
				throw new ArgumentNullException("array", SR.ArgumentNull_Buffer);
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (array.Length - offset < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException("UnmanagedMemoryAccessor", SR.ObjectDisposed_ViewAccessorClosed);
			}
			if (!_canRead)
			{
				throw new NotSupportedException(SR.NotSupported_Reading);
			}
			if (position < 0)
			{
				throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			uint num = SafeBuffer.AlignedSizeOf<T>();
			if (position >= _capacity)
			{
				throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_PositionLessThanCapacityRequired);
			}
			int num2 = count;
			long num3 = _capacity - position;
			if (num3 < 0)
			{
				num2 = 0;
			}
			else
			{
				ulong num4 = (ulong)(num * count);
				if ((ulong)num3 < num4)
				{
					num2 = (int)(num3 / num);
				}
			}
			_buffer.ReadArray((ulong)(_offset + position), array, offset, num2);
			return num2;
		}

		public void Write(long position, bool value)
		{
			Write(position, (byte)(value ? 1u : 0u));
		}

		public unsafe void Write(long position, byte value)
		{
			EnsureSafeToWrite(position, 1);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				(pointer + _offset)[position] = value;
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public void Write(long position, char value)
		{
			Write(position, (short)value);
		}

		public unsafe void Write(long position, short value)
		{
			EnsureSafeToWrite(position, 2);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				Unsafe.WriteUnaligned(pointer + _offset + position, value);
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public unsafe void Write(long position, int value)
		{
			EnsureSafeToWrite(position, 4);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				Unsafe.WriteUnaligned(pointer + _offset + position, value);
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public unsafe void Write(long position, long value)
		{
			EnsureSafeToWrite(position, 8);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				Unsafe.WriteUnaligned(pointer + _offset + position, value);
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public unsafe void Write(long position, decimal value)
		{
			EnsureSafeToWrite(position, 16);
			Span<int> destination = stackalloc int[4];
			decimal.TryGetBits(value, destination, out var _);
			byte* pointer = null;
			try
			{
				_buffer.AcquirePointer(ref pointer);
				pointer += _offset + position;
				Unsafe.WriteUnaligned(pointer, destination[0]);
				Unsafe.WriteUnaligned(pointer + 4, destination[1]);
				Unsafe.WriteUnaligned(pointer + 8, destination[2]);
				Unsafe.WriteUnaligned(pointer + 12, destination[3]);
			}
			finally
			{
				if (pointer != null)
				{
					_buffer.ReleasePointer();
				}
			}
		}

		public void Write(long position, float value)
		{
			Write(position, BitConverter.SingleToInt32Bits(value));
		}

		public void Write(long position, double value)
		{
			Write(position, BitConverter.DoubleToInt64Bits(value));
		}

		[CLSCompliant(false)]
		public void Write(long position, sbyte value)
		{
			Write(position, (byte)value);
		}

		[CLSCompliant(false)]
		public void Write(long position, ushort value)
		{
			Write(position, (short)value);
		}

		[CLSCompliant(false)]
		public void Write(long position, uint value)
		{
			Write(position, (int)value);
		}

		[CLSCompliant(false)]
		public void Write(long position, ulong value)
		{
			Write(position, (long)value);
		}

		public void Write<T>(long position, ref T structure) where T : struct
		{
			if (position < 0)
			{
				throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException("UnmanagedMemoryAccessor", SR.ObjectDisposed_ViewAccessorClosed);
			}
			if (!_canWrite)
			{
				throw new NotSupportedException(SR.NotSupported_Writing);
			}
			uint num = SafeBuffer.SizeOf<T>();
			if (position > _capacity - num)
			{
				if (position >= _capacity)
				{
					throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_PositionLessThanCapacityRequired);
				}
				throw new ArgumentException(SR.Format(SR.Argument_NotEnoughBytesToWrite, typeof(T)), "position");
			}
			_buffer.Write((ulong)(_offset + position), structure);
		}

		public void WriteArray<T>(long position, T[] array, int offset, int count) where T : struct
		{
			if (array == null)
			{
				throw new ArgumentNullException("array", SR.ArgumentNull_Buffer);
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (array.Length - offset < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (position < 0)
			{
				throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (position >= Capacity)
			{
				throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_PositionLessThanCapacityRequired);
			}
			if (!_isOpen)
			{
				throw new ObjectDisposedException("UnmanagedMemoryAccessor", SR.ObjectDisposed_ViewAccessorClosed);
			}
			if (!_canWrite)
			{
				throw new NotSupportedException(SR.NotSupported_Writing);
			}
			_buffer.WriteArray((ulong)(_offset + position), array, offset, count);
		}

		private void EnsureSafeToRead(long position, int sizeOfType)
		{
			if (!_isOpen)
			{
				throw new ObjectDisposedException("UnmanagedMemoryAccessor", SR.ObjectDisposed_ViewAccessorClosed);
			}
			if (!_canRead)
			{
				throw new NotSupportedException(SR.NotSupported_Reading);
			}
			if (position < 0)
			{
				throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (position > _capacity - sizeOfType)
			{
				if (position >= _capacity)
				{
					throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_PositionLessThanCapacityRequired);
				}
				throw new ArgumentException(SR.Argument_NotEnoughBytesToRead, "position");
			}
		}

		private void EnsureSafeToWrite(long position, int sizeOfType)
		{
			if (!_isOpen)
			{
				throw new ObjectDisposedException("UnmanagedMemoryAccessor", SR.ObjectDisposed_ViewAccessorClosed);
			}
			if (!_canWrite)
			{
				throw new NotSupportedException(SR.NotSupported_Writing);
			}
			if (position < 0)
			{
				throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (position > _capacity - sizeOfType)
			{
				if (position >= _capacity)
				{
					throw new ArgumentOutOfRangeException("position", SR.ArgumentOutOfRange_PositionLessThanCapacityRequired);
				}
				throw new ArgumentException(SR.Argument_NotEnoughBytesToWrite, "position");
			}
		}
	}
	public class UnmanagedMemoryStream : Stream
	{
		private SafeBuffer _buffer;

		private unsafe byte* _mem;

		private long _length;

		private long _capacity;

		private long _position;

		private long _offset;

		private FileAccess _access;

		private bool _isOpen;

		private Task<int> _lastReadTask;

		public override bool CanRead
		{
			get
			{
				if (_isOpen)
				{
					return (_access & FileAccess.Read) != 0;
				}
				return false;
			}
		}

		public override bool CanSeek => _isOpen;

		public override bool CanWrite
		{
			get
			{
				if (_isOpen)
				{
					return (_access & FileAccess.Write) != 0;
				}
				return false;
			}
		}

		public override long Length
		{
			get
			{
				EnsureNotClosed();
				return Interlocked.Read(ref _length);
			}
		}

		public long Capacity
		{
			get
			{
				EnsureNotClosed();
				return _capacity;
			}
		}

		public override long Position
		{
			get
			{
				if (!CanSeek)
				{
					ThrowHelper.ThrowObjectDisposedException_StreamClosed(null);
				}
				return Interlocked.Read(ref _position);
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (!CanSeek)
				{
					ThrowHelper.ThrowObjectDisposedException_StreamClosed(null);
				}
				Interlocked.Exchange(ref _position, value);
			}
		}

		[CLSCompliant(false)]
		public unsafe byte* PositionPointer
		{
			get
			{
				if (_buffer != null)
				{
					throw new NotSupportedException(SR.NotSupported_UmsSafeBuffer);
				}
				EnsureNotClosed();
				long num = Interlocked.Read(ref _position);
				if (num > _capacity)
				{
					throw new IndexOutOfRangeException(SR.IndexOutOfRange_UMSPosition);
				}
				return _mem + num;
			}
			set
			{
				if (_buffer != null)
				{
					throw new NotSupportedException(SR.NotSupported_UmsSafeBuffer);
				}
				EnsureNotClosed();
				if (value < _mem)
				{
					throw new IOException(SR.IO_SeekBeforeBegin);
				}
				long num = (long)value - (long)_mem;
				if (num < 0)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_UnmanagedMemStreamLength);
				}
				Interlocked.Exchange(ref _position, num);
			}
		}

		protected UnmanagedMemoryStream()
		{
		}

		public UnmanagedMemoryStream(SafeBuffer buffer, long offset, long length)
		{
			Initialize(buffer, offset, length, FileAccess.Read);
		}

		public UnmanagedMemoryStream(SafeBuffer buffer, long offset, long length, FileAccess access)
		{
			Initialize(buffer, offset, length, access);
		}

		protected unsafe void Initialize(SafeBuffer buffer, long offset, long length, FileAccess access)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (buffer.ByteLength < (ulong)(offset + length))
			{
				throw new ArgumentException(SR.Argument_InvalidSafeBufferOffLen);
			}
			if (access < FileAccess.Read || access > FileAccess.ReadWrite)
			{
				throw new ArgumentOutOfRangeException("access");
			}
			if (_isOpen)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CalledTwice);
			}
			byte* pointer = null;
			try
			{
				buffer.AcquirePointer(ref pointer);
				if (pointer + offset + length < pointer)
				{
					throw new ArgumentException(SR.ArgumentOutOfRange_UnmanagedMemStreamWrapAround);
				}
			}
			finally
			{
				if (pointer != null)
				{
					buffer.ReleasePointer();
				}
			}
			_offset = offset;
			_buffer = buffer;
			_length = length;
			_capacity = length;
			_access = access;
			_isOpen = true;
		}

		[CLSCompliant(false)]
		public unsafe UnmanagedMemoryStream(byte* pointer, long length)
		{
			Initialize(pointer, length, length, FileAccess.Read);
		}

		[CLSCompliant(false)]
		public unsafe UnmanagedMemoryStream(byte* pointer, long length, long capacity, FileAccess access)
		{
			Initialize(pointer, length, capacity, access);
		}

		[CLSCompliant(false)]
		protected unsafe void Initialize(byte* pointer, long length, long capacity, FileAccess access)
		{
			if (pointer == null)
			{
				throw new ArgumentNullException("pointer");
			}
			if (length < 0 || capacity < 0)
			{
				throw new ArgumentOutOfRangeException((length < 0) ? "length" : "capacity", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (length > capacity)
			{
				throw new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_LengthGreaterThanCapacity);
			}
			if ((nuint)((long)pointer + capacity) < (nuint)pointer)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_UnmanagedMemStreamWrapAround);
			}
			if (access < FileAccess.Read || access > FileAccess.ReadWrite)
			{
				throw new ArgumentOutOfRangeException("access", SR.ArgumentOutOfRange_Enum);
			}
			if (_isOpen)
			{
				throw new InvalidOperationException(SR.InvalidOperation_CalledTwice);
			}
			_mem = pointer;
			_offset = 0L;
			_length = length;
			_capacity = capacity;
			_access = access;
			_isOpen = true;
		}

		protected unsafe override void Dispose(bool disposing)
		{
			_isOpen = false;
			_mem = null;
			base.Dispose(disposing);
		}

		private void EnsureNotClosed()
		{
			if (!_isOpen)
			{
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(null);
			}
		}

		private void EnsureReadable()
		{
			if (!CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
		}

		private void EnsureWriteable()
		{
			if (!CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
		}

		public override void Flush()
		{
			EnsureNotClosed();
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			try
			{
				Flush();
				return Task.CompletedTask;
			}
			catch (Exception exception)
			{
				return Task.FromException(exception);
			}
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			return ReadCore(new Span<byte>(buffer, offset, count));
		}

		public override int Read(Span<byte> buffer)
		{
			if (GetType() == typeof(UnmanagedMemoryStream))
			{
				return ReadCore(buffer);
			}
			return base.Read(buffer);
		}

		internal unsafe int ReadCore(Span<byte> buffer)
		{
			EnsureNotClosed();
			EnsureReadable();
			long num = Interlocked.Read(ref _position);
			long num2 = Interlocked.Read(ref _length);
			long num3 = Math.Min(num2 - num, buffer.Length);
			if (num3 <= 0)
			{
				return 0;
			}
			int num4 = (int)num3;
			if (num4 < 0)
			{
				return 0;
			}
			if (_buffer != null)
			{
				byte* pointer = null;
				try
				{
					_buffer.AcquirePointer(ref pointer);
					Buffer.Memmove(ref MemoryMarshal.GetReference(buffer), ref (pointer + num)[_offset], (nuint)num4);
				}
				finally
				{
					if (pointer != null)
					{
						_buffer.ReleasePointer();
					}
				}
			}
			else
			{
				Buffer.Memmove(ref MemoryMarshal.GetReference(buffer), ref _mem[num], (nuint)num4);
			}
			Interlocked.Exchange(ref _position, num + num3);
			return num4;
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<int>(cancellationToken);
			}
			try
			{
				int num = Read(buffer, offset, count);
				Task<int> lastReadTask = _lastReadTask;
				return (lastReadTask != null && lastReadTask.Result == num) ? lastReadTask : (_lastReadTask = Task.FromResult(num));
			}
			catch (Exception exception)
			{
				return Task.FromException<int>(exception);
			}
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			try
			{
				ArraySegment<byte> segment;
				return new ValueTask<int>(MemoryMarshal.TryGetArray((ReadOnlyMemory<byte>)buffer, out segment) ? Read(segment.Array, segment.Offset, segment.Count) : Read(buffer.Span));
			}
			catch (Exception exception)
			{
				return ValueTask.FromException<int>(exception);
			}
		}

		public unsafe override int ReadByte()
		{
			EnsureNotClosed();
			EnsureReadable();
			long num = Interlocked.Read(ref _position);
			long num2 = Interlocked.Read(ref _length);
			if (num >= num2)
			{
				return -1;
			}
			Interlocked.Exchange(ref _position, num + 1);
			if (_buffer != null)
			{
				byte* pointer = null;
				try
				{
					_buffer.AcquirePointer(ref pointer);
					return (pointer + num)[_offset];
				}
				finally
				{
					if (pointer != null)
					{
						_buffer.ReleasePointer();
					}
				}
			}
			return _mem[num];
		}

		public override long Seek(long offset, SeekOrigin loc)
		{
			EnsureNotClosed();
			switch (loc)
			{
			case SeekOrigin.Begin:
				if (offset < 0)
				{
					throw new IOException(SR.IO_SeekBeforeBegin);
				}
				Interlocked.Exchange(ref _position, offset);
				break;
			case SeekOrigin.Current:
			{
				long num2 = Interlocked.Read(ref _position);
				if (offset + num2 < 0)
				{
					throw new IOException(SR.IO_SeekBeforeBegin);
				}
				Interlocked.Exchange(ref _position, offset + num2);
				break;
			}
			case SeekOrigin.End:
			{
				long num = Interlocked.Read(ref _length);
				if (num + offset < 0)
				{
					throw new IOException(SR.IO_SeekBeforeBegin);
				}
				Interlocked.Exchange(ref _position, num + offset);
				break;
			}
			default:
				throw new ArgumentException(SR.Argument_InvalidSeekOrigin);
			}
			return Interlocked.Read(ref _position);
		}

		public unsafe override void SetLength(long value)
		{
			if (value < 0)
			{
				throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_buffer != null)
			{
				throw new NotSupportedException(SR.NotSupported_UmsSafeBuffer);
			}
			EnsureNotClosed();
			EnsureWriteable();
			if (value > _capacity)
			{
				throw new IOException(SR.IO_FixedCapacity);
			}
			long num = Interlocked.Read(ref _position);
			long num2 = Interlocked.Read(ref _length);
			if (value > num2)
			{
				Buffer.ZeroMemory(_mem + num2, (nuint)(value - num2));
			}
			Interlocked.Exchange(ref _length, value);
			if (num > value)
			{
				Interlocked.Exchange(ref _position, value);
			}
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			WriteCore(new ReadOnlySpan<byte>(buffer, offset, count));
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			if (GetType() == typeof(UnmanagedMemoryStream))
			{
				WriteCore(buffer);
			}
			else
			{
				base.Write(buffer);
			}
		}

		internal unsafe void WriteCore(ReadOnlySpan<byte> buffer)
		{
			EnsureNotClosed();
			EnsureWriteable();
			long num = Interlocked.Read(ref _position);
			long num2 = Interlocked.Read(ref _length);
			long num3 = num + buffer.Length;
			if (num3 < 0)
			{
				throw new IOException(SR.IO_StreamTooLong);
			}
			if (num3 > _capacity)
			{
				throw new NotSupportedException(SR.IO_FixedCapacity);
			}
			if (_buffer == null)
			{
				if (num > num2)
				{
					Buffer.ZeroMemory(_mem + num2, (nuint)(num - num2));
				}
				if (num3 > num2)
				{
					Interlocked.Exchange(ref _length, num3);
				}
			}
			if (_buffer != null)
			{
				long num4 = _capacity - num;
				if (num4 < buffer.Length)
				{
					throw new ArgumentException(SR.Arg_BufferTooSmall);
				}
				byte* pointer = null;
				try
				{
					_buffer.AcquirePointer(ref pointer);
					Buffer.Memmove(ref (pointer + num)[_offset], ref MemoryMarshal.GetReference(buffer), (nuint)buffer.Length);
				}
				finally
				{
					if (pointer != null)
					{
						_buffer.ReleasePointer();
					}
				}
			}
			else
			{
				Buffer.Memmove(ref _mem[num], ref MemoryMarshal.GetReference(buffer), (nuint)buffer.Length);
			}
			Interlocked.Exchange(ref _position, num3);
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			Stream.ValidateBufferArguments(buffer, offset, count);
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			try
			{
				Write(buffer, offset, count);
				return Task.CompletedTask;
			}
			catch (Exception exception)
			{
				return Task.FromException(exception);
			}
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled(cancellationToken);
			}
			try
			{
				if (MemoryMarshal.TryGetArray(buffer, out var segment))
				{
					Write(segment.Array, segment.Offset, segment.Count);
				}
				else
				{
					Write(buffer.Span);
				}
				return default(ValueTask);
			}
			catch (Exception exception)
			{
				return ValueTask.FromException(exception);
			}
		}

		public unsafe override void WriteByte(byte value)
		{
			EnsureNotClosed();
			EnsureWriteable();
			long num = Interlocked.Read(ref _position);
			long num2 = Interlocked.Read(ref _length);
			long num3 = num + 1;
			if (num >= num2)
			{
				if (num3 < 0)
				{
					throw new IOException(SR.IO_StreamTooLong);
				}
				if (num3 > _capacity)
				{
					throw new NotSupportedException(SR.IO_FixedCapacity);
				}
				if (_buffer == null)
				{
					if (num > num2)
					{
						Buffer.ZeroMemory(_mem + num2, (nuint)(num - num2));
					}
					Interlocked.Exchange(ref _length, num3);
				}
			}
			if (_buffer != null)
			{
				byte* pointer = null;
				try
				{
					_buffer.AcquirePointer(ref pointer);
					(pointer + num)[_offset] = value;
				}
				finally
				{
					if (pointer != null)
					{
						_buffer.ReleasePointer();
					}
				}
			}
			else
			{
				_mem[num] = value;
			}
			Interlocked.Exchange(ref _position, num3);
		}
	}
	internal sealed class UnmanagedMemoryStreamWrapper : MemoryStream
	{
		private readonly UnmanagedMemoryStream _unmanagedStream;

		public override bool CanRead => _unmanagedStream.CanRead;

		public override bool CanSeek => _unmanagedStream.CanSeek;

		public override bool CanWrite => _unmanagedStream.CanWrite;

		public override int Capacity
		{
			get
			{
				return (int)_unmanagedStream.Capacity;
			}
			set
			{
				throw new IOException(SR.IO_FixedCapacity);
			}
		}

		public override long Length => _unmanagedStream.Length;

		public override long Position
		{
			get
			{
				return _unmanagedStream.Position;
			}
			set
			{
				_unmanagedStream.Position = value;
			}
		}

		internal UnmanagedMemoryStreamWrapper(UnmanagedMemoryStream stream)
		{
			_unmanagedStream = stream;
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing)
				{
					_unmanagedStream.Dispose();
				}
			}
			finally
			{
				base.Dispose(disposing);
			}
		}

		public override void Flush()
		{
			_unmanagedStream.Flush();
		}

		public override byte[] GetBuffer()
		{
			throw new UnauthorizedAccessException(SR.UnauthorizedAccess_MemStreamBuffer);
		}

		public override bool TryGetBuffer(out ArraySegment<byte> buffer)
		{
			buffer = default(ArraySegment<byte>);
			return false;
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			return _unmanagedStream.Read(buffer, offset, count);
		}

		public override int Read(Span<byte> buffer)
		{
			return _unmanagedStream.Read(buffer);
		}

		public override int ReadByte()
		{
			return _unmanagedStream.ReadByte();
		}

		public override long Seek(long offset, SeekOrigin loc)
		{
			return _unmanagedStream.Seek(offset, loc);
		}

		public override byte[] ToArray()
		{
			byte[] array = new byte[_unmanagedStream.Length];
			_unmanagedStream.Read(array, 0, (int)_unmanagedStream.Length);
			return array;
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			_unmanagedStream.Write(buffer, offset, count);
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			_unmanagedStream.Write(buffer);
		}

		public override void WriteByte(byte value)
		{
			_unmanagedStream.WriteByte(value);
		}

		public override void WriteTo(Stream stream)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream", SR.ArgumentNull_Stream);
			}
			byte[] array = ToArray();
			stream.Write(array, 0, array.Length);
		}

		public override void SetLength(long value)
		{
			base.SetLength(value);
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			if (bufferSize <= 0)
			{
				throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedPosNum);
			}
			if (!CanRead && !CanWrite)
			{
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(null);
			}
			if (!destination.CanRead && !destination.CanWrite)
			{
				ThrowHelper.ThrowObjectDisposedException_StreamClosed("destination");
			}
			if (!CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			if (!destination.CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
			return _unmanagedStream.CopyToAsync(destination, bufferSize, cancellationToken);
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			return _unmanagedStream.FlushAsync(cancellationToken);
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return _unmanagedStream.ReadAsync(buffer, offset, count, cancellationToken);
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			return _unmanagedStream.ReadAsync(buffer, cancellationToken);
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return _unmanagedStream.WriteAsync(buffer, offset, count, cancellationToken);
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			return _unmanagedStream.WriteAsync(buffer, cancellationToken);
		}
	}
	internal struct DisableMediaInsertionPrompt : IDisposable
	{
		private bool _disableSuccess;

		private uint _oldMode;

		public static DisableMediaInsertionPrompt Create()
		{
			DisableMediaInsertionPrompt result = default(DisableMediaInsertionPrompt);
			result._disableSuccess = Interop.Kernel32.SetThreadErrorMode(1u, out result._oldMode);
			return result;
		}

		public void Dispose()
		{
			if (_disableSuccess)
			{
				Interop.Kernel32.SetThreadErrorMode(_oldMode, out var _);
			}
		}
	}
	internal static class DriveInfoInternal
	{
		public static string[] GetLogicalDrives()
		{
			int logicalDrives = Interop.Kernel32.GetLogicalDrives();
			if (logicalDrives == 0)
			{
				throw Win32Marshal.GetExceptionForLastWin32Error();
			}
			uint num = (uint)logicalDrives;
			int num2 = 0;
			while (num != 0)
			{
				if ((num & (true ? 1u : 0u)) != 0)
				{
					num2++;
				}
				num >>= 1;
			}
			string[] array = new string[num2];
			Span<char> span = stackalloc char[3] { 'A', ':', '\\' };
			num = (uint)logicalDrives;
			num2 = 0;
			while (num != 0)
			{
				if ((num & (true ? 1u : 0u)) != 0)
				{
					array[num2++] = span.ToString();
				}
				num >>= 1;
				span[0] += '\u0001';
			}
			return array;
		}

		public static string NormalizeDriveName(string driveName)
		{
			string text;
			if (driveName.Length == 1)
			{
				text = driveName + ":\\";
			}
			else
			{
				text = Path.GetPathRoot(driveName);
				if (string.IsNullOrEmpty(text) || text.StartsWith("\\\\", StringComparison.Ordinal))
				{
					throw new ArgumentException(SR.Arg_MustBeDriveLetterOrRootDir, "driveName");
				}
			}
			if (text.Length == 2 && text[1] == ':')
			{
				text += "\\";
			}
			char c = driveName[0];
			if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z'))
			{
				throw new ArgumentException(SR.Arg_MustBeDriveLetterOrRootDir, "driveName");
			}
			return text;
		}
	}
	internal static class PathHelper
	{
		internal static string Normalize(string path)
		{
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder builder = new ValueStringBuilder(initialBuffer);
			GetFullPathName(path.AsSpan(), ref builder);
			string result = ((builder.AsSpan().IndexOf('~') >= 0) ? TryExpandShortFileName(ref builder, path) : (MemoryExtensions.Equals(builder.AsSpan(), path.AsSpan(), StringComparison.Ordinal) ? path : builder.ToString()));
			builder.Dispose();
			return result;
		}

		internal static string Normalize(ref ValueStringBuilder path)
		{
			Span<char> initialBuffer = stackalloc char[260];
			ValueStringBuilder builder = new ValueStringBuilder(initialBuffer);
			GetFullPathName(path.AsSpan(terminate: true), ref builder);
			string result = ((builder.AsSpan().IndexOf('~') >= 0) ? TryExpandShortFileName(ref builder, null) : builder.ToString());
			builder.Dispose();
			return result;
		}

		private static void GetFullPathName(ReadOnlySpan<char> path, ref ValueStringBuilder builder)
		{
			uint fullPathNameW;
			while ((fullPathNameW = Interop.Kernel32.GetFullPathNameW(ref MemoryMarshal.GetReference(path), (uint)builder.Capacity, ref builder.GetPinnableReference(), IntPtr.Zero)) > builder.Capacity)
			{
				builder.EnsureCapacity(checked((int)fullPathNameW));
			}
			if (fullPathNameW == 0)
			{
				int num = Marshal.GetLastWin32Error();
				if (num == 0)
				{
					num = 161;
				}
				throw Win32Marshal.GetExceptionForWin32Error(num, path.ToString());
			}
			builder.Length = (int)fullPathNameW;
		}

		internal static int PrependDevicePathChars(ref ValueStringBuilder content, bool isDosUnc, ref ValueStringBuilder buffer)
		{
			int length = content.Length;
			length += (isDosUnc ? 6 : 4);
			buffer.EnsureCapacity(length + 1);
			buffer.Length = 0;
			if (isDosUnc)
			{
				buffer.Append("\\\\?\\UNC\\");
				buffer.Append(content.AsSpan(2));
				return 6;
			}
			buffer.Append("\\\\?\\");
			buffer.Append(content.AsSpan());
			return 4;
		}

		internal static string TryExpandShortFileName(ref ValueStringBuilder outputBuilder, string originalPath)
		{
			int rootLength = PathInternal.GetRootLength(outputBuilder.AsSpan());
			bool flag = PathInternal.IsDevice(outputBuilder.AsSpan());
			ValueStringBuilder buffer = default(ValueStringBuilder);
			bool flag2 = false;
			int num = 0;
			bool flag3 = false;
			if (flag)
			{
				buffer.Append(outputBuilder.AsSpan());
				if (outputBuilder[2] == '.')
				{
					flag3 = true;
					buffer[2] = '?';
				}
			}
			else
			{
				flag2 = !PathInternal.IsDevice(outputBuilder.AsSpan()) && outputBuilder.Length > 1 && outputBuilder[0] == '\\' && outputBuilder[1] == '\\';
				num = PrependDevicePathChars(ref outputBuilder, flag2, ref buffer);
			}
			rootLength += num;
			int length = buffer.Length;
			bool flag4 = false;
			int num2 = buffer.Length - 1;
			while (!flag4)
			{
				uint longPathNameW = Interop.Kernel32.GetLongPathNameW(ref buffer.GetPinnableReference(terminate: true), ref outputBuilder.GetPinnableReference(), (uint)outputBuilder.Capacity);
				if (buffer[num2] == '\0')
				{
					buffer[num2] = '\\';
				}
				if (longPathNameW == 0)
				{
					int lastWin32Error = Marshal.GetLastWin32Error();
					if (lastWin32Error != 2 && lastWin32Error != 3)
					{
						break;
					}
					num2--;
					while (num2 > rootLength && buffer[num2] != '\\')
					{
						num2--;
					}
					if (num2 == rootLength)
					{
						break;
					}
					buffer[num2] = '\0';
				}
				else if (longPathNameW > outputBuilder.Capacity)
				{
					outputBuilder.EnsureCapacity(checked((int)longPathNameW));
				}
				else
				{
					flag4 = true;
					outputBuilder.Length = checked((int)longPathNameW);
					if (num2 < length - 1)
					{
						outputBuilder.Append(buffer.AsSpan(num2, buffer.Length - num2));
					}
				}
			}
			ref ValueStringBuilder reference = ref flag4 ? ref outputBuilder : ref buffer;
			if (flag3)
			{
				reference[2] = '.';
			}
			if (flag2)
			{
				reference[6] = '\\';
			}
			ReadOnlySpan<char> span = reference.AsSpan(num);
			string result = ((originalPath != null && MemoryExtensions.Equals(span, originalPath.AsSpan(), StringComparison.Ordinal)) ? originalPath : span.ToString());
			buffer.Dispose();
			return result;
		}
	}
	internal static class Win32Marshal
	{
		internal static Exception GetExceptionForLastWin32Error(string path = "")
		{
			return GetExceptionForWin32Error(Marshal.GetLastWin32Error(), path);
		}

		internal static Exception GetExceptionForWin32Error(int errorCode, string path = "")
		{
			switch (errorCode)
			{
			case 2:
				return new FileNotFoundException(string.IsNullOrEmpty(path) ? SR.IO_FileNotFound : SR.Format(SR.IO_FileNotFound_FileName, path), path);
			case 3:
				return new DirectoryNotFoundException(string.IsNullOrEmpty(path) ? SR.IO_PathNotFound_NoPathName : SR.Format(SR.IO_PathNotFound_Path, path));
			case 5:
				return new UnauthorizedAccessException(string.IsNullOrEmpty(path) ? SR.UnauthorizedAccess_IODenied_NoPathName : SR.Format(SR.UnauthorizedAccess_IODenied_Path, path));
			case 183:
				if (!string.IsNullOrEmpty(path))
				{
					return new IOException(SR.Format(SR.IO_AlreadyExists_Name, path), MakeHRFromErrorCode(errorCode));
				}
				break;
			case 206:
				return new PathTooLongException(string.IsNullOrEmpty(path) ? SR.IO_PathTooLong : SR.Format(SR.IO_PathTooLong_Path, path));
			case 32:
				return new IOException(string.IsNullOrEmpty(path) ? SR.IO_SharingViolation_NoFileName : SR.Format(SR.IO_SharingViolation_File, path), MakeHRFromErrorCode(errorCode));
			case 80:
				if (!string.IsNullOrEmpty(path))
				{
					return new IOException(SR.Format(SR.IO_FileExists_Name, path), MakeHRFromErrorCode(errorCode));
				}
				break;
			case 995:
				return new OperationCanceledException();
			}
			return new IOException(string.IsNullOrEmpty(path) ? GetMessage(errorCode) : (GetMessage(errorCode) + " : '" + path + "'"), MakeHRFromErrorCode(errorCode));
		}

		internal static int MakeHRFromErrorCode(int errorCode)
		{
			if ((0xFFFF0000u & errorCode) != 0L)
			{
				return errorCode;
			}
			return -2147024896 | errorCode;
		}

		internal static string GetMessage(int errorCode)
		{
			return Interop.Kernel32.GetMessage(errorCode);
		}
	}
}
namespace System.IO.Strategies
{
	internal sealed class BufferedFileStreamStrategy : FileStreamStrategy
	{
		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <ReadAsyncSlowPath>d__39 : IAsyncStateMachine
		{
			public int <>1__state;

			public PoolingAsyncValueTaskMethodBuilder<int> <>t__builder;

			public Task semaphoreLockTask;

			public BufferedFileStreamStrategy <>4__this;

			public Memory<byte> buffer;

			public CancellationToken cancellationToken;

			private ConfiguredTaskAwaitable.ConfiguredTaskAwaiter <>u__1;

			private int <bytesAlreadySatisfied>5__2;

			private ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter <>u__2;

			private ConfiguredValueTaskAwaitable<int>.ConfiguredValueTaskAwaiter <>u__3;

			private void MoveNext()
			{
				int num = <>1__state;
				BufferedFileStreamStrategy bufferedFileStreamStrategy = <>4__this;
				int result;
				try
				{
					ConfiguredTaskAwaitable.ConfiguredTaskAwaiter awaiter;
					if (num != 0)
					{
						if ((uint)(num - 1) <= 2u)
						{
							goto IL_007d;
						}
						awaiter = semaphoreLockTask.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(ConfiguredTaskAwaitable.ConfiguredTaskAwaiter);
						num = (<>1__state = -1);
					}
					awaiter.GetResult();
					goto IL_007d;
					IL_007d:
					try
					{
						ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter awaiter4;
						ConfiguredValueTaskAwaitable<int>.ConfiguredValueTaskAwaiter awaiter3;
						ConfiguredValueTaskAwaitable<int>.ConfiguredValueTaskAwaiter awaiter2;
						int result2;
						int num2;
						switch (num)
						{
						default:
							num2 = 0;
							<bytesAlreadySatisfied>5__2 = 0;
							if (bufferedFileStreamStrategy._readLen - bufferedFileStreamStrategy._readPos <= 0)
							{
								goto IL_0146;
							}
							num2 = Math.Min(buffer.Length, bufferedFileStreamStrategy._readLen - bufferedFileStreamStrategy._readPos);
							if (num2 > 0)
							{
								bufferedFileStreamStrategy._buffer.AsSpan(bufferedFileStreamStrategy._readPos, num2).CopyTo(buffer.Span);
								bufferedFileStreamStrategy._readPos += num2;
							}
							if (num2 != buffer.Length)
							{
								if (num2 > 0)
								{
									buffer = buffer.Slice(num2);
									<bytesAlreadySatisfied>5__2 += num2;
								}
								goto IL_0146;
							}
							result = num2;
							goto end_IL_007d;
						case 1:
							awaiter4 = <>u__2;
							<>u__2 = default(ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter);
							num = (<>1__state = -1);
							goto IL_01e6;
						case 2:
							awaiter3 = <>u__3;
							<>u__3 = default(ConfiguredValueTaskAwaitable<int>.ConfiguredValueTaskAwaiter);
							num = (<>1__state = -1);
							goto IL_0280;
						case 3:
							{
								awaiter2 = <>u__3;
								<>u__3 = default(ConfiguredValueTaskAwaitable<int>.ConfiguredValueTaskAwaiter);
								num = (<>1__state = -1);
								break;
							}
							IL_0280:
							result2 = awaiter3.GetResult();
							result = result2 + <bytesAlreadySatisfied>5__2;
							goto end_IL_007d;
							IL_0146:
							bufferedFileStreamStrategy._readPos = (bufferedFileStreamStrategy._readLen = 0);
							if (bufferedFileStreamStrategy._writePos > 0)
							{
								awaiter4 = bufferedFileStreamStrategy._strategy.WriteAsync(new ReadOnlyMemory<byte>(bufferedFileStreamStrategy._buffer, 0, bufferedFileStreamStrategy._writePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
								if (!awaiter4.IsCompleted)
								{
									num = (<>1__state = 1);
									<>u__2 = awaiter4;
									<>t__builder.AwaitUnsafeOnCompleted(ref awaiter4, ref this);
									return;
								}
								goto IL_01e6;
							}
							goto IL_01f4;
							IL_01e6:
							awaiter4.GetResult();
							bufferedFileStreamStrategy._writePos = 0;
							goto IL_01f4;
							IL_01f4:
							if (buffer.Length >= bufferedFileStreamStrategy._bufferSize)
							{
								awaiter3 = bufferedFileStreamStrategy._strategy.ReadAsync(buffer, cancellationToken).ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
								if (!awaiter3.IsCompleted)
								{
									num = (<>1__state = 2);
									<>u__3 = awaiter3;
									<>t__builder.AwaitUnsafeOnCompleted(ref awaiter3, ref this);
									return;
								}
								goto IL_0280;
							}
							bufferedFileStreamStrategy.EnsureBufferAllocated();
							awaiter2 = bufferedFileStreamStrategy._strategy.ReadAsync(new Memory<byte>(bufferedFileStreamStrategy._buffer, 0, bufferedFileStreamStrategy._bufferSize), cancellationToken).ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								num = (<>1__state = 3);
								<>u__3 = awaiter2;
								<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref this);
								return;
							}
							break;
						}
						int result3 = awaiter2.GetResult();
						bufferedFileStreamStrategy._readLen = result3;
						num2 = Math.Min(bufferedFileStreamStrategy._readLen, buffer.Length);
						bufferedFileStreamStrategy._buffer.AsSpan(0, num2).CopyTo(buffer.Span);
						bufferedFileStreamStrategy._readPos += num2;
						result = <bytesAlreadySatisfied>5__2 + num2;
						end_IL_007d:;
					}
					finally
					{
						if (num < 0)
						{
							bufferedFileStreamStrategy._asyncActiveSemaphore.Release();
						}
					}
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				<>t__builder.SetStateMachine(stateMachine);
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <WriteAsyncSlowPath>d__50 : IAsyncStateMachine
		{
			public int <>1__state;

			public PoolingAsyncValueTaskMethodBuilder <>t__builder;

			public Task semaphoreLockTask;

			public BufferedFileStreamStrategy <>4__this;

			public ReadOnlyMemory<byte> source;

			public CancellationToken cancellationToken;

			private ConfiguredTaskAwaitable.ConfiguredTaskAwaiter <>u__1;

			private ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter <>u__2;

			private void MoveNext()
			{
				int num = <>1__state;
				BufferedFileStreamStrategy bufferedFileStreamStrategy = <>4__this;
				try
				{
					ConfiguredTaskAwaitable.ConfiguredTaskAwaiter awaiter;
					if (num != 0)
					{
						if ((uint)(num - 1) <= 1u)
						{
							goto IL_007c;
						}
						awaiter = semaphoreLockTask.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
						if (!awaiter.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(ConfiguredTaskAwaitable.ConfiguredTaskAwaiter);
						num = (<>1__state = -1);
					}
					awaiter.GetResult();
					goto IL_007c;
					IL_007c:
					try
					{
						ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter awaiter2;
						if (num == 1)
						{
							awaiter2 = <>u__2;
							<>u__2 = default(ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter);
							num = (<>1__state = -1);
							goto IL_01e1;
						}
						ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter awaiter3;
						if (num == 2)
						{
							awaiter3 = <>u__2;
							<>u__2 = default(ConfiguredValueTaskAwaitable.ConfiguredValueTaskAwaiter);
							num = (<>1__state = -1);
							goto IL_0278;
						}
						if (bufferedFileStreamStrategy._writePos == 0)
						{
							bufferedFileStreamStrategy.ClearReadBufferBeforeWrite();
						}
						if (bufferedFileStreamStrategy._writePos <= 0)
						{
							goto IL_01ef;
						}
						int num2 = bufferedFileStreamStrategy._bufferSize - bufferedFileStreamStrategy._writePos;
						if (num2 <= 0)
						{
							goto IL_015f;
						}
						ReadOnlySpan<byte> readOnlySpan;
						if (num2 < source.Length)
						{
							readOnlySpan = source.Span;
							readOnlySpan = readOnlySpan.Slice(0, num2);
							readOnlySpan.CopyTo(bufferedFileStreamStrategy._buffer.AsSpan(bufferedFileStreamStrategy._writePos));
							bufferedFileStreamStrategy._writePos += num2;
							source = source.Slice(num2);
							goto IL_015f;
						}
						readOnlySpan = source.Span;
						readOnlySpan.CopyTo(bufferedFileStreamStrategy._buffer.AsSpan(bufferedFileStreamStrategy._writePos));
						bufferedFileStreamStrategy._writePos += source.Length;
						goto end_IL_007c;
						IL_01ef:
						if (source.Length >= bufferedFileStreamStrategy._bufferSize)
						{
							awaiter3 = bufferedFileStreamStrategy._strategy.WriteAsync(source, cancellationToken).ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
							if (!awaiter3.IsCompleted)
							{
								num = (<>1__state = 2);
								<>u__2 = awaiter3;
								<>t__builder.AwaitUnsafeOnCompleted(ref awaiter3, ref this);
								return;
							}
							goto IL_0278;
						}
						if (source.Length != 0)
						{
							bufferedFileStreamStrategy.EnsureBufferAllocated();
							readOnlySpan = source.Span;
							readOnlySpan.CopyTo(bufferedFileStreamStrategy._buffer.AsSpan(bufferedFileStreamStrategy._writePos));
							bufferedFileStreamStrategy._writePos = source.Length;
						}
						goto end_IL_007c;
						IL_01e1:
						awaiter2.GetResult();
						bufferedFileStreamStrategy._writePos = 0;
						goto IL_01ef;
						IL_0278:
						awaiter3.GetResult();
						goto end_IL_007c;
						IL_015f:
						awaiter2 = bufferedFileStreamStrategy._strategy.WriteAsync(new ReadOnlyMemory<byte>(bufferedFileStreamStrategy._buffer, 0, bufferedFileStreamStrategy._writePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
						if (!awaiter2.IsCompleted)
						{
							num = (<>1__state = 1);
							<>u__2 = awaiter2;
							<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref this);
							return;
						}
						goto IL_01e1;
						end_IL_007c:;
					}
					finally
					{
						if (num < 0)
						{
							bufferedFileStreamStrategy._asyncActiveSemaphore.Release();
						}
					}
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<>t__builder.SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				<>t__builder.SetStateMachine(stateMachine);
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		private readonly FileStreamStrategy _strategy;

		private readonly int _bufferSize;

		private byte[] _buffer;

		private int _writePos;

		private int _readPos;

		private int _readLen;

		private Task<int> _lastSyncCompletedReadTask;

		public override bool CanRead => _strategy.CanRead;

		public override bool CanWrite => _strategy.CanWrite;

		public override bool CanSeek => _strategy.CanSeek;

		public override long Length
		{
			get
			{
				long num = _strategy.Length;
				if (_writePos > 0 && _strategy.Position + _writePos > num)
				{
					num = _writePos + _strategy.Position;
				}
				return num;
			}
		}

		public override long Position
		{
			get
			{
				return _strategy.Position + _readPos - _readLen + _writePos;
			}
			set
			{
				if (_writePos > 0)
				{
					FlushWrite();
				}
				_readPos = 0;
				_readLen = 0;
				_strategy.Position = value;
			}
		}

		internal override bool IsAsync => _strategy.IsAsync;

		internal override bool IsClosed => _strategy.IsClosed;

		internal override string Name => _strategy.Name;

		internal override SafeFileHandle SafeFileHandle
		{
			get
			{
				Flush();
				return _strategy.SafeFileHandle;
			}
		}

		internal BufferedFileStreamStrategy(FileStreamStrategy strategy, int bufferSize)
		{
			_strategy = strategy;
			_bufferSize = bufferSize;
		}

		~BufferedFileStreamStrategy()
		{
			try
			{
				Dispose(disposing: true);
			}
			catch (Exception e) when (FileStreamHelpers.IsIoRelatedException(e))
			{
			}
		}

		public override async ValueTask DisposeAsync()
		{
			_ = 1;
			try
			{
				if (!_strategy.IsClosed)
				{
					try
					{
						await FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
					}
					finally
					{
						await _strategy.DisposeAsync().ConfigureAwait(continueOnCapturedContext: false);
					}
				}
			}
			finally
			{
				_writePos = 0;
			}
		}

		internal override void DisposeInternal(bool disposing)
		{
			Dispose(disposing);
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing && !_strategy.IsClosed)
				{
					try
					{
						Flush();
						return;
					}
					finally
					{
						_strategy.Dispose();
					}
				}
			}
			finally
			{
				base.Dispose(disposing);
				_writePos = 0;
			}
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			return ReadSpan(new Span<byte>(buffer, offset, count), new ArraySegment<byte>(buffer, offset, count));
		}

		public override int Read(Span<byte> destination)
		{
			EnsureNotClosed();
			return ReadSpan(destination, default(ArraySegment<byte>));
		}

		private int ReadSpan(Span<byte> destination, ArraySegment<byte> arraySegment)
		{
			bool flag = false;
			int num = _readLen - _readPos;
			if (num == 0)
			{
				EnsureCanRead();
				if (_writePos > 0)
				{
					FlushWrite();
				}
				if (!_strategy.CanSeek || destination.Length >= _bufferSize)
				{
					num = ((arraySegment.Array != null) ? _strategy.Read(arraySegment.Array, arraySegment.Offset, arraySegment.Count) : _strategy.Read(destination));
					_readPos = 0;
					_readLen = 0;
					return num;
				}
				EnsureBufferAllocated();
				num = _strategy.Read(_buffer, 0, _bufferSize);
				if (num == 0)
				{
					return 0;
				}
				flag = num < _bufferSize;
				_readPos = 0;
				_readLen = num;
			}
			if (num > destination.Length)
			{
				num = destination.Length;
			}
			new ReadOnlySpan<byte>(_buffer, _readPos, num).CopyTo(destination);
			_readPos += num;
			if (_strategy.CanSeek && num < destination.Length && !flag)
			{
				int num2 = ((arraySegment.Array != null) ? _strategy.Read(arraySegment.Array, arraySegment.Offset + num, arraySegment.Count - num) : _strategy.Read(destination.Slice(num)));
				num += num2;
				_readPos = 0;
				_readLen = 0;
			}
			return num;
		}

		public override int ReadByte()
		{
			if (_readPos == _readLen)
			{
				return ReadByteSlow();
			}
			return _buffer[_readPos++];
		}

		private int ReadByteSlow()
		{
			EnsureNotClosed();
			EnsureCanRead();
			if (_writePos > 0)
			{
				FlushWrite();
			}
			EnsureBufferAllocated();
			_readLen = _strategy.Read(_buffer, 0, _bufferSize);
			_readPos = 0;
			if (_readLen == 0)
			{
				return -1;
			}
			return _buffer[_readPos++];
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			ValueTask<int> valueTask = ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken);
			if (!valueTask.IsCompletedSuccessfully)
			{
				return valueTask.AsTask();
			}
			return LastSyncCompletedReadTask(valueTask.Result);
			Task<int> LastSyncCompletedReadTask(int val)
			{
				Task<int> lastSyncCompletedReadTask = _lastSyncCompletedReadTask;
				if (lastSyncCompletedReadTask != null && lastSyncCompletedReadTask.Result == val)
				{
					return lastSyncCompletedReadTask;
				}
				return _lastSyncCompletedReadTask = Task.FromResult(val);
			}
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled<int>(cancellationToken);
			}
			EnsureCanRead();
			if (!_strategy.CanSeek)
			{
				return ReadFromNonSeekableAsync(buffer, cancellationToken);
			}
			SemaphoreSlim semaphoreSlim = EnsureAsyncActiveSemaphoreInitialized();
			Task task = semaphoreSlim.WaitAsync(cancellationToken);
			if (task.IsCompletedSuccessfully && _writePos == 0)
			{
				bool flag = true;
				try
				{
					if (_readLen == _readPos && buffer.Length >= _bufferSize)
					{
						return _strategy.ReadAsync(buffer, cancellationToken);
					}
					if (_readLen - _readPos >= buffer.Length)
					{
						_buffer.AsSpan(_readPos, buffer.Length).CopyTo(buffer.Span);
						_readPos += buffer.Length;
						return new ValueTask<int>(buffer.Length);
					}
					flag = false;
				}
				finally
				{
					if (flag)
					{
						semaphoreSlim.Release();
					}
				}
			}
			return ReadAsyncSlowPath(task, buffer, cancellationToken);
		}

		private async ValueTask<int> ReadFromNonSeekableAsync(Memory<byte> destination, CancellationToken cancellationToken)
		{
			await EnsureAsyncActiveSemaphoreInitialized().WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				if (_readPos < _readLen)
				{
					int num = Math.Min(_readLen - _readPos, destination.Length);
					new Span<byte>(_buffer, _readPos, num).CopyTo(destination.Span);
					_readPos += num;
					return num;
				}
				return await _strategy.ReadAsync(destination, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				_asyncActiveSemaphore.Release();
			}
		}

		[AsyncStateMachine(typeof(<ReadAsyncSlowPath>d__39))]
		[AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))]
		private ValueTask<int> ReadAsyncSlowPath(Task semaphoreLockTask, Memory<byte> buffer, CancellationToken cancellationToken)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out <ReadAsyncSlowPath>d__39 stateMachine);
			stateMachine.<>t__builder = PoolingAsyncValueTaskMethodBuilder<int>.Create();
			stateMachine.<>4__this = this;
			stateMachine.semaphoreLockTask = semaphoreLockTask;
			stateMachine.buffer = buffer;
			stateMachine.cancellationToken = cancellationToken;
			stateMachine.<>1__state = -1;
			stateMachine.<>t__builder.Start(ref stateMachine);
			return stateMachine.<>t__builder.Task;
		}

		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return TaskToApm.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state);
		}

		public override int EndRead(IAsyncResult asyncResult)
		{
			return TaskToApm.End<int>(asyncResult);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			WriteSpan(new ReadOnlySpan<byte>(buffer, offset, count), new ArraySegment<byte>(buffer, offset, count));
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			EnsureNotClosed();
			WriteSpan(buffer, default(ArraySegment<byte>));
		}

		private void WriteSpan(ReadOnlySpan<byte> source, ArraySegment<byte> arraySegment)
		{
			if (_writePos == 0)
			{
				EnsureCanWrite();
				ClearReadBufferBeforeWrite();
			}
			if (_writePos > 0)
			{
				int num = _bufferSize - _writePos;
				if (num > 0)
				{
					if (num >= source.Length)
					{
						source.CopyTo(_buffer.AsSpan(_writePos));
						_writePos += source.Length;
						return;
					}
					source.Slice(0, num).CopyTo(_buffer.AsSpan(_writePos));
					_writePos += num;
					source = source.Slice(num);
					if (arraySegment.Array != null)
					{
						arraySegment = arraySegment.Slice(num);
					}
				}
				FlushWrite();
			}
			if (source.Length >= _bufferSize)
			{
				if (arraySegment.Array != null)
				{
					_strategy.Write(arraySegment.Array, arraySegment.Offset, arraySegment.Count);
				}
				else
				{
					_strategy.Write(source);
				}
			}
			else if (source.Length != 0)
			{
				EnsureBufferAllocated();
				source.CopyTo(_buffer.AsSpan(_writePos));
				_writePos = source.Length;
			}
		}

		public override void WriteByte(byte value)
		{
			if (_writePos > 0 && _writePos < _bufferSize - 1)
			{
				_buffer[_writePos++] = value;
			}
			else
			{
				WriteByteSlow(value);
			}
		}

		private void WriteByteSlow(byte value)
		{
			if (_writePos == 0)
			{
				EnsureNotClosed();
				EnsureCanWrite();
				ClearReadBufferBeforeWrite();
				EnsureBufferAllocated();
			}
			else
			{
				FlushWrite();
			}
			_buffer[_writePos++] = value;
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return ValueTask.FromCanceled(cancellationToken);
			}
			EnsureCanWrite();
			if (!_strategy.CanSeek)
			{
				return WriteToNonSeekableAsync(buffer, cancellationToken);
			}
			SemaphoreSlim semaphoreSlim = EnsureAsyncActiveSemaphoreInitialized();
			Task task = semaphoreSlim.WaitAsync(cancellationToken);
			if (task.IsCompletedSuccessfully && _readPos == _readLen)
			{
				bool flag = true;
				try
				{
					if (_writePos == 0 && buffer.Length >= _bufferSize)
					{
						return _strategy.WriteAsync(buffer, cancellationToken);
					}
					if (_bufferSize - _writePos >= buffer.Length)
					{
						EnsureBufferAllocated();
						buffer.Span.CopyTo(_buffer.AsSpan(_writePos));
						_writePos += buffer.Length;
						return default(ValueTask);
					}
					flag = false;
				}
				finally
				{
					if (flag)
					{
						semaphoreSlim.Release();
					}
				}
			}
			return WriteAsyncSlowPath(task, buffer, cancellationToken);
		}

		private async ValueTask WriteToNonSeekableAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
		{
			await EnsureAsyncActiveSemaphoreInitialized().WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				await _strategy.WriteAsync(source, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				_asyncActiveSemaphore.Release();
			}
		}

		[AsyncStateMachine(typeof(<WriteAsyncSlowPath>d__50))]
		[AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder))]
		private ValueTask WriteAsyncSlowPath(Task semaphoreLockTask, ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out <WriteAsyncSlowPath>d__50 stateMachine);
			stateMachine.<>t__builder = PoolingAsyncValueTaskMethodBuilder.Create();
			stateMachine.<>4__this = this;
			stateMachine.semaphoreLockTask = semaphoreLockTask;
			stateMachine.source = source;
			stateMachine.cancellationToken = cancellationToken;
			stateMachine.<>1__state = -1;
			stateMachine.<>t__builder.Start(ref stateMachine);
			return stateMachine.<>t__builder.Task;
		}

		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);
		}

		public override void EndWrite(IAsyncResult asyncResult)
		{
			TaskToApm.End(asyncResult);
		}

		public override void SetLength(long value)
		{
			Flush();
			_strategy.SetLength(value);
		}

		public override void Flush()
		{
			Flush(flushToDisk: false);
		}

		internal override void Flush(bool flushToDisk)
		{
			EnsureNotClosed();
			if (_writePos > 0 && _strategy.CanWrite)
			{
				FlushWrite();
			}
			else if (_readPos < _readLen)
			{
				if (_strategy.CanSeek)
				{
					FlushRead();
				}
			}
			else
			{
				_strategy.Flush(flushToDisk);
				_writePos = (_readPos = (_readLen = 0));
			}
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<int>(cancellationToken);
			}
			EnsureNotClosed();
			return FlushAsyncInternal(cancellationToken);
		}

		private async Task FlushAsyncInternal(CancellationToken cancellationToken)
		{
			await EnsureAsyncActiveSemaphoreInitialized().WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				if (_writePos > 0)
				{
					await _strategy.WriteAsync(new ReadOnlyMemory<byte>(_buffer, 0, _writePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					_writePos = 0;
				}
				else if (_readPos < _readLen && _strategy.CanSeek)
				{
					FlushRead();
				}
			}
			finally
			{
				_asyncActiveSemaphore.Release();
			}
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			EnsureNotClosed();
			EnsureCanRead();
			if (!cancellationToken.IsCancellationRequested)
			{
				return CopyToAsyncCore(destination, bufferSize, cancellationToken);
			}
			return Task.FromCanceled<int>(cancellationToken);
		}

		private async Task CopyToAsyncCore(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			await EnsureAsyncActiveSemaphoreInitialized().WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				int num = _readLen - _readPos;
				if (num > 0)
				{
					await destination.WriteAsync(new ReadOnlyMemory<byte>(_buffer, _readPos, num), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					_readPos = (_readLen = 0);
				}
				else if (_writePos > 0)
				{
					await _strategy.WriteAsync(new ReadOnlyMemory<byte>(_buffer, 0, _writePos), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					_writePos = 0;
				}
				await _strategy.CopyToAsync(destination, bufferSize, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				_asyncActiveSemaphore.Release();
			}
		}

		public override void CopyTo(Stream destination, int bufferSize)
		{
			EnsureNotClosed();
			EnsureCanRead();
			int num = _readLen - _readPos;
			if (num > 0)
			{
				destination.Write(_buffer, _readPos, num);
				_readPos = (_readLen = 0);
			}
			else if (_writePos > 0)
			{
				FlushWrite();
			}
			_strategy.CopyTo(destination, bufferSize);
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			EnsureNotClosed();
			EnsureCanSeek();
			if (_writePos > 0)
			{
				FlushWrite();
				return _strategy.Seek(offset, origin);
			}
			if (_readLen - _readPos > 0 && origin == SeekOrigin.Current)
			{
				offset -= _readLen - _readPos;
			}
			long position = Position;
			long num = _strategy.Seek(offset, origin);
			long num2 = num - (position - _readPos);
			if (0 <= num2 && num2 < _readLen)
			{
				_readPos = (int)num2;
				_strategy.Seek(_readLen - _readPos, SeekOrigin.Current);
			}
			else
			{
				_readPos = (_readLen = 0);
			}
			return num;
		}

		internal override void Lock(long position, long length)
		{
			_strategy.Lock(position, length);
		}

		internal override void Unlock(long position, long length)
		{
			_strategy.Unlock(position, length);
		}

		private void FlushRead()
		{
			if (_readPos - _readLen != 0)
			{
				_strategy.Seek(_readPos - _readLen, SeekOrigin.Current);
			}
			_readPos = 0;
			_readLen = 0;
		}

		private void FlushWrite()
		{
			_strategy.Write(_buffer, 0, _writePos);
			_writePos = 0;
		}

		private void ClearReadBufferBeforeWrite()
		{
			if (_readPos == _readLen)
			{
				_readPos = (_readLen = 0);
			}
			else
			{
				FlushRead();
			}
		}

		private void EnsureNotClosed()
		{
			if (_strategy.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_StreamClosed(null);
			}
		}

		private void EnsureCanSeek()
		{
			if (!_strategy.CanSeek)
			{
				ThrowHelper.ThrowNotSupportedException_UnseekableStream();
			}
		}

		private void EnsureCanRead()
		{
			if (!_strategy.CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
		}

		private void EnsureCanWrite()
		{
			if (!_strategy.CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
		}

		[MemberNotNull("_buffer")]
		private void EnsureBufferAllocated()
		{
			if (_buffer == null)
			{
				AllocateBuffer();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[MemberNotNull("_buffer")]
		private void AllocateBuffer()
		{
			Interlocked.CompareExchange(ref _buffer, GC.AllocateUninitializedArray<byte>(_bufferSize), null);
		}
	}
	internal sealed class DerivedFileStreamStrategy : FileStreamStrategy
	{
		private readonly FileStreamStrategy _strategy;

		private readonly FileStream _fileStream;

		public override bool CanRead => _strategy.CanRead;

		public override bool CanWrite => _strategy.CanWrite;

		public override bool CanSeek => _strategy.CanSeek;

		public override long Length => _strategy.Length;

		public override long Position
		{
			get
			{
				return _strategy.Position;
			}
			set
			{
				_strategy.Position = value;
			}
		}

		internal override bool IsAsync => _strategy.IsAsync;

		internal override string Name => _strategy.Name;

		internal override SafeFileHandle SafeFileHandle
		{
			get
			{
				_fileStream.Flush(flushToDisk: false);
				return _strategy.SafeFileHandle;
			}
		}

		internal override bool IsClosed => _strategy.IsClosed;

		internal DerivedFileStreamStrategy(FileStream fileStream, FileStreamStrategy strategy)
		{
			_fileStream = fileStream;
			_strategy = strategy;
		}

		~DerivedFileStreamStrategy()
		{
			_fileStream.DisposeInternal(disposing: false);
		}

		internal override void Lock(long position, long length)
		{
			_strategy.Lock(position, length);
		}

		internal override void Unlock(long position, long length)
		{
			_strategy.Unlock(position, length);
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			return _strategy.Seek(offset, origin);
		}

		public override void SetLength(long value)
		{
			_strategy.SetLength(value);
		}

		public override int ReadByte()
		{
			return _strategy.ReadByte();
		}

		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			if (!_strategy.IsAsync)
			{
				return _fileStream.BaseBeginRead(buffer, offset, count, callback, state);
			}
			return _strategy.BeginRead(buffer, offset, count, callback, state);
		}

		public override int EndRead(IAsyncResult asyncResult)
		{
			if (!_strategy.IsAsync)
			{
				return _fileStream.BaseEndRead(asyncResult);
			}
			return _strategy.EndRead(asyncResult);
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			return _strategy.Read(buffer, offset, count);
		}

		public override int Read(Span<byte> buffer)
		{
			return _fileStream.BaseRead(buffer);
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return _fileStream.BaseReadAsync(buffer, offset, count, cancellationToken);
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			return _fileStream.BaseReadAsync(buffer, cancellationToken);
		}

		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			if (!_strategy.IsAsync)
			{
				return _fileStream.BaseBeginWrite(buffer, offset, count, callback, state);
			}
			return _strategy.BeginWrite(buffer, offset, count, callback, state);
		}

		public override void EndWrite(IAsyncResult asyncResult)
		{
			if (_strategy.IsAsync)
			{
				_strategy.EndWrite(asyncResult);
			}
			else
			{
				_fileStream.BaseEndWrite(asyncResult);
			}
		}

		public override void WriteByte(byte value)
		{
			_strategy.WriteByte(value);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			_strategy.Write(buffer, offset, count);
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			_fileStream.BaseWrite(buffer);
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return _fileStream.BaseWriteAsync(buffer, offset, count, cancellationToken);
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			return _fileStream.BaseWriteAsync(buffer, cancellationToken);
		}

		public override void Flush()
		{
			throw new InvalidOperationException("FileStream should never call this method.");
		}

		internal override void Flush(bool flushToDisk)
		{
			_strategy.Flush(flushToDisk);
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			return _fileStream.BaseFlushAsync(cancellationToken);
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			return _fileStream.BaseCopyToAsync(destination, bufferSize, cancellationToken);
		}

		public override ValueTask DisposeAsync()
		{
			return _fileStream.BaseDisposeAsync();
		}

		internal override void DisposeInternal(bool disposing)
		{
			_strategy.DisposeInternal(disposing);
			if (disposing)
			{
				GC.SuppressFinalize(this);
			}
		}
	}
	internal static class FileStreamHelpers
	{
		private sealed class AsyncCopyToAwaitable : ICriticalNotifyCompletion, INotifyCompletion
		{
			private static readonly Action s_sentinel = delegate
			{
			};

			internal unsafe static readonly IOCompletionCallback s_callback = IOCallback;

			internal readonly SafeFileHandle _fileHandle;

			internal long _position;

			internal unsafe NativeOverlapped* _nativeOverlapped;

			internal Action _continuation;

			internal uint _errorCode;

			internal uint _numBytes;

			internal object CancellationLock => this;

			public bool IsCompleted => (object)_continuation == s_sentinel;

			internal AsyncCopyToAwaitable(SafeFileHandle fileHandle)
			{
				_fileHandle = fileHandle;
			}

			internal void ResetForNextOperation()
			{
				_continuation = null;
				_errorCode = 0u;
				_numBytes = 0u;
			}

			internal unsafe static void IOCallback(uint errorCode, uint numBytes, NativeOverlapped* pOVERLAP)
			{
				AsyncCopyToAwaitable asyncCopyToAwaitable = (AsyncCopyToAwaitable)ThreadPoolBoundHandle.GetNativeOverlappedState(pOVERLAP);
				asyncCopyToAwaitable._errorCode = errorCode;
				asyncCopyToAwaitable._numBytes = numBytes;
				(asyncCopyToAwaitable._continuation ?? Interlocked.CompareExchange(ref asyncCopyToAwaitable._continuation, s_sentinel, null))?.Invoke();
			}

			internal void MarkCompleted()
			{
				_continuation = s_sentinel;
			}

			public AsyncCopyToAwaitable GetAwaiter()
			{
				return this;
			}

			public void GetResult()
			{
			}

			public void OnCompleted(Action continuation)
			{
				UnsafeOnCompleted(continuation);
			}

			public void UnsafeOnCompleted(Action continuation)
			{
				if ((object)_continuation == s_sentinel || Interlocked.CompareExchange(ref _continuation, continuation, null) != null)
				{
					Task.Run(continuation);
				}
			}
		}

		private static int s_cachedSerializationSwitch;

		internal static bool UseNet5CompatStrategy { get; } = AppContextConfigHelper.GetBooleanConfig("System.IO.UseNet5CompatFileStream", "DOTNET_SYSTEM_IO_USENET5COMPATFILESTREAM");


		internal static FileStreamStrategy ChooseStrategy(FileStream fileStream, SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync)
		{
			FileStreamStrategy strategy = (UseNet5CompatStrategy ? new Net5CompatFileStreamStrategy(handle, access, (bufferSize == 0) ? 1 : bufferSize, isAsync) : EnableBufferingIfNeeded(ChooseStrategyCore(handle, access, isAsync), bufferSize));
			return WrapIfDerivedType(fileStream, strategy);
		}

		internal static FileStreamStrategy ChooseStrategy(FileStream fileStream, string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
		{
			FileStreamStrategy strategy = (UseNet5CompatStrategy ? new Net5CompatFileStreamStrategy(path, mode, access, share, (bufferSize == 0) ? 1 : bufferSize, options, preallocationSize) : EnableBufferingIfNeeded(ChooseStrategyCore(path, mode, access, share, options, preallocationSize), bufferSize));
			return WrapIfDerivedType(fileStream, strategy);
		}

		private static FileStreamStrategy EnableBufferingIfNeeded(FileStreamStrategy strategy, int bufferSize)
		{
			if (bufferSize <= 1)
			{
				return strategy;
			}
			return new BufferedFileStreamStrategy(strategy, bufferSize);
		}

		private static FileStreamStrategy WrapIfDerivedType(FileStream fileStream, FileStreamStrategy strategy)
		{
			if (!(fileStream.GetType() == typeof(FileStream)))
			{
				return new DerivedFileStreamStrategy(fileStream, strategy);
			}
			return strategy;
		}

		internal static bool IsIoRelatedException(Exception e)
		{
			if (!(e is IOException) && !(e is UnauthorizedAccessException) && !(e is NotSupportedException))
			{
				if (e is ArgumentException)
				{
					return !(e is ArgumentNullException);
				}
				return false;
			}
			return true;
		}

		internal static void ValidateArguments(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path", SR.ArgumentNull_Path);
			}
			if (path.Length == 0)
			{
				throw new ArgumentException(SR.Argument_EmptyPath, "path");
			}
			FileShare fileShare = share & ~FileShare.Inheritable;
			string text = null;
			if (mode < FileMode.CreateNew || mode > FileMode.Append)
			{
				text = "mode";
			}
			else if (access < FileAccess.Read || access > FileAccess.ReadWrite)
			{
				text = "access";
			}
			else if ((fileShare < FileShare.None) || fileShare > (FileShare.ReadWrite | FileShare.Delete))
			{
				text = "share";
			}
			if (text != null)
			{
				throw new ArgumentOutOfRangeException(text, SR.ArgumentOutOfRange_Enum);
			}
			if (options != 0 && (options & (FileOptions)67092479) != 0)
			{
				throw new ArgumentOutOfRangeException("options", SR.ArgumentOutOfRange_Enum);
			}
			if (bufferSize < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum("bufferSize");
			}
			else if (preallocationSize < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_NeedNonNegNum("preallocationSize");
			}
			if ((access & FileAccess.Write) == 0 && (mode == FileMode.Truncate || mode == FileMode.CreateNew || mode == FileMode.Create || mode == FileMode.Append))
			{
				throw new ArgumentException(SR.Format(SR.Argument_InvalidFileModeAndAccessCombo, mode, access), "access");
			}
			if ((access & FileAccess.Read) != 0 && mode == FileMode.Append)
			{
				throw new ArgumentException(SR.Argument_InvalidAppendMode, "access");
			}
			if (preallocationSize > 0)
			{
				ValidateArgumentsForPreallocation(mode, access);
			}
			SerializationGuard(access);
		}

		internal static void ValidateArgumentsForPreallocation(FileMode mode, FileAccess access)
		{
			if ((access & FileAccess.Write) == 0)
			{
				throw new ArgumentException(SR.Argument_InvalidPreallocateAccess, "access");
			}
			if (mode != FileMode.Create && mode != FileMode.CreateNew)
			{
				throw new ArgumentException(SR.Argument_InvalidPreallocateMode, "mode");
			}
		}

		internal static void SerializationGuard(FileAccess access)
		{
			if ((access & FileAccess.Write) == FileAccess.Write)
			{
				SerializationInfo.ThrowIfDeserializationInProgress("AllowFileWrites", ref s_cachedSerializationSwitch);
			}
		}

		private static OSFileStreamStrategy ChooseStrategyCore(SafeFileHandle handle, FileAccess access, bool isAsync)
		{
			if (!isAsync)
			{
				return new SyncWindowsFileStreamStrategy(handle, access);
			}
			return new AsyncWindowsFileStreamStrategy(handle, access);
		}

		private static FileStreamStrategy ChooseStrategyCore(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
		{
			if ((options & FileOptions.Asynchronous) == 0)
			{
				return new SyncWindowsFileStreamStrategy(path, mode, access, share, options, preallocationSize);
			}
			return new AsyncWindowsFileStreamStrategy(path, mode, access, share, options, preallocationSize);
		}

		internal static void FlushToDisk(SafeFileHandle handle)
		{
			if (!Interop.Kernel32.FlushFileBuffers(handle))
			{
				throw Win32Marshal.GetExceptionForLastWin32Error(handle.Path);
			}
		}

		internal static long Seek(SafeFileHandle handle, long offset, SeekOrigin origin, bool closeInvalidHandle = false)
		{
			if (!Interop.Kernel32.SetFilePointerEx(handle, offset, out var lpNewFilePointer, (uint)origin))
			{
				if (closeInvalidHandle)
				{
					throw Win32Marshal.GetExceptionForWin32Error(GetLastWin32ErrorAndDisposeHandleIfInvalid(handle), handle.Path);
				}
				throw Win32Marshal.GetExceptionForLastWin32Error(handle.Path);
			}
			return lpNewFilePointer;
		}

		internal static void ThrowInvalidArgument(SafeFileHandle handle)
		{
			throw Win32Marshal.GetExceptionForWin32Error(87, handle.Path);
		}

		internal static int GetLastWin32ErrorAndDisposeHandleIfInvalid(SafeFileHandle handle)
		{
			int lastPInvokeError = Marshal.GetLastPInvokeError();
			if (lastPInvokeError == 6)
			{
				handle.Dispose();
			}
			return lastPInvokeError;
		}

		internal static void Lock(SafeFileHandle handle, bool canWrite, long position, long length)
		{
			int offsetLow = (int)position;
			int offsetHigh = (int)(position >> 32);
			int countLow = (int)length;
			int countHigh = (int)(length >> 32);
			if (!Interop.Kernel32.LockFile(handle, offsetLow, offsetHigh, countLow, countHigh))
			{
				throw Win32Marshal.GetExceptionForLastWin32Error(handle.Path);
			}
		}

		internal static void Unlock(SafeFileHandle handle, long position, long length)
		{
			int offsetLow = (int)position;
			int offsetHigh = (int)(position >> 32);
			int countLow = (int)length;
			int countHigh = (int)(length >> 32);
			if (!Interop.Kernel32.UnlockFile(handle, offsetLow, offsetHigh, countLow, countHigh))
			{
				throw Win32Marshal.GetExceptionForLastWin32Error(handle.Path);
			}
		}

		internal static void SetFileLength(SafeFileHandle handle, long length)
		{
			if (!TrySetFileLength(handle, length, out var errorCode))
			{
				throw (errorCode == 87) ? new ArgumentOutOfRangeException("length", SR.ArgumentOutOfRange_FileLengthTooBig) : Win32Marshal.GetExceptionForWin32Error(errorCode, handle.Path);
			}
		}

		internal unsafe static bool TrySetFileLength(SafeFileHandle handle, long length, out int errorCode)
		{
			Interop.Kernel32.FILE_END_OF_FILE_INFO fILE_END_OF_FILE_INFO = default(Interop.Kernel32.FILE_END_OF_FILE_INFO);
			fILE_END_OF_FILE_INFO.EndOfFile = length;
			Interop.Kernel32.FILE_END_OF_FILE_INFO fILE_END_OF_FILE_INFO2 = fILE_END_OF_FILE_INFO;
			if (!Interop.Kernel32.SetFileInformationByHandle(handle, 6, &fILE_END_OF_FILE_INFO2, (uint)sizeof(Interop.Kernel32.FILE_END_OF_FILE_INFO)))
			{
				errorCode = Marshal.GetLastPInvokeError();
				return false;
			}
			errorCode = 0;
			return true;
		}

		internal unsafe static int ReadFileNative(SafeFileHandle handle, Span<byte> bytes, NativeOverlapped* overlapped, out int errorCode)
		{
			int numBytesRead = 0;
			int num;
			fixed (byte* bytes2 = &MemoryMarshal.GetReference(bytes))
			{
				num = ((overlapped == null) ? Interop.Kernel32.ReadFile(handle, bytes2, bytes.Length, out numBytesRead, overlapped) : Interop.Kernel32.ReadFile(handle, bytes2, bytes.Length, IntPtr.Zero, overlapped));
			}
			if (num == 0)
			{
				errorCode = GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
				return -1;
			}
			errorCode = 0;
			return numBytesRead;
		}

		internal unsafe static async Task AsyncModeCopyToAsync(SafeFileHandle handle, bool canSeek, long filePosition, Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			AsyncCopyToAwaitable readAwaitable = new AsyncCopyToAwaitable(handle);
			if (canSeek)
			{
				readAwaitable._position = filePosition;
			}
			byte[] copyBuffer = ArrayPool<byte>.Shared.Rent(bufferSize);
			PreAllocatedOverlapped awaitableOverlapped = new PreAllocatedOverlapped(AsyncCopyToAwaitable.s_callback, readAwaitable, copyBuffer);
			CancellationTokenRegistration cancellationReg = default(CancellationTokenRegistration);
			try
			{
				if (cancellationToken.CanBeCanceled)
				{
					cancellationReg = cancellationToken.UnsafeRegister(delegate(object s)
					{
						AsyncCopyToAwaitable asyncCopyToAwaitable = (AsyncCopyToAwaitable)s;
						lock (asyncCopyToAwaitable.CancellationLock)
						{
							if (asyncCopyToAwaitable._nativeOverlapped != null)
							{
								Interop.Kernel32.CancelIoEx(asyncCopyToAwaitable._fileHandle, asyncCopyToAwaitable._nativeOverlapped);
							}
						}
					}, readAwaitable);
				}
				while (true)
				{
					cancellationToken.ThrowIfCancellationRequested();
					readAwaitable.ResetForNextOperation();
					try
					{
						readAwaitable._nativeOverlapped = handle.ThreadPoolBinding.AllocateNativeOverlapped(awaitableOverlapped);
						if (canSeek)
						{
							readAwaitable._nativeOverlapped->OffsetLow = (int)readAwaitable._position;
							readAwaitable._nativeOverlapped->OffsetHigh = (int)(readAwaitable._position >> 32);
						}
						if (ReadFileNative(handle, copyBuffer, readAwaitable._nativeOverlapped, out var errorCode) < 0)
						{
							switch (errorCode)
							{
							case 38:
							case 109:
								readAwaitable.MarkCompleted();
								break;
							default:
								throw Win32Marshal.GetExceptionForWin32Error(errorCode, handle.Path);
							case 997:
								break;
							}
						}
						await readAwaitable;
						switch (readAwaitable._errorCode)
						{
						case 995u:
							throw new OperationCanceledException(cancellationToken.IsCancellationRequested ? cancellationToken : new CancellationToken(canceled: true));
						default:
							throw Win32Marshal.GetExceptionForWin32Error((int)readAwaitable._errorCode, handle.Path);
						case 0u:
						case 38u:
						case 109u:
						{
							int numBytes = (int)readAwaitable._numBytes;
							if (numBytes == 0)
							{
								return;
							}
							if (canSeek)
							{
								readAwaitable._position += numBytes;
							}
							break;
						}
						}
					}
					finally
					{
						NativeOverlapped* nativeOverlapped;
						lock (readAwaitable.CancellationLock)
						{
							nativeOverlapped = readAwaitable._nativeOverlapped;
							readAwaitable._nativeOverlapped = null;
						}
						if (nativeOverlapped != null)
						{
							handle.ThreadPoolBinding.FreeNativeOverlapped(nativeOverlapped);
						}
					}
					await destination.WriteAsync(new ReadOnlyMemory<byte>(copyBuffer, 0, (int)readAwaitable._numBytes), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			finally
			{
				cancellationReg.Dispose();
				awaitableOverlapped.Dispose();
				ArrayPool<byte>.Shared.Return(copyBuffer);
			}
		}
	}
	internal abstract class FileStreamStrategy : Stream
	{
		internal abstract bool IsAsync { get; }

		internal abstract string Name { get; }

		internal abstract SafeFileHandle SafeFileHandle { get; }

		internal IntPtr Handle => SafeFileHandle.DangerousGetHandle();

		internal abstract bool IsClosed { get; }

		internal abstract void Lock(long position, long length);

		internal abstract void Unlock(long position, long length);

		internal abstract void Flush(bool flushToDisk);

		internal abstract void DisposeInternal(bool disposing);
	}
	internal sealed class Net5CompatFileStreamStrategy : FileStreamStrategy
	{
		private class CompletionSource : TaskCompletionSource<int>
		{
			internal unsafe static readonly IOCompletionCallback s_ioCallback = IOCallback;

			private static Action<object> s_cancelCallback;

			private readonly Net5CompatFileStreamStrategy _strategy;

			private readonly int _numBufferedBytes;

			private CancellationTokenRegistration _cancellationRegistration;

			private unsafe NativeOverlapped* _overlapped;

			private long _result;

			internal unsafe NativeOverlapped* Overlapped => _overlapped;

			internal unsafe CompletionSource(Net5CompatFileStreamStrategy strategy, PreAllocatedOverlapped preallocatedOverlapped, int numBufferedBytes, byte[] bytes)
				: base(TaskCreationOptions.RunContinuationsAsynchronously)
			{
				_numBufferedBytes = numBufferedBytes;
				_strategy = strategy;
				_result = 0L;
				_overlapped = ((bytes != null && strategy.CompareExchangeCurrentOverlappedOwner(this, null) == null) ? strategy._fileHandle.ThreadPoolBinding.AllocateNativeOverlapped(preallocatedOverlapped) : strategy._fileHandle.ThreadPoolBinding.AllocateNativeOverlapped(s_ioCallback, this, bytes));
			}

			public void SetCompletedSynchronously(int numBytes)
			{
				ReleaseNativeResource();
				TrySetResult(numBytes + _numBufferedBytes);
			}

			public unsafe void RegisterForCancellation(CancellationToken cancellationToken)
			{
				if (_overlapped != null)
				{
					Action<object> callback = Cancel;
					long num = Interlocked.CompareExchange(ref _result, 17179869184L, 0L);
					switch (num)
					{
					case 0L:
						_cancellationRegistration = cancellationToken.UnsafeRegister(callback, this);
						num = Interlocked.Exchange(ref _result, 0L);
						break;
					default:
						num = Interlocked.Exchange(ref _result, 0L);
						break;
					case 34359738368L:
						break;
					}
					if (num != 0L && num != 34359738368L && num != 17179869184L)
					{
						CompleteCallback((ulong)num);
					}
				}
			}

			internal unsafe virtual void ReleaseNativeResource()
			{
				_cancellationRegistration.Dispose();
				if (_overlapped != null)
				{
					_strategy._fileHandle.ThreadPoolBinding.FreeNativeOverlapped(_overlapped);
					_overlapped = null;
				}
				_strategy.CompareExchangeCurrentOverlappedOwner(null, this);
			}

			internal unsafe static void IOCallback(uint errorCode, uint numBytes, NativeOverlapped* pOverlapped)
			{
				object nativeOverlappedState = ThreadPoolBoundHandle.GetNativeOverlappedState(pOverlapped);
				CompletionSource completionSource = ((!(nativeOverlappedState is Net5CompatFileStreamStrategy net5CompatFileStreamStrategy)) ? ((CompletionSource)nativeOverlappedState) : net5CompatFileStreamStrategy._currentOverlappedOwner);
				CompletionSource completionSource2 = completionSource;
				ulong num = ((errorCode == 0 || errorCode == 109 || errorCode == 232) ? (0x100000000uL | numBytes) : (0x200000000uL | errorCode));
				if (Interlocked.Exchange(ref completionSource2._result, (long)num) == 0L && Interlocked.Exchange(ref completionSource2._result, 34359738368L) != 0L)
				{
					completionSource2.CompleteCallback(num);
				}
			}

			private void CompleteCallback(ulong packedResult)
			{
				CancellationToken token = _cancellationRegistration.Token;
				ReleaseNativeResource();
				long num = (long)packedResult & -4294967296L;
				if (num == 8589934592L)
				{
					int num2 = (int)(packedResult & 0xFFFFFFFFu);
					if (num2 == 995)
					{
						TrySetCanceled(token.IsCancellationRequested ? token : new CancellationToken(canceled: true));
						return;
					}
					Exception exceptionForWin32Error = Win32Marshal.GetExceptionForWin32Error(num2);
					exceptionForWin32Error.SetCurrentStackTrace();
					TrySetException(exceptionForWin32Error);
				}
				else
				{
					TrySetResult((int)(packedResult & 0xFFFFFFFFu) + _numBufferedBytes);
				}
			}

			private unsafe static void Cancel(object state)
			{
				CompletionSource completionSource = (CompletionSource)state;
				if (!completionSource._strategy._fileHandle.IsInvalid && !Interop.Kernel32.CancelIoEx(completionSource._strategy._fileHandle, completionSource._overlapped))
				{
					int lastPInvokeError = Marshal.GetLastPInvokeError();
					if (lastPInvokeError != 1168)
					{
						throw Win32Marshal.GetExceptionForWin32Error(lastPInvokeError);
					}
				}
			}

			public static CompletionSource Create(Net5CompatFileStreamStrategy strategy, PreAllocatedOverlapped preallocatedOverlapped, int numBufferedBytesRead, ReadOnlyMemory<byte> memory)
			{
				if (preallocatedOverlapped == null || !MemoryMarshal.TryGetArray(memory, out var segment) || !preallocatedOverlapped.IsUserObject(segment.Array))
				{
					return new MemoryFileStreamCompletionSource(strategy, numBufferedBytesRead, memory);
				}
				return new CompletionSource(strategy, preallocatedOverlapped, numBufferedBytesRead, segment.Array);
			}
		}

		private sealed class MemoryFileStreamCompletionSource : CompletionSource
		{
			private MemoryHandle _handle;

			internal MemoryFileStreamCompletionSource(Net5CompatFileStreamStrategy strategy, int numBufferedBytes, ReadOnlyMemory<byte> memory)
				: base(strategy, null, numBufferedBytes, null)
			{
				_handle = memory.Pin();
			}

			internal override void ReleaseNativeResource()
			{
				_handle.Dispose();
				base.ReleaseNativeResource();
			}
		}

		private byte[] _buffer;

		private readonly int _bufferLength;

		private readonly SafeFileHandle _fileHandle;

		private readonly FileAccess _access;

		private int _readPos;

		private int _readLength;

		private int _writePos;

		private readonly bool _useAsyncIO;

		private Task<int> _lastSynchronouslyCompletedTask;

		private long _filePosition;

		private bool _exposedHandle;

		private long _appendStart;

		private Task _activeBufferOperation = Task.CompletedTask;

		private PreAllocatedOverlapped _preallocatedOverlapped;

		private CompletionSource _currentOverlappedOwner;

		public override bool CanRead
		{
			get
			{
				if (!_fileHandle.IsClosed)
				{
					return (_access & FileAccess.Read) != 0;
				}
				return false;
			}
		}

		public override bool CanWrite
		{
			get
			{
				if (!_fileHandle.IsClosed)
				{
					return (_access & FileAccess.Write) != 0;
				}
				return false;
			}
		}

		internal override SafeFileHandle SafeFileHandle
		{
			get
			{
				Flush();
				_exposedHandle = true;
				return _fileHandle;
			}
		}

		internal override string Name => _fileHandle.Path ?? SR.IO_UnknownFileName;

		internal override bool IsAsync => _useAsyncIO;

		public override long Position
		{
			get
			{
				VerifyOSHandlePosition();
				return _filePosition - _readLength + _readPos + _writePos;
			}
			set
			{
				Seek(value, SeekOrigin.Begin);
			}
		}

		internal override bool IsClosed => _fileHandle.IsClosed;

		private bool HasActiveBufferOperation => !_activeBufferOperation.IsCompleted;

		public override bool CanSeek => _fileHandle.CanSeek;

		public override long Length
		{
			get
			{
				long num = RandomAccess.GetFileLength(_fileHandle);
				if (_writePos > 0 && _filePosition + _writePos > num)
				{
					num = _writePos + _filePosition;
				}
				return num;
			}
		}

		internal Net5CompatFileStreamStrategy(SafeFileHandle handle, FileAccess access, int bufferSize, bool isAsync)
		{
			_exposedHandle = true;
			_bufferLength = bufferSize;
			InitFromHandle(handle, access, isAsync);
			_access = access;
			_useAsyncIO = isAsync;
			_fileHandle = handle;
		}

		internal Net5CompatFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
		{
			string fullPath = Path.GetFullPath(path);
			_access = access;
			_bufferLength = bufferSize;
			if ((options & FileOptions.Asynchronous) != 0)
			{
				_useAsyncIO = true;
			}
			_fileHandle = SafeFileHandle.Open(fullPath, mode, access, share, options, preallocationSize);
			try
			{
				Init(mode, path, options);
			}
			catch
			{
				_fileHandle.Dispose();
				_fileHandle = null;
				throw;
			}
		}

		~Net5CompatFileStreamStrategy()
		{
			Dispose(disposing: false);
		}

		internal override void DisposeInternal(bool disposing)
		{
			Dispose(disposing);
		}

		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			try
			{
				FlushInternalBuffer();
			}
			catch (Exception exception)
			{
				return Task.FromException(exception);
			}
			return Task.CompletedTask;
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			if (!_useAsyncIO)
			{
				return ReadSpan(new Span<byte>(buffer, offset, count));
			}
			return ReadAsyncTask(buffer, offset, count, CancellationToken.None).GetAwaiter().GetResult();
		}

		public override int Read(Span<byte> buffer)
		{
			if (!_useAsyncIO)
			{
				if (_fileHandle.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				return ReadSpan(buffer);
			}
			return base.Read(buffer);
		}

		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			if (!_useAsyncIO)
			{
				return BeginReadInternal(buffer, offset, count, null, null, serializeAsynchronously: true, apm: false);
			}
			return ReadAsyncTask(buffer, offset, count, cancellationToken);
		}

		public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!_useAsyncIO)
			{
				if (!MemoryMarshal.TryGetArray((ReadOnlyMemory<byte>)buffer, out ArraySegment<byte> segment))
				{
					return base.ReadAsync(buffer, cancellationToken);
				}
				return new ValueTask<int>(BeginReadInternal(segment.Array, segment.Offset, segment.Count, null, null, serializeAsynchronously: true, apm: false));
			}
			int synchronousResult;
			Task<int> task = ReadAsyncInternal(buffer, cancellationToken, out synchronousResult);
			if (task == null)
			{
				return new ValueTask<int>(synchronousResult);
			}
			return new ValueTask<int>(task);
		}

		private Task<int> ReadAsyncTask(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			int synchronousResult;
			Task<int> task = ReadAsyncInternal(new Memory<byte>(buffer, offset, count), cancellationToken, out synchronousResult);
			if (task == null)
			{
				task = _lastSynchronouslyCompletedTask;
				if (task == null || task.Result != synchronousResult)
				{
					task = (_lastSynchronouslyCompletedTask = Task.FromResult(synchronousResult));
				}
			}
			return task;
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			if (_useAsyncIO)
			{
				WriteAsyncInternal(new ReadOnlyMemory<byte>(buffer, offset, count), CancellationToken.None).AsTask().GetAwaiter().GetResult();
			}
			else
			{
				WriteSpan(new ReadOnlySpan<byte>(buffer, offset, count));
			}
		}

		public override void Write(ReadOnlySpan<byte> buffer)
		{
			if (!_useAsyncIO)
			{
				if (_fileHandle.IsClosed)
				{
					ThrowHelper.ThrowObjectDisposedException_FileClosed();
				}
				WriteSpan(buffer);
			}
			else
			{
				base.Write(buffer);
			}
		}

		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			if (!_useAsyncIO)
			{
				return BeginWriteInternal(buffer, offset, count, null, null, serializeAsynchronously: true, apm: false);
			}
			return WriteAsyncInternal(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
		}

		public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!_useAsyncIO)
			{
				if (!MemoryMarshal.TryGetArray(buffer, out var segment))
				{
					return base.WriteAsync(buffer, cancellationToken);
				}
				return new ValueTask(BeginWriteInternal(segment.Array, segment.Offset, segment.Count, null, null, serializeAsynchronously: true, apm: false));
			}
			return WriteAsyncInternal(buffer, cancellationToken);
		}

		public override void Flush()
		{
			Flush(flushToDisk: false);
		}

		internal override void Flush(bool flushToDisk)
		{
			FlushInternalBuffer();
			if (flushToDisk && CanWrite)
			{
				FileStreamHelpers.FlushToDisk(_fileHandle);
			}
		}

		private void VerifyOSHandlePosition()
		{
			if (!_exposedHandle || !CanSeek)
			{
				return;
			}
			long filePosition = _filePosition;
			long num = SeekCore(_fileHandle, 0L, SeekOrigin.Current);
			if (filePosition != num)
			{
				_readPos = (_readLength = 0);
				if (_writePos > 0)
				{
					_writePos = 0;
					throw new IOException(SR.IO_FileStreamHandlePosition);
				}
			}
		}

		private void PrepareForReading()
		{
			if (_fileHandle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			if (_readLength == 0 && !CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
		}

		private long SeekCore(SafeFileHandle fileHandle, long offset, SeekOrigin origin, bool closeInvalidHandle = false)
		{
			return _filePosition = FileStreamHelpers.Seek(fileHandle, offset, origin, closeInvalidHandle);
		}

		private byte[] GetBuffer()
		{
			if (_buffer == null)
			{
				_buffer = new byte[_bufferLength];
				OnBufferAllocated();
			}
			return _buffer;
		}

		private void FlushInternalBuffer()
		{
			if (_writePos > 0)
			{
				FlushWriteBuffer();
			}
			else if (_readPos < _readLength && CanSeek)
			{
				FlushReadBuffer();
			}
		}

		private void FlushReadBuffer()
		{
			int num = _readPos - _readLength;
			if (num != 0)
			{
				SeekCore(_fileHandle, num, SeekOrigin.Current);
			}
			_readPos = (_readLength = 0);
		}

		public override int ReadByte()
		{
			PrepareForReading();
			byte[] buffer = GetBuffer();
			if (_readPos == _readLength)
			{
				FlushWriteBuffer();
				_readLength = FillReadBufferForReadByte();
				_readPos = 0;
				if (_readLength == 0)
				{
					return -1;
				}
			}
			return buffer[_readPos++];
		}

		public override void WriteByte(byte value)
		{
			PrepareForWriting();
			if (_writePos == _bufferLength)
			{
				FlushWriteBufferForWriteByte();
			}
			GetBuffer()[_writePos++] = value;
		}

		private void PrepareForWriting()
		{
			if (_fileHandle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			if (_writePos == 0)
			{
				if (!CanWrite)
				{
					ThrowHelper.ThrowNotSupportedException_UnwritableStream();
				}
				FlushReadBuffer();
			}
		}

		private void OnBufferAllocated()
		{
			if (_useAsyncIO)
			{
				_preallocatedOverlapped = PreAllocatedOverlapped.UnsafeCreate(CompletionSource.s_ioCallback, this, _buffer);
			}
		}

		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			if (!_useAsyncIO)
			{
				return base.BeginRead(buffer, offset, count, callback, state);
			}
			return TaskToApm.Begin(ReadAsyncTask(buffer, offset, count, CancellationToken.None), callback, state);
		}

		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			if (!_useAsyncIO)
			{
				return base.BeginWrite(buffer, offset, count, callback, state);
			}
			return TaskToApm.Begin(WriteAsyncInternal(new ReadOnlyMemory<byte>(buffer, offset, count), CancellationToken.None).AsTask(), callback, state);
		}

		public override int EndRead(IAsyncResult asyncResult)
		{
			if (!_useAsyncIO)
			{
				return base.EndRead(asyncResult);
			}
			return TaskToApm.End<int>(asyncResult);
		}

		public override void EndWrite(IAsyncResult asyncResult)
		{
			if (!_useAsyncIO)
			{
				base.EndWrite(asyncResult);
			}
			else
			{
				TaskToApm.End(asyncResult);
			}
		}

		private void Init(FileMode mode, string originalPath, FileOptions options)
		{
			if (mode == FileMode.Append)
			{
				_appendStart = SeekCore(_fileHandle, 0L, SeekOrigin.End);
			}
			else
			{
				_appendStart = -1L;
			}
		}

		private void InitFromHandle(SafeFileHandle handle, FileAccess access, bool useAsyncIO)
		{
			InitFromHandleImpl(handle, useAsyncIO);
		}

		private void InitFromHandleImpl(SafeFileHandle handle, bool useAsyncIO)
		{
			handle.EnsureThreadPoolBindingInitialized();
			if (handle.CanSeek)
			{
				SeekCore(handle, 0L, SeekOrigin.Current);
			}
			else
			{
				_filePosition = 0L;
			}
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (_fileHandle != null && !_fileHandle.IsClosed && _writePos > 0)
				{
					try
					{
						FlushWriteBuffer(!disposing);
						return;
					}
					catch (Exception e) when (!disposing && FileStreamHelpers.IsIoRelatedException(e))
					{
						return;
					}
				}
			}
			finally
			{
				if (_fileHandle != null && !_fileHandle.IsClosed)
				{
					_fileHandle.ThreadPoolBinding?.Dispose();
					_fileHandle.Dispose();
				}
				_preallocatedOverlapped?.Dispose();
			}
		}

		public override async ValueTask DisposeAsync()
		{
			try
			{
				if (_fileHandle != null && !_fileHandle.IsClosed && _writePos > 0)
				{
					await FlushAsync(default(CancellationToken)).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			finally
			{
				if (_fileHandle != null && !_fileHandle.IsClosed)
				{
					_fileHandle.ThreadPoolBinding?.Dispose();
					_fileHandle.Dispose();
				}
				_preallocatedOverlapped?.Dispose();
				GC.SuppressFinalize(this);
			}
		}

		private Task FlushWriteAsync(CancellationToken cancellationToken)
		{
			if (_writePos == 0)
			{
				return Task.CompletedTask;
			}
			Task task = WriteAsyncInternalCore(new ReadOnlyMemory<byte>(GetBuffer(), 0, _writePos), cancellationToken);
			_writePos = 0;
			_activeBufferOperation = (HasActiveBufferOperation ? Task.WhenAll(_activeBufferOperation, task) : task);
			return task;
		}

		private void FlushWriteBufferForWriteByte()
		{
			FlushWriteBuffer();
		}

		private void FlushWriteBuffer(bool calledFromFinalizer = false)
		{
			if (_writePos == 0)
			{
				return;
			}
			if (_useAsyncIO)
			{
				Task task = FlushWriteAsync(CancellationToken.None);
				if (!calledFromFinalizer)
				{
					task.GetAwaiter().GetResult();
				}
			}
			else
			{
				WriteCore(new ReadOnlySpan<byte>(GetBuffer(), 0, _writePos));
			}
			_writePos = 0;
		}

		public override void SetLength(long value)
		{
			if (_writePos > 0)
			{
				FlushWriteBuffer();
			}
			else if (_readPos < _readLength)
			{
				FlushReadBuffer();
			}
			_readPos = 0;
			_readLength = 0;
			if (_appendStart != -1 && value < _appendStart)
			{
				throw new IOException(SR.IO_SetLengthAppendTruncate);
			}
			SetLengthCore(value);
		}

		private void SetLengthCore(long value)
		{
			VerifyOSHandlePosition();
			FileStreamHelpers.SetFileLength(_fileHandle, value);
			if (_filePosition > value)
			{
				SeekCore(_fileHandle, 0L, SeekOrigin.End);
			}
		}

		private int ReadSpan(Span<byte> destination)
		{
			bool flag = false;
			int num = _readLength - _readPos;
			if (num == 0)
			{
				if (!CanRead)
				{
					ThrowHelper.ThrowNotSupportedException_UnreadableStream();
				}
				if (_writePos > 0)
				{
					FlushWriteBuffer();
				}
				if (!CanSeek || destination.Length >= _bufferLength)
				{
					num = ReadNative(destination);
					_readPos = 0;
					_readLength = 0;
					return num;
				}
				num = ReadNative(GetBuffer());
				if (num == 0)
				{
					return 0;
				}
				flag = num < _bufferLength;
				_readPos = 0;
				_readLength = num;
			}
			if (num > destination.Length)
			{
				num = destination.Length;
			}
			new ReadOnlySpan<byte>(GetBuffer(), _readPos, num).CopyTo(destination);
			_readPos += num;
			if (_fileHandle.CanSeek && num < destination.Length && !flag)
			{
				int num2 = ReadNative(destination.Slice(num));
				num += num2;
				_readPos = 0;
				_readLength = 0;
			}
			return num;
		}

		private int FillReadBufferForReadByte()
		{
			if (!_useAsyncIO)
			{
				return ReadNative(_buffer);
			}
			return ReadNativeAsync(new Memory<byte>(_buffer), 0, CancellationToken.None).GetAwaiter().GetResult();
		}

		private unsafe int ReadNative(Span<byte> buffer)
		{
			VerifyOSHandlePosition();
			int errorCode;
			int num = ReadFileNative(_fileHandle, buffer, null, out errorCode);
			if (num == -1)
			{
				if (errorCode != 109)
				{
					if (errorCode == 87)
					{
						ThrowHelper.ThrowArgumentException_HandleNotSync("_fileHandle");
					}
					throw Win32Marshal.GetExceptionForWin32Error(errorCode, _fileHandle.Path);
				}
				num = 0;
			}
			_filePosition += num;
			return num;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			if (origin < SeekOrigin.Begin || origin > SeekOrigin.End)
			{
				throw new ArgumentException(SR.Argument_InvalidSeekOrigin, "origin");
			}
			if (_fileHandle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			if (!CanSeek)
			{
				ThrowHelper.ThrowNotSupportedException_UnseekableStream();
			}
			if (_writePos > 0)
			{
				FlushWriteBuffer();
			}
			else if (origin == SeekOrigin.Current)
			{
				offset -= _readLength - _readPos;
			}
			_readPos = (_readLength = 0);
			VerifyOSHandlePosition();
			long num = _filePosition + (_readPos - _readLength);
			long num2 = SeekCore(_fileHandle, offset, origin);
			if (_appendStart != -1 && num2 < _appendStart)
			{
				SeekCore(_fileHandle, num, SeekOrigin.Begin);
				throw new IOException(SR.IO_SeekAppendOverwrite);
			}
			if (_readLength > 0)
			{
				if (num == num2)
				{
					if (_readPos > 0)
					{
						Buffer.BlockCopy(GetBuffer(), _readPos, GetBuffer(), 0, _readLength - _readPos);
						_readLength -= _readPos;
						_readPos = 0;
					}
					if (_readLength > 0)
					{
						SeekCore(_fileHandle, _readLength, SeekOrigin.Current);
					}
				}
				else if (num - _readPos < num2 && num2 < num + _readLength - _readPos)
				{
					int num3 = (int)(num2 - num);
					Buffer.BlockCopy(GetBuffer(), _readPos + num3, GetBuffer(), 0, _readLength - (_readPos + num3));
					_readLength -= _readPos + num3;
					_readPos = 0;
					if (_readLength > 0)
					{
						SeekCore(_fileHandle, _readLength, SeekOrigin.Current);
					}
				}
				else
				{
					_readPos = 0;
					_readLength = 0;
				}
			}
			return num2;
		}

		private CompletionSource CompareExchangeCurrentOverlappedOwner(CompletionSource newSource, CompletionSource existingSource)
		{
			return Interlocked.CompareExchange(ref _currentOverlappedOwner, newSource, existingSource);
		}

		private void WriteSpan(ReadOnlySpan<byte> source)
		{
			if (_writePos == 0)
			{
				if (!CanWrite)
				{
					ThrowHelper.ThrowNotSupportedException_UnwritableStream();
				}
				if (_readPos < _readLength)
				{
					FlushReadBuffer();
				}
				_readPos = 0;
				_readLength = 0;
			}
			if (_writePos > 0)
			{
				int num = _bufferLength - _writePos;
				if (num > 0)
				{
					if (num >= source.Length)
					{
						source.CopyTo(GetBuffer().AsSpan(_writePos));
						_writePos += source.Length;
						return;
					}
					source.Slice(0, num).CopyTo(GetBuffer().AsSpan(_writePos));
					_writePos += num;
					source = source.Slice(num);
				}
				WriteCore(new ReadOnlySpan<byte>(GetBuffer(), 0, _writePos));
				_writePos = 0;
			}
			if (source.Length >= _bufferLength)
			{
				WriteCore(source);
			}
			else if (source.Length != 0)
			{
				source.CopyTo(GetBuffer().AsSpan(_writePos));
				_writePos = source.Length;
			}
		}

		private unsafe void WriteCore(ReadOnlySpan<byte> source)
		{
			VerifyOSHandlePosition();
			int errorCode;
			int num = WriteFileNative(_fileHandle, source, null, out errorCode);
			if (num == -1)
			{
				switch (errorCode)
				{
				case 232:
					break;
				case 87:
					throw new IOException(SR.IO_FileTooLongOrHandleNotSync);
				default:
					throw Win32Marshal.GetExceptionForWin32Error(errorCode, _fileHandle.Path);
				}
				num = 0;
			}
			_filePosition += num;
		}

		private Task<int> ReadAsyncInternal(Memory<byte> destination, CancellationToken cancellationToken, out int synchronousResult)
		{
			if (!CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			if (!_fileHandle.CanSeek)
			{
				if (_readPos < _readLength)
				{
					int num = Math.Min(_readLength - _readPos, destination.Length);
					new Span<byte>(GetBuffer(), _readPos, num).CopyTo(destination.Span);
					_readPos += num;
					synchronousResult = num;
					return null;
				}
				synchronousResult = 0;
				return ReadNativeAsync(destination, 0, cancellationToken);
			}
			if (_writePos > 0)
			{
				FlushWriteBuffer();
			}
			if (_readPos == _readLength)
			{
				if (destination.Length < _bufferLength)
				{
					Task<int> task = ReadNativeAsync(new Memory<byte>(GetBuffer()), 0, cancellationToken);
					_readLength = task.GetAwaiter().GetResult();
					int num2 = Math.Min(_readLength, destination.Length);
					new Span<byte>(GetBuffer(), 0, num2).CopyTo(destination.Span);
					_readPos = num2;
					synchronousResult = num2;
					return null;
				}
				_readPos = 0;
				_readLength = 0;
				synchronousResult = 0;
				return ReadNativeAsync(destination, 0, cancellationToken);
			}
			int num3 = Math.Min(_readLength - _readPos, destination.Length);
			new Span<byte>(GetBuffer(), _readPos, num3).CopyTo(destination.Span);
			_readPos += num3;
			if (num3 == destination.Length)
			{
				synchronousResult = num3;
				return null;
			}
			_readPos = 0;
			_readLength = 0;
			synchronousResult = 0;
			return ReadNativeAsync(destination.Slice(num3), num3, cancellationToken);
		}

		private unsafe Task<int> ReadNativeAsync(Memory<byte> destination, int numBufferedBytesRead, CancellationToken cancellationToken)
		{
			CompletionSource completionSource = CompletionSource.Create(this, _preallocatedOverlapped, numBufferedBytesRead, destination);
			NativeOverlapped* overlapped = completionSource.Overlapped;
			if (CanSeek)
			{
				long length = Length;
				VerifyOSHandlePosition();
				if (_filePosition + destination.Length > length)
				{
					destination = ((_filePosition > length) ? default(Memory<byte>) : destination.Slice(0, (int)(length - _filePosition)));
				}
				overlapped->OffsetLow = (int)_filePosition;
				overlapped->OffsetHigh = (int)(_filePosition >> 32);
				SeekCore(_fileHandle, destination.Length, SeekOrigin.Current);
			}
			int errorCode;
			int num = ReadFileNative(_fileHandle, destination.Span, overlapped, out errorCode);
			if (num == -1)
			{
				switch (errorCode)
				{
				case 109:
					overlapped->InternalLow = IntPtr.Zero;
					completionSource.SetCompletedSynchronously(0);
					break;
				default:
					if (!_fileHandle.IsClosed && CanSeek)
					{
						SeekCore(_fileHandle, 0L, SeekOrigin.Current);
					}
					completionSource.ReleaseNativeResource();
					if (errorCode == 38)
					{
						ThrowHelper.ThrowEndOfFileException();
						break;
					}
					throw Win32Marshal.GetExceptionForWin32Error(errorCode, _fileHandle.Path);
				case 997:
					if (cancellationToken.CanBeCanceled)
					{
						completionSource.RegisterForCancellation(cancellationToken);
					}
					break;
				}
			}
			return completionSource.Task;
		}

		private ValueTask WriteAsyncInternal(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
		{
			if (!CanWrite)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
			bool flag = false;
			if (_fileHandle.CanSeek)
			{
				if (_writePos == 0)
				{
					if (_readPos < _readLength)
					{
						FlushReadBuffer();
					}
					_readPos = 0;
					_readLength = 0;
				}
				int num = _bufferLength - _writePos;
				if (source.Length < _bufferLength && !HasActiveBufferOperation && source.Length <= num)
				{
					source.Span.CopyTo(new Span<byte>(GetBuffer(), _writePos, source.Length));
					_writePos += source.Length;
					flag = true;
					if (source.Length != num)
					{
						return default(ValueTask);
					}
				}
			}
			Task task = null;
			if (_writePos > 0)
			{
				task = FlushWriteAsync(cancellationToken);
				if (flag || task.IsFaulted || task.IsCanceled)
				{
					return new ValueTask(task);
				}
			}
			Task task2 = WriteAsyncInternalCore(source, cancellationToken);
			return new ValueTask((task == null || task.Status == TaskStatus.RanToCompletion) ? task2 : ((task2.Status == TaskStatus.RanToCompletion) ? task : Task.WhenAll(task, task2)));
		}

		private unsafe Task WriteAsyncInternalCore(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
		{
			CompletionSource completionSource = CompletionSource.Create(this, _preallocatedOverlapped, 0, source);
			NativeOverlapped* overlapped = completionSource.Overlapped;
			if (CanSeek)
			{
				long length = Length;
				VerifyOSHandlePosition();
				if (_filePosition + source.Length > length)
				{
					SetLengthCore(_filePosition + source.Length);
				}
				overlapped->OffsetLow = (int)_filePosition;
				overlapped->OffsetHigh = (int)(_filePosition >> 32);
				SeekCore(_fileHandle, source.Length, SeekOrigin.Current);
			}
			int errorCode;
			int num = WriteFileNative(_fileHandle, source.Span, overlapped, out errorCode);
			if (num == -1)
			{
				switch (errorCode)
				{
				case 232:
					completionSource.SetCompletedSynchronously(0);
					return Task.CompletedTask;
				default:
					if (!_fileHandle.IsClosed && CanSeek)
					{
						SeekCore(_fileHandle, 0L, SeekOrigin.Current);
					}
					completionSource.ReleaseNativeResource();
					if (errorCode == 38)
					{
						ThrowHelper.ThrowEndOfFileException();
						break;
					}
					throw Win32Marshal.GetExceptionForWin32Error(errorCode, _fileHandle.Path);
				case 997:
					if (cancellationToken.CanBeCanceled)
					{
						completionSource.RegisterForCancellation(cancellationToken);
					}
					break;
				}
			}
			return completionSource.Task;
		}

		private unsafe int ReadFileNative(SafeFileHandle handle, Span<byte> bytes, NativeOverlapped* overlapped, out int errorCode)
		{
			return FileStreamHelpers.ReadFileNative(handle, bytes, overlapped, out errorCode);
		}

		private unsafe int WriteFileNative(SafeFileHandle handle, ReadOnlySpan<byte> buffer, NativeOverlapped* overlapped, out int errorCode)
		{
			int numBytesWritten = 0;
			int num;
			fixed (byte* bytes = &MemoryMarshal.GetReference(buffer))
			{
				num = ((overlapped == null) ? Interop.Kernel32.WriteFile(handle, bytes, buffer.Length, out numBytesWritten, overlapped) : Interop.Kernel32.WriteFile(handle, bytes, buffer.Length, IntPtr.Zero, overlapped));
			}
			if (num == 0)
			{
				errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
				return -1;
			}
			errorCode = 0;
			return numBytesWritten;
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			if (!_useAsyncIO)
			{
				return base.CopyToAsync(destination, bufferSize, cancellationToken);
			}
			if (_fileHandle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			if (!CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<int>(cancellationToken);
			}
			return AsyncModeCopyToAsync(destination, bufferSize, cancellationToken);
		}

		private async Task AsyncModeCopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			if (_writePos > 0)
			{
				await FlushWriteAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			if (GetBuffer() != null)
			{
				int num = _readLength - _readPos;
				if (num > 0)
				{
					await destination.WriteAsync(new ReadOnlyMemory<byte>(GetBuffer(), _readPos, num), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					_readPos = (_readLength = 0);
				}
			}
			bool canSeek = CanSeek;
			if (canSeek)
			{
				VerifyOSHandlePosition();
			}
			try
			{
				await FileStreamHelpers.AsyncModeCopyToAsync(_fileHandle, canSeek, _filePosition, destination, bufferSize, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				if (!_fileHandle.IsClosed && CanSeek)
				{
					SeekCore(_fileHandle, 0L, SeekOrigin.End);
				}
			}
		}

		internal override void Lock(long position, long length)
		{
			FileStreamHelpers.Lock(_fileHandle, CanWrite, position, length);
		}

		internal override void Unlock(long position, long length)
		{
			FileStreamHelpers.Unlock(_fileHandle, position, length);
		}
	}
	internal abstract class OSFileStreamStrategy : FileStreamStrategy
	{
		protected readonly SafeFileHandle _fileHandle;

		private readonly FileAccess _access;

		protected long _filePosition;

		private long _length = -1L;

		private long _appendStart;

		private bool _lengthCanBeCached;

		internal override bool IsAsync => _fileHandle.IsAsync;

		public sealed override bool CanSeek => _fileHandle.CanSeek;

		public sealed override bool CanRead
		{
			get
			{
				if (!_fileHandle.IsClosed)
				{
					return (_access & FileAccess.Read) != 0;
				}
				return false;
			}
		}

		public sealed override bool CanWrite
		{
			get
			{
				if (!_fileHandle.IsClosed)
				{
					return (_access & FileAccess.Write) != 0;
				}
				return false;
			}
		}

		public sealed override long Length
		{
			get
			{
				if (!LengthCachingSupported)
				{
					return RandomAccess.GetFileLength(_fileHandle);
				}
				if (_length < 0)
				{
					_length = RandomAccess.GetFileLength(_fileHandle);
				}
				return _length;
			}
		}

		private bool LengthCachingSupported
		{
			get
			{
				OperatingSystem.IsWindows();
				return _lengthCanBeCached;
			}
		}

		public sealed override long Position
		{
			get
			{
				return _filePosition;
			}
			set
			{
				_filePosition = value;
			}
		}

		internal sealed override string Name => _fileHandle.Path ?? SR.IO_UnknownFileName;

		internal sealed override bool IsClosed => _fileHandle.IsClosed;

		internal sealed override SafeFileHandle SafeFileHandle
		{
			get
			{
				if (CanSeek)
				{
					FileStreamHelpers.Seek(_fileHandle, _filePosition, SeekOrigin.Begin);
				}
				_lengthCanBeCached = false;
				_length = -1L;
				return _fileHandle;
			}
		}

		internal OSFileStreamStrategy(SafeFileHandle handle, FileAccess access)
		{
			_access = access;
			handle.EnsureThreadPoolBindingInitialized();
			if (handle.CanSeek)
			{
				_filePosition = FileStreamHelpers.Seek(handle, 0L, SeekOrigin.Current);
			}
			else
			{
				_filePosition = 0L;
			}
			_fileHandle = handle;
		}

		internal OSFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
		{
			string fullPath = Path.GetFullPath(path);
			_access = access;
			_lengthCanBeCached = (share & FileShare.Write) == 0 && (access & FileAccess.Write) == 0;
			_fileHandle = SafeFileHandle.Open(fullPath, mode, access, share, options, preallocationSize);
			try
			{
				if (mode == FileMode.Append && CanSeek)
				{
					_appendStart = (_filePosition = Length);
				}
				else
				{
					_appendStart = -1L;
				}
			}
			catch
			{
				_fileHandle.Dispose();
				_fileHandle = null;
				throw;
			}
		}

		internal void OnIncompleteOperation(int expectedBytesTransferred, int actualBytesTransferred)
		{
			Interlocked.Add(ref _filePosition, actualBytesTransferred - expectedBytesTransferred);
		}

		public sealed override ValueTask DisposeAsync()
		{
			if (_fileHandle != null && !_fileHandle.IsClosed)
			{
				_fileHandle.ThreadPoolBinding?.Dispose();
				_fileHandle.Dispose();
			}
			return ValueTask.CompletedTask;
		}

		internal sealed override void DisposeInternal(bool disposing)
		{
			Dispose(disposing);
		}

		protected sealed override void Dispose(bool disposing)
		{
			if (disposing && _fileHandle != null && !_fileHandle.IsClosed)
			{
				_fileHandle.ThreadPoolBinding?.Dispose();
				_fileHandle.Dispose();
			}
		}

		public sealed override void Flush()
		{
		}

		public sealed override Task FlushAsync(CancellationToken cancellationToken)
		{
			return Task.CompletedTask;
		}

		internal sealed override void Flush(bool flushToDisk)
		{
			if (flushToDisk && CanWrite)
			{
				FileStreamHelpers.FlushToDisk(_fileHandle);
			}
		}

		public sealed override long Seek(long offset, SeekOrigin origin)
		{
			if (origin < SeekOrigin.Begin || origin > SeekOrigin.End)
			{
				throw new ArgumentException(SR.Argument_InvalidSeekOrigin, "origin");
			}
			if (_fileHandle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			if (!CanSeek)
			{
				ThrowHelper.ThrowNotSupportedException_UnseekableStream();
			}
			long filePosition = _filePosition;
			long num = origin switch
			{
				SeekOrigin.Begin => offset, 
				SeekOrigin.End => Length + offset, 
				_ => _filePosition + offset, 
			};
			if (num >= 0)
			{
				_filePosition = num;
			}
			else
			{
				FileStreamHelpers.ThrowInvalidArgument(_fileHandle);
			}
			if (_appendStart != -1 && num < _appendStart)
			{
				_filePosition = filePosition;
				throw new IOException(SR.IO_SeekAppendOverwrite);
			}
			return num;
		}

		internal sealed override void Lock(long position, long length)
		{
			FileStreamHelpers.Lock(_fileHandle, CanWrite, position, length);
		}

		internal sealed override void Unlock(long position, long length)
		{
			FileStreamHelpers.Unlock(_fileHandle, position, length);
		}

		public sealed override void SetLength(long value)
		{
			if (_appendStart != -1 && value < _appendStart)
			{
				throw new IOException(SR.IO_SetLengthAppendTruncate);
			}
			SetLengthCore(value);
		}

		protected void SetLengthCore(long value)
		{
			FileStreamHelpers.SetFileLength(_fileHandle, value);
			if (LengthCachingSupported)
			{
				_length = value;
			}
			if (_filePosition > value)
			{
				_filePosition = value;
			}
		}

		public unsafe sealed override int ReadByte()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out byte result);
			if (Read(new Span<byte>(&result, 1)) == 0)
			{
				return -1;
			}
			return result;
		}

		public sealed override int Read(byte[] buffer, int offset, int count)
		{
			return Read(new Span<byte>(buffer, offset, count));
		}

		public sealed override int Read(Span<byte> buffer)
		{
			if (_fileHandle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			else if ((_access & FileAccess.Read) == 0)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			int num = RandomAccess.ReadAtOffset(_fileHandle, buffer, _filePosition);
			_filePosition += num;
			return num;
		}

		public unsafe sealed override void WriteByte(byte value)
		{
			Write(new ReadOnlySpan<byte>(&value, 1));
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			Write(new ReadOnlySpan<byte>(buffer, offset, count));
		}

		public sealed override void Write(ReadOnlySpan<byte> buffer)
		{
			if (_fileHandle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			else if ((_access & FileAccess.Write) == 0)
			{
				ThrowHelper.ThrowNotSupportedException_UnwritableStream();
			}
			RandomAccess.WriteAtOffset(_fileHandle, buffer, _filePosition);
			_filePosition += buffer.Length;
		}

		public sealed override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return TaskToApm.Begin(WriteAsync(buffer, offset, count), callback, state);
		}

		public sealed override void EndWrite(IAsyncResult asyncResult)
		{
			TaskToApm.End(asyncResult);
		}

		public sealed override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
		}

		public sealed override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
		{
			long fileOffset = (CanSeek ? (Interlocked.Add(ref _filePosition, source.Length) - source.Length) : (-1));
			return RandomAccess.WriteAtOffsetAsync(_fileHandle, source, fileOffset, cancellationToken, this);
		}

		public sealed override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
		{
			return TaskToApm.Begin(ReadAsync(buffer, offset, count), callback, state);
		}

		public sealed override int EndRead(IAsyncResult asyncResult)
		{
			return TaskToApm.End<int>(asyncResult);
		}

		public sealed override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			return ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
		}

		public sealed override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken)
		{
			if (!CanSeek)
			{
				return RandomAccess.ReadAtOffsetAsync(_fileHandle, destination, -1L, cancellationToken);
			}
			if (LengthCachingSupported && _length >= 0 && Volatile.Read(ref _filePosition) >= _length)
			{
				return ValueTask.FromResult(0);
			}
			long fileOffset = Interlocked.Add(ref _filePosition, destination.Length) - destination.Length;
			return RandomAccess.ReadAtOffsetAsync(_fileHandle, destination, fileOffset, cancellationToken, this);
		}
	}
	internal sealed class AsyncWindowsFileStreamStrategy : OSFileStreamStrategy
	{
		internal override bool IsAsync => true;

		internal AsyncWindowsFileStreamStrategy(SafeFileHandle handle, FileAccess access)
			: base(handle, access)
		{
		}

		internal AsyncWindowsFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
			: base(path, mode, access, share, options, preallocationSize)
		{
		}

		public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			if (_fileHandle.IsClosed)
			{
				ThrowHelper.ThrowObjectDisposedException_FileClosed();
			}
			if (!CanRead)
			{
				ThrowHelper.ThrowNotSupportedException_UnreadableStream();
			}
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<int>(cancellationToken);
			}
			return AsyncModeCopyToAsync(destination, bufferSize, cancellationToken);
		}

		private async Task AsyncModeCopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
		{
			try
			{
				await FileStreamHelpers.AsyncModeCopyToAsync(_fileHandle, CanSeek, _filePosition, destination, bufferSize, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				if (!_fileHandle.IsClosed && CanSeek)
				{
					_filePosition = Length;
				}
			}
		}
	}
	internal sealed class SyncWindowsFileStreamStrategy : OSFileStreamStrategy
	{
		internal override bool IsAsync => false;

		internal SyncWindowsFileStreamStrategy(SafeFileHandle handle, FileAccess access)
			: base(handle, access)
		{
		}

		internal SyncWindowsFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
			: base(path, mode, access, share, options, preallocationSize)
		{
		}
	}
}
namespace System.IO.Enumeration
{
	public ref struct FileSystemEntry
	{
		internal unsafe Interop.NtDll.FILE_FULL_DIR_INFORMATION* _info;

		public ReadOnlySpan<char> Directory { get; private set; }

		public ReadOnlySpan<char> RootDirectory { get; private set; }

		public ReadOnlySpan<char> OriginalRootDirectory { get; private set; }

		public unsafe ReadOnlySpan<char> FileName => _info->FileName;

		public unsafe FileAttributes Attributes => _info->FileAttributes;

		public unsafe long Length => _info->EndOfFile;

		public unsafe DateTimeOffset CreationTimeUtc => _info->CreationTime.ToDateTimeOffset();

		public unsafe DateTimeOffset LastAccessTimeUtc => _info->LastAccessTime.ToDateTimeOffset();

		public unsafe DateTimeOffset LastWriteTimeUtc => _info->LastWriteTime.ToDateTimeOffset();

		public bool IsDirectory => (Attributes & FileAttributes.Directory) != 0;

		public bool IsHidden => (Attributes & FileAttributes.Hidden) != 0;

		public string ToSpecifiedFullPath()
		{
			ReadOnlySpan<char> readOnlySpan = Directory.Slice(RootDirectory.Length);
			if (Path.EndsInDirectorySeparator(OriginalRootDirectory) && PathInternal.StartsWithDirectorySeparator(readOnlySpan))
			{
				readOnlySpan = readOnlySpan.Slice(1);
			}
			return Path.Join(OriginalRootDirectory, readOnlySpan, FileName);
		}

		internal unsafe static void Initialize(ref FileSystemEntry entry, Interop.NtDll.FILE_FULL_DIR_INFORMATION* info, ReadOnlySpan<char> directory, ReadOnlySpan<char> rootDirectory, ReadOnlySpan<char> originalRootDirectory)
		{
			entry._info = info;
			entry.Directory = directory;
			entry.RootDirectory = rootDirectory;
			entry.OriginalRootDirectory = originalRootDirectory;
		}

		public FileSystemInfo ToFileSystemInfo()
		{
			return FileSystemInfo.Create(Path.Join(Directory, FileName), ref this);
		}

		public string ToFullPath()
		{
			return Path.Join(Directory, FileName);
		}
	}
	public abstract class FileSystemEnumerator<TResult> : CriticalFinalizerObject, IEnumerator<TResult>, IDisposable, System.Collections.IEnumerator
	{
		private int _remainingRecursionDepth;

		private readonly string _originalRootDirectory;

		private readonly string _rootDirectory;

		private readonly EnumerationOptions _options;

		private readonly object _lock = new object();

		private unsafe Interop.NtDll.FILE_FULL_DIR_INFORMATION* _entry;

		private TResult _current;

		private IntPtr _buffer;

		private int _bufferLength;

		private IntPtr _directoryHandle;

		private string _currentPath;

		private bool _lastEntryFound;

		private Queue<(IntPtr Handle, string Path, int RemainingDepth)> _pending;

		public TResult Current => _current;

		object? System.Collections.IEnumerator.Current => Current;

		public FileSystemEnumerator(string directory, EnumerationOptions? options = null)
			: this(directory, isNormalized: false, options)
		{
		}

		internal FileSystemEnumerator(string directory, bool isNormalized, EnumerationOptions options = null)
		{
			_originalRootDirectory = directory ?? throw new ArgumentNullException("directory");
			_rootDirectory = Path.TrimEndingDirectorySeparator(isNormalized ? directory : Path.GetFullPath(directory));
			_options = options ?? EnumerationOptions.Default;
			_remainingRecursionDepth = _options.MaxRecursionDepth;
			Init();
		}

		protected virtual bool ShouldIncludeEntry(ref FileSystemEntry entry)
		{
			return true;
		}

		protected virtual bool ShouldRecurseIntoEntry(ref FileSystemEntry entry)
		{
			return true;
		}

		protected abstract TResult TransformEntry(ref FileSystemEntry entry);

		protected virtual void OnDirectoryFinished(ReadOnlySpan<char> directory)
		{
		}

		protected virtual bool ContinueOnError(int error)
		{
			return false;
		}

		private unsafe void DirectoryFinished()
		{
			_entry = default(Interop.NtDll.FILE_FULL_DIR_INFORMATION*);
			CloseDirectoryHandle();
			OnDirectoryFinished(_currentPath.AsSpan());
			if (!DequeueNextDirectory())
			{
				_lastEntryFound = true;
			}
			else
			{
				FindNextEntry();
			}
		}

		public void Reset()
		{
			throw new NotSupportedException();
		}

		public void Dispose()
		{
			InternalDispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
		}

		~FileSystemEnumerator()
		{
			InternalDispose(disposing: false);
		}

		private void Init()
		{
			using (default(DisableMediaInsertionPrompt))
			{
				_directoryHandle = CreateDirectoryHandle(_rootDirectory);
				if (_directoryHandle == IntPtr.Zero)
				{
					_lastEntryFound = true;
				}
			}
			_currentPath = _rootDirectory;
			int bufferSize = _options.BufferSize;
			_bufferLength = ((bufferSize <= 0) ? 4096 : Math.Max(1024, bufferSize));
			try
			{
				_buffer = Marshal.AllocHGlobal(_bufferLength);
			}
			catch
			{
				CloseDirectoryHandle();
				throw;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe bool GetData()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out Interop.NtDll.IO_STATUS_BLOCK iO_STATUS_BLOCK);
			int num = Interop.NtDll.NtQueryDirectoryFile(_directoryHandle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, &iO_STATUS_BLOCK, _buffer, (uint)_bufferLength, Interop.NtDll.FILE_INFORMATION_CLASS.FileFullDirectoryInformation, Interop.BOOLEAN.FALSE, null, Interop.BOOLEAN.FALSE);
			switch ((uint)num)
			{
			case 2147483654u:
				DirectoryFinished();
				return false;
			case 0u:
				return true;
			case 3221225487u:
				DirectoryFinished();
				return false;
			default:
			{
				int num2 = (int)Interop.NtDll.RtlNtStatusToDosError(num);
				if ((num2 == 5 && _options.IgnoreInaccessible) || ContinueOnError(num2))
				{
					DirectoryFinished();
					return false;
				}
				throw Win32Marshal.GetExceptionForWin32Error(num2, _currentPath);
			}
			}
		}

		private unsafe IntPtr CreateRelativeDirectoryHandle(ReadOnlySpan<char> relativePath, string fullPath)
		{
			var (num, result) = Interop.NtDll.CreateFile(relativePath, _directoryHandle, Interop.NtDll.CreateDisposition.FILE_OPEN, Interop.NtDll.DesiredAccess.FILE_READ_DATA | Interop.NtDll.DesiredAccess.SYNCHRONIZE, FileShare.ReadWrite | FileShare.Delete, (FileAttributes)0, (Interop.NtDll.CreateOptions)16417u, Interop.ObjectAttributes.OBJ_CASE_INSENSITIVE, null, 0u, null, null);
			if (num == 0)
			{
				return result;
			}
			int num2 = (int)Interop.NtDll.RtlNtStatusToDosError((int)num);
			if (ContinueOnDirectoryError(num2, ignoreNotFound: true))
			{
				return IntPtr.Zero;
			}
			throw Win32Marshal.GetExceptionForWin32Error(num2, fullPath);
		}

		private void CloseDirectoryHandle()
		{
			IntPtr intPtr = Interlocked.Exchange(ref _directoryHandle, IntPtr.Zero);
			if (intPtr != IntPtr.Zero)
			{
				Interop.Kernel32.CloseHandle(intPtr);
			}
		}

		private IntPtr CreateDirectoryHandle(string path, bool ignoreNotFound = false)
		{
			IntPtr intPtr = Interop.Kernel32.CreateFile_IntPtr(path, 1, FileShare.ReadWrite | FileShare.Delete, FileMode.Open, 33554432);
			if (intPtr == IntPtr.Zero || intPtr == (IntPtr)(-1))
			{
				int num = Marshal.GetLastWin32Error();
				if (ContinueOnDirectoryError(num, ignoreNotFound))
				{
					return IntPtr.Zero;
				}
				if (num == 2)
				{
					num = 3;
				}
				throw Win32Marshal.GetExceptionForWin32Error(num, path);
			}
			return intPtr;
		}

		private bool ContinueOnDirectoryError(int error, bool ignoreNotFound)
		{
			if ((!ignoreNotFound || (error != 2 && error != 3 && error != 267)) && (error != 5 || !_options.IgnoreInaccessible))
			{
				return ContinueOnError(error);
			}
			return true;
		}

		public unsafe bool MoveNext()
		{
			if (_lastEntryFound)
			{
				return false;
			}
			FileSystemEntry entry = default(FileSystemEntry);
			lock (_lock)
			{
				if (_lastEntryFound)
				{
					return false;
				}
				while (true)
				{
					FindNextEntry();
					if (_lastEntryFound)
					{
						return false;
					}
					FileSystemEntry.Initialize(ref entry, _entry, _currentPath.AsSpan(), _rootDirectory.AsSpan(), _originalRootDirectory.AsSpan());
					if ((_entry->FileAttributes & _options.AttributesToSkip) != 0)
					{
						continue;
					}
					if ((_entry->FileAttributes & FileAttributes.Directory) != 0)
					{
						if (_entry->FileName.Length <= 2 && _entry->FileName[0] == '.' && (_entry->FileName.Length != 2 || _entry->FileName[1] == '.'))
						{
							if (!_options.ReturnSpecialDirectories)
							{
								continue;
							}
						}
						else if (_options.RecurseSubdirectories && _remainingRecursionDepth > 0 && ShouldRecurseIntoEntry(ref entry))
						{
							string text = Path.Join(_currentPath.AsSpan(), _entry->FileName);
							IntPtr intPtr = CreateRelativeDirectoryHandle(_entry->FileName, text);
							if (intPtr != IntPtr.Zero)
							{
								try
								{
									if (_pending == null)
									{
										_pending = new Queue<(IntPtr, string, int)>();
									}
									_pending.Enqueue((intPtr, text, _remainingRecursionDepth - 1));
								}
								catch
								{
									Interop.Kernel32.CloseHandle(intPtr);
									throw;
								}
							}
						}
					}
					if (ShouldIncludeEntry(ref entry))
					{
						break;
					}
				}
				_current = TransformEntry(ref entry);
				return true;
			}
		}

		private unsafe void FindNextEntry()
		{
			_entry = Interop.NtDll.FILE_FULL_DIR_INFORMATION.GetNextInfo(_entry);
			if (_entry == null && GetData())
			{
				_entry = (Interop.NtDll.FILE_FULL_DIR_INFORMATION*)(void*)_buffer;
			}
		}

		private bool DequeueNextDirectory()
		{
			if (_pending == null || _pending.Count == 0)
			{
				return false;
			}
			(_directoryHandle, _currentPath, _remainingRecursionDepth) = _pending.Dequeue();
			return true;
		}

		private void InternalDispose(bool disposing)
		{
			if (_lock != null)
			{
				lock (_lock)
				{
					_lastEntryFound = true;
					CloseDirectoryHandle();
					if (_pending != null)
					{
						while (_pending.Count > 0)
						{
							Interop.Kernel32.CloseHandle(_pending.Dequeue().Handle);
						}
						_pending = null;
					}
					if (_buffer != (IntPtr)0)
					{
						Marshal.FreeHGlobal(_buffer);
					}
					_buffer = default(IntPtr);
				}
			}
			Dispose(disposing);
		}
	}
	public class FileSystemEnumerable<TResult> : IEnumerable<TResult>, System.Collections.IEnumerable
	{
		public delegate bool FindPredicate(ref FileSystemEntry entry);

		public delegate TResult FindTransform(ref FileSystemEntry entry);

		private sealed class DelegateEnumerator : FileSystemEnumerator<TResult>
		{
			private readonly FileSystemEnumerable<TResult> _enumerable;

			public DelegateEnumerator(FileSystemEnumerable<TResult> enumerable, bool isNormalized)
				: base(enumerable._directory, isNormalized, enumerable._options)
			{
				_enumerable = enumerable;
			}

			protected override TResult TransformEntry(ref FileSystemEntry entry)
			{
				return _enumerable._transform(ref entry);
			}

			protected override bool ShouldRecurseIntoEntry(ref FileSystemEntry entry)
			{
				return _enumerable.ShouldRecursePredicate?.Invoke(ref entry) ?? true;
			}

			protected override bool ShouldIncludeEntry(ref FileSystemEntry entry)
			{
				return _enumerable.ShouldIncludePredicate?.Invoke(ref entry) ?? true;
			}
		}

		private DelegateEnumerator _enumerator;

		private readonly FindTransform _transform;

		private readonly EnumerationOptions _options;

		private readonly string _directory;

		public FindPredicate? ShouldIncludePredicate { get; set; }

		public FindPredicate? ShouldRecursePredicate { get; set; }

		public FileSystemEnumerable(string directory, FindTransform transform, EnumerationOptions? options = null)
			: this(directory, transform, options, isNormalized: false)
		{
		}

		internal FileSystemEnumerable(string directory, FindTransform transform, EnumerationOptions options, bool isNormalized)
		{
			_directory = directory ?? throw new ArgumentNullException("directory");
			_transform = transform ?? throw new ArgumentNullException("transform");
			_options = options ?? EnumerationOptions.Default;
			_enumerator = new DelegateEnumerator(this, isNormalized);
		}

		public IEnumerator<TResult> GetEnumerator()
		{
			return Interlocked.Exchange(ref _enumerator, null) ?? new DelegateEnumerator(this, isNormalized: false);
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal static class FileSystemEnumerableFactory
	{
		private static readonly char[] s_unixEscapeChars = new char[4] { '\\', '"', '<', '>' };

		internal static bool NormalizeInputs(ref string directory, ref string expression, MatchType matchType)
		{
			if (Path.IsPathRooted(expression))
			{
				throw new ArgumentException(SR.Arg_Path2IsRooted, "expression");
			}
			if (expression.Contains('\0'))
			{
				throw new ArgumentException(SR.Argument_InvalidPathChars, expression);
			}
			if (directory.Contains('\0'))
			{
				throw new ArgumentException(SR.Argument_InvalidPathChars, directory);
			}
			ReadOnlySpan<char> directoryName = Path.GetDirectoryName(expression.AsSpan());
			bool result = true;
			if (directoryName.Length != 0)
			{
				directory = Path.Join(directory.AsSpan(), directoryName);
				expression = expression.Substring(directoryName.Length + 1);
				result = false;
			}
			switch (matchType)
			{
			case MatchType.Win32:
				if (expression == "*")
				{
					break;
				}
				if (string.IsNullOrEmpty(expression) || expression == "." || expression == "*.*")
				{
					expression = "*";
					break;
				}
				if (Path.DirectorySeparatorChar != '\\' && expression.IndexOfAny(s_unixEscapeChars) != -1)
				{
					expression = expression.Replace("\\", "\\\\");
					expression = expression.Replace("\"", "\\\"");
					expression = expression.Replace(">", "\\>");
					expression = expression.Replace("<", "\\<");
				}
				expression = FileSystemName.TranslateWin32Expression(expression);
				break;
			default:
				throw new ArgumentOutOfRangeException("matchType");
			case MatchType.Simple:
				break;
			}
			return result;
		}

		private static bool MatchesPattern(string expression, ReadOnlySpan<char> name, EnumerationOptions options)
		{
			bool ignoreCase = (options.MatchCasing == MatchCasing.PlatformDefault && !PathInternal.IsCaseSensitive) || options.MatchCasing == MatchCasing.CaseInsensitive;
			return options.MatchType switch
			{
				MatchType.Simple => FileSystemName.MatchesSimpleExpression(expression.AsSpan(), name, ignoreCase), 
				MatchType.Win32 => FileSystemName.MatchesWin32Expression(expression.AsSpan(), name, ignoreCase), 
				_ => throw new ArgumentOutOfRangeException("options"), 
			};
		}

		internal static IEnumerable<string> UserFiles(string directory, string expression, EnumerationOptions options)
		{
			return new FileSystemEnumerable<string>(directory, delegate(ref FileSystemEntry entry)
			{
				return entry.ToSpecifiedFullPath();
			}, options)
			{
				ShouldIncludePredicate = delegate(ref FileSystemEntry entry)
				{
					return !entry.IsDirectory && MatchesPattern(expression, entry.FileName, options);
				}
			};
		}

		internal static IEnumerable<string> UserDirectories(string directory, string expression, EnumerationOptions options)
		{
			return new FileSystemEnumerable<string>(directory, delegate(ref FileSystemEntry entry)
			{
				return entry.ToSpecifiedFullPath();
			}, options)
			{
				ShouldIncludePredicate = delegate(ref FileSystemEntry entry)
				{
					return entry.IsDirectory && MatchesPattern(expression, entry.FileName, options);
				}
			};
		}

		internal static IEnumerable<string> UserEntries(string directory, string expression, EnumerationOptions options)
		{
			return new FileSystemEnumerable<string>(directory, delegate(ref FileSystemEntry entry)
			{
				return entry.ToSpecifiedFullPath();
			}, options)
			{
				ShouldIncludePredicate = delegate(ref FileSystemEntry entry)
				{
					return MatchesPattern(expression, entry.FileName, options);
				}
			};
		}

		internal static IEnumerable<FileInfo> FileInfos(string directory, string expression, EnumerationOptions options, bool isNormalized)
		{
			return new FileSystemEnumerable<FileInfo>(directory, delegate(ref FileSystemEntry entry)
			{
				return (FileInfo)entry.ToFileSystemInfo();
			}, options, isNormalized)
			{
				ShouldIncludePredicate = delegate(ref FileSystemEntry entry)
				{
					return !entry.IsDirectory && MatchesPattern(expression, entry.FileName, options);
				}
			};
		}

		internal static IEnumerable<DirectoryInfo> DirectoryInfos(string directory, string expression, EnumerationOptions options, bool isNormalized)
		{
			return new FileSystemEnumerable<DirectoryInfo>(directory, delegate(ref FileSystemEntry entry)
			{
				return (DirectoryInfo)entry.ToFileSystemInfo();
			}, options, isNormalized)
			{
				ShouldIncludePredicate = delegate(ref FileSystemEntry entry)
				{
					return entry.IsDirectory && MatchesPattern(expression, entry.FileName, options);
				}
			};
		}

		internal static IEnumerable<FileSystemInfo> FileSystemInfos(string directory, string expression, EnumerationOptions options, bool isNormalized)
		{
			return new FileSystemEnumerable<FileSystemInfo>(directory, delegate(ref FileSystemEntry entry)
			{
				return entry.ToFileSystemInfo();
			}, options, isNormalized)
			{
				ShouldIncludePredicate = delegate(ref FileSystemEntry entry)
				{
					return MatchesPattern(expression, entry.FileName, options);
				}
			};
		}
	}
	public static class FileSystemName
	{
		private static readonly char[] s_wildcardChars = new char[5] { '"', '<', '>', '*', '?' };

		private static readonly char[] s_simpleWildcardChars = new char[2] { '*', '?' };

		public static string TranslateWin32Expression(string? expression)
		{
			if (string.IsNullOrEmpty(expression) || expression == "*" || expression == "*.*")
			{
				return "*";
			}
			bool flag = false;
			Span<char> initialBuffer = stackalloc char[32];
			ValueStringBuilder valueStringBuilder = new ValueStringBuilder(initialBuffer);
			int length = expression.Length;
			for (int i = 0; i < length; i++)
			{
				char c = expression[i];
				switch (c)
				{
				case '.':
					flag = true;
					if (i >= 1 && i == length - 1 && expression[i - 1] == '*')
					{
						valueStringBuilder[valueStringBuilder.Length - 1] = '<';
					}
					else if (i < length - 1 && (expression[i + 1] == '?' || expression[i + 1] == '*'))
					{
						valueStringBuilder.Append('"');
					}
					else
					{
						valueStringBuilder.Append('.');
					}
					break;
				case '?':
					flag = true;
					valueStringBuilder.Append('>');
					break;
				default:
					valueStringBuilder.Append(c);
					break;
				}
			}
			if (!flag)
			{
				return expression;
			}
			return valueStringBuilder.ToString();
		}

		public static bool MatchesWin32Expression(ReadOnlySpan<char> expression, ReadOnlySpan<char> name, bool ignoreCase = true)
		{
			return MatchPattern(expression, name, ignoreCase, useExtendedWildcards: true);
		}

		public static bool MatchesSimpleExpression(ReadOnlySpan<char> expression, ReadOnlySpan<char> name, bool ignoreCase = true)
		{
			return MatchPattern(expression, name, ignoreCase, useExtendedWildcards: false);
		}

		private static bool MatchPattern(ReadOnlySpan<char> expression, ReadOnlySpan<char> name, bool ignoreCase, bool useExtendedWildcards)
		{
			if (expression.Length == 0 || name.Length == 0)
			{
				return false;
			}
			if (expression[0] == '*')
			{
				if (expression.Length == 1)
				{
					return true;
				}
				ReadOnlySpan<char> readOnlySpan = expression.Slice(1);
				if (readOnlySpan.IndexOfAny(useExtendedWildcards ? s_wildcardChars : s_simpleWildcardChars) == -1)
				{
					if (name.Length < readOnlySpan.Length)
					{
						return false;
					}
					return name.EndsWith(readOnlySpan, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
				}
			}
			int num = 0;
			int num2 = 1;
			char c = '\0';
			Span<int> span = default(Span<int>);
			Span<int> span2 = stackalloc int[16];
			Span<int> span3 = stackalloc int[16];
			span3[0] = 0;
			int num3 = expression.Length * 2;
			bool flag = false;
			int num6;
			while (!flag)
			{
				if (num < name.Length)
				{
					c = name[num++];
				}
				else
				{
					if (span3[num2 - 1] == num3)
					{
						break;
					}
					flag = true;
				}
				int i = 0;
				int num4 = 0;
				int j = 0;
				while (i < num2)
				{
					int num5 = (span3[i++] + 1) / 2;
					while (num5 < expression.Length)
					{
						num6 = num5 * 2;
						char c2 = expression[num5];
						if (num4 >= span2.Length - 2)
						{
							int num7 = span2.Length * 2;
							span = new int[num7];
							span2.CopyTo(span);
							span2 = span;
							span = new int[num7];
							span3.CopyTo(span);
							span3 = span;
						}
						if (c2 != '*')
						{
							if (!useExtendedWildcards || c2 != '<')
							{
								num6 += 2;
								if (useExtendedWildcards && c2 == '>')
								{
									if (!flag && c != '.')
									{
										span2[num4++] = num6;
										break;
									}
								}
								else
								{
									if (!useExtendedWildcards || c2 != '"')
									{
										if (c2 == '\\')
										{
											if (++num5 == expression.Length)
											{
												span2[num4++] = num3;
												break;
											}
											num6 = num5 * 2 + 2;
											c2 = expression[num5];
										}
										if (!flag)
										{
											if (c2 == '?')
											{
												span2[num4++] = num6;
											}
											else if (ignoreCase ? (char.ToUpperInvariant(c2) == char.ToUpperInvariant(c)) : (c2 == c))
											{
												span2[num4++] = num6;
											}
										}
										break;
									}
									if (!flag)
									{
										if (c == '.')
										{
											span2[num4++] = num6;
										}
										break;
									}
								}
								goto IL_02e4;
							}
							bool flag2 = false;
							if (!flag && c == '.')
							{
								for (int k = num; k < name.Length; k++)
								{
									if (name[k] == '.')
									{
										flag2 = true;
										break;
									}
								}
							}
							if (!(flag || c != '.' || flag2))
							{
								goto IL_02d3;
							}
						}
						span2[num4++] = num6;
						goto IL_02d3;
						IL_02e4:
						if (++num5 == expression.Length)
						{
							span2[num4++] = num3;
						}
						continue;
						IL_02d3:
						span2[num4++] = num6 + 1;
						goto IL_02e4;
					}
					if (i >= num2 || j >= num4)
					{
						continue;
					}
					for (; j < num4; j++)
					{
						for (int length = span3.Length; i < length && span3[i] < span2[j]; i++)
						{
						}
					}
				}
				if (num4 == 0)
				{
					return false;
				}
				span = span3;
				span3 = span2;
				span2 = span;
				num2 = num4;
			}
			num6 = span3[num2 - 1];
			return num6 == num3;
		}
	}
}
namespace System.Diagnostics
{
	public static class Debugger
	{
		private sealed class CrossThreadDependencyNotification : ICustomDebuggerNotification
		{
		}

		public static readonly string? DefaultCategory;

		public static extern bool IsAttached
		{
			[MethodImpl(MethodImplOptions.InternalCall)]
			get;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void Break()
		{
			BreakInternal();
		}

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void BreakInternal();

		public static bool Launch()
		{
			if (!IsAttached)
			{
				return LaunchInternal();
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void NotifyOfCrossThreadDependencySlow()
		{
			CustomNotification(new CrossThreadDependencyNotification());
		}

		public static void NotifyOfCrossThreadDependency()
		{
			if (IsAttached)
			{
				NotifyOfCrossThreadDependencySlow();
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern bool LaunchInternal();

		public static void Log(int level, string? category, string? message)
		{
			LogInternal(level, category, message);
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private static extern void LogInternal(int level, string category, string message);

		[MethodImpl(MethodImplOptions.InternalCall)]
		public static extern bool IsLogging();

		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void CustomNotification(ICustomDebuggerNotification data);
	}
	internal sealed class EditAndContinueHelper
	{
		private object _objectReference;
	}
	internal interface ICustomDebuggerNotification
	{
	}
	public class StackFrame
	{
		private MethodBase _method;

		private int _nativeOffset;

		private int _ilOffset;

		private string _fileName;

		private int _lineNumber;

		private int _columnNumber;

		private bool _isLastFrameFromForeignExceptionStackTrace;

		public const int OFFSET_UNKNOWN = -1;

		internal bool IsLastFrameFromForeignExceptionStackTrace => _isLastFrameFromForeignExceptionStackTrace;

		internal StackFrame(StackFrameHelper stackFrameHelper, int skipFrames, bool needFileInfo)
		{
			_method = stackFrameHelper.GetMethodBase(skipFrames);
			_nativeOffset = stackFrameHelper.GetOffset(skipFrames);
			_ilOffset = stackFrameHelper.GetILOffset(skipFrames);
			_isLastFrameFromForeignExceptionStackTrace = stackFrameHelper.IsLastFrameFromForeignExceptionStackTrace(skipFrames);
			if (needFileInfo)
			{
				_fileName = stackFrameHelper.GetFilename(skipFrames);
				_lineNumber = stackFrameHelper.GetLineNumber(skipFrames);
				_columnNumber = stackFrameHelper.GetColumnNumber(skipFrames);
			}
		}

		private void BuildStackFrame(int skipFrames, bool needFileInfo)
		{
			StackFrameHelper stackFrameHelper = new StackFrameHelper(null);
			stackFrameHelper.InitializeSourceInfo(0, needFileInfo, null);
			int numberOfFrames = stackFrameHelper.GetNumberOfFrames();
			skipFrames += StackTrace.CalculateFramesToSkip(stackFrameHelper, numberOfFrames);
			if (numberOfFrames - skipFrames > 0)
			{
				_method = stackFrameHelper.GetMethodBase(skipFrames);
				_nativeOffset = stackFrameHelper.GetOffset(skipFrames);
				_ilOffset = stackFrameHelper.GetILOffset(skipFrames);
				if (needFileInfo)
				{
					_fileName = stackFrameHelper.GetFilename(skipFrames);
					_lineNumber = stackFrameHelper.GetLineNumber(skipFrames);
					_columnNumber = stackFrameHelper.GetColumnNumber(skipFrames);
				}
			}
		}

		private static bool AppendStackFrameWithoutMethodBase(StringBuilder sb)
		{
			return false;
		}

		internal static MethodBase GetMethodFromNativeIP(IntPtr ip)
		{
			RuntimeMethodHandleInternal methodDescFromNativeIP = StackTrace.GetMethodDescFromNativeIP(ip);
			if (methodDescFromNativeIP.Value == IntPtr.Zero)
			{
				return null;
			}
			return RuntimeType.GetMethodBase(null, methodDescFromNativeIP);
		}

		private void InitMembers()
		{
			_nativeOffset = -1;
			_ilOffset = -1;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackFrame()
		{
			InitMembers();
			BuildStackFrame(0, needFileInfo: false);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackFrame(bool needFileInfo)
		{
			InitMembers();
			BuildStackFrame(0, needFileInfo);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackFrame(int skipFrames)
		{
			InitMembers();
			BuildStackFrame(skipFrames, needFileInfo: false);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackFrame(int skipFrames, bool needFileInfo)
		{
			InitMembers();
			BuildStackFrame(skipFrames, needFileInfo);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackFrame(string? fileName, int lineNumber)
		{
			InitMembers();
			BuildStackFrame(0, needFileInfo: false);
			_fileName = fileName;
			_lineNumber = lineNumber;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackFrame(string? fileName, int lineNumber, int colNumber)
		{
			InitMembers();
			BuildStackFrame(0, needFileInfo: false);
			_fileName = fileName;
			_lineNumber = lineNumber;
			_columnNumber = colNumber;
		}

		public virtual MethodBase? GetMethod()
		{
			return _method;
		}

		public virtual int GetNativeOffset()
		{
			return _nativeOffset;
		}

		public virtual int GetILOffset()
		{
			return _ilOffset;
		}

		public virtual string? GetFileName()
		{
			return _fileName;
		}

		public virtual int GetFileLineNumber()
		{
			return _lineNumber;
		}

		public virtual int GetFileColumnNumber()
		{
			return _columnNumber;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder(255);
			bool flag2;
			if (_method != null)
			{
				stringBuilder.Append(_method.Name);
				if (_method is MethodInfo methodInfo && methodInfo.IsGenericMethod)
				{
					Type[] genericArguments = methodInfo.GetGenericArguments();
					stringBuilder.Append('<');
					int i = 0;
					bool flag = true;
					for (; i < genericArguments.Length; i++)
					{
						if (!flag)
						{
							stringBuilder.Append(',');
						}
						else
						{
							flag = false;
						}
						stringBuilder.Append(genericArguments[i].Name);
					}
					stringBuilder.Append('>');
				}
				flag2 = true;
			}
			else
			{
				flag2 = AppendStackFrameWithoutMethodBase(stringBuilder);
			}
			if (flag2)
			{
				stringBuilder.Append(" at offset ");
				if (_nativeOffset == -1)
				{
					stringBuilder.Append("<offset unknown>");
				}
				else
				{
					stringBuilder.Append(_nativeOffset);
				}
				stringBuilder.Append(" in file:line:column ");
				stringBuilder.Append(_fileName ?? "<filename unknown>");
				stringBuilder.Append(':');
				stringBuilder.Append(_lineNumber);
				stringBuilder.Append(':');
				stringBuilder.Append(_columnNumber);
			}
			else
			{
				stringBuilder.Append("<null>");
			}
			stringBuilder.AppendLine();
			return stringBuilder.ToString();
		}
	}
	internal sealed class StackFrameHelper
	{
		private delegate void GetSourceLineInfoDelegate(Assembly assembly, string assemblyPath, IntPtr loadedPeAddress, int loadedPeSize, bool isFileLayout, IntPtr inMemoryPdbAddress, int inMemoryPdbSize, int methodToken, int ilOffset, out string sourceFile, out int sourceLine, out int sourceColumn);

		private Thread targetThread;

		private int[] rgiOffset;

		private int[] rgiILOffset;

		private object dynamicMethods;

		private IntPtr[] rgMethodHandle;

		private string[] rgAssemblyPath;

		private Assembly[] rgAssembly;

		private IntPtr[] rgLoadedPeAddress;

		private int[] rgiLoadedPeSize;

		private bool[] rgiIsFileLayout;

		private IntPtr[] rgInMemoryPdbAddress;

		private int[] rgiInMemoryPdbSize;

		private int[] rgiMethodToken;

		private string[] rgFilename;

		private int[] rgiLineNumber;

		private int[] rgiColumnNumber;

		private bool[] rgiLastFrameFromForeignExceptionStackTrace;

		private int iFrameCount;

		private static GetSourceLineInfoDelegate s_getSourceLineInfo;

		[ThreadStatic]
		private static int t_reentrancy;

		public StackFrameHelper(Thread target)
		{
			targetThread = target;
			rgMethodHandle = null;
			rgiMethodToken = null;
			rgiOffset = null;
			rgiILOffset = null;
			rgAssemblyPath = null;
			rgAssembly = null;
			rgLoadedPeAddress = null;
			rgiLoadedPeSize = null;
			rgiIsFileLayout = null;
			rgInMemoryPdbAddress = null;
			rgiInMemoryPdbSize = null;
			dynamicMethods = null;
			rgFilename = null;
			rgiLineNumber = null;
			rgiColumnNumber = null;
			rgiLastFrameFromForeignExceptionStackTrace = null;
			iFrameCount = 0;
		}

		internal void InitializeSourceInfo(int iSkip, bool fNeedFileInfo, Exception exception)
		{
			StackTrace.GetStackFramesInternal(this, iSkip, fNeedFileInfo, exception);
			if (!fNeedFileInfo || t_reentrancy > 0)
			{
				return;
			}
			t_reentrancy++;
			try
			{
				if (s_getSourceLineInfo == null)
				{
					Type type = Type.GetType("System.Diagnostics.StackTraceSymbols, System.Diagnostics.StackTrace, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", throwOnError: false);
					if (type == null)
					{
						return;
					}
					Type[] types = new Type[12]
					{
						typeof(Assembly),
						typeof(string),
						typeof(IntPtr),
						typeof(int),
						typeof(bool),
						typeof(IntPtr),
						typeof(int),
						typeof(int),
						typeof(int),
						typeof(string).MakeByRefType(),
						typeof(int).MakeByRefType(),
						typeof(int).MakeByRefType()
					};
					MethodInfo method = type.GetMethod("GetSourceLineInfo", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
					if (method == null)
					{
						return;
					}
					object target = Activator.CreateInstance(type);
					GetSourceLineInfoDelegate value = method.CreateDelegate<GetSourceLineInfoDelegate>(target);
					Interlocked.CompareExchange(ref s_getSourceLineInfo, value, null);
				}
				for (int i = 0; i < iFrameCount; i++)
				{
					if (rgiMethodToken[i] != 0)
					{
						s_getSourceLineInfo(rgAssembly[i], rgAssemblyPath[i], rgLoadedPeAddress[i], rgiLoadedPeSize[i], rgiIsFileLayout[i], rgInMemoryPdbAddress[i], rgiInMemoryPdbSize[i], rgiMethodToken[i], rgiILOffset[i], out rgFilename[i], out rgiLineNumber[i], out rgiColumnNumber[i]);
					}
				}
			}
			catch
			{
			}
			finally
			{
				t_reentrancy--;
			}
		}

		public MethodBase GetMethodBase(int i)
		{
			IntPtr intPtr = rgMethodHandle[i];
			if (intPtr == IntPtr.Zero)
			{
				return null;
			}
			IRuntimeMethodInfo typicalMethodDefinition = RuntimeMethodHandle.GetTypicalMethodDefinition(new RuntimeMethodInfoStub(intPtr, this));
			return RuntimeType.GetMethodBase(typicalMethodDefinition);
		}

		public int GetOffset(int i)
		{
			return rgiOffset[i];
		}

		public int GetILOffset(int i)
		{
			return rgiILOffset[i];
		}

		public string GetFilename(int i)
		{
			string[] array = rgFilename;
			if (array == null)
			{
				return null;
			}
			return array[i];
		}

		public int GetLineNumber(int i)
		{
			if (rgiLineNumber != null)
			{
				return rgiLineNumber[i];
			}
			return 0;
		}

		public int GetColumnNumber(int i)
		{
			if (rgiColumnNumber != null)
			{
				return rgiColumnNumber[i];
			}
			return 0;
		}

		public bool IsLastFrameFromForeignExceptionStackTrace(int i)
		{
			if (rgiLastFrameFromForeignExceptionStackTrace != null)
			{
				return rgiLastFrameFromForeignExceptionStackTrace[i];
			}
			return false;
		}

		public int GetNumberOfFrames()
		{
			return iFrameCount;
		}
	}
	public class StackTrace
	{
		internal enum TraceFormat
		{
			Normal,
			TrailingNewLine
		}

		public const int METHODS_TO_SKIP = 0;

		private int _numOfFrames;

		private int _methodsToSkip;

		private StackFrame[] _stackFrames;

		public virtual int FrameCount => _numOfFrames;

		[MethodImpl(MethodImplOptions.InternalCall)]
		internal static extern void GetStackFramesInternal(StackFrameHelper sfh, int iSkip, bool fNeedFileInfo, Exception e);

		[DllImport("QCall")]
		internal static extern RuntimeMethodHandleInternal GetMethodDescFromNativeIP(IntPtr ip);

		internal static int CalculateFramesToSkip(StackFrameHelper StackF, int iNumFrames)
		{
			int num = 0;
			for (int i = 0; i < iNumFrames; i++)
			{
				MethodBase methodBase = StackF.GetMethodBase(i);
				if (methodBase != null)
				{
					Type declaringType = methodBase.DeclaringType;
					if (declaringType == null)
					{
						break;
					}
					string @namespace = declaringType.Namespace;
					if (@namespace == null || !string.Equals(@namespace, "System.Diagnostics", StringComparison.Ordinal))
					{
						break;
					}
				}
				num++;
			}
			return num;
		}

		private void InitializeForException(Exception exception, int skipFrames, bool fNeedFileInfo)
		{
			CaptureStackTrace(skipFrames, fNeedFileInfo, exception);
		}

		private void InitializeForCurrentThread(int skipFrames, bool fNeedFileInfo)
		{
			CaptureStackTrace(skipFrames, fNeedFileInfo, null);
		}

		private void CaptureStackTrace(int skipFrames, bool fNeedFileInfo, Exception e)
		{
			_methodsToSkip = skipFrames;
			StackFrameHelper stackFrameHelper = new StackFrameHelper(null);
			stackFrameHelper.InitializeSourceInfo(0, fNeedFileInfo, e);
			_numOfFrames = stackFrameHelper.GetNumberOfFrames();
			if (_methodsToSkip > _numOfFrames)
			{
				_methodsToSkip = _numOfFrames;
			}
			if (_numOfFrames != 0)
			{
				_stackFrames = new StackFrame[_numOfFrames];
				for (int i = 0; i < _numOfFrames; i++)
				{
					_stackFrames[i] = new StackFrame(stackFrameHelper, i, fNeedFileInfo);
				}
				if (e == null)
				{
					_methodsToSkip += CalculateFramesToSkip(stackFrameHelper, _numOfFrames);
				}
				_numOfFrames -= _methodsToSkip;
				if (_numOfFrames < 0)
				{
					_numOfFrames = 0;
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackTrace()
		{
			InitializeForCurrentThread(0, fNeedFileInfo: false);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackTrace(bool fNeedFileInfo)
		{
			InitializeForCurrentThread(0, fNeedFileInfo);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackTrace(int skipFrames)
		{
			if (skipFrames < 0)
			{
				throw new ArgumentOutOfRangeException("skipFrames", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			InitializeForCurrentThread(skipFrames, fNeedFileInfo: false);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public StackTrace(int skipFrames, bool fNeedFileInfo)
		{
			if (skipFrames < 0)
			{
				throw new ArgumentOutOfRangeException("skipFrames", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			InitializeForCurrentThread(skipFrames, fNeedFileInfo);
		}

		public StackTrace(Exception e)
		{
			if (e == null)
			{
				throw new ArgumentNullException("e");
			}
			InitializeForException(e, 0, fNeedFileInfo: false);
		}

		public StackTrace(Exception e, bool fNeedFileInfo)
		{
			if (e == null)
			{
				throw new ArgumentNullException("e");
			}
			InitializeForException(e, 0, fNeedFileInfo);
		}

		public StackTrace(Exception e, int skipFrames)
		{
			if (e == null)
			{
				throw new ArgumentNullException("e");
			}
			if (skipFrames < 0)
			{
				throw new ArgumentOutOfRangeException("skipFrames", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			InitializeForException(e, skipFrames, fNeedFileInfo: false);
		}

		public StackTrace(Exception e, int skipFrames, bool fNeedFileInfo)
		{
			if (e == null)
			{
				throw new ArgumentNullException("e");
			}
			if (skipFrames < 0)
			{
				throw new ArgumentOutOfRangeException("skipFrames", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			InitializeForException(e, skipFrames, fNeedFileInfo);
		}

		public StackTrace(StackFrame frame)
		{
			_stackFrames = new StackFrame[1] { frame };
			_numOfFrames = 1;
		}

		public virtual StackFrame? GetFrame(int index)
		{
			if (_stackFrames != null && index < _numOfFrames && index >= 0)
			{
				return _stackFrames[index + _methodsToSkip];
			}
			return null;
		}

		public virtual StackFrame[] GetFrames()
		{
			if (_stackFrames == null || _numOfFrames <= 0)
			{
				return Array.Empty<StackFrame>();
			}
			StackFrame[] array = new StackFrame[_numOfFrames];
			Array.Copy(_stackFrames, _methodsToSkip, array, 0, _numOfFrames);
			return array;
		}

		public override string ToString()
		{
			return ToString(TraceFormat.TrailingNewLine);
		}

		internal string ToString(TraceFormat traceFormat)
		{
			StringBuilder stringBuilder = new StringBuilder(256);
			ToString(traceFormat, stringBuilder);
			return stringBuilder.ToString();
		}

		internal void ToString(TraceFormat traceFormat, StringBuilder sb)
		{
			string resourceString = SR.GetResourceString("Word_At", "at");
			string resourceString2 = SR.GetResourceString("StackTrace_InFileLineNumber", "in {0}:line {1}");
			string resourceString3 = SR.GetResourceString("StackTrace_InFileILOffset", "in {0}:token 0x{1:x}+0x{2:x}");
			bool flag = true;
			for (int i = 0; i < _numOfFrames; i++)
			{
				StackFrame frame = GetFrame(i);
				MethodBase method = frame?.GetMethod();
				if (!(method != null) || (!ShowInStackTrace(method) && i != _numOfFrames - 1))
				{
					continue;
				}
				if (flag)
				{
					flag = false;
				}
				else
				{
					sb.AppendLine();
				}
				sb.Append("   ").Append(resourceString).Append(' ');
				bool flag2 = false;
				Type declaringType = method.DeclaringType;
				string name = method.Name;
				bool flag3 = false;
				if (declaringType != null && declaringType.IsDefined(typeof(CompilerGeneratedAttribute), inherit: false))
				{
					flag2 = declaringType.IsAssignableTo(typeof(IAsyncStateMachine));
					if (flag2 || declaringType.IsAssignableTo(typeof(System.Collections.IEnumerator)))
					{
						flag3 = TryResolveStateMachineMethod(ref method, out declaringType);
					}
				}
				if (declaringType != null)
				{
					string fullName = declaringType.FullName;
					foreach (char c in fullName)
					{
						sb.Append((c == '+') ? '.' : c);
					}
					sb.Append('.');
				}
				sb.Append(method.Name);
				if (method is MethodInfo methodInfo && methodInfo.IsGenericMethod)
				{
					Type[] genericArguments = methodInfo.GetGenericArguments();
					sb.Append('[');
					int k = 0;
					bool flag4 = true;
					for (; k < genericArguments.Length; k++)
					{
						if (!flag4)
						{
							sb.Append(',');
						}
						else
						{
							flag4 = false;
						}
						sb.Append(genericArguments[k].Name);
					}
					sb.Append(']');
				}
				ParameterInfo[] array = null;
				try
				{
					array = method.GetParameters();
				}
				catch
				{
				}
				if (array != null)
				{
					sb.Append('(');
					bool flag5 = true;
					for (int l = 0; l < array.Length; l++)
					{
						if (!flag5)
						{
							sb.Append(", ");
						}
						else
						{
							flag5 = false;
						}
						string value = "<UnknownType>";
						if (array[l].ParameterType != null)
						{
							value = array[l].ParameterType.Name;
						}
						sb.Append(value);
						sb.Append(' ');
						sb.Append(array[l].Name);
					}
					sb.Append(')');
				}
				if (flag3)
				{
					sb.Append('+');
					sb.Append(name);
					sb.Append('(').Append(')');
				}
				if (frame.GetILOffset() != -1)
				{
					string fileName = frame.GetFileName();
					if (fileName != null)
					{
						sb.Append(' ');
						sb.AppendFormat(CultureInfo.InvariantCulture, resourceString2, fileName, frame.GetFileLineNumber());
					}
					else if (LocalAppContextSwitches.ShowILOffsets && method.ReflectedType != null)
					{
						string scopeName = method.ReflectedType.Module.ScopeName;
						try
						{
							int metadataToken = method.MetadataToken;
							sb.Append(' ');
							sb.AppendFormat(CultureInfo.InvariantCulture, resourceString3, scopeName, metadataToken, frame.GetILOffset());
						}
						catch (InvalidOperationException)
						{
						}
					}
				}
				if (frame.IsLastFrameFromForeignExceptionStackTrace && !flag2)
				{
					sb.AppendLine();
					sb.Append(SR.GetResourceString("Exception_EndStackTraceFromPreviousThrow", "--- End of stack trace from previous location ---"));
				}
			}
			if (traceFormat == TraceFormat.TrailingNewLine)
			{
				sb.AppendLine();
			}
		}

		private static bool ShowInStackTrace(MethodBase mb)
		{
			if ((mb.MethodImplementationFlags & MethodImplAttributes.AggressiveInlining) != 0)
			{
				return false;
			}
			try
			{
				if (mb.IsDefined(typeof(StackTraceHiddenAttribute), inherit: false))
				{
					return false;
				}
				Type declaringType = mb.DeclaringType;
				if (declaringType != null && declaringType.IsDefined(typeof(StackTraceHiddenAttribute), inherit: false))
				{
					return false;
				}
			}
			catch
			{
			}
			return true;
		}

		private static bool TryResolveStateMachineMethod(ref MethodBase method, out Type declaringType)
		{
			declaringType = method.DeclaringType;
			Type declaringType2 = declaringType.DeclaringType;
			if (declaringType2 == null)
			{
				return false;
			}
			MethodInfo[] array = GetDeclaredMethods(declaringType2);
			if (array == null)
			{
				return false;
			}
			MethodInfo[] array2 = array;
			foreach (MethodInfo methodInfo in array2)
			{
				IEnumerable<StateMachineAttribute> customAttributes = methodInfo.GetCustomAttributes<StateMachineAttribute>(inherit: false);
				if (customAttributes == null)
				{
					continue;
				}
				bool flag = false;
				bool flag2 = false;
				foreach (StateMachineAttribute item in customAttributes)
				{
					if (item.StateMachineType == declaringType)
					{
						flag = true;
						flag2 = flag2 || item is IteratorStateMachineAttribute || item is AsyncIteratorStateMachineAttribute;
					}
				}
				if (flag)
				{
					method = methodInfo;
					declaringType = methodInfo.DeclaringType;
					return flag2;
				}
			}
			return false;
			[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "Using Reflection to find the state machine's corresponding method is safe because the corresponding method is the only caller of the state machine. If the state machine is present, the corresponding method will be, too.")]
			static MethodInfo[] GetDeclaredMethods(Type type)
			{
				return type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
	public sealed class ConditionalAttribute : Attribute
	{
		public string ConditionString { get; }

		public ConditionalAttribute(string conditionString)
		{
			ConditionString = conditionString;
		}
	}
	public static class Debug
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		[InterpolatedStringHandler]
		public struct AssertInterpolatedStringHandler
		{
			private StringBuilder.AppendInterpolatedStringHandler _stringBuilderHandler;

			public AssertInterpolatedStringHandler(int literalLength, int formattedCount, bool condition, out bool shouldAppend)
			{
				if (condition)
				{
					_stringBuilderHandler = default(StringBuilder.AppendInterpolatedStringHandler);
					shouldAppend = false;
				}
				else
				{
					_stringBuilderHandler = new StringBuilder.AppendInterpolatedStringHandler(literalLength, formattedCount, new StringBuilder());
					shouldAppend = true;
				}
			}

			internal string ToStringAndClear()
			{
				StringBuilder stringBuilder = _stringBuilderHandler._stringBuilder;
				string result = ((stringBuilder != null) ? stringBuilder.ToString() : string.Empty);
				_stringBuilderHandler = default(StringBuilder.AppendInterpolatedStringHandler);
				return result;
			}

			public void AppendLiteral(string value)
			{
				_stringBuilderHandler.AppendLiteral(value);
			}

			public void AppendFormatted<T>(T value)
			{
				_stringBuilderHandler.AppendFormatted(value);
			}

			public void AppendFormatted<T>(T value, string? format)
			{
				_stringBuilderHandler.AppendFormatted(value, format);
			}

			public void AppendFormatted<T>(T value, int alignment)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment);
			}

			public void AppendFormatted<T>(T value, int alignment, string? format)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment, format);
			}

			public void AppendFormatted(ReadOnlySpan<char> value)
			{
				_stringBuilderHandler.AppendFormatted(value);
			}

			public void AppendFormatted(ReadOnlySpan<char> value, int alignment = 0, string? format = null)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment, format);
			}

			public void AppendFormatted(string? value)
			{
				_stringBuilderHandler.AppendFormatted(value);
			}

			public void AppendFormatted(string? value, int alignment = 0, string? format = null)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment, format);
			}

			public void AppendFormatted(object? value, int alignment = 0, string? format = null)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment, format);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[InterpolatedStringHandler]
		public struct WriteIfInterpolatedStringHandler
		{
			private StringBuilder.AppendInterpolatedStringHandler _stringBuilderHandler;

			public WriteIfInterpolatedStringHandler(int literalLength, int formattedCount, bool condition, out bool shouldAppend)
			{
				if (condition)
				{
					_stringBuilderHandler = new StringBuilder.AppendInterpolatedStringHandler(literalLength, formattedCount, StringBuilderCache.Acquire(DefaultInterpolatedStringHandler.GetDefaultLength(literalLength, formattedCount)));
					shouldAppend = true;
				}
				else
				{
					_stringBuilderHandler = default(StringBuilder.AppendInterpolatedStringHandler);
					shouldAppend = false;
				}
			}

			internal string ToStringAndClear()
			{
				StringBuilder stringBuilder = _stringBuilderHandler._stringBuilder;
				string result = ((stringBuilder != null) ? StringBuilderCache.GetStringAndRelease(stringBuilder) : string.Empty);
				_stringBuilderHandler = default(StringBuilder.AppendInterpolatedStringHandler);
				return result;
			}

			public void AppendLiteral(string value)
			{
				_stringBuilderHandler.AppendLiteral(value);
			}

			public void AppendFormatted<T>(T value)
			{
				_stringBuilderHandler.AppendFormatted(value);
			}

			public void AppendFormatted<T>(T value, string? format)
			{
				_stringBuilderHandler.AppendFormatted(value, format);
			}

			public void AppendFormatted<T>(T value, int alignment)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment);
			}

			public void AppendFormatted<T>(T value, int alignment, string? format)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment, format);
			}

			public void AppendFormatted(ReadOnlySpan<char> value)
			{
				_stringBuilderHandler.AppendFormatted(value);
			}

			public void AppendFormatted(ReadOnlySpan<char> value, int alignment = 0, string? format = null)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment, format);
			}

			public void AppendFormatted(string? value)
			{
				_stringBuilderHandler.AppendFormatted(value);
			}

			public void AppendFormatted(string? value, int alignment = 0, string? format = null)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment, format);
			}

			public void AppendFormatted(object? value, int alignment = 0, string? format = null)
			{
				_stringBuilderHandler.AppendFormatted(value, alignment, format);
			}
		}

		private static volatile DebugProvider s_provider = new DebugProvider();

		[ThreadStatic]
		private static int t_indentLevel;

		private static volatile int s_indentSize = 4;

		public static bool AutoFlush
		{
			get
			{
				return true;
			}
			set
			{
			}
		}

		public static int IndentLevel
		{
			get
			{
				return t_indentLevel;
			}
			set
			{
				t_indentLevel = ((value >= 0) ? value : 0);
				s_provider.OnIndentLevelChanged(t_indentLevel);
			}
		}

		public static int IndentSize
		{
			get
			{
				return s_indentSize;
			}
			set
			{
				s_indentSize = ((value >= 0) ? value : 0);
				s_provider.OnIndentSizeChanged(s_indentSize);
			}
		}

		public static DebugProvider SetProvider(DebugProvider provider)
		{
			if (provider == null)
			{
				throw new ArgumentNullException("provider");
			}
			return Interlocked.Exchange(ref s_provider, provider);
		}

		[Conditional("DEBUG")]
		public static void Close()
		{
		}

		[Conditional("DEBUG")]
		public static void Flush()
		{
		}

		[Conditional("DEBUG")]
		public static void Indent()
		{
			IndentLevel++;
		}

		[Conditional("DEBUG")]
		public static void Unindent()
		{
			IndentLevel--;
		}

		[Conditional("DEBUG")]
		public static void Print(string? message)
		{
			WriteLine(message);
		}

		[Conditional("DEBUG")]
		public static void Print(string format, params object?[] args)
		{
			WriteLine(string.Format(null, format, args));
		}

		[Conditional("DEBUG")]
		public static void Assert([DoesNotReturnIf(false)] bool condition)
		{
			Assert(condition, string.Empty, string.Empty);
		}

		[Conditional("DEBUG")]
		public static void Assert([DoesNotReturnIf(false)] bool condition, string? message)
		{
			Assert(condition, message, string.Empty);
		}

		[Conditional("DEBUG")]
		public static void Assert([DoesNotReturnIf(false)] bool condition, [InterpolatedStringHandlerArgument("condition")] ref AssertInterpolatedStringHandler message)
		{
			Assert(condition, message.ToStringAndClear());
		}

		[Conditional("DEBUG")]
		public static void Assert([DoesNotReturnIf(false)] bool condition, string? message, string? detailMessage)
		{
			if (!condition)
			{
				Fail(message, detailMessage);
			}
		}

		[Conditional("DEBUG")]
		public static void Assert([DoesNotReturnIf(false)] bool condition, [InterpolatedStringHandlerArgument("condition")] ref AssertInterpolatedStringHandler message, [InterpolatedStringHandlerArgument("condition")] ref AssertInterpolatedStringHandler detailMessage)
		{
			Assert(condition, message.ToStringAndClear(), detailMessage.ToStringAndClear());
		}

		[Conditional("DEBUG")]
		public static void Assert([DoesNotReturnIf(false)] bool condition, string? message, string detailMessageFormat, params object?[] args)
		{
			Assert(condition, message, string.Format(detailMessageFormat, args));
		}

		internal static void ContractFailure(string message, string detailMessage, string failureKindMessage)
		{
			string stackTrace;
			try
			{
				stackTrace = new StackTrace(2, fNeedFileInfo: true).ToString(StackTrace.TraceFormat.Normal);
			}
			catch
			{
				stackTrace = "";
			}
			s_provider.WriteAssert(stackTrace, message, detailMessage);
			DebugProvider.FailCore(stackTrace, message, detailMessage, failureKindMessage);
		}

		[Conditional("DEBUG")]
		[DoesNotReturn]
		public static void Fail(string? message)
		{
			Fail(message, string.Empty);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[Conditional("DEBUG")]
		[DoesNotReturn]
		public static void Fail(string? message, string? detailMessage)
		{
			s_provider.Fail(message, detailMessage);
		}

		[Conditional("DEBUG")]
		public static void WriteLine(string? message)
		{
			s_provider.WriteLine(message);
		}

		[Conditional("DEBUG")]
		public static void Write(string? message)
		{
			s_provider.Write(message);
		}

		[Conditional("DEBUG")]
		public static void WriteLine(object? value)
		{
			WriteLine(value?.ToString());
		}

		[Conditional("DEBUG")]
		public static void WriteLine(object? value, string? category)
		{
			WriteLine(value?.ToString(), category);
		}

		[Conditional("DEBUG")]
		public static void WriteLine(string format, params object?[] args)
		{
			WriteLine(string.Format(null, format, args));
		}

		[Conditional("DEBUG")]
		public static void WriteLine(string? message, string? category)
		{
			if (category == null)
			{
				WriteLine(message);
			}
			else
			{
				WriteLine(category + ": " + message);
			}
		}

		[Conditional("DEBUG")]
		public static void Write(object? value)
		{
			Write(value?.ToString());
		}

		[Conditional("DEBUG")]
		public static void Write(string? message, string? category)
		{
			if (category == null)
			{
				Write(message);
			}
			else
			{
				Write(category + ": " + message);
			}
		}

		[Conditional("DEBUG")]
		public static void Write(object? value, string? category)
		{
			Write(value?.ToString(), category);
		}

		[Conditional("DEBUG")]
		public static void WriteIf(bool condition, string? message)
		{
			if (condition)
			{
				Write(message);
			}
		}

		[Conditional("DEBUG")]
		public static void WriteIf(bool condition, [InterpolatedStringHandlerArgument("condition")] ref WriteIfInterpolatedStringHandler message)
		{
			WriteIf(condition, message.ToStringAndClear());
		}

		[Conditional("DEBUG")]
		public static void WriteIf(bool condition, object? value)
		{
			if (condition)
			{
				Write(value);
			}
		}

		[Conditional("DEBUG")]
		public static void WriteIf(bool condition, string? message, string? category)
		{
			if (condition)
			{
				Write(message, category);
			}
		}

		[Conditional("DEBUG")]
		public static void WriteIf(bool condition, [InterpolatedStringHandlerArgument("condition")] ref WriteIfInterpolatedStringHandler message, string? category)
		{
			WriteIf(condition, message.ToStringAndClear(), category);
		}

		[Conditional("DEBUG")]
		public static void WriteIf(bool condition, object? value, string? category)
		{
			if (condition)
			{
				Write(value, category);
			}
		}

		[Conditional("DEBUG")]
		public static void WriteLineIf(bool condition, object? value)
		{
			if (condition)
			{
				WriteLine(value);
			}
		}

		[Conditional("DEBUG")]
		public static void WriteLineIf(bool condition, object? value, string? category)
		{
			if (condition)
			{
				WriteLine(value, category);
			}
		}

		[Conditional("DEBUG")]
		public static void WriteLineIf(bool condition, string? message)
		{
			if (condition)
			{
				WriteLine(message);
			}
		}

		[Conditional("DEBUG")]
		public static void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("condition")] ref WriteIfInterpolatedStringHandler message)
		{
			WriteLineIf(condition, message.ToStringAndClear());
		}

		[Conditional("DEBUG")]
		public static void WriteLineIf(bool condition, string? message, string? category)
		{
			if (condition)
			{
				WriteLine(message, category);
			}
		}

		[Conditional("DEBUG")]
		public static void WriteLineIf(bool condition, [InterpolatedStringHandlerArgument("condition")] ref WriteIfInterpolatedStringHandler message, string? category)
		{
			WriteLineIf(condition, message.ToStringAndClear(), category);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module, AllowMultiple = false)]
	public sealed class DebuggableAttribute : Attribute
	{
		[Flags]
		public enum DebuggingModes
		{
			None = 0,
			Default = 1,
			DisableOptimizations = 0x100,
			IgnoreSymbolStoreSequencePoints = 2,
			EnableEditAndContinue = 4
		}

		public bool IsJITTrackingEnabled => (DebuggingFlags & DebuggingModes.Default) != 0;

		public bool IsJITOptimizerDisabled => (DebuggingFlags & DebuggingModes.DisableOptimizations) != 0;

		public DebuggingModes DebuggingFlags { get; }

		public DebuggableAttribute(bool isJITTrackingEnabled, bool isJITOptimizerDisabled)
		{
			DebuggingFlags = DebuggingModes.None;
			if (isJITTrackingEnabled)
			{
				DebuggingFlags |= DebuggingModes.Default;
			}
			if (isJITOptimizerDisabled)
			{
				DebuggingFlags |= DebuggingModes.DisableOptimizations;
			}
		}

		public DebuggableAttribute(DebuggingModes modes)
		{
			DebuggingFlags = modes;
		}
	}
	public enum DebuggerBrowsableState
	{
		Never = 0,
		Collapsed = 2,
		RootHidden = 3
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	public sealed class DebuggerBrowsableAttribute : Attribute
	{
		public DebuggerBrowsableState State { get; }

		public DebuggerBrowsableAttribute(DebuggerBrowsableState state)
		{
			if (state < DebuggerBrowsableState.Never || state > DebuggerBrowsableState.RootHidden)
			{
				throw new ArgumentOutOfRangeException("state");
			}
			State = state;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Delegate, AllowMultiple = true)]
	public sealed class DebuggerDisplayAttribute : Attribute
	{
		private Type _target;

		public string Value { get; }

		public string? Name { get; set; }

		public string? Type { get; set; }

		public Type? Target
		{
			get
			{
				return _target;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				TargetTypeName = value.AssemblyQualifiedName;
				_target = value;
			}
		}

		public string? TargetTypeName { get; set; }

		public DebuggerDisplayAttribute(string? value)
		{
			Value = value ?? "";
			Name = "";
			Type = "";
		}
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, Inherited = false)]
	public sealed class DebuggerHiddenAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, Inherited = false)]
	public sealed class DebuggerNonUserCodeAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	public sealed class DebuggerStepperBoundaryAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	public sealed class DebuggerStepThroughAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true)]
	public sealed class DebuggerTypeProxyAttribute : Attribute
	{
		private Type _target;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public string ProxyTypeName { get; }

		public Type? Target
		{
			get
			{
				return _target;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				TargetTypeName = value.AssemblyQualifiedName;
				_target = value;
			}
		}

		public string? TargetTypeName { get; set; }

		public DebuggerTypeProxyAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			ProxyTypeName = type.AssemblyQualifiedName;
		}

		public DebuggerTypeProxyAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] string typeName)
		{
			ProxyTypeName = typeName;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = true)]
	public sealed class DebuggerVisualizerAttribute : Attribute
	{
		private Type _target;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public string? VisualizerObjectSourceTypeName { get; }

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
		public string VisualizerTypeName { get; }

		public string? Description { get; set; }

		public Type? Target
		{
			get
			{
				return _target;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				TargetTypeName = value.AssemblyQualifiedName;
				_target = value;
			}
		}

		public string? TargetTypeName { get; set; }

		public DebuggerVisualizerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] string visualizerTypeName)
		{
			VisualizerTypeName = visualizerTypeName;
		}

		public DebuggerVisualizerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] string visualizerTypeName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] string? visualizerObjectSourceTypeName)
		{
			VisualizerTypeName = visualizerTypeName;
			VisualizerObjectSourceTypeName = visualizerObjectSourceTypeName;
		}

		public DebuggerVisualizerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] string visualizerTypeName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type visualizerObjectSource)
		{
			if (visualizerObjectSource == null)
			{
				throw new ArgumentNullException("visualizerObjectSource");
			}
			VisualizerTypeName = visualizerTypeName;
			VisualizerObjectSourceTypeName = visualizerObjectSource.AssemblyQualifiedName;
		}

		public DebuggerVisualizerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type visualizer)
		{
			if (visualizer == null)
			{
				throw new ArgumentNullException("visualizer");
			}
			VisualizerTypeName = visualizer.AssemblyQualifiedName;
		}

		public DebuggerVisualizerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type visualizer, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type visualizerObjectSource)
		{
			if (visualizer == null)
			{
				throw new ArgumentNullException("visualizer");
			}
			if (visualizerObjectSource == null)
			{
				throw new ArgumentNullException("visualizerObjectSource");
			}
			VisualizerTypeName = visualizer.AssemblyQualifiedName;
			VisualizerObjectSourceTypeName = visualizerObjectSource.AssemblyQualifiedName;
		}

		public DebuggerVisualizerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type visualizer, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] string? visualizerObjectSourceTypeName)
		{
			if (visualizer == null)
			{
				throw new ArgumentNullException("visualizer");
			}
			VisualizerTypeName = visualizer.AssemblyQualifiedName;
			VisualizerObjectSourceTypeName = visualizerObjectSourceTypeName;
		}
	}
	public class DebugProvider
	{
		private sealed class DebugAssertException : Exception
		{
			internal DebugAssertException(string message, string detailMessage, string stackTrace)
				: base(Terminate(message) + Terminate(detailMessage) + stackTrace)
			{
			}

			private static string Terminate(string s)
			{
				if (s == null)
				{
					return s;
				}
				s = s.Trim();
				if (s.Length > 0)
				{
					s += "\r\n";
				}
				return s;
			}
		}

		private static readonly object s_lock = new object();

		private bool _needIndent = true;

		private string _indentString;

		internal static Action<string, string, string, string> s_FailCore;

		internal static Action<string> s_WriteCore;

		private static readonly object s_ForLock = new object();

		[DoesNotReturn]
		public virtual void Fail(string? message, string? detailMessage)
		{
			string stackTrace;
			try
			{
				stackTrace = new StackTrace(0, fNeedFileInfo: true).ToString(StackTrace.TraceFormat.Normal);
			}
			catch
			{
				stackTrace = "";
			}
			WriteAssert(stackTrace, message, detailMessage);
			FailCore(stackTrace, message, detailMessage, "Assertion failed.");
		}

		internal void WriteAssert(string stackTrace, string message, string detailMessage)
		{
			WriteLine(SR.DebugAssertBanner + "\r\n" + SR.DebugAssertShortMessage + "\r\n" + message + "\r\n" + SR.DebugAssertLongMessage + "\r\n" + detailMessage + "\r\n" + stackTrace);
		}

		public virtual void Write(string? message)
		{
			lock (s_lock)
			{
				if (message == null)
				{
					WriteCore(string.Empty);
					return;
				}
				if (_needIndent)
				{
					message = GetIndentString() + message;
					_needIndent = false;
				}
				WriteCore(message);
				if (message.EndsWith("\r\n", StringComparison.Ordinal))
				{
					_needIndent = true;
				}
			}
		}

		public virtual void WriteLine(string? message)
		{
			Write(message + "\r\n");
		}

		public virtual void OnIndentLevelChanged(int indentLevel)
		{
		}

		public virtual void OnIndentSizeChanged(int indentSize)
		{
		}

		private string GetIndentString()
		{
			int num = Debug.IndentSize * Debug.IndentLevel;
			string indentString = _indentString;
			if (indentString != null && indentString.Length == num)
			{
				return _indentString;
			}
			return _indentString = new string(' ', num);
		}

		public static void FailCore(string stackTrace, string? message, string? detailMessage, string errorSource)
		{
			if (s_FailCore != null)
			{
				s_FailCore(stackTrace, message, detailMessage, errorSource);
				return;
			}
			if (Debugger.IsAttached)
			{
				Debugger.Break();
				return;
			}
			DebugAssertException ex = new DebugAssertException(message, detailMessage, stackTrace);
			Environment.FailFast(ex.Message, ex, errorSource);
		}

		public static void WriteCore(string message)
		{
			if (s_WriteCore != null)
			{
				s_WriteCore(message);
				return;
			}
			lock (s_ForLock)
			{
				if (message.Length <= 4091)
				{
					WriteToDebugger(message);
					return;
				}
				int i;
				for (i = 0; i < message.Length - 4091; i += 4091)
				{
					WriteToDebugger(message.Substring(i, 4091));
				}
				WriteToDebugger(message.Substring(i));
			}
		}

		private static void WriteToDebugger(string message)
		{
			if (Debugger.IsLogging())
			{
				Debugger.Log(0, null, message);
			}
			else
			{
				Interop.Kernel32.OutputDebugString(message ?? string.Empty);
			}
		}
	}
	public static class StackFrameExtensions
	{
		public static bool HasNativeImage(this StackFrame stackFrame)
		{
			return stackFrame.GetNativeImageBase() != IntPtr.Zero;
		}

		public static bool HasMethod(this StackFrame stackFrame)
		{
			return stackFrame.GetMethod() != null;
		}

		public static bool HasILOffset(this StackFrame stackFrame)
		{
			return stackFrame.GetILOffset() != -1;
		}

		public static bool HasSource(this StackFrame stackFrame)
		{
			return stackFrame.GetFileName() != null;
		}

		public static IntPtr GetNativeIP(this StackFrame stackFrame)
		{
			return IntPtr.Zero;
		}

		public static IntPtr GetNativeImageBase(this StackFrame stackFrame)
		{
			return IntPtr.Zero;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	public sealed class StackTraceHiddenAttribute : Attribute
	{
	}
	public class Stopwatch
	{
		private long _elapsed;

		private long _startTimeStamp;

		private bool _isRunning;

		public static readonly long Frequency = QueryPerformanceFrequency();

		public static readonly bool IsHighResolution = true;

		private static readonly double s_tickFrequency = 10000000.0 / (double)Frequency;

		public bool IsRunning => _isRunning;

		public TimeSpan Elapsed => new TimeSpan(GetElapsedDateTimeTicks());

		public long ElapsedMilliseconds => GetElapsedDateTimeTicks() / 10000;

		public long ElapsedTicks => GetRawElapsedTicks();

		public Stopwatch()
		{
			Reset();
		}

		public void Start()
		{
			if (!_isRunning)
			{
				_startTimeStamp = GetTimestamp();
				_isRunning = true;
			}
		}

		public static Stopwatch StartNew()
		{
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			return stopwatch;
		}

		public void Stop()
		{
			if (_isRunning)
			{
				long timestamp = GetTimestamp();
				long num = timestamp - _startTimeStamp;
				_elapsed += num;
				_isRunning = false;
				if (_elapsed < 0)
				{
					_elapsed = 0L;
				}
			}
		}

		public void Reset()
		{
			_elapsed = 0L;
			_isRunning = false;
			_startTimeStamp = 0L;
		}

		public void Restart()
		{
			_elapsed = 0L;
			_startTimeStamp = GetTimestamp();
			_isRunning = true;
		}

		public static long GetTimestamp()
		{
			return QueryPerformanceCounter();
		}

		private long GetRawElapsedTicks()
		{
			long num = _elapsed;
			if (_isRunning)
			{
				long timestamp = GetTimestamp();
				long num2 = timestamp - _startTimeStamp;
				num += num2;
			}
			return num;
		}

		private long GetElapsedDateTimeTicks()
		{
			return (long)((double)GetRawElapsedTicks() * s_tickFrequency);
		}

		private unsafe static long QueryPerformanceFrequency()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out long result);
			Interop.BOOL bOOL = Interop.Kernel32.QueryPerformanceFrequency(&result);
			return result;
		}

		private unsafe static long QueryPerformanceCounter()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out long result);
			Interop.BOOL bOOL = Interop.Kernel32.QueryPerformanceCounter(&result);
			return result;
		}
	}
}
namespace System.Diagnostics.Contracts
{
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class ContractException : Exception
	{
		private readonly ContractFailureKind _kind;

		private readonly string _userMessage;

		private readonly string _condition;

		public ContractFailureKind Kind => _kind;

		public string Failure => Message;

		public string? UserMessage => _userMessage;

		public string? Condition => _condition;

		private ContractException()
		{
			base.HResult = -2146233022;
		}

		public ContractException(ContractFailureKind kind, string? failure, string? userMessage, string? condition, Exception? innerException)
			: base(failure, innerException)
		{
			base.HResult = -2146233022;
			_kind = kind;
			_userMessage = userMessage;
			_condition = condition;
		}

		private ContractException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
			_kind = (ContractFailureKind)info.GetInt32("Kind");
			_userMessage = info.GetString("UserMessage");
			_condition = info.GetString("Condition");
		}

		public override void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			base.GetObjectData(info, context);
			info.AddValue("Kind", _kind);
			info.AddValue("UserMessage", _userMessage);
			info.AddValue("Condition", _condition);
		}
	}
	public sealed class ContractFailedEventArgs : EventArgs
	{
		private readonly ContractFailureKind _failureKind;

		private readonly string _message;

		private readonly string _condition;

		private readonly Exception _originalException;

		private bool _handled;

		private bool _unwind;

		internal Exception thrownDuringHandler;

		public string? Message => _message;

		public string? Condition => _condition;

		public ContractFailureKind FailureKind => _failureKind;

		public Exception? OriginalException => _originalException;

		public bool Handled => _handled;

		public bool Unwind => _unwind;

		public ContractFailedEventArgs(ContractFailureKind failureKind, string? message, string? condition, Exception? originalException)
		{
			_failureKind = failureKind;
			_message = message;
			_condition = condition;
			_originalException = originalException;
		}

		public void SetHandled()
		{
			_handled = true;
		}

		public void SetUnwind()
		{
			_unwind = true;
		}
	}
	[Conditional("CONTRACTS_FULL")]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.Delegate, AllowMultiple = false, Inherited = true)]
	public sealed class PureAttribute : Attribute
	{
	}
	[Conditional("CONTRACTS_FULL")]
	[Conditional("DEBUG")]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	public sealed class ContractClassAttribute : Attribute
	{
		private readonly Type _typeWithContracts;

		public Type TypeContainingContracts => _typeWithContracts;

		public ContractClassAttribute(Type typeContainingContracts)
		{
			_typeWithContracts = typeContainingContracts;
		}
	}
	[Conditional("CONTRACTS_FULL")]
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public sealed class ContractClassForAttribute : Attribute
	{
		private readonly Type _typeIAmAContractFor;

		public Type TypeContractsAreFor => _typeIAmAContractFor;

		public ContractClassForAttribute(Type typeContractsAreFor)
		{
			_typeIAmAContractFor = typeContractsAreFor;
		}
	}
	[Conditional("CONTRACTS_FULL")]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public sealed class ContractInvariantMethodAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly)]
	public sealed class ContractReferenceAssemblyAttribute : Attribute
	{
	}
	[Conditional("CONTRACTS_FULL")]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
	public sealed class ContractRuntimeIgnoredAttribute : Attribute
	{
	}
	[Conditional("CONTRACTS_FULL")]
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property)]
	public sealed class ContractVerificationAttribute : Attribute
	{
		private readonly bool _value;

		public bool Value => _value;

		public ContractVerificationAttribute(bool value)
		{
			_value = value;
		}
	}
	[Conditional("CONTRACTS_FULL")]
	[AttributeUsage(AttributeTargets.Field)]
	public sealed class ContractPublicPropertyNameAttribute : Attribute
	{
		private readonly string _publicName;

		public string Name => _publicName;

		public ContractPublicPropertyNameAttribute(string name)
		{
			_publicName = name;
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	[Conditional("CONTRACTS_FULL")]
	public sealed class ContractArgumentValidatorAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	[Conditional("CONTRACTS_FULL")]
	public sealed class ContractAbbreviatorAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[Conditional("CONTRACTS_FULL")]
	public sealed class ContractOptionAttribute : Attribute
	{
		private readonly string _category;

		private readonly string _setting;

		private readonly bool _enabled;

		private readonly string _value;

		public string Category => _category;

		public string Setting => _setting;

		public bool Enabled => _enabled;

		public string? Value => _value;

		public ContractOptionAttribute(string category, string setting, bool enabled)
		{
			_category = category;
			_setting = setting;
			_enabled = enabled;
		}

		public ContractOptionAttribute(string category, string setting, string value)
		{
			_category = category;
			_setting = setting;
			_value = value;
		}
	}
	public static class Contract
	{
		public static event EventHandler<ContractFailedEventArgs>? ContractFailed
		{
			add
			{
				ContractHelper.InternalContractFailed += value;
			}
			remove
			{
				ContractHelper.InternalContractFailed -= value;
			}
		}

		[Conditional("DEBUG")]
		[Conditional("CONTRACTS_FULL")]
		public static void Assume([DoesNotReturnIf(false)] bool condition)
		{
			if (!condition)
			{
				ReportFailure(ContractFailureKind.Assume, null, null, null);
			}
		}

		[Conditional("DEBUG")]
		[Conditional("CONTRACTS_FULL")]
		public static void Assume([DoesNotReturnIf(false)] bool condition, string? userMessage)
		{
			if (!condition)
			{
				ReportFailure(ContractFailureKind.Assume, userMessage, null, null);
			}
		}

		[Conditional("DEBUG")]
		[Conditional("CONTRACTS_FULL")]
		public static void Assert([DoesNotReturnIf(false)] bool condition)
		{
			if (!condition)
			{
				ReportFailure(ContractFailureKind.Assert, null, null, null);
			}
		}

		[Conditional("DEBUG")]
		[Conditional("CONTRACTS_FULL")]
		public static void Assert([DoesNotReturnIf(false)] bool condition, string? userMessage)
		{
			if (!condition)
			{
				ReportFailure(ContractFailureKind.Assert, userMessage, null, null);
			}
		}

		[Conditional("CONTRACTS_FULL")]
		public static void Requires(bool condition)
		{
			AssertMustUseRewriter(ContractFailureKind.Precondition, "Requires");
		}

		[Conditional("CONTRACTS_FULL")]
		public static void Requires(bool condition, string? userMessage)
		{
			AssertMustUseRewriter(ContractFailureKind.Precondition, "Requires");
		}

		public static void Requires<TException>(bool condition) where TException : Exception
		{
			AssertMustUseRewriter(ContractFailureKind.Precondition, "Requires<TException>");
		}

		public static void Requires<TException>(bool condition, string? userMessage) where TException : Exception
		{
			AssertMustUseRewriter(ContractFailureKind.Precondition, "Requires<TException>");
		}

		[Conditional("CONTRACTS_FULL")]
		public static void Ensures(bool condition)
		{
			AssertMustUseRewriter(ContractFailureKind.Postcondition, "Ensures");
		}

		[Conditional("CONTRACTS_FULL")]
		public static void Ensures(bool condition, string? userMessage)
		{
			AssertMustUseRewriter(ContractFailureKind.Postcondition, "Ensures");
		}

		[Conditional("CONTRACTS_FULL")]
		public static void EnsuresOnThrow<TException>(bool condition) where TException : Exception
		{
			AssertMustUseRewriter(ContractFailureKind.PostconditionOnException, "EnsuresOnThrow");
		}

		[Conditional("CONTRACTS_FULL")]
		public static void EnsuresOnThrow<TException>(bool condition, string? userMessage) where TException : Exception
		{
			AssertMustUseRewriter(ContractFailureKind.PostconditionOnException, "EnsuresOnThrow");
		}

		public static T Result<T>()
		{
			return default(T);
		}

		public static T ValueAtReturn<T>(out T value)
		{
			value = default(T);
			return value;
		}

		public static T OldValue<T>(T value)
		{
			return default(T);
		}

		[Conditional("CONTRACTS_FULL")]
		public static void Invariant(bool condition)
		{
			AssertMustUseRewriter(ContractFailureKind.Invariant, "Invariant");
		}

		[Conditional("CONTRACTS_FULL")]
		public static void Invariant(bool condition, string? userMessage)
		{
			AssertMustUseRewriter(ContractFailureKind.Invariant, "Invariant");
		}

		public static bool ForAll(int fromInclusive, int toExclusive, Predicate<int> predicate)
		{
			if (fromInclusive > toExclusive)
			{
				throw new ArgumentException(SR.Argument_ToExclusiveLessThanFromExclusive);
			}
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			for (int i = fromInclusive; i < toExclusive; i++)
			{
				if (!predicate(i))
				{
					return false;
				}
			}
			return true;
		}

		public static bool ForAll<T>(IEnumerable<T> collection, Predicate<T> predicate)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			foreach (T item in collection)
			{
				if (!predicate(item))
				{
					return false;
				}
			}
			return true;
		}

		public static bool Exists(int fromInclusive, int toExclusive, Predicate<int> predicate)
		{
			if (fromInclusive > toExclusive)
			{
				throw new ArgumentException(SR.Argument_ToExclusiveLessThanFromExclusive);
			}
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			for (int i = fromInclusive; i < toExclusive; i++)
			{
				if (predicate(i))
				{
					return true;
				}
			}
			return false;
		}

		public static bool Exists<T>(IEnumerable<T> collection, Predicate<T> predicate)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			if (predicate == null)
			{
				throw new ArgumentNullException("predicate");
			}
			foreach (T item in collection)
			{
				if (predicate(item))
				{
					return true;
				}
			}
			return false;
		}

		[Conditional("CONTRACTS_FULL")]
		public static void EndContractBlock()
		{
		}

		private static void AssertMustUseRewriter(ContractFailureKind kind, string contractKind)
		{
			Assembly assembly = typeof(Contract).Assembly;
			StackTrace stackTrace = new StackTrace();
			Assembly assembly2 = null;
			for (int i = 0; i < stackTrace.FrameCount; i++)
			{
				Assembly assembly3 = stackTrace.GetFrame(i).GetMethod()?.DeclaringType?.Assembly;
				if (assembly3 != null && assembly3 != assembly)
				{
					assembly2 = assembly3;
					break;
				}
			}
			if ((object)assembly2 == null)
			{
				assembly2 = assembly;
			}
			string name = assembly2.GetName().Name;
			ContractHelper.TriggerFailure(kind, SR.Format(SR.MustUseCCRewrite, contractKind, name), null, null, null);
		}

		[DebuggerNonUserCode]
		private static void ReportFailure(ContractFailureKind failureKind, string userMessage, string conditionText, Exception innerException)
		{
			if (failureKind < ContractFailureKind.Precondition || failureKind > ContractFailureKind.Assume)
			{
				throw new ArgumentException(SR.Format(SR.Arg_EnumIllegalVal, failureKind), "failureKind");
			}
			string text = ContractHelper.RaiseContractFailedEvent(failureKind, userMessage, conditionText, innerException);
			if (text != null)
			{
				ContractHelper.TriggerFailure(failureKind, text, userMessage, conditionText, innerException);
			}
		}
	}
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public enum ContractFailureKind
	{
		Precondition,
		Postcondition,
		PostconditionOnException,
		Invariant,
		Assert,
		Assume
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event, Inherited = false, AllowMultiple = false)]
	public sealed class RequiresAssemblyFilesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresAssemblyFilesAttribute()
		{
		}

		public RequiresAssemblyFilesAttribute(string message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	public sealed class RequiresUnreferencedCodeAttribute : Attribute
	{
		public string Message { get; }

		public string? Url { get; set; }

		public RequiresUnreferencedCodeAttribute(string message)
		{
			Message = message;
		}
	}
	[Flags]
	public enum DynamicallyAccessedMemberTypes
	{
		None = 0,
		PublicParameterlessConstructor = 1,
		PublicConstructors = 3,
		NonPublicConstructors = 4,
		PublicMethods = 8,
		NonPublicMethods = 0x10,
		PublicFields = 0x20,
		NonPublicFields = 0x40,
		PublicNestedTypes = 0x80,
		NonPublicNestedTypes = 0x100,
		PublicProperties = 0x200,
		NonPublicProperties = 0x400,
		PublicEvents = 0x800,
		NonPublicEvents = 0x1000,
		Interfaces = 0x2000,
		All = -1
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, Inherited = false)]
	public sealed class DynamicallyAccessedMembersAttribute : Attribute
	{
		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
		{
			MemberTypes = memberTypes;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	public sealed class DynamicDependencyAttribute : Attribute
	{
		public string? MemberSignature { get; }

		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public Type? Type { get; }

		public string? TypeName { get; }

		public string? AssemblyName { get; }

		public string? Condition { get; set; }

		public DynamicDependencyAttribute(string memberSignature)
		{
			MemberSignature = memberSignature;
		}

		public DynamicDependencyAttribute(string memberSignature, Type type)
		{
			MemberSignature = memberSignature;
			Type = type;
		}

		public DynamicDependencyAttribute(string memberSignature, string typeName, string assemblyName)
		{
			MemberSignature = memberSignature;
			TypeName = typeName;
			AssemblyName = assemblyName;
		}

		public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes memberTypes, Type type)
		{
			MemberTypes = memberTypes;
			Type = type;
		}

		public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes memberTypes, string typeName, string assemblyName)
		{
			MemberTypes = memberTypes;
			TypeName = typeName;
			AssemblyName = assemblyName;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	public sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	public sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	public sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	public sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	public sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	public sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	public sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	public sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	public sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
	public sealed class UnconditionalSuppressMessageAttribute : Attribute
	{
		public string Category { get; }

		public string CheckId { get; }

		public string? Scope { get; set; }

		public string? Target { get; set; }

		public string? MessageId { get; set; }

		public string? Justification { get; set; }

		public UnconditionalSuppressMessageAttribute(string category, string checkId)
		{
			Category = category;
			CheckId = checkId;
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
	[Conditional("CODE_ANALYSIS")]
	public sealed class SuppressMessageAttribute : Attribute
	{
		public string Category { get; }

		public string CheckId { get; }

		public string? Scope { get; set; }

		public string? Target { get; set; }

		public string? MessageId { get; set; }

		public string? Justification { get; set; }

		public SuppressMessageAttribute(string category, string checkId)
		{
			Category = category;
			CheckId = checkId;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event, Inherited = false, AllowMultiple = false)]
	public sealed class ExcludeFromCodeCoverageAttribute : Attribute
	{
		public string? Justification { get; set; }
	}
}
namespace System.Diagnostics.SymbolStore
{
	public interface ISymbolDocumentWriter
	{
		void SetCheckSum(Guid algorithmId, byte[] checkSum);

		void SetSource(byte[] source);
	}
}
namespace System.Diagnostics.Tracing
{
	internal static class EventPipeInternal
	{
		private struct EventPipeProviderConfigurationNative
		{
			private unsafe char* m_pProviderName;

			private ulong m_keywords;

			private uint m_loggingLevel;

			private unsafe char* m_pFilterData;

			internal unsafe static void MarshalToNative(EventPipeProviderConfiguration managed, ref EventPipeProviderConfigurationNative native)
			{
				native.m_pProviderName = (char*)(void*)Marshal.StringToCoTaskMemUni(managed.ProviderName);
				native.m_keywords = managed.Keywords;
				native.m_loggingLevel = managed.LoggingLevel;
				native.m_pFilterData = (char*)(void*)Marshal.StringToCoTaskMemUni(managed.FilterData);
			}

			internal unsafe void Release()
			{
				if (m_pProviderName != null)
				{
					Marshal.FreeCoTaskMem((IntPtr)m_pProviderName);
				}
				if (m_pFilterData != null)
				{
					Marshal.FreeCoTaskMem((IntPtr)m_pFilterData);
				}
			}
		}

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		private unsafe static extern ulong Enable(char* outputFile, EventPipeSerializationFormat format, uint circularBufferSizeInMB, EventPipeProviderConfigurationNative* providers, uint numProviders);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void Disable(ulong sessionID);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern IntPtr CreateProvider(string providerName, Interop.Advapi32.EtwEnableCallback callbackFunc);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal unsafe static extern IntPtr DefineEvent(IntPtr provHandle, uint eventID, long keywords, uint eventVersion, uint level, void* pMetadata, uint metadataLength);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern IntPtr GetProvider(string providerName);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern void DeleteProvider(IntPtr provHandle);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern int EventActivityIdControl(uint controlCode, ref Guid activityId);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal unsafe static extern void WriteEventData(IntPtr eventHandle, EventProvider.EventData* pEventData, uint dataCount, Guid* activityId, Guid* relatedActivityId);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal unsafe static extern bool GetSessionInfo(ulong sessionID, EventPipeSessionInfo* pSessionInfo);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal unsafe static extern bool GetNextEvent(ulong sessionID, EventPipeEventInstanceData* pInstance);

		[DllImport("QCall", CharSet = CharSet.Unicode)]
		internal static extern IntPtr GetWaitHandle(ulong sessionID);

		internal unsafe static ulong Enable(string outputFile, EventPipeSerializationFormat format, uint circularBufferSizeInMB, EventPipeProviderConfiguration[] providers)
		{
			Span<EventPipeProviderConfigurationNative> span = new Span<EventPipeProviderConfigurationNative>((void*)Marshal.AllocCoTaskMem(sizeof(EventPipeProviderConfigurationNative) * providers.Length), providers.Length);
			span.Clear();
			try
			{
				for (int i = 0; i < providers.Length; i++)
				{
					EventPipeProviderConfigurationNative.MarshalToNative(providers[i], ref span[i]);
				}
				fixed (char* outputFile2 = outputFile)
				{
					fixed (EventPipeProviderConfigurationNative* providers2 = span)
					{
						return Enable(outputFile2, format, circularBufferSizeInMB, providers2, (uint)span.Length);
					}
				}
			}
			finally
			{
				for (int j = 0; j < providers.Length; j++)
				{
					span[j].Release();
				}
				fixed (EventPipeProviderConfigurationNative* ptr = span)
				{
					Marshal.FreeCoTaskMem((IntPtr)ptr);
				}
			}
		}
	}
	[EventSource(Guid = "E13C0D23-CCBC-4E12-931B-D9CC2EEE27E4", Name = "Microsoft-Windows-DotNETRuntime")]
	internal sealed class NativeRuntimeEventSource : EventSource
	{
		private static class Messages
		{
			public const string WorkerThread = "ActiveWorkerThreadCount={0};\nRetiredWorkerThreadCount={1};\nClrInstanceID={2}";

			public const string WorkerThreadAdjustmentSample = "Throughput={0};\nClrInstanceID={1}";

			public const string WorkerThreadAdjustmentAdjustment = "AverageThroughput={0};\nNewWorkerThreadCount={1};\nReason={2};\nClrInstanceID={3}";

			public const string WorkerThreadAdjustmentStats = "Duration={0};\nThroughput={1};\nThreadWave={2};\nThroughputWave={3};\nThroughputErrorEstimate={4};\nAverageThroughputErrorEstimate={5};\nThroughputRatio={6};\nConfidence={7};\nNewControlSetting={8};\nNewThreadWaveMagnitude={9};\nClrInstanceID={10}";

			public const string IOEnqueue = "NativeOverlapped={0};\nOverlapped={1};\nMultiDequeues={2};\nClrInstanceID={3}";

			public const string IO = "NativeOverlapped={0};\nOverlapped={1};\nClrInstanceID={2}";

			public const string WorkingThreadCount = "Count={0};\nClrInstanceID={1}";
		}

		public static class Tasks
		{
			public const EventTask ThreadPoolWorkerThread = (EventTask)16;

			public const EventTask ThreadPoolWorkerThreadAdjustment = (EventTask)18;

			public const EventTask ThreadPool = (EventTask)23;

			public const EventTask ThreadPoolWorkingThreadCount = (EventTask)22;
		}

		public static class Opcodes
		{
			public const EventOpcode IOEnqueue = (EventOpcode)13;

			public const EventOpcode IODequeue = (EventOpcode)14;

			public const EventOpcode IOPack = (EventOpcode)15;

			public const EventOpcode Wait = (EventOpcode)90;

			public const EventOpcode Sample = (EventOpcode)100;

			public const EventOpcode Adjustment = (EventOpcode)101;

			public const EventOpcode Stats = (EventOpcode)102;
		}

		public enum ThreadAdjustmentReasonMap : uint
		{
			Warmup,
			Initializing,
			RandomMove,
			ClimbingMove,
			ChangePoint,
			Stabilizing,
			Starvation,
			ThreadTimedOut
		}

		public static class Keywords
		{
			public const EventKeywords GCKeyword = (EventKeywords)1L;

			public const EventKeywords GCHandleKeyword = (EventKeywords)2L;

			public const EventKeywords AssemblyLoaderKeyword = (EventKeywords)4L;

			public const EventKeywords LoaderKeyword = (EventKeywords)8L;

			public const EventKeywords JitKeyword = (EventKeywords)16L;

			public const EventKeywords NGenKeyword = (EventKeywords)32L;

			public const EventKeywords StartEnumerationKeyword = (EventKeywords)64L;

			public const EventKeywords EndEnumerationKeyword = (EventKeywords)128L;

			public const EventKeywords SecurityKeyword = (EventKeywords)1024L;

			public const EventKeywords AppDomainResourceManagementKeyword = (EventKeywords)2048L;

			public const EventKeywords JitTracingKeyword = (EventKeywords)4096L;

			public const EventKeywords InteropKeyword = (EventKeywords)8192L;

			public const EventKeywords ContentionKeyword = (EventKeywords)16384L;

			public const EventKeywords ExceptionKeyword = (EventKeywords)32768L;

			public const EventKeywords ThreadingKeyword = (EventKeywords)65536L;

			public const EventKeywords JittedMethodILToNativeMapKeyword = (EventKeywords)131072L;

			public const EventKeywords OverrideAndSuppressNGenEventsKeyword = (EventKeywords)262144L;

			public const EventKeywords TypeKeyword = (EventKeywords)524288L;

			public const EventKeywords GCHeapDumpKeyword = (EventKeywords)1048576L;

			public const EventKeywords GCSampledObjectAllocationHighKeyword = (EventKeywords)2097152L;

			public const EventKeywords GCHeapSurvivalAndMovementKeyword = (EventKeywords)4194304L;

			public const EventKeywords GCHeapCollectKeyword = (EventKeywords)8388608L;

			public const EventKeywords GCHeapAndTypeNamesKeyword = (EventKeywords)16777216L;

			public const EventKeywords GCSampledObjectAllocationLowKeyword = (EventKeywords)33554432L;

			public const EventKeywords PerfTrackKeyword = (EventKeywords)536870912L;

			public const EventKeywords StackKeyword = (EventKeywords)1073741824L;

			public const EventKeywords ThreadTransferKeyword = (EventKeywords)2147483648L;

			public const EventKeywords DebuggerKeyword = (EventKeywords)4294967296L;

			public const EventKeywords MonitoringKeyword = (EventKeywords)8589934592L;

			public const EventKeywords CodeSymbolsKeyword = (EventKeywords)17179869184L;

			public const EventKeywords EventSourceKeyword = (EventKeywords)34359738368L;

			public const EventKeywords CompilationKeyword = (EventKeywords)68719476736L;

			public const EventKeywords CompilationDiagnosticKeyword = (EventKeywords)137438953472L;

			public const EventKeywords MethodDiagnosticKeyword = (EventKeywords)274877906944L;

			public const EventKeywords TypeDiagnosticKeyword = (EventKeywords)549755813888L;

			public const EventKeywords JitInstrumentationDataKeyword = (EventKeywords)1099511627776L;

			public const EventKeywords ProfilerKeyword = (EventKeywords)2199023255552L;
		}

		internal const string EventSourceName = "Microsoft-Windows-DotNETRuntime";

		public static readonly NativeRuntimeEventSource Log = new NativeRuntimeEventSource();

		private const ushort DefaultClrInstanceId = 0;

		private protected override ReadOnlySpan<byte> ProviderMetadata => new byte[34]
		{
			34, 0, 77, 105, 99, 114, 111, 115, 111, 102,
			116, 45, 87, 105, 110, 100, 111, 119, 115, 45,
			68, 111, 116, 78, 69, 84, 82, 117, 110, 116,
			105, 109, 101, 0
		};

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID);

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID);

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount, ushort ClrInstanceID);

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID);

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID);

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolWorkerThreadAdjustmentStats(double Duration, double Throughput, double ThreadPoolWorkerThreadWait, double ThroughputWave, double ThroughputErrorEstimate, double AverageThroughputErrorEstimate, double ThroughputRatio, double Confidence, double NewControlSetting, ushort NewThreadWaveMagnitude, ushort ClrInstanceID);

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolIOEnqueue(IntPtr NativeOverlapped, IntPtr Overlapped, bool MultiDequeues, ushort ClrInstanceID);

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolIODequeue(IntPtr NativeOverlapped, IntPtr Overlapped, ushort ClrInstanceID);

		[DllImport("QCall")]
		[NonEvent]
		internal static extern void LogThreadPoolWorkingThreadCount(uint Count, ushort ClrInstanceID);

		private NativeRuntimeEventSource(int _)
		{
		}

		[NonEvent]
		internal unsafe void ProcessEvent(uint eventID, uint osThreadID, DateTime timeStamp, Guid activityId, Guid childActivityId, ReadOnlySpan<byte> payload)
		{
			if (System.Diagnostics.Tracing.EventSource.IsSupported && eventID < m_eventData.Length)
			{
				object[] list = EventPipePayloadDecoder.DecodePayload(ref m_eventData[eventID], payload);
				EventWrittenEventArgs eventCallbackArgs = new EventWrittenEventArgs(this, (int)eventID, &activityId, &childActivityId)
				{
					OSThreadId = (int)osThreadID,
					TimeStamp = timeStamp,
					Payload = new ReadOnlyCollection<object>(list)
				};
				DispatchToAllListeners(eventCallbackArgs);
			}
		}

		[Event(50, Level = EventLevel.Informational, Message = "ActiveWorkerThreadCount={0};\nRetiredWorkerThreadCount={1};\nClrInstanceID={2}", Task = (EventTask)16, Opcode = EventOpcode.Start, Version = 0, Keywords = (EventKeywords)65536L)]
		public void ThreadPoolWorkerThreadStart(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount = 0u, ushort ClrInstanceID = 0)
		{
			if (IsEnabled(EventLevel.Informational, (EventKeywords)65536L))
			{
				LogThreadPoolWorkerThreadStart(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID);
			}
		}

		[Event(51, Level = EventLevel.Informational, Message = "ActiveWorkerThreadCount={0};\nRetiredWorkerThreadCount={1};\nClrInstanceID={2}", Task = (EventTask)16, Opcode = EventOpcode.Stop, Version = 0, Keywords = (EventKeywords)65536L)]
		public void ThreadPoolWorkerThreadStop(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount = 0u, ushort ClrInstanceID = 0)
		{
			if (IsEnabled(EventLevel.Informational, (EventKeywords)65536L))
			{
				LogThreadPoolWorkerThreadStop(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[Event(57, Level = EventLevel.Informational, Message = "ActiveWorkerThreadCount={0};\nRetiredWorkerThreadCount={1};\nClrInstanceID={2}", Task = (EventTask)16, Opcode = (EventOpcode)90, Version = 0, Keywords = (EventKeywords)65536L)]
		public void ThreadPoolWorkerThreadWait(uint ActiveWorkerThreadCount, uint RetiredWorkerThreadCount = 0u, ushort ClrInstanceID = 0)
		{
			if (IsEnabled(EventLevel.Informational, (EventKeywords)65536L))
			{
				LogThreadPoolWorkerThreadWait(ActiveWorkerThreadCount, RetiredWorkerThreadCount, ClrInstanceID);
			}
		}

		[Event(54, Level = EventLevel.Informational, Message = "Throughput={0};\nClrInstanceID={1}", Task = (EventTask)18, Opcode = (EventOpcode)100, Version = 0, Keywords = (EventKeywords)65536L)]
		public void ThreadPoolWorkerThreadAdjustmentSample(double Throughput, ushort ClrInstanceID = 0)
		{
			if (IsEnabled(EventLevel.Informational, (EventKeywords)65536L))
			{
				LogThreadPoolWorkerThreadAdjustmentSample(Throughput, ClrInstanceID);
			}
		}

		[Event(55, Level = EventLevel.Informational, Message = "AverageThroughput={0};\nNewWorkerThreadCount={1};\nReason={2};\nClrInstanceID={3}", Task = (EventTask)18, Opcode = (EventOpcode)101, Version = 0, Keywords = (EventKeywords)65536L)]
		public void ThreadPoolWorkerThreadAdjustmentAdjustment(double AverageThroughput, uint NewWorkerThreadCount, ThreadAdjustmentReasonMap Reason, ushort ClrInstanceID = 0)
		{
			if (IsEnabled(EventLevel.Informational, (EventKeywords)65536L))
			{
				LogThreadPoolWorkerThreadAdjustmentAdjustment(AverageThroughput, NewWorkerThreadCount, Reason, ClrInstanceID);
			}
		}

		[Event(56, Level = EventLevel.Verbose, Message = "Duration={0};\nThroughput={1};\nThreadWave={2};\nThroughputWave={3};\nThroughputErrorEstimate={4};\nAverageThroughputErrorEstimate={5};\nThroughputRatio={6};\nConfidence={7};\nNewControlSetting={8};\nNewThreadWaveMagnitude={9};\nClrInstanceID={10}", Task = (EventTask)18, Opcode = (EventOpcode)102, Version = 0, Keywords = (EventKeywords)65536L)]
		public void ThreadPoolWorkerThreadAdjustmentStats(double Duration, double Throughput, double ThreadWave, double ThroughputWave, double ThroughputErrorEstimate, double AverageThroughputErrorEstimate, double ThroughputRatio, double Confidence, double NewControlSetting, ushort NewThreadWaveMagnitude, ushort ClrInstanceID = 0)
		{
			if (IsEnabled(EventLevel.Verbose, (EventKeywords)65536L))
			{
				LogThreadPoolWorkerThreadAdjustmentStats(Duration, Throughput, ThreadWave, ThroughputWave, ThroughputErrorEstimate, AverageThroughputErrorEstimate, ThroughputRatio, Confidence, NewControlSetting, NewThreadWaveMagnitude, ClrInstanceID);
			}
		}

		[Event(63, Level = EventLevel.Verbose, Message = "NativeOverlapped={0};\nOverlapped={1};\nMultiDequeues={2};\nClrInstanceID={3}", Task = (EventTask)23, Opcode = (EventOpcode)13, Version = 0, Keywords = (EventKeywords)2147549184L)]
		private void ThreadPoolIOEnqueue(IntPtr NativeOverlapped, IntPtr Overlapped, bool MultiDequeues, ushort ClrInstanceID = 0)
		{
			int num = Convert.ToInt32(MultiDequeues);
			LogThreadPoolIOEnqueue(NativeOverlapped, Overlapped, MultiDequeues, ClrInstanceID);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[NonEvent]
		public void ThreadPoolIOEnqueue(RegisteredWaitHandle registeredWaitHandle)
		{
			if (IsEnabled(EventLevel.Verbose, (EventKeywords)2147549184L))
			{
				ThreadPoolIOEnqueue((IntPtr)registeredWaitHandle.GetHashCode(), IntPtr.Zero, registeredWaitHandle.Repeating, 0);
			}
		}

		[Event(64, Level = EventLevel.Verbose, Message = "NativeOverlapped={0};\nOverlapped={1};\nClrInstanceID={2}", Task = (EventTask)23, Opcode = (EventOpcode)14, Version = 0, Keywords = (EventKeywords)2147549184L)]
		private void ThreadPoolIODequeue(IntPtr NativeOverlapped, IntPtr Overlapped, ushort ClrInstanceID = 0)
		{
			LogThreadPoolIODequeue(NativeOverlapped, Overlapped, ClrInstanceID);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[NonEvent]
		public void ThreadPoolIODequeue(RegisteredWaitHandle registeredWaitHandle)
		{
			if (IsEnabled(EventLevel.Verbose, (EventKeywords)2147549184L))
			{
				ThreadPoolIODequeue((IntPtr)registeredWaitHandle.GetHashCode(), IntPtr.Zero, 0);
			}
		}

		[Event(60, Level = EventLevel.Verbose, Message = "Count={0};\nClrInstanceID={1}", Task = (EventTask)22, Opcode = EventOpcode.Start, Version = 0, Keywords = (EventKeywords)65536L)]
		public void ThreadPoolWorkingThreadCount(uint Count, ushort ClrInstanceID = 0)
		{
			if (IsEnabled(EventLevel.Verbose, (EventKeywords)65536L))
			{
				LogThreadPoolWorkingThreadCount(Count, ClrInstanceID);
			}
		}

		[Event(65, Level = EventLevel.Verbose, Message = "NativeOverlapped={0};\nOverlapped={1};\nClrInstanceID={2}", Task = (EventTask)23, Opcode = (EventOpcode)15, Version = 0, Keywords = (EventKeywords)65536L)]
		private void ThreadPoolIOPack(IntPtr NativeOverlapped, IntPtr Overlapped, ushort ClrInstanceID = 0)
		{
			throw new NotImplementedException();
		}

		[Event(1, Version = 2, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCStart_V2(uint Count, uint Depth, uint Reason, uint Type, ushort ClrInstanceID, ulong ClientSequenceNumber)
		{
			throw new NotImplementedException();
		}

		[Event(2, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCEnd_V1(uint Count, uint Depth, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(3, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCRestartEEEnd_V1(ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(4, Version = 2, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCHeapStats_V2(ulong GenerationSize0, ulong TotalPromotedSize0, ulong GenerationSize1, ulong TotalPromotedSize1, ulong GenerationSize2, ulong TotalPromotedSize2, ulong GenerationSize3, ulong TotalPromotedSize3, ulong FinalizationPromotedSize, ulong FinalizationPromotedCount, uint PinnedObjectCount, uint SinkBlockCount, uint GCHandleCount, ushort ClrInstanceID, ulong GenerationSize4, ulong TotalPromotedSize4)
		{
			throw new NotImplementedException();
		}

		[Event(5, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCCreateSegment_V1(ulong Address, ulong Size, uint Type, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(6, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCFreeSegment_V1(ulong Address, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(7, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCRestartEEBegin_V1(ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(8, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCSuspendEEEnd_V1(ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(9, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCSuspendEEBegin_V1(uint Reason, uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(10, Version = 4, Level = EventLevel.Verbose, Keywords = (EventKeywords)1L)]
		private void GCAllocationTick_V4(uint AllocationAmount, uint AllocationKind, ushort ClrInstanceID, ulong AllocationAmount64, IntPtr TypeID, string TypeName, uint HeapIndex, IntPtr Address, ulong ObjectSize)
		{
			throw new NotImplementedException();
		}

		[Event(11, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)65537L)]
		private void GCCreateConcurrentThread_V1(ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(12, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)65537L)]
		private void GCTerminateConcurrentThread_V1(ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(13, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCFinalizersEnd_V1(uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(14, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCFinalizersBegin_V1(ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(15, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)524288L)]
		private void BulkType(uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(16, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GCBulkRootEdge(uint Index, uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(17, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GCBulkRootConditionalWeakTableElementEdge(uint Index, uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(18, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GCBulkNode(uint Index, uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(19, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GCBulkEdge(uint Index, uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(20, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)2097152L)]
		private void GCSampledObjectAllocationHigh(IntPtr Address, IntPtr TypeID, uint ObjectCountForTypeSample, ulong TotalSizeForTypeSample, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(21, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4194304L)]
		private void GCBulkSurvivingObjectRanges(uint Index, uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(22, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4194304L)]
		private void GCBulkMovedObjectRanges(uint Index, uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(23, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4194304L)]
		private void GCGenerationRange(byte Generation, IntPtr RangeStart, ulong RangeUsedLength, ulong RangeReservedLength, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(25, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCMarkStackRoots(uint HeapNum, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(26, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCMarkFinalizeQueueRoots(uint HeapNum, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(27, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCMarkHandles(uint HeapNum, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(28, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCMarkOlderGenerationRoots(uint HeapNum, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(29, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)1L)]
		private void FinalizeObject(IntPtr TypeID, IntPtr ObjectID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(30, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)2L)]
		private void SetGCHandle(IntPtr HandleID, IntPtr ObjectID, uint Kind, uint Generation, ulong AppDomainID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(31, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)2L)]
		private void DestroyGCHandle(IntPtr HandleID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(32, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)33554432L)]
		private void GCSampledObjectAllocationLow(IntPtr Address, IntPtr TypeID, uint ObjectCountForTypeSample, ulong TotalSizeForTypeSample, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(33, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)1L)]
		private void PinObjectAtGCTime(IntPtr HandleID, IntPtr ObjectID, ulong ObjectSize, string TypeName, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(35, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCTriggered(uint Reason, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(36, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GCBulkRootCCW(uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(37, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GCBulkRCW(uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(38, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GCBulkRootStaticVar(uint Count, ulong AppDomainID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(39, Version = 0, Level = EventLevel.LogAlways, Keywords = (EventKeywords)66060291L)]
		private void GCDynamicEvent(string Name, uint DataSize)
		{
			throw new NotImplementedException();
		}

		[Event(40, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void WorkerThreadCreate(uint WorkerThreadCount, uint RetiredWorkerThreads)
		{
			throw new NotImplementedException();
		}

		[Event(41, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void WorkerThreadTerminate(uint WorkerThreadCount, uint RetiredWorkerThreads)
		{
			throw new NotImplementedException();
		}

		[Event(42, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void WorkerThreadRetire(uint WorkerThreadCount, uint RetiredWorkerThreads)
		{
			throw new NotImplementedException();
		}

		[Event(43, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void WorkerThreadUnretire(uint WorkerThreadCount, uint RetiredWorkerThreads)
		{
			throw new NotImplementedException();
		}

		[Event(44, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void IOThreadCreate_V1(uint IOThreadCount, uint RetiredIOThreads, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(45, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void IOThreadTerminate_V1(uint IOThreadCount, uint RetiredIOThreads, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(46, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void IOThreadRetire_V1(uint IOThreadCount, uint RetiredIOThreads, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(47, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void IOThreadUnretire_V1(uint IOThreadCount, uint RetiredIOThreads, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(48, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void ThreadpoolSuspensionSuspendThread(uint ClrThreadID, uint CpuUtilization)
		{
			throw new NotImplementedException();
		}

		[Event(49, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void ThreadpoolSuspensionResumeThread(uint ClrThreadID, uint CpuUtilization)
		{
			throw new NotImplementedException();
		}

		[Event(58, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)65536L)]
		private void YieldProcessorMeasurement(ushort ClrInstanceID, double NsPerYield, double EstablishedNsPerYield)
		{
			throw new NotImplementedException();
		}

		[Event(70, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)2147549184L)]
		private void ThreadCreating(IntPtr ID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(71, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)2147549184L)]
		private void ThreadRunning(IntPtr ID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(72, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)274877906944L)]
		private void MethodDetails(ulong MethodID, ulong TypeID, uint MethodToken, uint TypeParameterCount, ulong LoaderModuleID)
		{
			throw new NotImplementedException();
		}

		[Event(73, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)549755813888L)]
		private void TypeLoadStart(uint TypeLoadStartID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(74, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)549755813888L)]
		private void TypeLoadStop(uint TypeLoadStartID, ushort ClrInstanceID, ushort LoadLevel, ulong TypeID, string TypeName)
		{
			throw new NotImplementedException();
		}

		[Event(80, Version = 1, Level = EventLevel.Error, Keywords = (EventKeywords)8589967360L)]
		private void ExceptionThrown_V1(string ExceptionType, string ExceptionMessage, IntPtr ExceptionEIP, uint ExceptionHRESULT, ushort ExceptionFlags, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(250, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)32768L)]
		private void ExceptionCatchStart(ulong EntryEIP, ulong MethodID, string MethodName, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(251, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)32768L)]
		private void ExceptionCatchStop()
		{
			throw new NotImplementedException();
		}

		[Event(252, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)32768L)]
		private void ExceptionFinallyStart(ulong EntryEIP, ulong MethodID, string MethodName, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(253, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)32768L)]
		private void ExceptionFinallyStop()
		{
			throw new NotImplementedException();
		}

		[Event(254, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)32768L)]
		private void ExceptionFilterStart(ulong EntryEIP, ulong MethodID, string MethodName, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(255, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)32768L)]
		private void ExceptionFilterStop()
		{
			throw new NotImplementedException();
		}

		[Event(256, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)32768L)]
		private void ExceptionThrownStop()
		{
			throw new NotImplementedException();
		}

		[Event(81, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)16384L)]
		private void ContentionStart_V1(byte ContentionFlags, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(91, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)16384L)]
		private void ContentionStop_V1(byte ContentionFlags, ushort ClrInstanceID, double DurationNs)
		{
			throw new NotImplementedException();
		}

		[Event(82, Version = 0, Level = EventLevel.LogAlways, Keywords = (EventKeywords)1073741824L)]
		private void CLRStackWalk(ushort ClrInstanceID, byte Reserved1, byte Reserved2, uint FrameCount)
		{
			throw new NotImplementedException();
		}

		[Event(83, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)2048L)]
		private void AppDomainMemAllocated(ulong AppDomainID, ulong Allocated, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(84, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)2048L)]
		private void AppDomainMemSurvived(ulong AppDomainID, ulong Survived, ulong ProcessSurvived, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(85, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)67584L)]
		private void ThreadCreated(ulong ManagedThreadID, ulong AppDomainID, uint Flags, uint ManagedThreadIndex, uint OSThreadID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(86, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)67584L)]
		private void ThreadTerminated(ulong ManagedThreadID, ulong AppDomainID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(87, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)67584L)]
		private void ThreadDomainEnter(ulong ManagedThreadID, ulong AppDomainID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(88, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)8192L)]
		private void ILStubGenerated(ushort ClrInstanceID, ulong ModuleID, ulong StubMethodID, uint StubFlags, uint ManagedInteropMethodToken, string ManagedInteropMethodNamespace, string ManagedInteropMethodName, string ManagedInteropMethodSignature, string NativeMethodSignature, string StubMethodSignature, string StubMethodILCode)
		{
			throw new NotImplementedException();
		}

		[Event(89, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)8192L)]
		private void ILStubCacheHit(ushort ClrInstanceID, ulong ModuleID, ulong StubMethodID, uint ManagedInteropMethodToken, string ManagedInteropMethodNamespace, string ManagedInteropMethodName, string ManagedInteropMethodSignature)
		{
			throw new NotImplementedException();
		}

		[Event(135, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void DCStartCompleteV2()
		{
			throw new NotImplementedException();
		}

		[Event(136, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void DCEndCompleteV2()
		{
			throw new NotImplementedException();
		}

		[Event(137, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void MethodDCStartV2(ulong MethodID, ulong ModuleID, ulong MethodStartAddress, uint MethodSize, uint MethodToken, uint MethodFlags)
		{
			throw new NotImplementedException();
		}

		[Event(138, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void MethodDCEndV2(ulong MethodID, ulong ModuleID, ulong MethodStartAddress, uint MethodSize, uint MethodToken, uint MethodFlags)
		{
			throw new NotImplementedException();
		}

		[Event(139, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void MethodDCStartVerboseV2(ulong MethodID, ulong ModuleID, ulong MethodStartAddress, uint MethodSize, uint MethodToken, uint MethodFlags, string MethodNamespace, string MethodName, string MethodSignature)
		{
			throw new NotImplementedException();
		}

		[Event(140, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void MethodDCEndVerboseV2(ulong MethodID, ulong ModuleID, ulong MethodStartAddress, uint MethodSize, uint MethodToken, uint MethodFlags, string MethodNamespace, string MethodName, string MethodSignature)
		{
			throw new NotImplementedException();
		}

		[Event(141, Version = 2, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void MethodLoad_V2(ulong MethodID, ulong ModuleID, ulong MethodStartAddress, uint MethodSize, uint MethodToken, uint MethodFlags, ushort ClrInstanceID, ulong ReJITID)
		{
			throw new NotImplementedException();
		}

		[Event(159, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)137438953472L)]
		private void R2RGetEntryPoint(ulong MethodID, string MethodNamespace, string MethodName, string MethodSignature, ulong EntryPoint, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(160, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)137438953472L)]
		private void R2RGetEntryPointStart(ulong MethodID, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(142, Version = 2, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void MethodUnload_V2(ulong MethodID, ulong ModuleID, ulong MethodStartAddress, uint MethodSize, uint MethodToken, uint MethodFlags, ushort ClrInstanceID, ulong ReJITID)
		{
			throw new NotImplementedException();
		}

		[Event(143, Version = 2, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void MethodLoadVerbose_V2(ulong MethodID, ulong ModuleID, ulong MethodStartAddress, uint MethodSize, uint MethodToken, uint MethodFlags, string MethodNamespace, string MethodName, string MethodSignature, ushort ClrInstanceID, ulong ReJITID)
		{
			throw new NotImplementedException();
		}

		[Event(144, Version = 2, Level = EventLevel.Informational, Keywords = (EventKeywords)48L)]
		private void MethodUnloadVerbose_V2(ulong MethodID, ulong ModuleID, ulong MethodStartAddress, uint MethodSize, uint MethodToken, uint MethodFlags, string MethodNamespace, string MethodName, string MethodSignature, ushort ClrInstanceID, ulong ReJITID)
		{
			throw new NotImplementedException();
		}

		[Event(145, Version = 1, Level = EventLevel.Verbose, Keywords = (EventKeywords)16L)]
		private void MethodJittingStarted_V1(ulong MethodID, ulong ModuleID, uint MethodToken, uint MethodILSize, string MethodNamespace, string MethodName, string MethodSignature, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(146, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)16L)]
		private void MethodJitMemoryAllocatedForCode(ulong MethodID, ulong ModuleID, ulong JitHotCodeRequestSize, ulong JitRODataRequestSize, ulong AllocatedSizeForJitCode, uint JitAllocFlag, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(185, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)4096L)]
		private void MethodJitInliningSucceeded(string MethodBeingCompiledNamespace, string MethodBeingCompiledName, string MethodBeingCompiledNameSignature, string InlinerNamespace, string InlinerName, string InlinerNameSignature, string InlineeNamespace, string InlineeName, string InlineeNameSignature, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(186, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)4096L)]
		private void MethodJitInliningFailedAnsi(string MethodBeingCompiledNamespace, string MethodBeingCompiledName, string MethodBeingCompiledNameSignature, string InlinerNamespace, string InlinerName, string InlinerNameSignature, string InlineeNamespace, string InlineeName, string InlineeNameSignature, bool FailAlways)
		{
			throw new NotImplementedException();
		}

		[Event(188, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)4096L)]
		private void MethodJitTailCallSucceeded(string MethodBeingCompiledNamespace, string MethodBeingCompiledName, string MethodBeingCompiledNameSignature, string CallerNamespace, string CallerName, string CallerNameSignature, string CalleeNamespace, string CalleeName, string CalleeNameSignature, bool TailPrefix, uint TailCallType, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(189, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)4096L)]
		private void MethodJitTailCallFailedAnsi(string MethodBeingCompiledNamespace, string MethodBeingCompiledName, string MethodBeingCompiledNameSignature, string CallerNamespace, string CallerName, string CallerNameSignature, string CalleeNamespace, string CalleeName, string CalleeNameSignature, bool TailPrefix)
		{
			throw new NotImplementedException();
		}

		[Event(190, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)131072L)]
		private void MethodILToNativeMap(ulong MethodID, ulong ReJITID, byte MethodExtent, ushort CountOfMapEntries)
		{
			throw new NotImplementedException();
		}

		[Event(191, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)4096L)]
		private void MethodJitTailCallFailed(string MethodBeingCompiledNamespace, string MethodBeingCompiledName, string MethodBeingCompiledNameSignature, string CallerNamespace, string CallerName, string CallerNameSignature, string CalleeNamespace, string CalleeName, string CalleeNameSignature, bool TailPrefix, string FailReason, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(192, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)4096L)]
		private void MethodJitInliningFailed(string MethodBeingCompiledNamespace, string MethodBeingCompiledName, string MethodBeingCompiledNameSignature, string InlinerNamespace, string InlinerName, string InlinerNameSignature, string InlineeNamespace, string InlineeName, string InlineeNameSignature, bool FailAlways, string FailReason, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(149, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		private void ModuleDCStartV2(ulong ModuleID, ulong AssemblyID, uint ModuleFlags, uint Reserved1, string ModuleILPath, string ModuleNativePath)
		{
			throw new NotImplementedException();
		}

		[Event(150, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		private void ModuleDCEndV2(ulong ModuleID, ulong AssemblyID, uint ModuleFlags, uint Reserved1, string ModuleILPath, string ModuleNativePath)
		{
			throw new NotImplementedException();
		}

		[Event(151, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		private void DomainModuleLoad_V1(ulong ModuleID, ulong AssemblyID, ulong AppDomainID, uint ModuleFlags, uint Reserved1, string ModuleILPath, string ModuleNativePath, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(152, Version = 2, Level = EventLevel.Informational, Keywords = (EventKeywords)536870920L)]
		private void ModuleLoad_V2(ulong ModuleID, ulong AssemblyID, uint ModuleFlags, uint Reserved1, string ModuleILPath, string ModuleNativePath, ushort ClrInstanceID, Guid ManagedPdbSignature, uint ManagedPdbAge, string ManagedPdbBuildPath, Guid NativePdbSignature, uint NativePdbAge, string NativePdbBuildPath)
		{
			throw new NotImplementedException();
		}

		[Event(153, Version = 2, Level = EventLevel.Informational, Keywords = (EventKeywords)536870920L)]
		private void ModuleUnload_V2(ulong ModuleID, ulong AssemblyID, uint ModuleFlags, uint Reserved1, string ModuleILPath, string ModuleNativePath, ushort ClrInstanceID, Guid ManagedPdbSignature, uint ManagedPdbAge, string ManagedPdbBuildPath, Guid NativePdbSignature, uint NativePdbAge, string NativePdbBuildPath)
		{
			throw new NotImplementedException();
		}

		[Event(154, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		private void AssemblyLoad_V1(ulong AssemblyID, ulong AppDomainID, ulong BindingID, uint AssemblyFlags, string FullyQualifiedAssemblyName, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(155, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		private void AssemblyUnload_V1(ulong AssemblyID, ulong AppDomainID, ulong BindingID, uint AssemblyFlags, string FullyQualifiedAssemblyName, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(156, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		private void AppDomainLoad_V1(ulong AppDomainID, uint AppDomainFlags, string AppDomainName, uint AppDomainIndex, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(157, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)8L)]
		private void AppDomainUnload_V1(ulong AppDomainID, uint AppDomainFlags, string AppDomainName, uint AppDomainIndex, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(158, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)536870912L)]
		private void ModuleRangeLoad(ushort ClrInstanceID, ulong ModuleID, uint RangeBegin, uint RangeSize, byte RangeType)
		{
			throw new NotImplementedException();
		}

		[Event(181, Version = 1, Level = EventLevel.Verbose, Keywords = (EventKeywords)1024L)]
		private void StrongNameVerificationStart_V1(uint VerificationFlags, uint ErrorCode, string FullyQualifiedAssemblyName, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(182, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1024L)]
		private void StrongNameVerificationStop_V1(uint VerificationFlags, uint ErrorCode, string FullyQualifiedAssemblyName, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(183, Version = 1, Level = EventLevel.Verbose, Keywords = (EventKeywords)1024L)]
		private void AuthenticodeVerificationStart_V1(uint VerificationFlags, uint ErrorCode, string ModulePath, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(184, Version = 1, Level = EventLevel.Informational, Keywords = (EventKeywords)1024L)]
		private void AuthenticodeVerificationStop_V1(uint VerificationFlags, uint ErrorCode, string ModulePath, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(187, Version = 0, Level = EventLevel.Informational)]
		private void RuntimeInformationStart(ushort ClrInstanceID, ushort Sku, ushort BclMajorVersion, ushort BclMinorVersion, ushort BclBuildNumber, ushort BclQfeNumber, ushort VMMajorVersion, ushort VMMinorVersion, ushort VMBuildNumber, ushort VMQfeNumber, uint StartupFlags, byte StartupMode, string CommandLine, Guid ComObjectGuid, string RuntimeDllPath)
		{
			throw new NotImplementedException();
		}

		[Event(200, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)1L)]
		private void IncreaseMemoryPressure(ulong BytesAllocated, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(201, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)1L)]
		private void DecreaseMemoryPressure(ulong BytesFreed, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(202, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCMarkWithType(uint HeapNum, ushort ClrInstanceID, uint Type, ulong Bytes)
		{
			throw new NotImplementedException();
		}

		[Event(203, Version = 2, Level = EventLevel.Verbose, Keywords = (EventKeywords)1L)]
		private void GCJoin_V2(uint Heap, uint JoinTime, uint JoinType, ushort ClrInstanceID, uint JoinID)
		{
			throw new NotImplementedException();
		}

		[Event(204, Version = 3, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCPerHeapHistory_V3(ushort ClrInstanceID, IntPtr FreeListAllocated, IntPtr FreeListRejected, IntPtr EndOfSegAllocated, IntPtr CondemnedAllocated, IntPtr PinnedAllocated, IntPtr PinnedAllocatedAdvance, uint RunningFreeListEfficiency, uint CondemnReasons0, uint CondemnReasons1, uint CompactMechanisms, uint ExpandMechanisms, uint HeapIndex, IntPtr ExtraGen0Commit, uint Count)
		{
			throw new NotImplementedException();
		}

		[Event(205, Version = 4, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCGlobalHeapHistory_V4(ulong FinalYoungestDesired, int NumHeaps, uint CondemnedGeneration, uint Gen0ReductionCount, uint Reason, uint GlobalMechanisms, ushort ClrInstanceID, uint PauseMode, uint MemoryPressure, uint CondemnReasons0, uint CondemnReasons1, uint Count)
		{
			throw new NotImplementedException();
		}

		[Event(206, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GenAwareBegin(uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(207, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1048576L)]
		private void GenAwareEnd(uint Count, ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(208, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		private void GCLOHCompact(ushort ClrInstanceID, ushort Count)
		{
			throw new NotImplementedException();
		}

		[Event(209, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)1L)]
		private void GCFitBucketInfo(ushort ClrInstanceID, ushort BucketKind, ulong TotalSize, ushort Count)
		{
			throw new NotImplementedException();
		}

		[Event(240, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4294967296L)]
		private void DebugIPCEventStart()
		{
			throw new NotImplementedException();
		}

		[Event(241, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4294967296L)]
		private void DebugIPCEventEnd()
		{
			throw new NotImplementedException();
		}

		[Event(242, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4294967296L)]
		private void DebugExceptionProcessingStart()
		{
			throw new NotImplementedException();
		}

		[Event(243, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4294967296L)]
		private void DebugExceptionProcessingEnd()
		{
			throw new NotImplementedException();
		}

		[Event(260, Version = 0, Level = EventLevel.Verbose, Keywords = (EventKeywords)17179869184L)]
		private void CodeSymbols(ulong ModuleId, ushort TotalChunks, ushort ChunkNumber, uint ChunkLength)
		{
			throw new NotImplementedException();
		}

		[Event(270, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)34359738368L)]
		private void EventSource(int EventID, string EventName, string EventSourceName, string Payload)
		{
			throw new NotImplementedException();
		}

		[Event(280, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)68719476736L)]
		private void TieredCompilationSettings(ushort ClrInstanceID, uint Flags)
		{
			throw new NotImplementedException();
		}

		[Event(281, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)68719476736L)]
		private void TieredCompilationPause(ushort ClrInstanceID)
		{
			throw new NotImplementedException();
		}

		[Event(282, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)68719476736L)]
		private void TieredCompilationResume(ushort ClrInstanceID, uint NewMethodCount)
		{
			throw new NotImplementedException();
		}

		[Event(283, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)68719476736L)]
		private void TieredCompilationBackgroundJitStart(ushort ClrInstanceID, uint PendingMethodCount)
		{
			throw new NotImplementedException();
		}

		[Event(284, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)68719476736L)]
		private void TieredCompilationBackgroundJitStop(ushort ClrInstanceID, uint PendingMethodCount, uint JittedMethodCount)
		{
			throw new NotImplementedException();
		}

		[Event(290, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4L)]
		private void AssemblyLoadStart(ushort ClrInstanceID, string AssemblyName, string AssemblyPath, string RequestingAssembly, string AssemblyLoadContext, string RequestingAssemblyLoadContext)
		{
			throw new NotImplementedException();
		}

		[Event(291, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4L)]
		private void AssemblyLoadStop(ushort ClrInstanceID, string AssemblyName, string AssemblyPath, string RequestingAssembly, string AssemblyLoadContext, string RequestingAssemblyLoadContext, bool Success, string ResultAssemblyName, string ResultAssemblyPath, bool Cached)
		{
			throw new NotImplementedException();
		}

		[Event(292, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4L)]
		private void ResolutionAttempted(ushort ClrInstanceID, string AssemblyName, ushort Stage, string AssemblyLoadContext, ushort Result, string ResultAssemblyName, string ResultAssemblyPath, string ErrorMessage)
		{
			throw new NotImplementedException();
		}

		[Event(293, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4L)]
		private void AssemblyLoadContextResolvingHandlerInvoked(ushort ClrInstanceID, string AssemblyName, string HandlerName, string AssemblyLoadContext, string ResultAssemblyName, string ResultAssemblyPath)
		{
			throw new NotImplementedException();
		}

		[Event(294, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4L)]
		private void AppDomainAssemblyResolveHandlerInvoked(ushort ClrInstanceID, string AssemblyName, string HandlerName, string ResultAssemblyName, string ResultAssemblyPath)
		{
			throw new NotImplementedException();
		}

		[Event(295, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4L)]
		private void AssemblyLoadFromResolveHandlerInvoked(ushort ClrInstanceID, string AssemblyName, bool IsTrackedLoad, string RequestingAssemblyPath, string ComputedRequestedAssemblyPath)
		{
			throw new NotImplementedException();
		}

		[Event(296, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)4L)]
		private void KnownPathProbed(ushort ClrInstanceID, string FilePath, ushort Source, int Result)
		{
			throw new NotImplementedException();
		}

		[Event(297, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1099511627776L)]
		private void JitInstrumentationData(ushort ClrInstanceID, uint MethodFlags, uint DataSize, ulong MethodID)
		{
			throw new NotImplementedException();
		}

		[Event(298, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)1099511627776L)]
		private void JitInstrumentationDataVerbose(ushort ClrInstanceID, uint MethodFlags, uint DataSize, ulong MethodID, ulong ModuleID, uint MethodToken, string MethodNamespace, string MethodName, string MethodSignature)
		{
			throw new NotImplementedException();
		}

		[Event(299, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)2199023255552L)]
		private void ProfilerMessage(ushort ClrInstanceID, string Message)
		{
			throw new NotImplementedException();
		}

		[Event(300, Version = 0, Level = EventLevel.Informational, Keywords = (EventKeywords)536870912L)]
		private void ExecutionCheckpoint(ushort ClrInstanceID, string Name, long Timestamp)
		{
			throw new NotImplementedException();
		}

		private NativeRuntimeEventSource()
			: base(new Guid(3778809123u, 52412, 19986, 147, 27, 217, 204, 46, 238, 39, 228), "Microsoft-Windows-DotNETRuntime")
		{
		}
	}
	internal sealed class ActivityTracker
	{
		private sealed class ActivityInfo
		{
			internal readonly string m_name;

			private readonly long m_uniqueId;

			internal readonly Guid m_guid;

			internal readonly int m_activityPathGuidOffset;

			internal readonly int m_level;

			internal readonly EventActivityOptions m_eventOptions;

			internal long m_lastChildID;

			internal int m_stopped;

			internal readonly ActivityInfo m_creator;

			internal readonly Guid m_activityIdToRestore;

			public Guid ActivityId => m_guid;

			public ActivityInfo(string name, long uniqueId, ActivityInfo creator, Guid activityIDToRestore, EventActivityOptions options)
			{
				m_name = name;
				m_eventOptions = options;
				m_creator = creator;
				m_uniqueId = uniqueId;
				m_level = ((creator != null) ? (creator.m_level + 1) : 0);
				m_activityIdToRestore = activityIDToRestore;
				CreateActivityPathGuid(out m_guid, out m_activityPathGuidOffset);
			}

			public static string Path(ActivityInfo activityInfo)
			{
				if (activityInfo == null)
				{
					return "";
				}
				return $"{Path(activityInfo.m_creator)}/{activityInfo.m_uniqueId}";
			}

			public override string ToString()
			{
				return m_name + "(" + Path(this) + ((m_stopped != 0) ? ",DEAD)" : ")");
			}

			public static string LiveActivities(ActivityInfo list)
			{
				if (list == null)
				{
					return "";
				}
				return list.ToString() + ";" + LiveActivities(list.m_creator);
			}

			public bool CanBeOrphan()
			{
				if ((m_eventOptions & EventActivityOptions.Detachable) != 0)
				{
					return true;
				}
				return false;
			}

			private unsafe void CreateActivityPathGuid(out Guid idRet, out int activityPathGuidOffset)
			{
				fixed (Guid* outPtr = &idRet)
				{
					int whereToAddId = 0;
					if (m_creator != null)
					{
						whereToAddId = m_creator.m_activityPathGuidOffset;
						idRet = m_creator.m_guid;
					}
					else
					{
						int num = 0;
						num = Thread.GetDomainID();
						whereToAddId = AddIdToGuid(outPtr, whereToAddId, (uint)num);
					}
					activityPathGuidOffset = AddIdToGuid(outPtr, whereToAddId, (uint)m_uniqueId);
					if (12 < activityPathGuidOffset)
					{
						CreateOverflowGuid(outPtr);
					}
				}
			}

			private unsafe void CreateOverflowGuid(Guid* outPtr)
			{
				for (ActivityInfo creator = m_creator; creator != null; creator = creator.m_creator)
				{
					if (creator.m_activityPathGuidOffset <= 10)
					{
						uint id = (uint)Interlocked.Increment(ref creator.m_lastChildID);
						*outPtr = creator.m_guid;
						int num = AddIdToGuid(outPtr, creator.m_activityPathGuidOffset, id, overflow: true);
						if (num <= 12)
						{
							break;
						}
					}
				}
			}

			private unsafe static int AddIdToGuid(Guid* outPtr, int whereToAddId, uint id, bool overflow = false)
			{
				byte* ptr = (byte*)outPtr;
				byte* ptr2 = ptr + 12;
				ptr += whereToAddId;
				if (ptr2 <= ptr)
				{
					return 13;
				}
				if (0 < id && id <= 10 && !overflow)
				{
					WriteNibble(ref ptr, ptr2, id);
				}
				else
				{
					uint num = 4u;
					if (id <= 255)
					{
						num = 1u;
					}
					else if (id <= 65535)
					{
						num = 2u;
					}
					else if (id <= 16777215)
					{
						num = 3u;
					}
					if (overflow)
					{
						if (ptr2 <= ptr + 2)
						{
							return 13;
						}
						WriteNibble(ref ptr, ptr2, 11u);
					}
					WriteNibble(ref ptr, ptr2, 12 + (num - 1));
					if (ptr < ptr2 && *ptr != 0)
					{
						if (id < 4096)
						{
							*ptr = (byte)(192 + (id >> 8));
							id &= 0xFFu;
						}
						ptr++;
					}
					while (0 < num)
					{
						if (ptr2 <= ptr)
						{
							ptr++;
							break;
						}
						*(ptr++) = (byte)id;
						id >>= 8;
						num--;
					}
				}
				*(int*)((byte*)outPtr + (nint)3 * (nint)4) = (int)(*(uint*)outPtr + *(uint*)((byte*)outPtr + 4) + *(uint*)((byte*)outPtr + (nint)2 * (nint)4) + 1503500717) ^ Environment.ProcessId;
				return (int)(ptr - (byte*)outPtr);
			}

			private unsafe static void WriteNibble(ref byte* ptr, byte* endPtr, uint value)
			{
				if (*ptr != 0)
				{
					byte* intPtr = ptr++;
					*intPtr |= (byte)value;
				}
				else
				{
					*ptr = (byte)(value << 4);
				}
			}
		}

		private AsyncLocal<ActivityInfo> m_current;

		private bool m_checkedForEnable;

		private static readonly ActivityTracker s_activityTrackerInstance = new ActivityTracker();

		private static long m_nextId;

		public static ActivityTracker Instance => s_activityTrackerInstance;

		public void OnStart(string providerName, string activityName, int task, ref Guid activityId, ref Guid relatedActivityId, EventActivityOptions options, bool useTplSource = true)
		{
			if (m_current == null)
			{
				if (m_checkedForEnable)
				{
					return;
				}
				m_checkedForEnable = true;
				if (useTplSource && TplEventSource.Log.IsEnabled(EventLevel.Informational, (EventKeywords)128L))
				{
					Enable();
				}
				if (m_current == null)
				{
					return;
				}
			}
			ActivityInfo value = m_current.Value;
			string text = NormalizeActivityName(providerName, activityName, task);
			TplEventSource tplEventSource = (useTplSource ? TplEventSource.Log : null);
			bool flag = tplEventSource?.Debug ?? false;
			if (flag)
			{
				tplEventSource.DebugFacilityMessage("OnStartEnter", text);
				tplEventSource.DebugFacilityMessage("OnStartEnterActivityState", ActivityInfo.LiveActivities(value));
			}
			if (value != null)
			{
				if (value.m_level >= 100)
				{
					activityId = Guid.Empty;
					relatedActivityId = Guid.Empty;
					if (flag)
					{
						tplEventSource.DebugFacilityMessage("OnStartRET", "Fail");
					}
					return;
				}
				if ((options & EventActivityOptions.Recursive) == 0)
				{
					ActivityInfo activityInfo = FindActiveActivity(text, value);
					if (activityInfo != null)
					{
						OnStop(providerName, activityName, task, ref activityId);
						value = m_current.Value;
					}
				}
			}
			long uniqueId = ((value != null) ? Interlocked.Increment(ref value.m_lastChildID) : Interlocked.Increment(ref m_nextId));
			relatedActivityId = EventSource.CurrentThreadActivityId;
			ActivityInfo activityInfo2 = new ActivityInfo(text, uniqueId, value, relatedActivityId, options);
			m_current.Value = activityInfo2;
			activityId = activityInfo2.ActivityId;
			if (flag)
			{
				tplEventSource.DebugFacilityMessage("OnStartRetActivityState", ActivityInfo.LiveActivities(activityInfo2));
				tplEventSource.DebugFacilityMessage1("OnStartRet", activityId.ToString(), relatedActivityId.ToString());
			}
		}

		public void OnStop(string providerName, string activityName, int task, ref Guid activityId, bool useTplSource = true)
		{
			if (m_current == null)
			{
				return;
			}
			string text = NormalizeActivityName(providerName, activityName, task);
			TplEventSource tplEventSource = (useTplSource ? TplEventSource.Log : null);
			bool flag = tplEventSource?.Debug ?? false;
			if (flag)
			{
				tplEventSource.DebugFacilityMessage("OnStopEnter", text);
				tplEventSource.DebugFacilityMessage("OnStopEnterActivityState", ActivityInfo.LiveActivities(m_current.Value));
			}
			ActivityInfo activityInfo;
			ActivityInfo activityInfo2;
			do
			{
				ActivityInfo value = m_current.Value;
				activityInfo = null;
				activityInfo2 = FindActiveActivity(text, value);
				if (activityInfo2 == null)
				{
					activityId = Guid.Empty;
					if (flag)
					{
						tplEventSource.DebugFacilityMessage("OnStopRET", "Fail");
					}
					return;
				}
				activityId = activityInfo2.ActivityId;
				ActivityInfo activityInfo3 = value;
				while (activityInfo3 != activityInfo2 && activityInfo3 != null)
				{
					if (activityInfo3.m_stopped != 0)
					{
						activityInfo3 = activityInfo3.m_creator;
						continue;
					}
					if (activityInfo3.CanBeOrphan())
					{
						if (activityInfo == null)
						{
							activityInfo = activityInfo3;
						}
					}
					else
					{
						activityInfo3.m_stopped = 1;
					}
					activityInfo3 = activityInfo3.m_creator;
				}
			}
			while (Interlocked.CompareExchange(ref activityInfo2.m_stopped, 1, 0) != 0);
			if (activityInfo == null)
			{
				activityInfo = activityInfo2.m_creator;
			}
			m_current.Value = activityInfo;
			if (flag)
			{
				tplEventSource.DebugFacilityMessage("OnStopRetActivityState", ActivityInfo.LiveActivities(activityInfo));
				tplEventSource.DebugFacilityMessage("OnStopRet", activityId.ToString());
			}
		}

		public void Enable()
		{
			if (m_current == null)
			{
				try
				{
					m_current = new AsyncLocal<ActivityInfo>(ActivityChanging);
				}
				catch (NotImplementedException)
				{
					Debugger.Log(0, null, "Activity Enabled() called but AsyncLocals Not Supported (pre V4.6).  Ignoring Enable");
				}
			}
		}

		private static ActivityInfo FindActiveActivity(string name, ActivityInfo startLocation)
		{
			for (ActivityInfo activityInfo = startLocation; activityInfo != null; activityInfo = activityInfo.m_creator)
			{
				if (name == activityInfo.m_name && activityInfo.m_stopped == 0)
				{
					return activityInfo;
				}
			}
			return null;
		}

		private static string NormalizeActivityName(string providerName, string activityName, int task)
		{
			if (activityName.EndsWith("Start", StringComparison.Ordinal))
			{
				return providerName + activityName.AsSpan(0, activityName.Length - "Start".Length);
			}
			if (activityName.EndsWith("Stop", StringComparison.Ordinal))
			{
				return providerName + activityName.AsSpan(0, activityName.Length - "Stop".Length);
			}
			if (task != 0)
			{
				return providerName + "task" + task;
			}
			return providerName + activityName;
		}

		private void ActivityChanging(AsyncLocalValueChangedArgs<ActivityInfo> args)
		{
			ActivityInfo activityInfo = args.CurrentValue;
			ActivityInfo previousValue = args.PreviousValue;
			if (previousValue != null && previousValue.m_creator == activityInfo && (activityInfo == null || previousValue.m_activityIdToRestore != activityInfo.ActivityId))
			{
				EventSource.SetCurrentThreadActivityId(previousValue.m_activityIdToRestore);
				return;
			}
			while (activityInfo != null)
			{
				if (activityInfo.m_stopped == 0)
				{
					EventSource.SetCurrentThreadActivityId(activityInfo.ActivityId);
					return;
				}
				activityInfo = activityInfo.m_creator;
			}
			EventSource.SetCurrentThreadActivityId(Guid.Empty);
		}
	}
	[UnsupportedOSPlatform("browser")]
	public abstract class DiagnosticCounter : IDisposable
	{
		private string _displayName = "";

		private string _displayUnits = "";

		private CounterGroup _group;

		private Dictionary<string, string> _metadata;

		public string DisplayName
		{
			get
			{
				return _displayName;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("DisplayName");
				}
				_displayName = value;
			}
		}

		public string DisplayUnits
		{
			get
			{
				return _displayUnits;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("DisplayUnits");
				}
				_displayUnits = value;
			}
		}

		public string Name { get; }

		public EventSource EventSource { get; }

		internal DiagnosticCounter(string name, EventSource eventSource)
		{
			if (name == null)
			{
				throw new ArgumentNullException("Name");
			}
			if (eventSource == null)
			{
				throw new ArgumentNullException("EventSource");
			}
			Name = name;
			EventSource = eventSource;
		}

		private protected void Publish()
		{
			_group = CounterGroup.GetCounterGroup(EventSource);
			_group.Add(this);
		}

		public void Dispose()
		{
			if (_group != null)
			{
				_group.Remove(this);
				_group = null;
			}
		}

		public void AddMetadata(string key, string? value)
		{
			lock (this)
			{
				if (_metadata == null)
				{
					_metadata = new Dictionary<string, string>();
				}
				_metadata.Add(key, value);
			}
		}

		internal abstract void WritePayload(float intervalSec, int pollingIntervalMillisec);

		internal void ReportOutOfBandMessage(string message)
		{
			EventSource.ReportOutOfBandMessage(message);
		}

		internal string GetMetadataString()
		{
			if (_metadata == null)
			{
				return "";
			}
			Dictionary<string, string>.Enumerator enumerator = _metadata.GetEnumerator();
			bool flag = enumerator.MoveNext();
			KeyValuePair<string, string> current = enumerator.Current;
			if (!enumerator.MoveNext())
			{
				return current.Key + ":" + current.Value;
			}
			StringBuilder stringBuilder = new StringBuilder().Append(current.Key).Append(':').Append(current.Value);
			do
			{
				current = enumerator.Current;
				stringBuilder.Append(',').Append(current.Key).Append(':')
					.Append(current.Value);
			}
			while (enumerator.MoveNext());
			return stringBuilder.ToString();
		}
	}
	[UnsupportedOSPlatform("browser")]
	internal sealed class CounterGroup
	{
		private readonly EventSource _eventSource;

		private readonly List<DiagnosticCounter> _counters;

		private static readonly object s_counterGroupLock = new object();

		private static WeakReference<CounterGroup>[] s_counterGroups;

		private DateTime _timeStampSinceCollectionStarted;

		private int _pollingIntervalInMilliseconds;

		private DateTime _nextPollingTimeStamp;

		private static Thread s_pollingThread;

		private static AutoResetEvent s_pollingThreadSleepEvent;

		private static List<CounterGroup> s_counterGroupEnabledList;

		internal CounterGroup(EventSource eventSource)
		{
			_eventSource = eventSource;
			_counters = new List<DiagnosticCounter>();
			RegisterCommandCallback();
		}

		internal void Add(DiagnosticCounter eventCounter)
		{
			lock (s_counterGroupLock)
			{
				_counters.Add(eventCounter);
			}
		}

		internal void Remove(DiagnosticCounter eventCounter)
		{
			lock (s_counterGroupLock)
			{
				_counters.Remove(eventCounter);
			}
		}

		private void RegisterCommandCallback()
		{
			_eventSource.EventCommandExecuted += OnEventSourceCommand;
		}

		private void OnEventSourceCommand(object sender, EventCommandEventArgs e)
		{
			if (e.Command == EventCommand.Enable || e.Command == EventCommand.Update)
			{
				if (e.Arguments.TryGetValue("EventCounterIntervalSec", out string value) && float.TryParse(value, out var result))
				{
					lock (s_counterGroupLock)
					{
						EnableTimer(result);
					}
				}
			}
			else if (e.Command == EventCommand.Disable)
			{
				lock (s_counterGroupLock)
				{
					DisableTimer();
				}
			}
		}

		private static void EnsureEventSourceIndexAvailable(int eventSourceIndex)
		{
			if (s_counterGroups == null)
			{
				s_counterGroups = new WeakReference<CounterGroup>[eventSourceIndex + 1];
			}
			else if (eventSourceIndex >= s_counterGroups.Length)
			{
				WeakReference<CounterGroup>[] destinationArray = new WeakReference<CounterGroup>[eventSourceIndex + 1];
				Array.Copy(s_counterGroups, destinationArray, s_counterGroups.Length);
				s_counterGroups = destinationArray;
			}
		}

		internal static CounterGroup GetCounterGroup(EventSource eventSource)
		{
			lock (s_counterGroupLock)
			{
				int num = EventListener.EventSourceIndex(eventSource);
				EnsureEventSourceIndexAvailable(num);
				WeakReference<CounterGroup> weakReference = s_counterGroups[num];
				if (weakReference == null || !weakReference.TryGetTarget(out var target))
				{
					target = new CounterGroup(eventSource);
					s_counterGroups[num] = new WeakReference<CounterGroup>(target);
				}
				return target;
			}
		}

		private void EnableTimer(float pollingIntervalInSeconds)
		{
			if (pollingIntervalInSeconds <= 0f)
			{
				DisableTimer();
			}
			else if (_pollingIntervalInMilliseconds == 0 || pollingIntervalInSeconds * 1000f < (float)_pollingIntervalInMilliseconds)
			{
				_pollingIntervalInMilliseconds = (int)(pollingIntervalInSeconds * 1000f);
				ResetCounters();
				_timeStampSinceCollectionStarted = DateTime.UtcNow;
				_nextPollingTimeStamp = DateTime.UtcNow + new TimeSpan(0, 0, (int)pollingIntervalInSeconds);
				if (s_pollingThread == null)
				{
					s_pollingThreadSleepEvent = new AutoResetEvent(initialState: false);
					s_counterGroupEnabledList = new List<CounterGroup>();
					s_pollingThread = new Thread(PollForValues)
					{
						IsBackground = true,
						Name = ".NET Counter Poller"
					};
					s_pollingThread.UnsafeStart();
				}
				if (!s_counterGroupEnabledList.Contains(this))
				{
					s_counterGroupEnabledList.Add(this);
				}
				s_pollingThreadSleepEvent.Set();
			}
		}

		private void DisableTimer()
		{
			_pollingIntervalInMilliseconds = 0;
			s_counterGroupEnabledList?.Remove(this);
		}

		private void ResetCounters()
		{
			lock (s_counterGroupLock)
			{
				foreach (DiagnosticCounter counter in _counters)
				{
					if (counter is IncrementingEventCounter incrementingEventCounter)
					{
						incrementingEventCounter.UpdateMetric();
					}
					else if (counter is IncrementingPollingCounter incrementingPollingCounter)
					{
						incrementingPollingCounter.UpdateMetric();
					}
					else if (counter is EventCounter eventCounter)
					{
						eventCounter.ResetStatistics();
					}
				}
			}
		}

		private void OnTimer()
		{
			if (!_eventSource.IsEnabled())
			{
				return;
			}
			DateTime utcNow;
			TimeSpan timeSpan;
			int pollingIntervalInMilliseconds;
			DiagnosticCounter[] array;
			lock (s_counterGroupLock)
			{
				utcNow = DateTime.UtcNow;
				timeSpan = utcNow - _timeStampSinceCollectionStarted;
				pollingIntervalInMilliseconds = _pollingIntervalInMilliseconds;
				array = new DiagnosticCounter[_counters.Count];
				_counters.CopyTo(array);
			}
			DiagnosticCounter[] array2 = array;
			foreach (DiagnosticCounter diagnosticCounter in array2)
			{
				diagnosticCounter.WritePayload((float)timeSpan.TotalSeconds, pollingIntervalInMilliseconds);
			}
			lock (s_counterGroupLock)
			{
				_timeStampSinceCollectionStarted = utcNow;
				TimeSpan timeSpan2 = utcNow - _nextPollingTimeStamp;
				timeSpan2 = (((double)_pollingIntervalInMilliseconds > timeSpan2.TotalMilliseconds) ? TimeSpan.FromMilliseconds(_pollingIntervalInMilliseconds) : timeSpan2);
				if (_pollingIntervalInMilliseconds > 0)
				{
					_nextPollingTimeStamp += TimeSpan.FromMilliseconds((double)_pollingIntervalInMilliseconds * Math.Ceiling(timeSpan2.TotalMilliseconds / (double)_pollingIntervalInMilliseconds));
				}
			}
		}

		private static void PollForValues()
		{
			AutoResetEvent autoResetEvent = null;
			List<CounterGroup> list = new List<CounterGroup>();
			while (true)
			{
				int num = int.MaxValue;
				lock (s_counterGroupLock)
				{
					autoResetEvent = s_pollingThreadSleepEvent;
					foreach (CounterGroup s_counterGroupEnabled in s_counterGroupEnabledList)
					{
						DateTime utcNow = DateTime.UtcNow;
						if (s_counterGroupEnabled._nextPollingTimeStamp < utcNow + new TimeSpan(0, 0, 0, 0, 1))
						{
							list.Add(s_counterGroupEnabled);
						}
						int val = (int)(s_counterGroupEnabled._nextPollingTimeStamp - utcNow).TotalMilliseconds;
						val = Math.Max(1, val);
						num = Math.Min(num, val);
					}
				}
				foreach (CounterGroup item in list)
				{
					item.OnTimer();
				}
				list.Clear();
				if (num == int.MaxValue)
				{
					num = -1;
				}
				autoResetEvent?.WaitOne(num);
			}
		}
	}
	[EventData]
	internal sealed class CounterPayload : IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable
	{
		public string Name { get; set; }

		public string DisplayName { get; set; }

		public double Mean { get; set; }

		public double StandardDeviation { get; set; }

		public int Count { get; set; }

		public double Min { get; set; }

		public double Max { get; set; }

		public float IntervalSec { get; internal set; }

		public string Series { get; set; }

		public string CounterType { get; set; }

		public string Metadata { get; set; }

		public string DisplayUnits { get; set; }

		private IEnumerable<KeyValuePair<string, object>> ForEnumeration
		{
			get
			{
				yield return new KeyValuePair<string, object>("Name", Name);
				yield return new KeyValuePair<string, object>("DisplayName", DisplayName);
				yield return new KeyValuePair<string, object>("DisplayUnits", DisplayUnits);
				yield return new KeyValuePair<string, object>("Mean", Mean);
				yield return new KeyValuePair<string, object>("StandardDeviation", StandardDeviation);
				yield return new KeyValuePair<string, object>("Count", Count);
				yield return new KeyValuePair<string, object>("Min", Min);
				yield return new KeyValuePair<string, object>("Max", Max);
				yield return new KeyValuePair<string, object>("IntervalSec", IntervalSec);
				yield return new KeyValuePair<string, object>("Series", $"Interval={IntervalSec}");
				yield return new KeyValuePair<string, object>("CounterType", "Mean");
				yield return new KeyValuePair<string, object>("Metadata", Metadata);
			}
		}

		public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
		{
			return ForEnumeration.GetEnumerator();
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return ForEnumeration.GetEnumerator();
		}
	}
	[EventData]
	internal sealed class IncrementingCounterPayload : IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable
	{
		public string Name { get; set; }

		public string DisplayName { get; set; }

		public string DisplayRateTimeScale { get; set; }

		public double Increment { get; set; }

		public float IntervalSec { get; internal set; }

		public string Metadata { get; set; }

		public string Series { get; set; }

		public string CounterType { get; set; }

		public string DisplayUnits { get; set; }

		private IEnumerable<KeyValuePair<string, object>> ForEnumeration
		{
			get
			{
				yield return new KeyValuePair<string, object>("Name", Name);
				yield return new KeyValuePair<string, object>("DisplayName", DisplayName);
				yield return new KeyValuePair<string, object>("DisplayRateTimeScale", DisplayRateTimeScale);
				yield return new KeyValuePair<string, object>("Increment", Increment);
				yield return new KeyValuePair<string, object>("IntervalSec", IntervalSec);
				yield return new KeyValuePair<string, object>("Series", $"Interval={IntervalSec}");
				yield return new KeyValuePair<string, object>("CounterType", "Sum");
				yield return new KeyValuePair<string, object>("Metadata", Metadata);
				yield return new KeyValuePair<string, object>("DisplayUnits", DisplayUnits);
			}
		}

		public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
		{
			return ForEnumeration.GetEnumerator();
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return ForEnumeration.GetEnumerator();
		}
	}
	[Flags]
	public enum EventActivityOptions
	{
		None = 0,
		Disable = 2,
		Recursive = 4,
		Detachable = 8
	}
	[UnsupportedOSPlatform("browser")]
	public class EventCounter : DiagnosticCounter
	{
		private int _count;

		private double _sum;

		private double _sumSquared;

		private double _min;

		private double _max;

		private readonly double[] _bufferedValues;

		private volatile int _bufferedValuesIndex;

		public EventCounter(string name, EventSource eventSource)
			: base(name, eventSource)
		{
			_min = double.PositiveInfinity;
			_max = double.NegativeInfinity;
			double[] array = new double[10];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = double.NegativeInfinity;
			}
			_bufferedValues = array;
			Publish();
		}

		public void WriteMetric(float value)
		{
			Enqueue(value);
		}

		public void WriteMetric(double value)
		{
			Enqueue(value);
		}

		public override string ToString()
		{
			int num = Volatile.Read(ref _count);
			if (num != 0)
			{
				return $"EventCounter '{base.Name}' Count {num} Mean {_sum / (double)num:n3}";
			}
			return "EventCounter '" + base.Name + "' Count 0";
		}

		internal void OnMetricWritten(double value)
		{
			_sum += value;
			_sumSquared += value * value;
			if (value > _max)
			{
				_max = value;
			}
			if (value < _min)
			{
				_min = value;
			}
			_count++;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The DynamicDependency will preserve the properties of CounterPayload")]
		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicProperties, typeof(CounterPayload))]
		internal override void WritePayload(float intervalSec, int pollingIntervalMillisec)
		{
			lock (this)
			{
				Flush();
				CounterPayload counterPayload = new CounterPayload();
				counterPayload.Count = _count;
				counterPayload.IntervalSec = intervalSec;
				if (0 < _count)
				{
					counterPayload.Mean = _sum / (double)_count;
					counterPayload.StandardDeviation = Math.Sqrt(_sumSquared / (double)_count - _sum * _sum / (double)_count / (double)_count);
				}
				else
				{
					counterPayload.Mean = 0.0;
					counterPayload.StandardDeviation = 0.0;
				}
				counterPayload.Min = _min;
				counterPayload.Max = _max;
				counterPayload.Series = $"Interval={pollingIntervalMillisec}";
				counterPayload.CounterType = "Mean";
				counterPayload.Metadata = GetMetadataString();
				counterPayload.DisplayName = base.DisplayName ?? "";
				counterPayload.DisplayUnits = base.DisplayUnits ?? "";
				counterPayload.Name = base.Name;
				ResetStatistics();
				base.EventSource.Write("EventCounters", new EventSourceOptions
				{
					Level = EventLevel.LogAlways
				}, new CounterPayloadType(counterPayload));
			}
		}

		internal void ResetStatistics()
		{
			lock (this)
			{
				_count = 0;
				_sum = 0.0;
				_sumSquared = 0.0;
				_min = double.PositiveInfinity;
				_max = double.NegativeInfinity;
			}
		}

		private void Enqueue(double value)
		{
			int num = _bufferedValuesIndex;
			double num2;
			do
			{
				num2 = Interlocked.CompareExchange(ref _bufferedValues[num], value, double.NegativeInfinity);
				num++;
				if (_bufferedValues.Length <= num)
				{
					lock (this)
					{
						Flush();
					}
					num = 0;
				}
			}
			while (num2 != double.NegativeInfinity);
			_bufferedValuesIndex = num;
		}

		protected void Flush()
		{
			for (int i = 0; i < _bufferedValues.Length; i++)
			{
				double num = Interlocked.Exchange(ref _bufferedValues[i], double.NegativeInfinity);
				if (num != double.NegativeInfinity)
				{
					OnMetricWritten(num);
				}
			}
			_bufferedValuesIndex = 0;
		}
	}
	[EventData]
	internal sealed class CounterPayloadType
	{
		public CounterPayload Payload { get; set; }

		public CounterPayloadType(CounterPayload payload)
		{
			Payload = payload;
		}
	}
	[StructLayout(LayoutKind.Explicit, Size = 16)]
	internal struct EventDescriptor
	{
		[FieldOffset(0)]
		private readonly int m_traceloggingId;

		[FieldOffset(0)]
		private readonly ushort m_id;

		[FieldOffset(2)]
		private readonly byte m_version;

		[FieldOffset(3)]
		private readonly byte m_channel;

		[FieldOffset(4)]
		private readonly byte m_level;

		[FieldOffset(5)]
		private readonly byte m_opcode;

		[FieldOffset(6)]
		private readonly ushort m_task;

		[FieldOffset(8)]
		private readonly long m_keywords;

		public int EventId => m_id;

		public byte Version => m_version;

		public byte Channel => m_channel;

		public byte Level => m_level;

		public byte Opcode => m_opcode;

		public int Task => m_task;

		public long Keywords => m_keywords;

		public EventDescriptor(int traceloggingId, byte level, byte opcode, long keywords)
		{
			m_id = 0;
			m_version = 0;
			m_channel = 0;
			m_traceloggingId = traceloggingId;
			m_level = level;
			m_opcode = opcode;
			m_task = 0;
			m_keywords = keywords;
		}

		public EventDescriptor(int id, byte version, byte channel, byte level, byte opcode, int task, long keywords)
		{
			if (id < 0)
			{
				throw new ArgumentOutOfRangeException("id", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (id > 65535)
			{
				throw new ArgumentOutOfRangeException("id", SR.Format(SR.ArgumentOutOfRange_NeedValidId, 1, ushort.MaxValue));
			}
			m_traceloggingId = 0;
			m_id = (ushort)id;
			m_version = version;
			m_channel = channel;
			m_level = level;
			m_opcode = opcode;
			m_keywords = keywords;
			if (task < 0)
			{
				throw new ArgumentOutOfRangeException("task", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (task > 65535)
			{
				throw new ArgumentOutOfRangeException("task", SR.Format(SR.ArgumentOutOfRange_NeedValidId, 1, ushort.MaxValue));
			}
			m_task = (ushort)task;
		}

		public override bool Equals([NotNullWhen(true)] object obj)
		{
			if (obj is EventDescriptor other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return m_id ^ m_version ^ m_channel ^ m_level ^ m_opcode ^ m_task ^ (int)m_keywords;
		}

		public bool Equals(EventDescriptor other)
		{
			if (m_id == other.m_id && m_version == other.m_version && m_channel == other.m_channel && m_level == other.m_level && m_opcode == other.m_opcode && m_task == other.m_task)
			{
				return m_keywords == other.m_keywords;
			}
			return false;
		}
	}
	internal struct EventPipeEventInstanceData
	{
		internal IntPtr ProviderID;

		internal uint EventID;

		internal uint ThreadID;

		internal long TimeStamp;

		internal Guid ActivityId;

		internal Guid ChildActivityId;

		internal IntPtr Payload;

		internal uint PayloadLength;
	}
	internal struct EventPipeSessionInfo
	{
		internal long StartTimeAsUTCFileTime;

		internal long StartTimeStamp;

		internal long TimeStampFrequency;
	}
	internal struct EventPipeProviderConfiguration
	{
		[MarshalAs(UnmanagedType.LPWStr)]
		private readonly string m_providerName;

		private readonly ulong m_keywords;

		private readonly uint m_loggingLevel;

		[MarshalAs(UnmanagedType.LPWStr)]
		private readonly string m_filterData;

		internal string ProviderName => m_providerName;

		internal ulong Keywords => m_keywords;

		internal uint LoggingLevel => m_loggingLevel;

		internal string FilterData => m_filterData;

		internal EventPipeProviderConfiguration(string providerName, ulong keywords, uint loggingLevel, string filterData)
		{
			if (string.IsNullOrEmpty(providerName))
			{
				throw new ArgumentNullException("providerName");
			}
			if (loggingLevel > 5)
			{
				throw new ArgumentOutOfRangeException("loggingLevel");
			}
			m_providerName = providerName;
			m_keywords = keywords;
			m_loggingLevel = loggingLevel;
			m_filterData = filterData;
		}
	}
	internal enum EventPipeSerializationFormat
	{
		NetPerf,
		NetTrace
	}
	internal sealed class EventPipeWaitHandle : WaitHandle
	{
	}
	internal sealed class EventPipeEventDispatcher
	{
		internal sealed class EventListenerSubscription
		{
			internal EventKeywords MatchAnyKeywords { get; private set; }

			internal EventLevel Level { get; private set; }

			internal EventListenerSubscription(EventKeywords matchAnyKeywords, EventLevel level)
			{
				MatchAnyKeywords = matchAnyKeywords;
				Level = level;
			}
		}

		internal static readonly EventPipeEventDispatcher Instance = new EventPipeEventDispatcher();

		private readonly IntPtr m_RuntimeProviderID;

		private ulong m_sessionID;

		private DateTime m_syncTimeUtc;

		private long m_syncTimeQPC;

		private long m_timeQPCFrequency;

		private bool m_stopDispatchTask;

		private readonly EventPipeWaitHandle m_dispatchTaskWaitHandle = new EventPipeWaitHandle();

		private Task m_dispatchTask;

		private readonly object m_dispatchControlLock = new object();

		private readonly Dictionary<EventListener, EventListenerSubscription> m_subscriptions = new Dictionary<EventListener, EventListenerSubscription>();

		private EventPipeEventDispatcher()
		{
			m_RuntimeProviderID = EventPipeInternal.GetProvider("Microsoft-Windows-DotNETRuntime");
			m_dispatchTaskWaitHandle.SafeWaitHandle = new SafeWaitHandle(IntPtr.Zero, ownsHandle: false);
		}

		internal void SendCommand(EventListener eventListener, EventCommand command, bool enable, EventLevel level, EventKeywords matchAnyKeywords)
		{
			if (command == EventCommand.Update && enable)
			{
				lock (m_dispatchControlLock)
				{
					m_subscriptions[eventListener] = new EventListenerSubscription(matchAnyKeywords, level);
					CommitDispatchConfiguration();
					return;
				}
			}
			if (command == EventCommand.Update && !enable)
			{
				RemoveEventListener(eventListener);
			}
		}

		internal void RemoveEventListener(EventListener listener)
		{
			lock (m_dispatchControlLock)
			{
				if (m_subscriptions.ContainsKey(listener))
				{
					m_subscriptions.Remove(listener);
				}
				CommitDispatchConfiguration();
			}
		}

		private unsafe void CommitDispatchConfiguration()
		{
			StopDispatchTask();
			EventPipeInternal.Disable(m_sessionID);
			if (m_subscriptions.Count <= 0)
			{
				return;
			}
			EventKeywords eventKeywords = EventKeywords.None;
			EventLevel eventLevel = EventLevel.LogAlways;
			foreach (EventListenerSubscription value in m_subscriptions.Values)
			{
				eventKeywords |= value.MatchAnyKeywords;
				eventLevel = ((value.Level > eventLevel) ? value.Level : eventLevel);
			}
			EventPipeProviderConfiguration[] providers = new EventPipeProviderConfiguration[1]
			{
				new EventPipeProviderConfiguration("Microsoft-Windows-DotNETRuntime", (ulong)eventKeywords, (uint)eventLevel, null)
			};
			m_sessionID = EventPipeInternal.Enable(null, EventPipeSerializationFormat.NetTrace, 10u, providers);
			System.Runtime.CompilerServices.Unsafe.SkipInit(out EventPipeSessionInfo eventPipeSessionInfo);
			EventPipeInternal.GetSessionInfo(m_sessionID, &eventPipeSessionInfo);
			m_syncTimeUtc = DateTime.FromFileTimeUtc(eventPipeSessionInfo.StartTimeAsUTCFileTime);
			m_syncTimeQPC = eventPipeSessionInfo.StartTimeStamp;
			m_timeQPCFrequency = eventPipeSessionInfo.TimeStampFrequency;
			StartDispatchTask();
		}

		private void StartDispatchTask()
		{
			if (m_dispatchTask == null)
			{
				m_stopDispatchTask = false;
				m_dispatchTaskWaitHandle.SafeWaitHandle = new SafeWaitHandle(EventPipeInternal.GetWaitHandle(m_sessionID), ownsHandle: false);
				m_dispatchTask = Task.Factory.StartNew(DispatchEventsToEventListeners, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
			}
		}

		private void StopDispatchTask()
		{
			if (m_dispatchTask != null)
			{
				m_stopDispatchTask = true;
				EventWaitHandle.Set(m_dispatchTaskWaitHandle.SafeWaitHandle);
				m_dispatchTask.Wait();
				m_dispatchTask = null;
			}
		}

		private unsafe void DispatchEventsToEventListeners()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out EventPipeEventInstanceData eventPipeEventInstanceData);
			while (!m_stopDispatchTask)
			{
				bool flag = false;
				while (!m_stopDispatchTask && EventPipeInternal.GetNextEvent(m_sessionID, &eventPipeEventInstanceData))
				{
					flag = true;
					if (eventPipeEventInstanceData.ProviderID == m_RuntimeProviderID)
					{
						ReadOnlySpan<byte> payload = new ReadOnlySpan<byte>((void*)eventPipeEventInstanceData.Payload, (int)eventPipeEventInstanceData.PayloadLength);
						DateTime timeStamp = TimeStampToDateTime(eventPipeEventInstanceData.TimeStamp);
						NativeRuntimeEventSource.Log.ProcessEvent(eventPipeEventInstanceData.EventID, eventPipeEventInstanceData.ThreadID, timeStamp, eventPipeEventInstanceData.ActivityId, eventPipeEventInstanceData.ChildActivityId, payload);
					}
				}
				if (!m_stopDispatchTask)
				{
					if (!flag)
					{
						m_dispatchTaskWaitHandle.WaitOne();
					}
					Thread.Sleep(10);
				}
			}
		}

		private DateTime TimeStampToDateTime(long timeStamp)
		{
			if (timeStamp == long.MaxValue)
			{
				return DateTime.MaxValue;
			}
			long num = (long)((double)(timeStamp - m_syncTimeQPC) * 10000000.0 / (double)m_timeQPCFrequency) + m_syncTimeUtc.Ticks;
			if (num < 0 || 3155378975999999999L < num)
			{
				num = 3155378975999999999L;
			}
			return new DateTime(num, DateTimeKind.Utc);
		}
	}
	internal sealed class EventPipeEventProvider : IEventProvider
	{
		private IntPtr m_provHandle = IntPtr.Zero;

		unsafe uint IEventProvider.EventRegister(EventSource eventSource, Interop.Advapi32.EtwEnableCallback enableCallback, void* callbackContext, ref long registrationHandle)
		{
			uint result = 0u;
			m_provHandle = EventPipeInternal.CreateProvider(eventSource.Name, enableCallback);
			if (m_provHandle != IntPtr.Zero)
			{
				registrationHandle = 1L;
			}
			else
			{
				result = 1u;
			}
			return result;
		}

		uint IEventProvider.EventUnregister(long registrationHandle)
		{
			EventPipeInternal.DeleteProvider(m_provHandle);
			return 0u;
		}

		unsafe EventProvider.WriteEventErrorCode IEventProvider.EventWriteTransfer(long registrationHandle, in EventDescriptor eventDescriptor, IntPtr eventHandle, Guid* activityId, Guid* relatedActivityId, int userDataCount, EventProvider.EventData* userData)
		{
			if (eventHandle != IntPtr.Zero)
			{
				if (userDataCount == 0)
				{
					EventPipeInternal.WriteEventData(eventHandle, null, 0u, activityId, relatedActivityId);
					return EventProvider.WriteEventErrorCode.NoError;
				}
				if (eventDescriptor.Channel == 11)
				{
					userData += 3;
					userDataCount -= 3;
				}
				EventPipeInternal.WriteEventData(eventHandle, userData, (uint)userDataCount, activityId, relatedActivityId);
			}
			return EventProvider.WriteEventErrorCode.NoError;
		}

		unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte* pMetadata, uint metadataLength)
		{
			return EventPipeInternal.DefineEvent(m_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength);
		}

		internal static int EventActivityIdControl(Interop.Advapi32.ActivityControl ControlCode, ref Guid ActivityId)
		{
			return EventPipeInternal.EventActivityIdControl((uint)ControlCode, ref ActivityId);
		}
	}
	internal sealed class EventPipeMetadataGenerator
	{
		public static EventPipeMetadataGenerator Instance = new EventPipeMetadataGenerator();

		private EventPipeMetadataGenerator()
		{
		}

		public byte[] GenerateEventMetadata(EventSource.EventMetadata eventMetadata)
		{
			ParameterInfo[] parameters = eventMetadata.Parameters;
			EventParameterInfo[] array = new EventParameterInfo[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				EventParameterInfo.GetTypeInfoFromType(parameters[i].ParameterType, out var typeInfo);
				array[i].SetInfo(parameters[i].Name, parameters[i].ParameterType, typeInfo);
			}
			return GenerateMetadata(eventMetadata.Descriptor.EventId, eventMetadata.Name, eventMetadata.Descriptor.Keywords, eventMetadata.Descriptor.Level, eventMetadata.Descriptor.Version, (EventOpcode)eventMetadata.Descriptor.Opcode, array);
		}

		public byte[] GenerateEventMetadata(int eventId, string eventName, EventKeywords keywords, EventLevel level, uint version, EventOpcode opcode, TraceLoggingEventTypes eventTypes)
		{
			TraceLoggingTypeInfo[] typeInfos = eventTypes.typeInfos;
			string[] paramNames = eventTypes.paramNames;
			EventParameterInfo[] array = new EventParameterInfo[typeInfos.Length];
			for (int i = 0; i < typeInfos.Length; i++)
			{
				string name = string.Empty;
				if (paramNames != null)
				{
					name = paramNames[i];
				}
				array[i].SetInfo(name, typeInfos[i].DataType, typeInfos[i]);
			}
			return GenerateMetadata(eventId, eventName, (long)keywords, (uint)level, version, opcode, array);
		}

		internal unsafe byte[] GenerateMetadata(int eventId, string eventName, long keywords, uint level, uint version, EventOpcode opcode, EventParameterInfo[] parameters)
		{
			byte[] array = null;
			bool flag = false;
			try
			{
				uint num = (uint)(24 + (eventName.Length + 1) * 2);
				uint num2 = 0u;
				uint num3 = num;
				if (parameters.Length == 1 && parameters[0].ParameterType == typeof(EmptyStruct))
				{
					parameters = Array.Empty<EventParameterInfo>();
				}
				EventParameterInfo[] array2 = parameters;
				foreach (EventParameterInfo eventParameterInfo in array2)
				{
					if (!eventParameterInfo.GetMetadataLength(out var size))
					{
						flag = true;
						break;
					}
					num += size;
				}
				if (flag)
				{
					num = num3;
					num2 = 4u;
					EventParameterInfo[] array3 = parameters;
					foreach (EventParameterInfo eventParameterInfo2 in array3)
					{
						if (!eventParameterInfo2.GetMetadataLengthV2(out var size2))
						{
							parameters = Array.Empty<EventParameterInfo>();
							num = num3;
							num2 = 0u;
							flag = false;
							break;
						}
						num2 += size2;
					}
				}
				uint num4 = ((opcode != 0) ? 6u : 0u);
				uint num5 = ((num2 != 0) ? (num2 + 5) : 0u);
				uint num6 = num5 + num4;
				uint num7 = num + num6;
				array = new byte[num7];
				fixed (byte* ptr = array)
				{
					uint offset = 0u;
					WriteToBuffer(ptr, num7, ref offset, (uint)eventId);
					fixed (char* src = eventName)
					{
						WriteToBuffer(ptr, num7, ref offset, (byte*)src, (uint)((eventName.Length + 1) * 2));
					}
					WriteToBuffer(ptr, num7, ref offset, keywords);
					WriteToBuffer(ptr, num7, ref offset, version);
					WriteToBuffer(ptr, num7, ref offset, level);
					if (flag)
					{
						WriteToBuffer(ptr, num7, ref offset, 0);
					}
					else
					{
						WriteToBuffer(ptr, num7, ref offset, (uint)parameters.Length);
						EventParameterInfo[] array4 = parameters;
						foreach (EventParameterInfo eventParameterInfo3 in array4)
						{
							if (!eventParameterInfo3.GenerateMetadata(ptr, ref offset, num7))
							{
								return GenerateMetadata(eventId, eventName, keywords, level, version, opcode, Array.Empty<EventParameterInfo>());
							}
						}
					}
					if (opcode != 0)
					{
						WriteToBuffer(ptr, num7, ref offset, 1);
						WriteToBuffer(ptr, num7, ref offset, (byte)1);
						WriteToBuffer(ptr, num7, ref offset, (byte)opcode);
					}
					if (flag)
					{
						WriteToBuffer(ptr, num7, ref offset, num2);
						WriteToBuffer(ptr, num7, ref offset, (byte)2);
						WriteToBuffer(ptr, num7, ref offset, (uint)parameters.Length);
						EventParameterInfo[] array5 = parameters;
						foreach (EventParameterInfo eventParameterInfo4 in array5)
						{
							if (!eventParameterInfo4.GenerateMetadataV2(ptr, ref offset, num7))
							{
								return GenerateMetadata(eventId, eventName, keywords, level, version, opcode, Array.Empty<EventParameterInfo>());
							}
						}
					}
				}
			}
			catch
			{
				array = null;
			}
			return array;
		}

		internal unsafe static void WriteToBuffer(byte* buffer, uint bufferLength, ref uint offset, byte* src, uint srcLength)
		{
			for (int i = 0; i < srcLength; i++)
			{
				(buffer + offset)[i] = src[i];
			}
			offset += srcLength;
		}

		internal unsafe static void WriteToBuffer<T>(byte* buffer, uint bufferLength, ref uint offset, T value) where T : unmanaged
		{
			*(T*)(buffer + offset) = value;
			offset += (uint)sizeof(T);
		}
	}
	internal struct EventParameterInfo
	{
		internal string ParameterName;

		internal Type ParameterType;

		internal TraceLoggingTypeInfo TypeInfo;

		internal void SetInfo(string name, Type type, TraceLoggingTypeInfo typeInfo = null)
		{
			ParameterName = name;
			ParameterType = type;
			TypeInfo = typeInfo;
		}

		internal unsafe bool GenerateMetadata(byte* pMetadataBlob, ref uint offset, uint blobSize)
		{
			TypeCode typeCodeExtended = GetTypeCodeExtended(ParameterType);
			if (typeCodeExtended == TypeCode.Object)
			{
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, 1u);
				if (!(TypeInfo is InvokeTypeInfo invokeTypeInfo))
				{
					return false;
				}
				PropertyAnalysis[] properties = invokeTypeInfo.properties;
				if (properties != null)
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)properties.Length);
					PropertyAnalysis[] array = properties;
					foreach (PropertyAnalysis property in array)
					{
						if (!GenerateMetadataForProperty(property, pMetadataBlob, ref offset, blobSize))
						{
							return false;
						}
					}
				}
				else
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, 0u);
				}
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, '\0');
			}
			else
			{
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)typeCodeExtended);
				fixed (char* src = ParameterName)
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (byte*)src, (uint)((ParameterName.Length + 1) * 2));
				}
			}
			return true;
		}

		private unsafe static bool GenerateMetadataForProperty(PropertyAnalysis property, byte* pMetadataBlob, ref uint offset, uint blobSize)
		{
			if (property.typeInfo is InvokeTypeInfo invokeTypeInfo)
			{
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, 1u);
				PropertyAnalysis[] properties = invokeTypeInfo.properties;
				if (properties != null)
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)properties.Length);
					PropertyAnalysis[] array = properties;
					foreach (PropertyAnalysis property2 in array)
					{
						if (!GenerateMetadataForProperty(property2, pMetadataBlob, ref offset, blobSize))
						{
							return false;
						}
					}
				}
				else
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, 0u);
				}
				fixed (char* src = property.name)
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (byte*)src, (uint)((property.name.Length + 1) * 2));
				}
			}
			else
			{
				TypeCode typeCodeExtended = GetTypeCodeExtended(property.typeInfo.DataType);
				if (typeCodeExtended == TypeCode.Object)
				{
					return false;
				}
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)typeCodeExtended);
				fixed (char* src2 = property.name)
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (byte*)src2, (uint)((property.name.Length + 1) * 2));
				}
			}
			return true;
		}

		internal unsafe bool GenerateMetadataV2(byte* pMetadataBlob, ref uint offset, uint blobSize)
		{
			if (TypeInfo == null)
			{
				return false;
			}
			return GenerateMetadataForNamedTypeV2(ParameterName, TypeInfo, pMetadataBlob, ref offset, blobSize);
		}

		private unsafe static bool GenerateMetadataForNamedTypeV2(string name, TraceLoggingTypeInfo typeInfo, byte* pMetadataBlob, ref uint offset, uint blobSize)
		{
			if (!GetMetadataLengthForNamedTypeV2(name, typeInfo, out var size))
			{
				return false;
			}
			EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, size);
			fixed (char* src = name)
			{
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (byte*)src, (uint)((name.Length + 1) * 2));
			}
			return GenerateMetadataForTypeV2(typeInfo, pMetadataBlob, ref offset, blobSize);
		}

		private unsafe static bool GenerateMetadataForTypeV2(TraceLoggingTypeInfo typeInfo, byte* pMetadataBlob, ref uint offset, uint blobSize)
		{
			if (typeInfo is InvokeTypeInfo invokeTypeInfo)
			{
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, 1u);
				PropertyAnalysis[] properties = invokeTypeInfo.properties;
				if (properties != null)
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)properties.Length);
					PropertyAnalysis[] array = properties;
					foreach (PropertyAnalysis propertyAnalysis in array)
					{
						if (!GenerateMetadataForNamedTypeV2(propertyAnalysis.name, propertyAnalysis.typeInfo, pMetadataBlob, ref offset, blobSize))
						{
							return false;
						}
					}
				}
				else
				{
					EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, 0u);
				}
			}
			else if (typeInfo is EnumerableTypeInfo enumerableTypeInfo)
			{
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, 19);
				GenerateMetadataForTypeV2(enumerableTypeInfo.ElementInfo, pMetadataBlob, ref offset, blobSize);
			}
			else if (typeInfo is ScalarArrayTypeInfo scalarArrayTypeInfo)
			{
				if (!scalarArrayTypeInfo.DataType.HasElementType)
				{
					return false;
				}
				if (!GetTypeInfoFromType(scalarArrayTypeInfo.DataType.GetElementType(), out var typeInfo2))
				{
					return false;
				}
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, 19);
				GenerateMetadataForTypeV2(typeInfo2, pMetadataBlob, ref offset, blobSize);
			}
			else
			{
				TypeCode typeCodeExtended = GetTypeCodeExtended(typeInfo.DataType);
				if (typeCodeExtended == TypeCode.Object)
				{
					return false;
				}
				EventPipeMetadataGenerator.WriteToBuffer(pMetadataBlob, blobSize, ref offset, (uint)typeCodeExtended);
			}
			return true;
		}

		internal static bool GetTypeInfoFromType(Type type, out TraceLoggingTypeInfo typeInfo)
		{
			if (type == typeof(bool))
			{
				typeInfo = ScalarTypeInfo.Boolean();
				return true;
			}
			if (type == typeof(byte))
			{
				typeInfo = ScalarTypeInfo.Byte();
				return true;
			}
			if (type == typeof(sbyte))
			{
				typeInfo = ScalarTypeInfo.SByte();
				return true;
			}
			if (type == typeof(char))
			{
				typeInfo = ScalarTypeInfo.Char();
				return true;
			}
			if (type == typeof(short))
			{
				typeInfo = ScalarTypeInfo.Int16();
				return true;
			}
			if (type == typeof(ushort))
			{
				typeInfo = ScalarTypeInfo.UInt16();
				return true;
			}
			if (type == typeof(int))
			{
				typeInfo = ScalarTypeInfo.Int32();
				return true;
			}
			if (type == typeof(uint))
			{
				typeInfo = ScalarTypeInfo.UInt32();
				return true;
			}
			if (type == typeof(long))
			{
				typeInfo = ScalarTypeInfo.Int64();
				return true;
			}
			if (type == typeof(ulong))
			{
				typeInfo = ScalarTypeInfo.UInt64();
				return true;
			}
			if (type == typeof(IntPtr))
			{
				typeInfo = ScalarTypeInfo.IntPtr();
				return true;
			}
			if (type == typeof(UIntPtr))
			{
				typeInfo = ScalarTypeInfo.UIntPtr();
				return true;
			}
			if (type == typeof(float))
			{
				typeInfo = ScalarTypeInfo.Single();
				return true;
			}
			if (type == typeof(double))
			{
				typeInfo = ScalarTypeInfo.Double();
				return true;
			}
			if (type == typeof(Guid))
			{
				typeInfo = ScalarTypeInfo.Guid();
				return true;
			}
			typeInfo = null;
			return false;
		}

		internal bool GetMetadataLength(out uint size)
		{
			size = 0u;
			TypeCode typeCodeExtended = GetTypeCodeExtended(ParameterType);
			if (typeCodeExtended == TypeCode.Object)
			{
				if (!(TypeInfo is InvokeTypeInfo invokeTypeInfo))
				{
					return false;
				}
				size += 8u;
				PropertyAnalysis[] properties = invokeTypeInfo.properties;
				if (properties != null)
				{
					PropertyAnalysis[] array = properties;
					foreach (PropertyAnalysis property in array)
					{
						size += GetMetadataLengthForProperty(property);
					}
				}
				size += 2u;
			}
			else
			{
				size += (uint)(4 + (ParameterName.Length + 1) * 2);
			}
			return true;
		}

		private static uint GetMetadataLengthForProperty(PropertyAnalysis property)
		{
			uint num = 0u;
			if (property.typeInfo is InvokeTypeInfo invokeTypeInfo)
			{
				num += 8;
				PropertyAnalysis[] properties = invokeTypeInfo.properties;
				if (properties != null)
				{
					PropertyAnalysis[] array = properties;
					foreach (PropertyAnalysis property2 in array)
					{
						num += GetMetadataLengthForProperty(property2);
					}
				}
				return num + (uint)((property.name.Length + 1) * 2);
			}
			return num + (uint)(4 + (property.name.Length + 1) * 2);
		}

		private static TypeCode GetTypeCodeExtended(Type parameterType)
		{
			if (parameterType == typeof(Guid))
			{
				return (TypeCode)17;
			}
			if (parameterType == typeof(IntPtr))
			{
				if (IntPtr.Size != 4)
				{
				}
				return TypeCode.Int32;
			}
			if (parameterType == typeof(UIntPtr))
			{
				if (UIntPtr.Size != 4)
				{
				}
				return TypeCode.UInt32;
			}
			return Type.GetTypeCode(parameterType);
		}

		internal bool GetMetadataLengthV2(out uint size)
		{
			return GetMetadataLengthForNamedTypeV2(ParameterName, TypeInfo, out size);
		}

		private static bool GetMetadataLengthForTypeV2(TraceLoggingTypeInfo typeInfo, out uint size)
		{
			size = 0u;
			if (typeInfo == null)
			{
				return false;
			}
			if (typeInfo is InvokeTypeInfo invokeTypeInfo)
			{
				size += 8u;
				PropertyAnalysis[] properties = invokeTypeInfo.properties;
				if (properties != null)
				{
					PropertyAnalysis[] array = properties;
					foreach (PropertyAnalysis propertyAnalysis in array)
					{
						if (!GetMetadataLengthForNamedTypeV2(propertyAnalysis.name, propertyAnalysis.typeInfo, out var size2))
						{
							return false;
						}
						size += size2;
					}
				}
			}
			else if (typeInfo is EnumerableTypeInfo enumerableTypeInfo)
			{
				size += 4u;
				if (!GetMetadataLengthForTypeV2(enumerableTypeInfo.ElementInfo, out var size3))
				{
					return false;
				}
				size += size3;
			}
			else if (typeInfo is ScalarArrayTypeInfo scalarArrayTypeInfo)
			{
				if (!scalarArrayTypeInfo.DataType.HasElementType || !GetTypeInfoFromType(scalarArrayTypeInfo.DataType.GetElementType(), out var typeInfo2))
				{
					return false;
				}
				size += 4u;
				if (!GetMetadataLengthForTypeV2(typeInfo2, out var size4))
				{
					return false;
				}
				size += size4;
			}
			else
			{
				size += 4u;
			}
			return true;
		}

		private static bool GetMetadataLengthForNamedTypeV2(string name, TraceLoggingTypeInfo typeInfo, out uint size)
		{
			size = (uint)(4 + (name.Length + 1) * 2);
			if (!GetMetadataLengthForTypeV2(typeInfo, out var size2))
			{
				return false;
			}
			size += size2;
			return true;
		}
	}
	internal static class EventPipePayloadDecoder
	{
		internal static object[] DecodePayload(ref EventSource.EventMetadata metadata, ReadOnlySpan<byte> payload)
		{
			ParameterInfo[] parameters = metadata.Parameters;
			object[] array = new object[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				if (payload.Length <= 0)
				{
					break;
				}
				Type parameterType = parameters[i].ParameterType;
				Type type = (parameterType.IsEnum ? Enum.GetUnderlyingType(parameterType) : null);
				if (parameterType == typeof(IntPtr))
				{
					if (IntPtr.Size == 8)
					{
					}
					array[i] = (IntPtr)BinaryPrimitives.ReadInt32LittleEndian(payload);
					payload = payload.Slice(IntPtr.Size);
				}
				else if (parameterType == typeof(int) || type == typeof(int))
				{
					array[i] = BinaryPrimitives.ReadInt32LittleEndian(payload);
					payload = payload.Slice(4);
				}
				else if (parameterType == typeof(uint) || type == typeof(uint))
				{
					array[i] = BinaryPrimitives.ReadUInt32LittleEndian(payload);
					payload = payload.Slice(4);
				}
				else if (parameterType == typeof(long) || type == typeof(long))
				{
					array[i] = BinaryPrimitives.ReadInt64LittleEndian(payload);
					payload = payload.Slice(8);
				}
				else if (parameterType == typeof(ulong) || type == typeof(ulong))
				{
					array[i] = BinaryPrimitives.ReadUInt64LittleEndian(payload);
					payload = payload.Slice(8);
				}
				else if (parameterType == typeof(byte) || type == typeof(byte))
				{
					array[i] = MemoryMarshal.Read<byte>(payload);
					payload = payload.Slice(1);
				}
				else if (parameterType == typeof(sbyte) || type == typeof(sbyte))
				{
					array[i] = MemoryMarshal.Read<sbyte>(payload);
					payload = payload.Slice(1);
				}
				else if (parameterType == typeof(short) || type == typeof(short))
				{
					array[i] = BinaryPrimitives.ReadInt16LittleEndian(payload);
					payload = payload.Slice(2);
				}
				else if (parameterType == typeof(ushort) || type == typeof(ushort))
				{
					array[i] = BinaryPrimitives.ReadUInt16LittleEndian(payload);
					payload = payload.Slice(2);
				}
				else if (parameterType == typeof(float))
				{
					array[i] = BitConverter.Int32BitsToSingle(BinaryPrimitives.ReadInt32LittleEndian(payload));
					payload = payload.Slice(4);
				}
				else if (parameterType == typeof(double))
				{
					array[i] = BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(payload));
					payload = payload.Slice(8);
				}
				else if (parameterType == typeof(bool))
				{
					array[i] = BinaryPrimitives.ReadInt32LittleEndian(payload) == 1;
					payload = payload.Slice(4);
				}
				else if (parameterType == typeof(Guid))
				{
					array[i] = new Guid(payload.Slice(0, 16));
					payload = payload.Slice(16);
				}
				else if (parameterType == typeof(char))
				{
					array[i] = (char)BinaryPrimitives.ReadUInt16LittleEndian(payload);
					payload = payload.Slice(2);
				}
				else
				{
					if (!(parameterType == typeof(string)))
					{
						continue;
					}
					int num = -1;
					for (int j = 1; j < payload.Length; j += 2)
					{
						if (payload[j - 1] == 0 && payload[j] == 0)
						{
							num = j + 1;
							break;
						}
					}
					ReadOnlySpan<char> value;
					if (num < 0)
					{
						value = MemoryMarshal.Cast<byte, char>(payload);
						payload = default(ReadOnlySpan<byte>);
					}
					else
					{
						value = MemoryMarshal.Cast<byte, char>(payload.Slice(0, num - 2));
						payload = payload.Slice(num);
					}
					int num2 = i;
					if (!BitConverter.IsLittleEndian)
					{
					}
					array[num2] = new string(value);
				}
			}
			return array;
		}
	}
	internal enum EventProviderType
	{
		None,
		ETW,
		EventPipe
	}
	internal enum ControllerCommand
	{
		Update = 0,
		SendManifest = -1,
		Enable = -2,
		Disable = -3
	}
	internal class EventProvider : IDisposable
	{
		public struct EventData
		{
			internal ulong Ptr;

			internal uint Size;

			internal uint Reserved;
		}

		public struct SessionInfo
		{
			internal int sessionIdBit;

			internal int etwSessionId;

			internal SessionInfo(int sessionIdBit_, int etwSessionId_)
			{
				sessionIdBit = sessionIdBit_;
				etwSessionId = etwSessionId_;
			}
		}

		public enum WriteEventErrorCode
		{
			NoError,
			NoFreeBuffers,
			EventTooBig,
			NullInput,
			TooManyArgs,
			Other
		}

		private delegate void SessionInfoCallback(int etwSessionId, long matchAllKeywords, ref List<SessionInfo> sessionList);

		private struct EightObjects
		{
			internal object _arg0;

			private object _arg1;

			private object _arg2;

			private object _arg3;

			private object _arg4;

			private object _arg5;

			private object _arg6;

			private object _arg7;
		}

		internal IEventProvider m_eventProvider;

		private Interop.Advapi32.EtwEnableCallback m_etwCallback;

		private long m_regHandle;

		private byte m_level;

		private long m_anyKeywordMask;

		private long m_allKeywordMask;

		private List<SessionInfo> m_liveSessions;

		private bool m_enabled;

		private string m_providerName;

		private Guid m_providerId;

		internal bool m_disposed;

		[ThreadStatic]
		private static WriteEventErrorCode s_returnCode;

		private const int BasicTypeAllocationBufferSize = 16;

		private const int EtwMaxNumberArguments = 128;

		private const int EtwAPIMaxRefObjCount = 8;

		private const int TraceEventMaximumSize = 65482;

		private static bool m_setInformationMissing;

		protected EventLevel Level
		{
			get
			{
				return (EventLevel)m_level;
			}
			set
			{
				m_level = (byte)value;
			}
		}

		protected EventKeywords MatchAnyKeyword
		{
			get
			{
				return (EventKeywords)m_anyKeywordMask;
			}
			set
			{
				m_anyKeywordMask = (long)value;
			}
		}

		protected EventKeywords MatchAllKeyword
		{
			get
			{
				return (EventKeywords)m_allKeywordMask;
			}
			set
			{
				m_allKeywordMask = (long)value;
			}
		}

		internal EventProvider(EventProviderType providerType)
		{
			m_eventProvider = providerType switch
			{
				EventProviderType.ETW => new EtwEventProvider(), 
				EventProviderType.EventPipe => new EventPipeEventProvider(), 
				_ => new NoOpEventProvider(), 
			};
		}

		internal unsafe void Register(EventSource eventSource)
		{
			m_etwCallback = EtwEnableCallBack;
			uint num = EventRegister(eventSource, m_etwCallback);
			if (num != 0)
			{
				throw new ArgumentException(Interop.Kernel32.GetMessage((int)num));
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (m_disposed)
			{
				return;
			}
			m_enabled = false;
			long num = 0L;
			lock (EventListener.EventListenersLock)
			{
				if (m_disposed)
				{
					return;
				}
				num = m_regHandle;
				m_regHandle = 0L;
				m_disposed = true;
			}
			if (num != 0L)
			{
				EventUnregister(num);
			}
		}

		public virtual void Close()
		{
			Dispose();
		}

		~EventProvider()
		{
			Dispose(disposing: false);
		}

		private unsafe void EtwEnableCallBack(in Guid sourceId, int controlCode, byte setLevel, long anyKeyword, long allKeyword, Interop.Advapi32.EVENT_FILTER_DESCRIPTOR* filterData, void* callbackContext)
		{
			try
			{
				ControllerCommand command = ControllerCommand.Update;
				IDictionary<string, string> dictionary = null;
				bool flag = false;
				switch (controlCode)
				{
				case 1:
				{
					m_enabled = true;
					m_level = setLevel;
					m_anyKeywordMask = anyKeyword;
					m_allKeywordMask = allKeyword;
					List<KeyValuePair<SessionInfo, bool>> sessions = GetSessions();
					if (sessions.Count == 0)
					{
						sessions.Add(new KeyValuePair<SessionInfo, bool>(new SessionInfo(0, 0), value: true));
					}
					foreach (KeyValuePair<SessionInfo, bool> item in sessions)
					{
						int sessionIdBit = item.Key.sessionIdBit;
						int etwSessionId = item.Key.etwSessionId;
						bool value = item.Value;
						flag = true;
						dictionary = null;
						if (sessions.Count > 1)
						{
							filterData = null;
						}
						if (value && GetDataFromController(etwSessionId, filterData, out command, out var data, out var dataStart))
						{
							dictionary = new Dictionary<string, string>(4);
							if (data != null)
							{
								while (dataStart < data.Length)
								{
									int num = FindNull(data, dataStart);
									int num2 = num + 1;
									int num3 = FindNull(data, num2);
									if (num3 < data.Length)
									{
										string @string = Encoding.UTF8.GetString(data, dataStart, num - dataStart);
										string string2 = Encoding.UTF8.GetString(data, num2, num3 - num2);
										dictionary[@string] = string2;
									}
									dataStart = num3 + 1;
								}
							}
						}
						OnControllerCommand(command, dictionary, value ? sessionIdBit : (-sessionIdBit), etwSessionId);
					}
					break;
				}
				case 0:
					m_enabled = false;
					m_level = 0;
					m_anyKeywordMask = 0L;
					m_allKeywordMask = 0L;
					m_liveSessions = null;
					break;
				case 2:
					command = ControllerCommand.SendManifest;
					break;
				default:
					return;
				}
				if (!flag)
				{
					OnControllerCommand(command, dictionary, 0, 0);
				}
			}
			catch
			{
			}
		}

		protected virtual void OnControllerCommand(ControllerCommand command, IDictionary<string, string> arguments, int sessionId, int etwSessionId)
		{
		}

		private static int FindNull(byte[] buffer, int idx)
		{
			while (idx < buffer.Length && buffer[idx] != 0)
			{
				idx++;
			}
			return idx;
		}

		private List<KeyValuePair<SessionInfo, bool>> GetSessions()
		{
			List<SessionInfo> sessionList2 = null;
			GetSessionInfo(delegate(int etwSessionId, long matchAllKeywords, ref List<SessionInfo> sessionList)
			{
				GetSessionInfoCallback(etwSessionId, matchAllKeywords, ref sessionList);
			}, ref sessionList2);
			List<KeyValuePair<SessionInfo, bool>> list = new List<KeyValuePair<SessionInfo, bool>>();
			if (m_liveSessions != null)
			{
				foreach (SessionInfo liveSession in m_liveSessions)
				{
					int index;
					if ((index = IndexOfSessionInList(sessionList2, liveSession.etwSessionId)) < 0 || sessionList2[index].sessionIdBit != liveSession.sessionIdBit)
					{
						list.Add(new KeyValuePair<SessionInfo, bool>(liveSession, value: false));
					}
				}
			}
			if (sessionList2 != null)
			{
				foreach (SessionInfo item in sessionList2)
				{
					int index2;
					if ((index2 = IndexOfSessionInList(m_liveSessions, item.etwSessionId)) < 0 || m_liveSessions[index2].sessionIdBit != item.sessionIdBit)
					{
						list.Add(new KeyValuePair<SessionInfo, bool>(item, value: true));
					}
				}
			}
			m_liveSessions = sessionList2;
			return list;
		}

		private static void GetSessionInfoCallback(int etwSessionId, long matchAllKeywords, ref List<SessionInfo> sessionList)
		{
			uint value = (uint)SessionMask.FromEventKeywords((ulong)matchAllKeywords);
			int num = BitOperations.PopCount(value);
			if (num <= 1)
			{
				if (sessionList == null)
				{
					sessionList = new List<SessionInfo>(8);
				}
				num = ((num != 1) ? BitOperations.PopCount((uint)SessionMask.All) : BitOperations.TrailingZeroCount(value));
				sessionList.Add(new SessionInfo(num + 1, etwSessionId));
			}
		}

		private unsafe void GetSessionInfo(SessionInfoCallback action, ref List<SessionInfo> sessionList)
		{
			int ReturnLength = 256;
			byte* ptr = stackalloc byte[(int)(uint)ReturnLength];
			byte* ptr2 = ptr;
			try
			{
				while (true)
				{
					int num = 0;
					fixed (Guid* inBuffer = &m_providerId)
					{
						num = Interop.Advapi32.EnumerateTraceGuidsEx(Interop.Advapi32.TRACE_QUERY_INFO_CLASS.TraceGuidQueryInfo, inBuffer, sizeof(Guid), ptr2, ReturnLength, out ReturnLength);
					}
					switch (num)
					{
					default:
						return;
					case 122:
						if (ptr2 != ptr)
						{
							byte* ptr7 = ptr2;
							ptr2 = null;
							Marshal.FreeHGlobal((IntPtr)ptr7);
						}
						break;
					case 0:
					{
						Interop.Advapi32.TRACE_GUID_INFO* ptr3 = (Interop.Advapi32.TRACE_GUID_INFO*)ptr2;
						Interop.Advapi32.TRACE_PROVIDER_INSTANCE_INFO* ptr4 = (Interop.Advapi32.TRACE_PROVIDER_INSTANCE_INFO*)(ptr3 + 1);
						int currentProcessId = (int)Interop.Kernel32.GetCurrentProcessId();
						for (int i = 0; i < ptr3->InstanceCount; i++)
						{
							if (ptr4->Pid == currentProcessId)
							{
								Interop.Advapi32.TRACE_ENABLE_INFO* ptr5 = (Interop.Advapi32.TRACE_ENABLE_INFO*)(ptr4 + 1);
								for (int j = 0; j < ptr4->EnableCount; j++)
								{
									action(ptr5[j].LoggerId, ptr5[j].MatchAllKeyword, ref sessionList);
								}
							}
							if (ptr4->NextOffset == 0)
							{
								break;
							}
							byte* ptr6 = (byte*)ptr4;
							ptr4 = (Interop.Advapi32.TRACE_PROVIDER_INSTANCE_INFO*)(ptr6 + ptr4->NextOffset);
						}
						return;
					}
					}
					ptr2 = (byte*)(void*)Marshal.AllocHGlobal(ReturnLength);
				}
			}
			finally
			{
				if (ptr2 != null && ptr2 != ptr)
				{
					Marshal.FreeHGlobal((IntPtr)ptr2);
				}
			}
		}

		private static int IndexOfSessionInList(List<SessionInfo> sessions, int etwSessionId)
		{
			if (sessions == null)
			{
				return -1;
			}
			for (int i = 0; i < sessions.Count; i++)
			{
				if (sessions[i].etwSessionId == etwSessionId)
				{
					return i;
				}
			}
			return -1;
		}

		private unsafe bool GetDataFromController(int etwSessionId, Interop.Advapi32.EVENT_FILTER_DESCRIPTOR* filterData, out ControllerCommand command, out byte[] data, out int dataStart)
		{
			data = null;
			dataStart = 0;
			if (filterData == null)
			{
				string text = "\\Microsoft\\Windows\\CurrentVersion\\Winevt\\Publishers\\{" + m_providerId.ToString() + "}";
				if (IntPtr.Size == 8)
				{
				}
				text = "Software" + text;
				string name = "ControllerData_Session_" + etwSessionId.ToString(CultureInfo.InvariantCulture);
				using (RegistryKey registryKey = Registry.LocalMachine.OpenSubKey(text))
				{
					data = registryKey?.GetValue(name, null) as byte[];
					if (data != null)
					{
						command = ControllerCommand.Update;
						return true;
					}
				}
				command = ControllerCommand.Update;
				return false;
			}
			if (filterData->Ptr != 0L && 0 < filterData->Size && filterData->Size <= 102400)
			{
				data = new byte[filterData->Size];
				Marshal.Copy((IntPtr)(void*)filterData->Ptr, data, 0, data.Length);
			}
			command = (ControllerCommand)filterData->Type;
			return true;
		}

		public bool IsEnabled()
		{
			return m_enabled;
		}

		public bool IsEnabled(byte level, long keywords)
		{
			if (!m_enabled)
			{
				return false;
			}
			if ((level <= m_level || m_level == 0) && (keywords == 0L || ((keywords & m_anyKeywordMask) != 0L && (keywords & m_allKeywordMask) == m_allKeywordMask)))
			{
				return true;
			}
			return false;
		}

		public static WriteEventErrorCode GetLastWriteEventError()
		{
			return s_returnCode;
		}

		private static void SetLastError(WriteEventErrorCode error)
		{
			s_returnCode = error;
		}

		private unsafe static object EncodeObject(ref object data, ref EventData* dataDescriptor, ref byte* dataBuffer, ref uint totalEventSize)
		{
			string text;
			byte[] array;
			while (true)
			{
				dataDescriptor->Reserved = 0u;
				text = data as string;
				array = null;
				if (text != null)
				{
					dataDescriptor->Size = (uint)((text.Length + 1) * 2);
					break;
				}
				if ((array = data as byte[]) != null)
				{
					*(int*)dataBuffer = array.Length;
					dataDescriptor->Ptr = (ulong)dataBuffer;
					dataDescriptor->Size = 4u;
					totalEventSize += dataDescriptor->Size;
					dataDescriptor++;
					dataBuffer += 16;
					dataDescriptor->Size = (uint)array.Length;
					break;
				}
				if (data is IntPtr)
				{
					dataDescriptor->Size = (uint)sizeof(IntPtr);
					IntPtr* ptr = (IntPtr*)dataBuffer;
					*ptr = (IntPtr)data;
					dataDescriptor->Ptr = (ulong)ptr;
					break;
				}
				if (data is int)
				{
					dataDescriptor->Size = 4u;
					int* ptr2 = (int*)dataBuffer;
					*ptr2 = (int)data;
					dataDescriptor->Ptr = (ulong)ptr2;
					break;
				}
				if (data is long)
				{
					dataDescriptor->Size = 8u;
					long* ptr3 = (long*)dataBuffer;
					*ptr3 = (long)data;
					dataDescriptor->Ptr = (ulong)ptr3;
					break;
				}
				if (data is uint)
				{
					dataDescriptor->Size = 4u;
					uint* ptr4 = (uint*)dataBuffer;
					*ptr4 = (uint)data;
					dataDescriptor->Ptr = (ulong)ptr4;
					break;
				}
				if (data is ulong)
				{
					dataDescriptor->Size = 8u;
					ulong* ptr5 = (ulong*)dataBuffer;
					*ptr5 = (ulong)data;
					dataDescriptor->Ptr = (ulong)ptr5;
					break;
				}
				if (data is char)
				{
					dataDescriptor->Size = 2u;
					char* ptr6 = (char*)dataBuffer;
					*ptr6 = (char)data;
					dataDescriptor->Ptr = (ulong)ptr6;
					break;
				}
				if (data is byte)
				{
					dataDescriptor->Size = 1u;
					byte* ptr7 = dataBuffer;
					*ptr7 = (byte)data;
					dataDescriptor->Ptr = (ulong)ptr7;
					break;
				}
				if (data is short)
				{
					dataDescriptor->Size = 2u;
					short* ptr8 = (short*)dataBuffer;
					*ptr8 = (short)data;
					dataDescriptor->Ptr = (ulong)ptr8;
					break;
				}
				if (data is sbyte)
				{
					dataDescriptor->Size = 1u;
					sbyte* ptr9 = (sbyte*)dataBuffer;
					*ptr9 = (sbyte)data;
					dataDescriptor->Ptr = (ulong)ptr9;
					break;
				}
				if (data is ushort)
				{
					dataDescriptor->Size = 2u;
					ushort* ptr10 = (ushort*)dataBuffer;
					*ptr10 = (ushort)data;
					dataDescriptor->Ptr = (ulong)ptr10;
					break;
				}
				if (data is float)
				{
					dataDescriptor->Size = 4u;
					float* ptr11 = (float*)dataBuffer;
					*ptr11 = (float)data;
					dataDescriptor->Ptr = (ulong)ptr11;
					break;
				}
				if (data is double)
				{
					dataDescriptor->Size = 8u;
					double* ptr12 = (double*)dataBuffer;
					*ptr12 = (double)data;
					dataDescriptor->Ptr = (ulong)ptr12;
					break;
				}
				if (data is bool)
				{
					dataDescriptor->Size = 4u;
					int* ptr13 = (int*)dataBuffer;
					if ((bool)data)
					{
						*ptr13 = 1;
					}
					else
					{
						*ptr13 = 0;
					}
					dataDescriptor->Ptr = (ulong)ptr13;
					break;
				}
				if (data is Guid)
				{
					dataDescriptor->Size = (uint)sizeof(Guid);
					Guid* ptr14 = (Guid*)dataBuffer;
					*ptr14 = (Guid)data;
					dataDescriptor->Ptr = (ulong)ptr14;
					break;
				}
				if (data is decimal)
				{
					dataDescriptor->Size = 16u;
					decimal* ptr15 = (decimal*)dataBuffer;
					*ptr15 = (decimal)data;
					dataDescriptor->Ptr = (ulong)ptr15;
					break;
				}
				if (data is DateTime)
				{
					long num = 0L;
					if (((DateTime)data).Ticks > 504911232000000000L)
					{
						num = ((DateTime)data).ToFileTimeUtc();
					}
					dataDescriptor->Size = 8u;
					long* ptr16 = (long*)dataBuffer;
					*ptr16 = num;
					dataDescriptor->Ptr = (ulong)ptr16;
					break;
				}
				if (data is Enum)
				{
					try
					{
						Type underlyingType = Enum.GetUnderlyingType(data.GetType());
						if (underlyingType == typeof(ulong))
						{
							data = (ulong)data;
						}
						else if (underlyingType == typeof(long))
						{
							data = (long)data;
						}
						else
						{
							data = (int)Convert.ToInt64(data);
						}
					}
					catch
					{
						goto IL_0411;
					}
					continue;
				}
				goto IL_0411;
				IL_0411:
				text = ((data != null) ? data.ToString() : "");
				dataDescriptor->Size = (uint)((text.Length + 1) * 2);
				break;
			}
			totalEventSize += dataDescriptor->Size;
			dataDescriptor++;
			dataBuffer += 16;
			return ((object)text) ?? ((object)array);
		}

		internal unsafe bool WriteEvent(ref EventDescriptor eventDescriptor, IntPtr eventHandle, Guid* activityID, Guid* childActivityID, object[] eventPayload)
		{
			//The blocks IL_0220, IL_0231, IL_0242, IL_0255, IL_025a, IL_0263, IL_0264, IL_0275, IL_0286, IL_0299, IL_029e, IL_02a7, IL_02a8, IL_02b9, IL_02ca, IL_02dd, IL_02e2, IL_02eb, IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_021b. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_0264, IL_0275, IL_0286, IL_0299, IL_029e, IL_02a7, IL_02a8, IL_02b9, IL_02ca, IL_02dd, IL_02e2, IL_02eb, IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_025f. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02a8, IL_02b9, IL_02ca, IL_02dd, IL_02e2, IL_02eb, IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02a3. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02e7. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02e7. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02a8, IL_02b9, IL_02ca, IL_02dd, IL_02e2, IL_02eb, IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02a3. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02e7. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02e7. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_0264, IL_0275, IL_0286, IL_0299, IL_029e, IL_02a7, IL_02a8, IL_02b9, IL_02ca, IL_02dd, IL_02e2, IL_02eb, IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_025f. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02a8, IL_02b9, IL_02ca, IL_02dd, IL_02e2, IL_02eb, IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02a3. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02e7. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02e7. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02a8, IL_02b9, IL_02ca, IL_02dd, IL_02e2, IL_02eb, IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02a3. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02e7. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			//The blocks IL_02ec, IL_02fd, IL_0319, IL_0324, IL_0340, IL_034b, IL_0367, IL_0372, IL_038e, IL_0399, IL_03b5, IL_03c0, IL_03dc, IL_03e7, IL_0403, IL_040e, IL_042a are reachable both inside and outside the pinned region starting at IL_02e7. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			WriteEventErrorCode writeEventErrorCode = WriteEventErrorCode.NoError;
			if (IsEnabled(eventDescriptor.Level, eventDescriptor.Keywords))
			{
				int num = eventPayload.Length;
				if (num > 128)
				{
					s_returnCode = WriteEventErrorCode.TooManyArgs;
					return false;
				}
				uint totalEventSize = 0u;
				int i = 0;
				EightObjects eightObjects = default(EightObjects);
				Span<int> span = stackalloc int[8];
				Span<object> span2 = new Span<object>(ref eightObjects._arg0, 8);
				EventData* ptr = stackalloc EventData[2 * num];
				for (int j = 0; j < 2 * num; j++)
				{
					ptr[j] = default(EventData);
				}
				EventData* dataDescriptor = ptr;
				byte* ptr2 = stackalloc byte[(int)(uint)(32 * num)];
				byte* dataBuffer = ptr2;
				bool flag = false;
				for (int k = 0; k < eventPayload.Length; k++)
				{
					if (eventPayload[k] != null)
					{
						object obj = EncodeObject(ref eventPayload[k], ref dataDescriptor, ref dataBuffer, ref totalEventSize);
						if (obj == null)
						{
							continue;
						}
						int num2 = (int)(dataDescriptor - ptr - 1);
						if (!(obj is string))
						{
							if (eventPayload.Length + num2 + 1 - k > 128)
							{
								s_returnCode = WriteEventErrorCode.TooManyArgs;
								return false;
							}
							flag = true;
						}
						if (i >= span2.Length)
						{
							Span<object> span3 = new object[span2.Length * 2];
							span2.CopyTo(span3);
							span2 = span3;
							Span<int> span4 = new int[span.Length * 2];
							span.CopyTo(span4);
							span = span4;
						}
						span2[i] = obj;
						span[i] = num2;
						i++;
						continue;
					}
					s_returnCode = WriteEventErrorCode.NullInput;
					return false;
				}
				num = (int)(dataDescriptor - ptr);
				if (totalEventSize > 65482)
				{
					s_returnCode = WriteEventErrorCode.EventTooBig;
					return false;
				}
				if (!flag && i <= 8)
				{
					for (; i < 8; i++)
					{
						span2[i] = null;
						span[i] = -1;
					}
					fixed (char* ptr13 = (string)span2[0])
					{
						string obj2 = (string)span2[1];
						char* intPtr;
						object obj3;
						object obj4;
						char* intPtr2;
						object obj5;
						object obj6;
						char* intPtr3;
						object obj7;
						object obj8;
						char* intPtr4;
						if (obj2 == null)
						{
							char* ptr3;
							intPtr = (ptr3 = null);
							obj3 = (string)span2[2];
							fixed (char* ptr4 = (string)obj3)
							{
								char* ptr5 = ptr4;
								obj4 = (string)span2[3];
								if (obj4 == null)
								{
									char* ptr6;
									intPtr2 = (ptr6 = null);
									obj5 = (string)span2[4];
									fixed (char* ptr7 = (string)obj5)
									{
										char* ptr8 = ptr7;
										obj6 = (string)span2[5];
										if (obj6 == null)
										{
											char* ptr9;
											intPtr3 = (ptr9 = null);
											obj7 = (string)span2[6];
											fixed (char* ptr10 = (string)obj7)
											{
												char* ptr11 = ptr10;
												obj8 = (string)span2[7];
												if (obj8 == null)
												{
													char* ptr12;
													intPtr4 = (ptr12 = null);
													dataDescriptor = ptr;
													if (span2[0] != null)
													{
														dataDescriptor[span[0]].Ptr = (ulong)ptr13;
													}
													if (span2[1] != null)
													{
														dataDescriptor[span[1]].Ptr = (ulong)ptr3;
													}
													if (span2[2] != null)
													{
														dataDescriptor[span[2]].Ptr = (ulong)ptr5;
													}
													if (span2[3] != null)
													{
														dataDescriptor[span[3]].Ptr = (ulong)ptr6;
													}
													if (span2[4] != null)
													{
														dataDescriptor[span[4]].Ptr = (ulong)ptr8;
													}
													if (span2[5] != null)
													{
														dataDescriptor[span[5]].Ptr = (ulong)ptr9;
													}
													if (span2[6] != null)
													{
														dataDescriptor[span[6]].Ptr = (ulong)ptr11;
													}
													if (span2[7] != null)
													{
														dataDescriptor[span[7]].Ptr = (ulong)ptr12;
													}
													writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
												}
												else
												{
													fixed (char* ptr14 = &((string)obj8).GetPinnableReference())
													{
														char* ptr12;
														intPtr4 = (ptr12 = ptr14);
														dataDescriptor = ptr;
														if (span2[0] != null)
														{
															dataDescriptor[span[0]].Ptr = (ulong)ptr13;
														}
														if (span2[1] != null)
														{
															dataDescriptor[span[1]].Ptr = (ulong)ptr3;
														}
														if (span2[2] != null)
														{
															dataDescriptor[span[2]].Ptr = (ulong)ptr5;
														}
														if (span2[3] != null)
														{
															dataDescriptor[span[3]].Ptr = (ulong)ptr6;
														}
														if (span2[4] != null)
														{
															dataDescriptor[span[4]].Ptr = (ulong)ptr8;
														}
														if (span2[5] != null)
														{
															dataDescriptor[span[5]].Ptr = (ulong)ptr9;
														}
														if (span2[6] != null)
														{
															dataDescriptor[span[6]].Ptr = (ulong)ptr11;
														}
														if (span2[7] != null)
														{
															dataDescriptor[span[7]].Ptr = (ulong)ptr12;
														}
														writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
													}
												}
											}
										}
										else
										{
											fixed (char* ptr15 = &((string)obj6).GetPinnableReference())
											{
												char* ptr9;
												intPtr3 = (ptr9 = ptr15);
												obj7 = (string)span2[6];
												fixed (char* ptr10 = (string)obj7)
												{
													char* ptr11 = ptr10;
													obj8 = (string)span2[7];
													if (obj8 == null)
													{
														char* ptr12;
														intPtr4 = (ptr12 = null);
														dataDescriptor = ptr;
														if (span2[0] != null)
														{
															dataDescriptor[span[0]].Ptr = (ulong)ptr13;
														}
														if (span2[1] != null)
														{
															dataDescriptor[span[1]].Ptr = (ulong)ptr3;
														}
														if (span2[2] != null)
														{
															dataDescriptor[span[2]].Ptr = (ulong)ptr5;
														}
														if (span2[3] != null)
														{
															dataDescriptor[span[3]].Ptr = (ulong)ptr6;
														}
														if (span2[4] != null)
														{
															dataDescriptor[span[4]].Ptr = (ulong)ptr8;
														}
														if (span2[5] != null)
														{
															dataDescriptor[span[5]].Ptr = (ulong)ptr9;
														}
														if (span2[6] != null)
														{
															dataDescriptor[span[6]].Ptr = (ulong)ptr11;
														}
														if (span2[7] != null)
														{
															dataDescriptor[span[7]].Ptr = (ulong)ptr12;
														}
														writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
													}
													else
													{
														fixed (char* ptr14 = &((string)obj8).GetPinnableReference())
														{
															char* ptr12;
															intPtr4 = (ptr12 = ptr14);
															dataDescriptor = ptr;
															if (span2[0] != null)
															{
																dataDescriptor[span[0]].Ptr = (ulong)ptr13;
															}
															if (span2[1] != null)
															{
																dataDescriptor[span[1]].Ptr = (ulong)ptr3;
															}
															if (span2[2] != null)
															{
																dataDescriptor[span[2]].Ptr = (ulong)ptr5;
															}
															if (span2[3] != null)
															{
																dataDescriptor[span[3]].Ptr = (ulong)ptr6;
															}
															if (span2[4] != null)
															{
																dataDescriptor[span[4]].Ptr = (ulong)ptr8;
															}
															if (span2[5] != null)
															{
																dataDescriptor[span[5]].Ptr = (ulong)ptr9;
															}
															if (span2[6] != null)
															{
																dataDescriptor[span[6]].Ptr = (ulong)ptr11;
															}
															if (span2[7] != null)
															{
																dataDescriptor[span[7]].Ptr = (ulong)ptr12;
															}
															writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
														}
													}
												}
											}
										}
									}
								}
								else
								{
									fixed (char* ptr16 = &((string)obj4).GetPinnableReference())
									{
										char* ptr6;
										intPtr2 = (ptr6 = ptr16);
										obj5 = (string)span2[4];
										fixed (char* ptr7 = (string)obj5)
										{
											char* ptr8 = ptr7;
											obj6 = (string)span2[5];
											if (obj6 == null)
											{
												char* ptr9;
												intPtr3 = (ptr9 = null);
												obj7 = (string)span2[6];
												fixed (char* ptr10 = (string)obj7)
												{
													char* ptr11 = ptr10;
													obj8 = (string)span2[7];
													if (obj8 == null)
													{
														char* ptr12;
														intPtr4 = (ptr12 = null);
														dataDescriptor = ptr;
														if (span2[0] != null)
														{
															dataDescriptor[span[0]].Ptr = (ulong)ptr13;
														}
														if (span2[1] != null)
														{
															dataDescriptor[span[1]].Ptr = (ulong)ptr3;
														}
														if (span2[2] != null)
														{
															dataDescriptor[span[2]].Ptr = (ulong)ptr5;
														}
														if (span2[3] != null)
														{
															dataDescriptor[span[3]].Ptr = (ulong)ptr6;
														}
														if (span2[4] != null)
														{
															dataDescriptor[span[4]].Ptr = (ulong)ptr8;
														}
														if (span2[5] != null)
														{
															dataDescriptor[span[5]].Ptr = (ulong)ptr9;
														}
														if (span2[6] != null)
														{
															dataDescriptor[span[6]].Ptr = (ulong)ptr11;
														}
														if (span2[7] != null)
														{
															dataDescriptor[span[7]].Ptr = (ulong)ptr12;
														}
														writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
													}
													else
													{
														fixed (char* ptr14 = &((string)obj8).GetPinnableReference())
														{
															char* ptr12;
															intPtr4 = (ptr12 = ptr14);
															dataDescriptor = ptr;
															if (span2[0] != null)
															{
																dataDescriptor[span[0]].Ptr = (ulong)ptr13;
															}
															if (span2[1] != null)
															{
																dataDescriptor[span[1]].Ptr = (ulong)ptr3;
															}
															if (span2[2] != null)
															{
																dataDescriptor[span[2]].Ptr = (ulong)ptr5;
															}
															if (span2[3] != null)
															{
																dataDescriptor[span[3]].Ptr = (ulong)ptr6;
															}
															if (span2[4] != null)
															{
																dataDescriptor[span[4]].Ptr = (ulong)ptr8;
															}
															if (span2[5] != null)
															{
																dataDescriptor[span[5]].Ptr = (ulong)ptr9;
															}
															if (span2[6] != null)
															{
																dataDescriptor[span[6]].Ptr = (ulong)ptr11;
															}
															if (span2[7] != null)
															{
																dataDescriptor[span[7]].Ptr = (ulong)ptr12;
															}
															writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
														}
													}
												}
											}
											else
											{
												fixed (char* ptr15 = &((string)obj6).GetPinnableReference())
												{
													char* ptr9;
													intPtr3 = (ptr9 = ptr15);
													obj7 = (string)span2[6];
													fixed (char* ptr10 = (string)obj7)
													{
														char* ptr11 = ptr10;
														obj8 = (string)span2[7];
														if (obj8 == null)
														{
															char* ptr12;
															intPtr4 = (ptr12 = null);
															dataDescriptor = ptr;
															if (span2[0] != null)
															{
																dataDescriptor[span[0]].Ptr = (ulong)ptr13;
															}
															if (span2[1] != null)
															{
																dataDescriptor[span[1]].Ptr = (ulong)ptr3;
															}
															if (span2[2] != null)
															{
																dataDescriptor[span[2]].Ptr = (ulong)ptr5;
															}
															if (span2[3] != null)
															{
																dataDescriptor[span[3]].Ptr = (ulong)ptr6;
															}
															if (span2[4] != null)
															{
																dataDescriptor[span[4]].Ptr = (ulong)ptr8;
															}
															if (span2[5] != null)
															{
																dataDescriptor[span[5]].Ptr = (ulong)ptr9;
															}
															if (span2[6] != null)
															{
																dataDescriptor[span[6]].Ptr = (ulong)ptr11;
															}
															if (span2[7] != null)
															{
																dataDescriptor[span[7]].Ptr = (ulong)ptr12;
															}
															writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
														}
														else
														{
															fixed (char* ptr14 = &((string)obj8).GetPinnableReference())
															{
																char* ptr12;
																intPtr4 = (ptr12 = ptr14);
																dataDescriptor = ptr;
																if (span2[0] != null)
																{
																	dataDescriptor[span[0]].Ptr = (ulong)ptr13;
																}
																if (span2[1] != null)
																{
																	dataDescriptor[span[1]].Ptr = (ulong)ptr3;
																}
																if (span2[2] != null)
																{
																	dataDescriptor[span[2]].Ptr = (ulong)ptr5;
																}
																if (span2[3] != null)
																{
																	dataDescriptor[span[3]].Ptr = (ulong)ptr6;
																}
																if (span2[4] != null)
																{
																	dataDescriptor[span[4]].Ptr = (ulong)ptr8;
																}
																if (span2[5] != null)
																{
																	dataDescriptor[span[5]].Ptr = (ulong)ptr9;
																}
																if (span2[6] != null)
																{
																	dataDescriptor[span[6]].Ptr = (ulong)ptr11;
																}
																if (span2[7] != null)
																{
																	dataDescriptor[span[7]].Ptr = (ulong)ptr12;
																}
																writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
						else
						{
							fixed (char* ptr17 = &obj2.GetPinnableReference())
							{
								char* ptr3;
								intPtr = (ptr3 = ptr17);
								obj3 = (string)span2[2];
								fixed (char* ptr4 = (string)obj3)
								{
									char* ptr5 = ptr4;
									obj4 = (string)span2[3];
									if (obj4 == null)
									{
										char* ptr6;
										intPtr2 = (ptr6 = null);
										obj5 = (string)span2[4];
										fixed (char* ptr7 = (string)obj5)
										{
											char* ptr8 = ptr7;
											obj6 = (string)span2[5];
											if (obj6 == null)
											{
												char* ptr9;
												intPtr3 = (ptr9 = null);
												obj7 = (string)span2[6];
												fixed (char* ptr10 = (string)obj7)
												{
													char* ptr11 = ptr10;
													obj8 = (string)span2[7];
													if (obj8 == null)
													{
														char* ptr12;
														intPtr4 = (ptr12 = null);
														dataDescriptor = ptr;
														if (span2[0] != null)
														{
															dataDescriptor[span[0]].Ptr = (ulong)ptr13;
														}
														if (span2[1] != null)
														{
															dataDescriptor[span[1]].Ptr = (ulong)ptr3;
														}
														if (span2[2] != null)
														{
															dataDescriptor[span[2]].Ptr = (ulong)ptr5;
														}
														if (span2[3] != null)
														{
															dataDescriptor[span[3]].Ptr = (ulong)ptr6;
														}
														if (span2[4] != null)
														{
															dataDescriptor[span[4]].Ptr = (ulong)ptr8;
														}
														if (span2[5] != null)
														{
															dataDescriptor[span[5]].Ptr = (ulong)ptr9;
														}
														if (span2[6] != null)
														{
															dataDescriptor[span[6]].Ptr = (ulong)ptr11;
														}
														if (span2[7] != null)
														{
															dataDescriptor[span[7]].Ptr = (ulong)ptr12;
														}
														writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
													}
													else
													{
														fixed (char* ptr14 = &((string)obj8).GetPinnableReference())
														{
															char* ptr12;
															intPtr4 = (ptr12 = ptr14);
															dataDescriptor = ptr;
															if (span2[0] != null)
															{
																dataDescriptor[span[0]].Ptr = (ulong)ptr13;
															}
															if (span2[1] != null)
															{
																dataDescriptor[span[1]].Ptr = (ulong)ptr3;
															}
															if (span2[2] != null)
															{
																dataDescriptor[span[2]].Ptr = (ulong)ptr5;
															}
															if (span2[3] != null)
															{
																dataDescriptor[span[3]].Ptr = (ulong)ptr6;
															}
															if (span2[4] != null)
															{
																dataDescriptor[span[4]].Ptr = (ulong)ptr8;
															}
															if (span2[5] != null)
															{
																dataDescriptor[span[5]].Ptr = (ulong)ptr9;
															}
															if (span2[6] != null)
															{
																dataDescriptor[span[6]].Ptr = (ulong)ptr11;
															}
															if (span2[7] != null)
															{
																dataDescriptor[span[7]].Ptr = (ulong)ptr12;
															}
															writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
														}
													}
												}
											}
											else
											{
												fixed (char* ptr15 = &((string)obj6).GetPinnableReference())
												{
													char* ptr9;
													intPtr3 = (ptr9 = ptr15);
													obj7 = (string)span2[6];
													fixed (char* ptr10 = (string)obj7)
													{
														char* ptr11 = ptr10;
														obj8 = (string)span2[7];
														if (obj8 == null)
														{
															char* ptr12;
															intPtr4 = (ptr12 = null);
															dataDescriptor = ptr;
															if (span2[0] != null)
															{
																dataDescriptor[span[0]].Ptr = (ulong)ptr13;
															}
															if (span2[1] != null)
															{
																dataDescriptor[span[1]].Ptr = (ulong)ptr3;
															}
															if (span2[2] != null)
															{
																dataDescriptor[span[2]].Ptr = (ulong)ptr5;
															}
															if (span2[3] != null)
															{
																dataDescriptor[span[3]].Ptr = (ulong)ptr6;
															}
															if (span2[4] != null)
															{
																dataDescriptor[span[4]].Ptr = (ulong)ptr8;
															}
															if (span2[5] != null)
															{
																dataDescriptor[span[5]].Ptr = (ulong)ptr9;
															}
															if (span2[6] != null)
															{
																dataDescriptor[span[6]].Ptr = (ulong)ptr11;
															}
															if (span2[7] != null)
															{
																dataDescriptor[span[7]].Ptr = (ulong)ptr12;
															}
															writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
														}
														else
														{
															fixed (char* ptr14 = &((string)obj8).GetPinnableReference())
															{
																char* ptr12;
																intPtr4 = (ptr12 = ptr14);
																dataDescriptor = ptr;
																if (span2[0] != null)
																{
																	dataDescriptor[span[0]].Ptr = (ulong)ptr13;
																}
																if (span2[1] != null)
																{
																	dataDescriptor[span[1]].Ptr = (ulong)ptr3;
																}
																if (span2[2] != null)
																{
																	dataDescriptor[span[2]].Ptr = (ulong)ptr5;
																}
																if (span2[3] != null)
																{
																	dataDescriptor[span[3]].Ptr = (ulong)ptr6;
																}
																if (span2[4] != null)
																{
																	dataDescriptor[span[4]].Ptr = (ulong)ptr8;
																}
																if (span2[5] != null)
																{
																	dataDescriptor[span[5]].Ptr = (ulong)ptr9;
																}
																if (span2[6] != null)
																{
																	dataDescriptor[span[6]].Ptr = (ulong)ptr11;
																}
																if (span2[7] != null)
																{
																	dataDescriptor[span[7]].Ptr = (ulong)ptr12;
																}
																writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
															}
														}
													}
												}
											}
										}
									}
									else
									{
										fixed (char* ptr16 = &((string)obj4).GetPinnableReference())
										{
											char* ptr6;
											intPtr2 = (ptr6 = ptr16);
											obj5 = (string)span2[4];
											fixed (char* ptr7 = (string)obj5)
											{
												char* ptr8 = ptr7;
												obj6 = (string)span2[5];
												if (obj6 == null)
												{
													char* ptr9;
													intPtr3 = (ptr9 = null);
													obj7 = (string)span2[6];
													fixed (char* ptr10 = (string)obj7)
													{
														char* ptr11 = ptr10;
														obj8 = (string)span2[7];
														if (obj8 == null)
														{
															char* ptr12;
															intPtr4 = (ptr12 = null);
															dataDescriptor = ptr;
															if (span2[0] != null)
															{
																dataDescriptor[span[0]].Ptr = (ulong)ptr13;
															}
															if (span2[1] != null)
															{
																dataDescriptor[span[1]].Ptr = (ulong)ptr3;
															}
															if (span2[2] != null)
															{
																dataDescriptor[span[2]].Ptr = (ulong)ptr5;
															}
															if (span2[3] != null)
															{
																dataDescriptor[span[3]].Ptr = (ulong)ptr6;
															}
															if (span2[4] != null)
															{
																dataDescriptor[span[4]].Ptr = (ulong)ptr8;
															}
															if (span2[5] != null)
															{
																dataDescriptor[span[5]].Ptr = (ulong)ptr9;
															}
															if (span2[6] != null)
															{
																dataDescriptor[span[6]].Ptr = (ulong)ptr11;
															}
															if (span2[7] != null)
															{
																dataDescriptor[span[7]].Ptr = (ulong)ptr12;
															}
															writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
														}
														else
														{
															fixed (char* ptr14 = &((string)obj8).GetPinnableReference())
															{
																char* ptr12;
																intPtr4 = (ptr12 = ptr14);
																dataDescriptor = ptr;
																if (span2[0] != null)
																{
																	dataDescriptor[span[0]].Ptr = (ulong)ptr13;
																}
																if (span2[1] != null)
																{
																	dataDescriptor[span[1]].Ptr = (ulong)ptr3;
																}
																if (span2[2] != null)
																{
																	dataDescriptor[span[2]].Ptr = (ulong)ptr5;
																}
																if (span2[3] != null)
																{
																	dataDescriptor[span[3]].Ptr = (ulong)ptr6;
																}
																if (span2[4] != null)
																{
																	dataDescriptor[span[4]].Ptr = (ulong)ptr8;
																}
																if (span2[5] != null)
																{
																	dataDescriptor[span[5]].Ptr = (ulong)ptr9;
																}
																if (span2[6] != null)
																{
																	dataDescriptor[span[6]].Ptr = (ulong)ptr11;
																}
																if (span2[7] != null)
																{
																	dataDescriptor[span[7]].Ptr = (ulong)ptr12;
																}
																writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
															}
														}
													}
												}
												else
												{
													fixed (char* ptr15 = &((string)obj6).GetPinnableReference())
													{
														char* ptr9;
														intPtr3 = (ptr9 = ptr15);
														obj7 = (string)span2[6];
														fixed (char* ptr10 = (string)obj7)
														{
															char* ptr11 = ptr10;
															obj8 = (string)span2[7];
															if (obj8 == null)
															{
																char* ptr12;
																intPtr4 = (ptr12 = null);
																dataDescriptor = ptr;
																if (span2[0] != null)
																{
																	dataDescriptor[span[0]].Ptr = (ulong)ptr13;
																}
																if (span2[1] != null)
																{
																	dataDescriptor[span[1]].Ptr = (ulong)ptr3;
																}
																if (span2[2] != null)
																{
																	dataDescriptor[span[2]].Ptr = (ulong)ptr5;
																}
																if (span2[3] != null)
																{
																	dataDescriptor[span[3]].Ptr = (ulong)ptr6;
																}
																if (span2[4] != null)
																{
																	dataDescriptor[span[4]].Ptr = (ulong)ptr8;
																}
																if (span2[5] != null)
																{
																	dataDescriptor[span[5]].Ptr = (ulong)ptr9;
																}
																if (span2[6] != null)
																{
																	dataDescriptor[span[6]].Ptr = (ulong)ptr11;
																}
																if (span2[7] != null)
																{
																	dataDescriptor[span[7]].Ptr = (ulong)ptr12;
																}
																writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
															}
															else
															{
																fixed (char* ptr14 = &((string)obj8).GetPinnableReference())
																{
																	char* ptr12;
																	intPtr4 = (ptr12 = ptr14);
																	dataDescriptor = ptr;
																	if (span2[0] != null)
																	{
																		dataDescriptor[span[0]].Ptr = (ulong)ptr13;
																	}
																	if (span2[1] != null)
																	{
																		dataDescriptor[span[1]].Ptr = (ulong)ptr3;
																	}
																	if (span2[2] != null)
																	{
																		dataDescriptor[span[2]].Ptr = (ulong)ptr5;
																	}
																	if (span2[3] != null)
																	{
																		dataDescriptor[span[3]].Ptr = (ulong)ptr6;
																	}
																	if (span2[4] != null)
																	{
																		dataDescriptor[span[4]].Ptr = (ulong)ptr8;
																	}
																	if (span2[5] != null)
																	{
																		dataDescriptor[span[5]].Ptr = (ulong)ptr9;
																	}
																	if (span2[6] != null)
																	{
																		dataDescriptor[span[6]].Ptr = (ulong)ptr11;
																	}
																	if (span2[7] != null)
																	{
																		dataDescriptor[span[7]].Ptr = (ulong)ptr12;
																	}
																	writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
				else
				{
					dataDescriptor = ptr;
					GCHandle[] array = new GCHandle[i];
					for (int l = 0; l < i; l++)
					{
						array[l] = GCHandle.Alloc(span2[l], GCHandleType.Pinned);
						if (span2[l] is string)
						{
							fixed (char* ptr18 = (string)span2[l])
							{
								dataDescriptor[span[l]].Ptr = (ulong)ptr18;
							}
						}
						else
						{
							fixed (byte* ptr19 = (byte[])span2[l])
							{
								dataDescriptor[span[l]].Ptr = (ulong)ptr19;
							}
						}
					}
					writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, num, ptr);
					for (int m = 0; m < i; m++)
					{
						array[m].Free();
					}
				}
			}
			if (writeEventErrorCode != 0)
			{
				SetLastError(writeEventErrorCode);
				return false;
			}
			return true;
		}

		protected internal unsafe bool WriteEvent(ref EventDescriptor eventDescriptor, IntPtr eventHandle, Guid* activityID, Guid* childActivityID, int dataCount, IntPtr data)
		{
			_ = 0u;
			WriteEventErrorCode writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, childActivityID, dataCount, (EventData*)(void*)data);
			if (writeEventErrorCode != 0)
			{
				SetLastError(writeEventErrorCode);
				return false;
			}
			return true;
		}

		internal unsafe bool WriteEventRaw(ref EventDescriptor eventDescriptor, IntPtr eventHandle, Guid* activityID, Guid* relatedActivityID, int dataCount, IntPtr data)
		{
			WriteEventErrorCode writeEventErrorCode = m_eventProvider.EventWriteTransfer(m_regHandle, in eventDescriptor, eventHandle, activityID, relatedActivityID, dataCount, (EventData*)(void*)data);
			if (writeEventErrorCode != 0)
			{
				SetLastError(writeEventErrorCode);
				return false;
			}
			return true;
		}

		private unsafe uint EventRegister(EventSource eventSource, Interop.Advapi32.EtwEnableCallback enableCallback)
		{
			m_providerName = eventSource.Name;
			m_providerId = eventSource.Guid;
			m_etwCallback = enableCallback;
			return m_eventProvider.EventRegister(eventSource, enableCallback, null, ref m_regHandle);
		}

		private void EventUnregister(long registrationHandle)
		{
			m_eventProvider.EventUnregister(registrationHandle);
		}

		internal unsafe int SetInformation(Interop.Advapi32.EVENT_INFO_CLASS eventInfoClass, void* data, uint dataSize)
		{
			int result = 50;
			if (!m_setInformationMissing)
			{
				try
				{
					result = Interop.Advapi32.EventSetInformation(m_regHandle, eventInfoClass, data, dataSize);
				}
				catch (TypeLoadException)
				{
					m_setInformationMissing = true;
				}
			}
			return result;
		}
	}
	internal sealed class EtwEventProvider : IEventProvider
	{
		unsafe uint IEventProvider.EventRegister(EventSource eventSource, Interop.Advapi32.EtwEnableCallback enableCallback, void* callbackContext, ref long registrationHandle)
		{
			Guid providerId = eventSource.Guid;
			return Interop.Advapi32.EventRegister(in providerId, enableCallback, callbackContext, ref registrationHandle);
		}

		uint IEventProvider.EventUnregister(long registrationHandle)
		{
			return Interop.Advapi32.EventUnregister(registrationHandle);
		}

		unsafe EventProvider.WriteEventErrorCode IEventProvider.EventWriteTransfer(long registrationHandle, in EventDescriptor eventDescriptor, IntPtr eventHandle, Guid* activityId, Guid* relatedActivityId, int userDataCount, EventProvider.EventData* userData)
		{
			switch (Interop.Advapi32.EventWriteTransfer(registrationHandle, in eventDescriptor, activityId, relatedActivityId, userDataCount, userData))
			{
			case 234:
			case 534:
				return EventProvider.WriteEventErrorCode.EventTooBig;
			case 8:
				return EventProvider.WriteEventErrorCode.NoFreeBuffers;
			default:
				return EventProvider.WriteEventErrorCode.NoError;
			}
		}

		unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte* pMetadata, uint metadataLength)
		{
			throw new NotSupportedException();
		}
	}
	internal sealed class NoOpEventProvider : IEventProvider
	{
		unsafe uint IEventProvider.EventRegister(EventSource eventSource, Interop.Advapi32.EtwEnableCallback enableCallback, void* callbackContext, ref long registrationHandle)
		{
			return 0u;
		}

		uint IEventProvider.EventUnregister(long registrationHandle)
		{
			return 0u;
		}

		unsafe EventProvider.WriteEventErrorCode IEventProvider.EventWriteTransfer(long registrationHandle, in EventDescriptor eventDescriptor, IntPtr eventHandle, Guid* activityId, Guid* relatedActivityId, int userDataCount, EventProvider.EventData* userData)
		{
			return EventProvider.WriteEventErrorCode.NoError;
		}

		unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte* pMetadata, uint metadataLength)
		{
			return IntPtr.Zero;
		}
	}
	[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
	[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2113:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves methods on Delegate and MulticastDelegate because the nested type OverrideEventProvider's base type EventProvider defines a delegate. This includes Delegate and MulticastDelegate methods which require unreferenced code, but EnsureDescriptorsInitialized does not access these members and is safe to call.")]
	[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2115:ReflectionToDynamicallyAccessedMembers", Justification = "EnsureDescriptorsInitialized's use of GetType preserves methods on Delegate and MulticastDelegate because the nested type OverrideEventProvider's base type EventProvider defines a delegate. This includes Delegate and MulticastDelegate methods which have dynamically accessed members requirements, but EnsureDescriptorsInitialized does not access these members and is safe to call.")]
	public class EventSource : IDisposable
	{
		protected internal struct EventData
		{
			internal ulong m_Ptr;

			internal int m_Size;

			internal int m_Reserved;

			public unsafe IntPtr DataPointer
			{
				get
				{
					return (IntPtr)(void*)m_Ptr;
				}
				set
				{
					m_Ptr = (ulong)(void*)value;
				}
			}

			public int Size
			{
				get
				{
					return m_Size;
				}
				set
				{
					m_Size = value;
				}
			}

			internal int Reserved
			{
				get
				{
					return m_Reserved;
				}
				set
				{
					m_Reserved = value;
				}
			}

			internal unsafe void SetMetadata(byte* pointer, int size, int reserved)
			{
				m_Ptr = (ulong)pointer;
				m_Size = size;
				m_Reserved = reserved;
			}
		}

		private sealed class OverrideEventProvider : EventProvider
		{
			private readonly EventSource m_eventSource;

			private readonly EventProviderType m_eventProviderType;

			public OverrideEventProvider(EventSource eventSource, EventProviderType providerType)
				: base(providerType)
			{
				m_eventSource = eventSource;
				m_eventProviderType = providerType;
			}

			protected override void OnControllerCommand(ControllerCommand command, IDictionary<string, string> arguments, int perEventSourceSessionId, int etwSessionId)
			{
				EventListener listener = null;
				m_eventSource.SendCommand(listener, m_eventProviderType, perEventSourceSessionId, etwSessionId, (EventCommand)command, IsEnabled(), base.Level, base.MatchAnyKeyword, arguments);
			}
		}

		internal struct EventMetadata
		{
			public EventDescriptor Descriptor;

			public IntPtr EventHandle;

			public EventTags Tags;

			public bool EnabledForAnyListener;

			public bool EnabledForETW;

			public bool EnabledForEventPipe;

			public bool HasRelatedActivityID;

			public string Name;

			public string Message;

			public ParameterInfo[] Parameters;

			public int EventListenerParameterCount;

			public bool AllParametersAreString;

			public bool AllParametersAreInt32;

			public EventActivityOptions ActivityOptions;

			private TraceLoggingEventTypes _traceLoggingEventTypes;

			private ReadOnlyCollection<string> _parameterNames;

			private Type[] _parameterTypes;

			public TraceLoggingEventTypes TraceLoggingEventTypes
			{
				[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
				[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
				get
				{
					if (_traceLoggingEventTypes == null)
					{
						TraceLoggingEventTypes value = new TraceLoggingEventTypes(Name, Tags, Parameters);
						Interlocked.CompareExchange(ref _traceLoggingEventTypes, value, null);
					}
					return _traceLoggingEventTypes;
				}
			}

			public ReadOnlyCollection<string> ParameterNames
			{
				get
				{
					if (_parameterNames == null)
					{
						ParameterInfo[] parameters = Parameters;
						string[] array = new string[parameters.Length];
						for (int i = 0; i < array.Length; i++)
						{
							array[i] = parameters[i].Name;
						}
						_parameterNames = new ReadOnlyCollection<string>(array);
					}
					return _parameterNames;
				}
			}

			public Type[] ParameterTypes
			{
				get
				{
					return _parameterTypes ?? (_parameterTypes = GetParameterTypes(Parameters));
					static Type[] GetParameterTypes(ParameterInfo[] parameters)
					{
						Type[] array = new Type[parameters.Length];
						for (int i = 0; i < array.Length; i++)
						{
							array[i] = parameters[i].ParameterType;
						}
						return array;
					}
				}
			}
		}

		private const DynamicallyAccessedMemberTypes ManifestMemberTypes = DynamicallyAccessedMemberTypes.All;

		private string m_name;

		internal int m_id;

		private Guid m_guid;

		internal volatile EventMetadata[] m_eventData;

		private volatile byte[] m_rawManifest;

		private EventHandler<EventCommandEventArgs> m_eventCommandExecuted;

		private readonly EventSourceSettings m_config;

		private bool m_eventSourceDisposed;

		private bool m_eventSourceEnabled;

		internal EventLevel m_level;

		internal EventKeywords m_matchAnyKeyword;

		internal volatile EventDispatcher m_Dispatchers;

		private volatile OverrideEventProvider m_etwProvider;

		private object m_createEventLock;

		private IntPtr m_writeEventStringEventHandle = IntPtr.Zero;

		private volatile OverrideEventProvider m_eventPipeProvider;

		private bool m_completelyInited;

		private Exception m_constructionException;

		private byte m_outOfBandMessageCount;

		private EventCommandEventArgs m_deferredCommands;

		private string[] m_traits;

		[ThreadStatic]
		private static byte m_EventSourceExceptionRecurenceCount;

		internal volatile ulong[] m_channelData;

		private ActivityTracker m_activityTracker;

		internal const string s_ActivityStartSuffix = "Start";

		internal const string s_ActivityStopSuffix = "Stop";

		internal const string DuplicateSourceNamesSwitch = "System.Diagnostics.Tracing.EventSource.AllowDuplicateSourceNames";

		private static readonly bool AllowDuplicateSourceNames = AppContext.TryGetSwitch("System.Diagnostics.Tracing.EventSource.AllowDuplicateSourceNames", out var isEnabled) && isEnabled;

		private byte[] m_providerMetadata;

		private const string EventSourceRequiresUnreferenceMessage = "EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type";

		private const string EventSourceSuppressMessage = "Parameters to this method are primitive and are trimmer safe";

		private readonly TraceLoggingEventHandleTable m_eventHandleTable;

		internal static bool IsSupported { get; } = InitializeIsSupported();


		public string Name => m_name;

		public Guid Guid => m_guid;

		public EventSourceSettings Settings => m_config;

		public Exception? ConstructionException => m_constructionException;

		public static Guid CurrentThreadActivityId
		{
			get
			{
				if (!IsSupported)
				{
					return default(Guid);
				}
				Guid ActivityId = default(Guid);
				Interop.Advapi32.EventActivityIdControl(Interop.Advapi32.ActivityControl.EVENT_ACTIVITY_CTRL_GET_ID, ref ActivityId);
				return ActivityId;
			}
		}

		private bool IsDisposed => m_eventSourceDisposed;

		private bool ThrowOnEventWriteErrors => (m_config & EventSourceSettings.ThrowOnEventWriteErrors) != 0;

		private bool SelfDescribingEvents => (m_config & EventSourceSettings.EtwSelfDescribingEventFormat) != 0;

		private protected virtual ReadOnlySpan<byte> ProviderMetadata => m_providerMetadata;

		public event EventHandler<EventCommandEventArgs>? EventCommandExecuted
		{
			add
			{
				if (value != null)
				{
					m_eventCommandExecuted = (EventHandler<EventCommandEventArgs>)Delegate.Combine(m_eventCommandExecuted, value);
					for (EventCommandEventArgs eventCommandEventArgs = m_deferredCommands; eventCommandEventArgs != null; eventCommandEventArgs = eventCommandEventArgs.nextCommand)
					{
						value(this, eventCommandEventArgs);
					}
				}
			}
			remove
			{
				m_eventCommandExecuted = (EventHandler<EventCommandEventArgs>)Delegate.Remove(m_eventCommandExecuted, value);
			}
		}

		private static bool InitializeIsSupported()
		{
			if (!AppContext.TryGetSwitch("System.Diagnostics.Tracing.EventSource.IsSupported", out var isEnabled))
			{
				return true;
			}
			return isEnabled;
		}

		public bool IsEnabled()
		{
			return m_eventSourceEnabled;
		}

		public bool IsEnabled(EventLevel level, EventKeywords keywords)
		{
			return IsEnabled(level, keywords, EventChannel.None);
		}

		public bool IsEnabled(EventLevel level, EventKeywords keywords, EventChannel channel)
		{
			if (!IsEnabled())
			{
				return false;
			}
			if (!IsEnabledCommon(m_eventSourceEnabled, m_level, m_matchAnyKeyword, level, keywords, channel))
			{
				return false;
			}
			return true;
		}

		public static Guid GetGuid(Type eventSourceType)
		{
			if (eventSourceType == null)
			{
				throw new ArgumentNullException("eventSourceType");
			}
			EventSourceAttribute eventSourceAttribute = (EventSourceAttribute)GetCustomAttributeHelper(eventSourceType, typeof(EventSourceAttribute));
			string name = eventSourceType.Name;
			if (eventSourceAttribute != null)
			{
				if (eventSourceAttribute.Guid != null && Guid.TryParse(eventSourceAttribute.Guid, out var result))
				{
					return result;
				}
				if (eventSourceAttribute.Name != null)
				{
					name = eventSourceAttribute.Name;
				}
			}
			if (name == null)
			{
				throw new ArgumentException(SR.Argument_InvalidTypeName, "eventSourceType");
			}
			return GenerateGuidFromName(name.ToUpperInvariant());
		}

		public static string GetName(Type eventSourceType)
		{
			return GetName(eventSourceType, EventManifestOptions.None);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2114:ReflectionToDynamicallyAccessedMembers", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which has dynamically accessed members requirements, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		public static string? GenerateManifest([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type eventSourceType, string? assemblyPathToIncludeInManifest)
		{
			return GenerateManifest(eventSourceType, assemblyPathToIncludeInManifest, EventManifestOptions.None);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2114:ReflectionToDynamicallyAccessedMembers", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which has dynamically accessed members requirements, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		public static string? GenerateManifest([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type eventSourceType, string? assemblyPathToIncludeInManifest, EventManifestOptions flags)
		{
			if (!IsSupported)
			{
				return null;
			}
			if (eventSourceType == null)
			{
				throw new ArgumentNullException("eventSourceType");
			}
			byte[] array = CreateManifestAndDescriptors(eventSourceType, assemblyPathToIncludeInManifest, null, flags);
			if (array != null)
			{
				return Encoding.UTF8.GetString(array, 0, array.Length);
			}
			return null;
		}

		public static IEnumerable<EventSource> GetSources()
		{
			if (!IsSupported)
			{
				return Array.Empty<EventSource>();
			}
			List<EventSource> list = new List<EventSource>();
			lock (EventListener.EventListenersLock)
			{
				foreach (WeakReference<EventSource> s_EventSource in EventListener.s_EventSources)
				{
					if (s_EventSource.TryGetTarget(out var target) && !target.IsDisposed)
					{
						list.Add(target);
					}
				}
				return list;
			}
		}

		public static void SendCommand(EventSource eventSource, EventCommand command, IDictionary<string, string?>? commandArguments)
		{
			if (IsSupported)
			{
				if (eventSource == null)
				{
					throw new ArgumentNullException("eventSource");
				}
				if (command <= EventCommand.Update && command != EventCommand.SendManifest)
				{
					throw new ArgumentException(SR.EventSource_InvalidCommand, "command");
				}
				eventSource.SendCommand(null, EventProviderType.ETW, 0, 0, command, enable: true, EventLevel.LogAlways, EventKeywords.None, commandArguments);
			}
		}

		public string? GetTrait(string key)
		{
			if (m_traits != null)
			{
				for (int i = 0; i < m_traits.Length - 1; i += 2)
				{
					if (m_traits[i] == key)
					{
						return m_traits[i + 1];
					}
				}
			}
			return null;
		}

		public override string ToString()
		{
			if (!IsSupported)
			{
				return base.ToString();
			}
			return SR.Format(SR.EventSource_ToString, Name, Guid);
		}

		public static void SetCurrentThreadActivityId(Guid activityId)
		{
			if (IsSupported)
			{
				if (TplEventSource.Log != null)
				{
					TplEventSource.Log.SetActivityId(activityId);
				}
				EventPipeEventProvider.EventActivityIdControl(Interop.Advapi32.ActivityControl.EVENT_ACTIVITY_CTRL_SET_ID, ref activityId);
				Interop.Advapi32.EventActivityIdControl(Interop.Advapi32.ActivityControl.EVENT_ACTIVITY_CTRL_SET_ID, ref activityId);
			}
		}

		public static void SetCurrentThreadActivityId(Guid activityId, out Guid oldActivityThatWillContinue)
		{
			if (!IsSupported)
			{
				oldActivityThatWillContinue = default(Guid);
				return;
			}
			oldActivityThatWillContinue = activityId;
			EventPipeEventProvider.EventActivityIdControl(Interop.Advapi32.ActivityControl.EVENT_ACTIVITY_CTRL_SET_ID, ref oldActivityThatWillContinue);
			Interop.Advapi32.EventActivityIdControl(Interop.Advapi32.ActivityControl.EVENT_ACTIVITY_CTRL_GET_SET_ID, ref oldActivityThatWillContinue);
			if (TplEventSource.Log != null)
			{
				TplEventSource.Log.SetActivityId(activityId);
			}
		}

		protected EventSource()
			: this(EventSourceSettings.EtwManifestEventFormat)
		{
		}

		protected EventSource(bool throwOnEventWriteErrors)
			: this(EventSourceSettings.EtwManifestEventFormat | (throwOnEventWriteErrors ? EventSourceSettings.ThrowOnEventWriteErrors : EventSourceSettings.Default))
		{
		}

		protected EventSource(EventSourceSettings settings)
			: this(settings, (string[]?)null)
		{
		}

		protected EventSource(EventSourceSettings settings, params string[]? traits)
		{
			if (IsSupported)
			{
				m_eventHandleTable = new TraceLoggingEventHandleTable();
				m_config = ValidateSettings(settings);
				Type type = GetType();
				Guid guid = GetGuid(type);
				string name = GetName(type);
				Initialize(guid, name, traits);
			}
		}

		private unsafe void DefineEventPipeEvents()
		{
			if (SelfDescribingEvents)
			{
				return;
			}
			int num = m_eventData.Length;
			for (int i = 0; i < num; i++)
			{
				uint eventId = (uint)m_eventData[i].Descriptor.EventId;
				if (eventId != 0)
				{
					byte[] array = EventPipeMetadataGenerator.Instance.GenerateEventMetadata(m_eventData[i]);
					uint metadataLength = ((array != null) ? ((uint)array.Length) : 0u);
					string name = m_eventData[i].Name;
					long keywords = m_eventData[i].Descriptor.Keywords;
					uint version = m_eventData[i].Descriptor.Version;
					uint level = m_eventData[i].Descriptor.Level;
					fixed (byte* pMetadata = array)
					{
						IntPtr eventHandle = m_eventPipeProvider.m_eventProvider.DefineEventHandle(eventId, name, keywords, version, level, pMetadata, metadataLength);
						m_eventData[i].EventHandle = eventHandle;
					}
				}
			}
		}

		protected virtual void OnEventCommand(EventCommandEventArgs command)
		{
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId)
		{
			WriteEventCore(eventId, 0, null);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, int arg1)
		{
			if (IsEnabled())
			{
				EventData* ptr = stackalloc EventData[1];
				ptr->DataPointer = (IntPtr)(&arg1);
				ptr->Size = 4;
				ptr->Reserved = 0;
				WriteEventCore(eventId, 1, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, int arg1, int arg2)
		{
			if (IsEnabled())
			{
				EventData* ptr = stackalloc EventData[2];
				ptr->DataPointer = (IntPtr)(&arg1);
				ptr->Size = 4;
				ptr->Reserved = 0;
				ptr[1].DataPointer = (IntPtr)(&arg2);
				ptr[1].Size = 4;
				ptr[1].Reserved = 0;
				WriteEventCore(eventId, 2, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, int arg1, int arg2, int arg3)
		{
			if (IsEnabled())
			{
				EventData* ptr = stackalloc EventData[3];
				ptr->DataPointer = (IntPtr)(&arg1);
				ptr->Size = 4;
				ptr->Reserved = 0;
				ptr[1].DataPointer = (IntPtr)(&arg2);
				ptr[1].Size = 4;
				ptr[1].Reserved = 0;
				ptr[2].DataPointer = (IntPtr)(&arg3);
				ptr[2].Size = 4;
				ptr[2].Reserved = 0;
				WriteEventCore(eventId, 3, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, long arg1)
		{
			if (IsEnabled())
			{
				EventData* ptr = stackalloc EventData[1];
				ptr->DataPointer = (IntPtr)(&arg1);
				ptr->Size = 8;
				ptr->Reserved = 0;
				WriteEventCore(eventId, 1, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, long arg1, long arg2)
		{
			if (IsEnabled())
			{
				EventData* ptr = stackalloc EventData[2];
				ptr->DataPointer = (IntPtr)(&arg1);
				ptr->Size = 8;
				ptr->Reserved = 0;
				ptr[1].DataPointer = (IntPtr)(&arg2);
				ptr[1].Size = 8;
				ptr[1].Reserved = 0;
				WriteEventCore(eventId, 2, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, long arg1, long arg2, long arg3)
		{
			if (IsEnabled())
			{
				EventData* ptr = stackalloc EventData[3];
				ptr->DataPointer = (IntPtr)(&arg1);
				ptr->Size = 8;
				ptr->Reserved = 0;
				ptr[1].DataPointer = (IntPtr)(&arg2);
				ptr[1].Size = 8;
				ptr[1].Reserved = 0;
				ptr[2].DataPointer = (IntPtr)(&arg3);
				ptr[2].Size = 8;
				ptr[2].Reserved = 0;
				WriteEventCore(eventId, 3, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, string? arg1)
		{
			if (IsEnabled())
			{
				if (arg1 == null)
				{
					arg1 = "";
				}
				fixed (char* ptr2 = arg1)
				{
					EventData* ptr = stackalloc EventData[1];
					ptr->DataPointer = (IntPtr)ptr2;
					ptr->Size = (arg1.Length + 1) * 2;
					ptr->Reserved = 0;
					WriteEventCore(eventId, 1, ptr);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, string? arg1, string? arg2)
		{
			//The blocks IL_0040 are reachable both inside and outside the pinned region starting at IL_003d. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			if (!IsEnabled())
			{
				return;
			}
			if (arg1 == null)
			{
				arg1 = "";
			}
			if (arg2 == null)
			{
				arg2 = "";
			}
			fixed (char* ptr3 = arg1)
			{
				char* intPtr;
				if (arg2 == null)
				{
					char* ptr;
					intPtr = (ptr = null);
					EventData* ptr2 = stackalloc EventData[2];
					ptr2->DataPointer = (IntPtr)ptr3;
					ptr2->Size = (arg1.Length + 1) * 2;
					ptr2->Reserved = 0;
					ptr2[1].DataPointer = (IntPtr)ptr;
					ptr2[1].Size = (arg2.Length + 1) * 2;
					ptr2[1].Reserved = 0;
					WriteEventCore(eventId, 2, ptr2);
					return;
				}
				fixed (char* ptr4 = &arg2.GetPinnableReference())
				{
					char* ptr;
					intPtr = (ptr = ptr4);
					EventData* ptr2 = stackalloc EventData[2];
					ptr2->DataPointer = (IntPtr)ptr3;
					ptr2->Size = (arg1.Length + 1) * 2;
					ptr2->Reserved = 0;
					ptr2[1].DataPointer = (IntPtr)ptr;
					ptr2[1].Size = (arg2.Length + 1) * 2;
					ptr2[1].Reserved = 0;
					WriteEventCore(eventId, 2, ptr2);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, string? arg1, string? arg2, string? arg3)
		{
			//The blocks IL_004b, IL_004e, IL_0060, IL_0122 are reachable both inside and outside the pinned region starting at IL_0048. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			if (!IsEnabled())
			{
				return;
			}
			if (arg1 == null)
			{
				arg1 = "";
			}
			if (arg2 == null)
			{
				arg2 = "";
			}
			if (arg3 == null)
			{
				arg3 = "";
			}
			fixed (char* ptr5 = arg1)
			{
				char* intPtr;
				if (arg2 == null)
				{
					char* ptr;
					intPtr = (ptr = null);
					fixed (char* ptr2 = arg3)
					{
						char* ptr3 = ptr2;
						EventData* ptr4 = stackalloc EventData[3];
						ptr4->DataPointer = (IntPtr)ptr5;
						ptr4->Size = (arg1.Length + 1) * 2;
						ptr4->Reserved = 0;
						ptr4[1].DataPointer = (IntPtr)ptr;
						ptr4[1].Size = (arg2.Length + 1) * 2;
						ptr4[1].Reserved = 0;
						ptr4[2].DataPointer = (IntPtr)ptr3;
						ptr4[2].Size = (arg3.Length + 1) * 2;
						ptr4[2].Reserved = 0;
						WriteEventCore(eventId, 3, ptr4);
					}
					return;
				}
				fixed (char* ptr6 = &arg2.GetPinnableReference())
				{
					char* ptr;
					intPtr = (ptr = ptr6);
					fixed (char* ptr2 = arg3)
					{
						char* ptr3 = ptr2;
						EventData* ptr4 = stackalloc EventData[3];
						ptr4->DataPointer = (IntPtr)ptr5;
						ptr4->Size = (arg1.Length + 1) * 2;
						ptr4->Reserved = 0;
						ptr4[1].DataPointer = (IntPtr)ptr;
						ptr4[1].Size = (arg2.Length + 1) * 2;
						ptr4[1].Reserved = 0;
						ptr4[2].DataPointer = (IntPtr)ptr3;
						ptr4[2].Size = (arg3.Length + 1) * 2;
						ptr4[2].Reserved = 0;
						WriteEventCore(eventId, 3, ptr4);
					}
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, string? arg1, int arg2)
		{
			if (IsEnabled())
			{
				if (arg1 == null)
				{
					arg1 = "";
				}
				fixed (char* ptr2 = arg1)
				{
					EventData* ptr = stackalloc EventData[2];
					ptr->DataPointer = (IntPtr)ptr2;
					ptr->Size = (arg1.Length + 1) * 2;
					ptr->Reserved = 0;
					ptr[1].DataPointer = (IntPtr)(&arg2);
					ptr[1].Size = 4;
					ptr[1].Reserved = 0;
					WriteEventCore(eventId, 2, ptr);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, string? arg1, int arg2, int arg3)
		{
			if (IsEnabled())
			{
				if (arg1 == null)
				{
					arg1 = "";
				}
				fixed (char* ptr2 = arg1)
				{
					EventData* ptr = stackalloc EventData[3];
					ptr->DataPointer = (IntPtr)ptr2;
					ptr->Size = (arg1.Length + 1) * 2;
					ptr->Reserved = 0;
					ptr[1].DataPointer = (IntPtr)(&arg2);
					ptr[1].Size = 4;
					ptr[1].Reserved = 0;
					ptr[2].DataPointer = (IntPtr)(&arg3);
					ptr[2].Size = 4;
					ptr[2].Reserved = 0;
					WriteEventCore(eventId, 3, ptr);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, string? arg1, long arg2)
		{
			if (IsEnabled())
			{
				if (arg1 == null)
				{
					arg1 = "";
				}
				fixed (char* ptr2 = arg1)
				{
					EventData* ptr = stackalloc EventData[2];
					ptr->DataPointer = (IntPtr)ptr2;
					ptr->Size = (arg1.Length + 1) * 2;
					ptr->Reserved = 0;
					ptr[1].DataPointer = (IntPtr)(&arg2);
					ptr[1].Size = 8;
					ptr[1].Reserved = 0;
					WriteEventCore(eventId, 2, ptr);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, long arg1, string? arg2)
		{
			if (IsEnabled())
			{
				if (arg2 == null)
				{
					arg2 = "";
				}
				fixed (char* ptr2 = arg2)
				{
					EventData* ptr = stackalloc EventData[2];
					ptr->DataPointer = (IntPtr)(&arg1);
					ptr->Size = 8;
					ptr->Reserved = 0;
					ptr[1].DataPointer = (IntPtr)ptr2;
					ptr[1].Size = (arg2.Length + 1) * 2;
					ptr[1].Reserved = 0;
					WriteEventCore(eventId, 2, ptr);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, int arg1, string? arg2)
		{
			if (IsEnabled())
			{
				if (arg2 == null)
				{
					arg2 = "";
				}
				fixed (char* ptr2 = arg2)
				{
					EventData* ptr = stackalloc EventData[2];
					ptr->DataPointer = (IntPtr)(&arg1);
					ptr->Size = 4;
					ptr->Reserved = 0;
					ptr[1].DataPointer = (IntPtr)ptr2;
					ptr[1].Size = (arg2.Length + 1) * 2;
					ptr[1].Reserved = 0;
					WriteEventCore(eventId, 2, ptr);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, byte[]? arg1)
		{
			if (!IsEnabled())
			{
				return;
			}
			EventData* ptr = stackalloc EventData[2];
			if (arg1 == null || arg1.Length == 0)
			{
				int num = 0;
				ptr->DataPointer = (IntPtr)(&num);
				ptr->Size = 4;
				ptr->Reserved = 0;
				ptr[1].DataPointer = (IntPtr)(&num);
				ptr[1].Size = 0;
				ptr[1].Reserved = 0;
				WriteEventCore(eventId, 2, ptr);
				return;
			}
			int size = arg1.Length;
			fixed (byte* ptr2 = &arg1[0])
			{
				ptr->DataPointer = (IntPtr)(&size);
				ptr->Size = 4;
				ptr->Reserved = 0;
				ptr[1].DataPointer = (IntPtr)ptr2;
				ptr[1].Size = size;
				ptr[1].Reserved = 0;
				WriteEventCore(eventId, 2, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		protected unsafe void WriteEvent(int eventId, long arg1, byte[]? arg2)
		{
			if (!IsEnabled())
			{
				return;
			}
			EventData* ptr = stackalloc EventData[3];
			ptr->DataPointer = (IntPtr)(&arg1);
			ptr->Size = 8;
			ptr->Reserved = 0;
			if (arg2 == null || arg2.Length == 0)
			{
				int num = 0;
				ptr[1].DataPointer = (IntPtr)(&num);
				ptr[1].Size = 4;
				ptr[1].Reserved = 0;
				ptr[2].DataPointer = (IntPtr)(&num);
				ptr[2].Size = 0;
				ptr[2].Reserved = 0;
				WriteEventCore(eventId, 3, ptr);
				return;
			}
			int size = arg2.Length;
			fixed (byte* ptr2 = &arg2[0])
			{
				ptr[1].DataPointer = (IntPtr)(&size);
				ptr[1].Size = 4;
				ptr[1].Reserved = 0;
				ptr[2].DataPointer = (IntPtr)ptr2;
				ptr[2].Size = size;
				ptr[2].Reserved = 0;
				WriteEventCore(eventId, 3, ptr);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		[CLSCompliant(false)]
		protected unsafe void WriteEventCore(int eventId, int eventDataCount, EventData* data)
		{
			WriteEventWithRelatedActivityIdCore(eventId, null, eventDataCount, data);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		[CLSCompliant(false)]
		protected unsafe void WriteEventWithRelatedActivityIdCore(int eventId, Guid* relatedActivityId, int eventDataCount, EventData* data)
		{
			if (!IsEnabled())
			{
				return;
			}
			try
			{
				ref EventMetadata reference = ref m_eventData[eventId];
				EventOpcode opcode = (EventOpcode)reference.Descriptor.Opcode;
				Guid* ptr = null;
				Guid activityId = Guid.Empty;
				Guid relatedActivityId2 = Guid.Empty;
				if (opcode != 0 && relatedActivityId == null && (reference.ActivityOptions & EventActivityOptions.Disable) == 0)
				{
					switch (opcode)
					{
					case EventOpcode.Start:
						m_activityTracker.OnStart(m_name, reference.Name, reference.Descriptor.Task, ref activityId, ref relatedActivityId2, reference.ActivityOptions);
						break;
					case EventOpcode.Stop:
						m_activityTracker.OnStop(m_name, reference.Name, reference.Descriptor.Task, ref activityId);
						break;
					}
					if (activityId != Guid.Empty)
					{
						ptr = &activityId;
					}
					if (relatedActivityId2 != Guid.Empty)
					{
						relatedActivityId = &relatedActivityId2;
					}
				}
				if (!SelfDescribingEvents)
				{
					if (reference.EnabledForETW && !m_etwProvider.WriteEvent(ref reference.Descriptor, reference.EventHandle, ptr, relatedActivityId, eventDataCount, (IntPtr)data))
					{
						ThrowEventSourceException(reference.Name);
					}
					if (reference.EnabledForEventPipe && !m_eventPipeProvider.WriteEvent(ref reference.Descriptor, reference.EventHandle, ptr, relatedActivityId, eventDataCount, (IntPtr)data))
					{
						ThrowEventSourceException(reference.Name);
					}
				}
				else if (reference.EnabledForETW || reference.EnabledForEventPipe)
				{
					EventSourceOptions eventSourceOptions = default(EventSourceOptions);
					eventSourceOptions.Keywords = (EventKeywords)reference.Descriptor.Keywords;
					eventSourceOptions.Level = (EventLevel)reference.Descriptor.Level;
					eventSourceOptions.Opcode = (EventOpcode)reference.Descriptor.Opcode;
					EventSourceOptions options = eventSourceOptions;
					WriteMultiMerge(reference.Name, ref options, reference.TraceLoggingEventTypes, ptr, relatedActivityId, data);
				}
				if (m_Dispatchers != null && reference.EnabledForAnyListener)
				{
					EventWrittenEventArgs eventCallbackArgs = new EventWrittenEventArgs(this, eventId, ptr, relatedActivityId);
					WriteToAllListeners(eventCallbackArgs, eventDataCount, data);
				}
			}
			catch (Exception ex)
			{
				if (ex is EventSourceException)
				{
					throw;
				}
				ThrowEventSourceException(m_eventData[eventId].Name, ex);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		protected unsafe void WriteEvent(int eventId, params object?[] args)
		{
			WriteEventVarargs(eventId, null, args);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		protected unsafe void WriteEventWithRelatedActivityId(int eventId, Guid relatedActivityId, params object?[] args)
		{
			WriteEventVarargs(eventId, &relatedActivityId, args);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!IsSupported)
			{
				return;
			}
			if (disposing)
			{
				if (m_eventSourceEnabled)
				{
					try
					{
						SendManifest(m_rawManifest);
					}
					catch
					{
					}
					m_eventSourceEnabled = false;
				}
				if (m_etwProvider != null)
				{
					m_etwProvider.Dispose();
					m_etwProvider = null;
				}
				if (m_eventPipeProvider != null)
				{
					m_eventPipeProvider.Dispose();
					m_eventPipeProvider = null;
				}
			}
			m_eventSourceEnabled = false;
			m_eventSourceDisposed = true;
		}

		~EventSource()
		{
			Dispose(disposing: false);
		}

		private unsafe void WriteEventRaw(string eventName, ref EventDescriptor eventDescriptor, IntPtr eventHandle, Guid* activityID, Guid* relatedActivityID, int dataCount, IntPtr data)
		{
			bool flag = true;
			flag &= m_etwProvider == null;
			if (m_etwProvider != null && !m_etwProvider.WriteEventRaw(ref eventDescriptor, eventHandle, activityID, relatedActivityID, dataCount, data))
			{
				ThrowEventSourceException(eventName);
			}
			flag &= m_eventPipeProvider == null;
			if (m_eventPipeProvider != null && !m_eventPipeProvider.WriteEventRaw(ref eventDescriptor, eventHandle, activityID, relatedActivityID, dataCount, data))
			{
				ThrowEventSourceException(eventName);
			}
			if (flag)
			{
				ThrowEventSourceException(eventName);
			}
		}

		internal EventSource(Guid eventSourceGuid, string eventSourceName)
			: this(eventSourceGuid, eventSourceName, EventSourceSettings.EtwManifestEventFormat)
		{
		}

		internal EventSource(Guid eventSourceGuid, string eventSourceName, EventSourceSettings settings, string[] traits = null)
		{
			if (IsSupported)
			{
				m_eventHandleTable = new TraceLoggingEventHandleTable();
				m_config = ValidateSettings(settings);
				Initialize(eventSourceGuid, eventSourceName, traits);
			}
		}

		private unsafe void Initialize(Guid eventSourceGuid, string eventSourceName, string[] traits)
		{
			try
			{
				m_traits = traits;
				if (m_traits != null && m_traits.Length % 2 != 0)
				{
					throw new ArgumentException(SR.EventSource_TraitEven, "traits");
				}
				if (eventSourceGuid == Guid.Empty)
				{
					throw new ArgumentException(SR.EventSource_NeedGuid);
				}
				if (eventSourceName == null)
				{
					throw new ArgumentException(SR.EventSource_NeedName);
				}
				m_name = eventSourceName;
				m_guid = eventSourceGuid;
				m_activityTracker = ActivityTracker.Instance;
				if (ProviderMetadata.Length == 0)
				{
					InitializeProviderMetadata();
				}
				OverrideEventProvider overrideEventProvider = new OverrideEventProvider(this, EventProviderType.ETW);
				overrideEventProvider.Register(this);
				OverrideEventProvider overrideEventProvider2 = new OverrideEventProvider(this, EventProviderType.EventPipe);
				lock (EventListener.EventListenersLock)
				{
					overrideEventProvider2.Register(this);
				}
				EventListener.AddEventSource(this);
				m_etwProvider = overrideEventProvider;
				if (Name != "System.Diagnostics.Eventing.FrameworkEventSource" || Environment.IsWindows8OrAbove)
				{
					ReadOnlySpan<byte> providerMetadata = ProviderMetadata;
					fixed (byte* data = providerMetadata)
					{
						m_etwProvider.SetInformation(Interop.Advapi32.EVENT_INFO_CLASS.SetTraits, data, (uint)providerMetadata.Length);
					}
				}
				m_eventPipeProvider = overrideEventProvider2;
				m_completelyInited = true;
			}
			catch (Exception ex)
			{
				if (m_constructionException == null)
				{
					m_constructionException = ex;
				}
				ReportOutOfBandMessage("ERROR: Exception during construction of EventSource " + Name + ": " + ex.Message);
			}
			lock (EventListener.EventListenersLock)
			{
				for (EventCommandEventArgs eventCommandEventArgs = m_deferredCommands; eventCommandEventArgs != null; eventCommandEventArgs = eventCommandEventArgs.nextCommand)
				{
					DoCommand(eventCommandEventArgs);
				}
			}
		}

		private static string GetName(Type eventSourceType, EventManifestOptions flags)
		{
			if (eventSourceType == null)
			{
				throw new ArgumentNullException("eventSourceType");
			}
			EventSourceAttribute eventSourceAttribute = (EventSourceAttribute)GetCustomAttributeHelper(eventSourceType, typeof(EventSourceAttribute), flags);
			if (eventSourceAttribute != null && eventSourceAttribute.Name != null)
			{
				return eventSourceAttribute.Name;
			}
			return eventSourceType.Name;
		}

		private static Guid GenerateGuidFromName(string name)
		{
			ReadOnlySpan<byte> input = new byte[16]
			{
				72, 44, 45, 178, 195, 144, 71, 200, 135, 248,
				26, 21, 191, 193, 48, 251
			};
			byte[] array = Encoding.BigEndianUnicode.GetBytes(name);
			Sha1ForNonSecretPurposes sha1ForNonSecretPurposes = default(Sha1ForNonSecretPurposes);
			sha1ForNonSecretPurposes.Start();
			sha1ForNonSecretPurposes.Append(input);
			sha1ForNonSecretPurposes.Append(array);
			Array.Resize(ref array, 16);
			sha1ForNonSecretPurposes.Finish(array);
			array[7] = (byte)((array[7] & 0xFu) | 0x50u);
			return new Guid(array);
		}

		private unsafe static void DecodeObjects(object[] decodedObjects, Type[] parameterTypes, EventData* data)
		{
			object obj;
			for (int i = 0; i < decodedObjects.Length; decodedObjects[i] = obj, i++, data++)
			{
				IntPtr dataPointer = data->DataPointer;
				Type type = parameterTypes[i];
				if (!(type == typeof(string)))
				{
					if (type == typeof(int))
					{
						obj = *(int*)(void*)dataPointer;
						continue;
					}
					TypeCode typeCode = Type.GetTypeCode(type);
					int size = data->Size;
					if (size == 4)
					{
						if ((uint)(typeCode - 5) <= 4u)
						{
							obj = *(int*)(void*)dataPointer;
							continue;
						}
						if (typeCode == TypeCode.UInt32)
						{
							obj = *(uint*)(void*)dataPointer;
							continue;
						}
						if (typeCode == TypeCode.Single)
						{
							obj = *(float*)(void*)dataPointer;
							continue;
						}
						if (typeCode == TypeCode.Boolean)
						{
							obj = *(int*)(void*)dataPointer == 1;
							continue;
						}
						if (type == typeof(byte[]))
						{
							data++;
							goto IL_0257;
						}
						_ = IntPtr.Size;
						if (type == typeof(IntPtr))
						{
							obj = *(IntPtr*)(void*)dataPointer;
							continue;
						}
					}
					else if (size <= 2)
					{
						switch (typeCode)
						{
						case TypeCode.Byte:
							obj = *(byte*)(void*)dataPointer;
							continue;
						case TypeCode.SByte:
							obj = *(sbyte*)(void*)dataPointer;
							continue;
						case TypeCode.Int16:
							obj = *(short*)(void*)dataPointer;
							continue;
						case TypeCode.UInt16:
							obj = *(ushort*)(void*)dataPointer;
							continue;
						case TypeCode.Char:
							obj = *(char*)(void*)dataPointer;
							continue;
						}
					}
					else
					{
						if (size == 8)
						{
							if (typeCode == TypeCode.Int64)
							{
								obj = *(long*)(void*)dataPointer;
								continue;
							}
							if (typeCode == TypeCode.UInt64)
							{
								obj = *(ulong*)(void*)dataPointer;
								continue;
							}
							if (typeCode == TypeCode.Double)
							{
								obj = *(double*)(void*)dataPointer;
								continue;
							}
							if (typeCode == TypeCode.DateTime)
							{
								obj = DateTime.FromFileTimeUtc(*(long*)(void*)dataPointer);
								continue;
							}
							if (IntPtr.Size != 8)
							{
								goto IL_0245;
							}
						}
						if (typeCode == TypeCode.Decimal)
						{
							obj = *(decimal*)(void*)dataPointer;
							continue;
						}
						if (type == typeof(Guid))
						{
							obj = *(Guid*)(void*)dataPointer;
							continue;
						}
					}
					goto IL_0245;
				}
				goto IL_028b;
				IL_0245:
				if (!(type != typeof(byte*)))
				{
					goto IL_0257;
				}
				goto IL_028b;
				IL_028b:
				obj = ((dataPointer == IntPtr.Zero) ? null : new string((char*)(void*)dataPointer, 0, (data->Size >> 1) - 1));
				continue;
				IL_0257:
				if (data->Size == 0)
				{
					obj = Array.Empty<byte>();
					continue;
				}
				byte[] array = new byte[data->Size];
				Marshal.Copy(data->DataPointer, array, 0, array.Length);
				obj = array;
			}
		}

		[Conditional("DEBUG")]
		private unsafe static void AssertValidString(EventData* data)
		{
			char* ptr = (char*)(void*)data->DataPointer;
			int num = data->Size / 2 - 1;
			for (int i = 0; i < num; i++)
			{
			}
		}

		private EventDispatcher GetDispatcher(EventListener listener)
		{
			EventDispatcher eventDispatcher;
			for (eventDispatcher = m_Dispatchers; eventDispatcher != null; eventDispatcher = eventDispatcher.m_Next)
			{
				if (eventDispatcher.m_Listener == listener)
				{
					return eventDispatcher;
				}
			}
			return eventDispatcher;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		private unsafe void WriteEventVarargs(int eventId, Guid* childActivityID, object[] args)
		{
			if (!IsEnabled())
			{
				return;
			}
			try
			{
				ref EventMetadata reference = ref m_eventData[eventId];
				if (childActivityID != null && !reference.HasRelatedActivityID)
				{
					throw new ArgumentException(SR.EventSource_NoRelatedActivityId);
				}
				LogEventArgsMismatches(eventId, args);
				Guid* ptr = null;
				Guid activityId = Guid.Empty;
				Guid relatedActivityId = Guid.Empty;
				EventOpcode opcode = (EventOpcode)reference.Descriptor.Opcode;
				EventActivityOptions activityOptions = reference.ActivityOptions;
				if (childActivityID == null && (activityOptions & EventActivityOptions.Disable) == 0)
				{
					switch (opcode)
					{
					case EventOpcode.Start:
						m_activityTracker.OnStart(m_name, reference.Name, reference.Descriptor.Task, ref activityId, ref relatedActivityId, reference.ActivityOptions);
						break;
					case EventOpcode.Stop:
						m_activityTracker.OnStop(m_name, reference.Name, reference.Descriptor.Task, ref activityId);
						break;
					}
					if (activityId != Guid.Empty)
					{
						ptr = &activityId;
					}
					if (relatedActivityId != Guid.Empty)
					{
						childActivityID = &relatedActivityId;
					}
				}
				if (reference.EnabledForETW || reference.EnabledForEventPipe)
				{
					if (!SelfDescribingEvents)
					{
						if (!m_etwProvider.WriteEvent(ref reference.Descriptor, reference.EventHandle, ptr, childActivityID, args))
						{
							ThrowEventSourceException(reference.Name);
						}
						if (!m_eventPipeProvider.WriteEvent(ref reference.Descriptor, reference.EventHandle, ptr, childActivityID, args))
						{
							ThrowEventSourceException(reference.Name);
						}
					}
					else
					{
						EventSourceOptions eventSourceOptions = default(EventSourceOptions);
						eventSourceOptions.Keywords = (EventKeywords)reference.Descriptor.Keywords;
						eventSourceOptions.Level = (EventLevel)reference.Descriptor.Level;
						eventSourceOptions.Opcode = (EventOpcode)reference.Descriptor.Opcode;
						EventSourceOptions options = eventSourceOptions;
						WriteMultiMerge(reference.Name, ref options, reference.TraceLoggingEventTypes, ptr, childActivityID, args);
					}
				}
				if (m_Dispatchers != null && reference.EnabledForAnyListener)
				{
					if (!LocalAppContextSwitches.PreserveEventListnerObjectIdentity)
					{
						args = SerializeEventArgs(eventId, args);
					}
					EventWrittenEventArgs eventCallbackArgs = new EventWrittenEventArgs(this, eventId, ptr, childActivityID)
					{
						Payload = new ReadOnlyCollection<object>(args)
					};
					DispatchToAllListeners(eventCallbackArgs);
				}
			}
			catch (Exception ex)
			{
				if (ex is EventSourceException)
				{
					throw;
				}
				ThrowEventSourceException(m_eventData[eventId].Name, ex);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		private object[] SerializeEventArgs(int eventId, object[] args)
		{
			TraceLoggingEventTypes traceLoggingEventTypes = m_eventData[eventId].TraceLoggingEventTypes;
			int num = Math.Min(traceLoggingEventTypes.typeInfos.Length, args.Length);
			object[] array = new object[traceLoggingEventTypes.typeInfos.Length];
			for (int i = 0; i < num; i++)
			{
				array[i] = traceLoggingEventTypes.typeInfos[i].GetData(args[i]);
			}
			return array;
		}

		private void LogEventArgsMismatches(int eventId, object[] args)
		{
			ParameterInfo[] parameters = m_eventData[eventId].Parameters;
			if (args.Length != parameters.Length)
			{
				ReportOutOfBandMessage(SR.Format(SR.EventSource_EventParametersMismatch, eventId, args.Length, parameters.Length));
				return;
			}
			for (int i = 0; i < args.Length; i++)
			{
				Type parameterType = parameters[i].ParameterType;
				object obj = args[i];
				if ((obj != null && !parameterType.IsAssignableFrom(obj.GetType())) || (obj == null && parameterType.IsValueType && (!parameterType.IsGenericType || !(parameterType.GetGenericTypeDefinition() == typeof(Nullable<>)))))
				{
					ReportOutOfBandMessage(SR.Format(SR.EventSource_VarArgsParameterMismatch, eventId, parameters[i].Name));
					break;
				}
			}
		}

		private unsafe void WriteToAllListeners(EventWrittenEventArgs eventCallbackArgs, int eventDataCount, EventData* data)
		{
			ref EventMetadata reference = ref m_eventData[eventCallbackArgs.EventId];
			if (eventDataCount != reference.EventListenerParameterCount)
			{
				ReportOutOfBandMessage(SR.Format(SR.EventSource_EventParametersMismatch, eventCallbackArgs.EventId, eventDataCount, reference.Parameters.Length));
			}
			if (eventDataCount == 0)
			{
				eventCallbackArgs.Payload = EventWrittenEventArgs.EmptyPayload;
			}
			else
			{
				object[] array = new object[Math.Min(eventDataCount, reference.Parameters.Length)];
				if (reference.AllParametersAreString)
				{
					int num = 0;
					while (num < array.Length)
					{
						IntPtr dataPointer = data->DataPointer;
						array[num] = ((dataPointer == IntPtr.Zero) ? null : new string((char*)(void*)dataPointer, 0, (data->Size >> 1) - 1));
						num++;
						data++;
					}
				}
				else if (reference.AllParametersAreInt32)
				{
					int num2 = 0;
					while (num2 < array.Length)
					{
						array[num2] = *(int*)(void*)data->DataPointer;
						num2++;
						data++;
					}
				}
				else
				{
					DecodeObjects(array, reference.ParameterTypes, data);
				}
				eventCallbackArgs.Payload = new ReadOnlyCollection<object>(array);
			}
			DispatchToAllListeners(eventCallbackArgs);
		}

		internal void DispatchToAllListeners(EventWrittenEventArgs eventCallbackArgs)
		{
			int eventId = eventCallbackArgs.EventId;
			Exception ex = null;
			for (EventDispatcher eventDispatcher = m_Dispatchers; eventDispatcher != null; eventDispatcher = eventDispatcher.m_Next)
			{
				if (eventId == -1 || eventDispatcher.m_EventEnabled[eventId])
				{
					try
					{
						eventDispatcher.m_Listener.OnEventWritten(eventCallbackArgs);
					}
					catch (Exception ex2)
					{
						ReportOutOfBandMessage("ERROR: Exception during EventSource.OnEventWritten: " + ex2.Message);
						ex = ex2;
					}
				}
			}
			if (ex != null && ThrowOnEventWriteErrors)
			{
				throw new EventSourceException(ex);
			}
		}

		private unsafe void WriteEventString(string msgString)
		{
			bool flag = true;
			flag &= m_etwProvider == null;
			if (flag & (m_eventPipeProvider == null))
			{
				return;
			}
			EventLevel eventLevel = EventLevel.LogAlways;
			long keywords = -1L;
			if (SelfDescribingEvents)
			{
				EventSourceOptions eventSourceOptions = default(EventSourceOptions);
				eventSourceOptions.Keywords = (EventKeywords)keywords;
				eventSourceOptions.Level = eventLevel;
				EventSourceOptions options = eventSourceOptions;
				TraceLoggingEventTypes eventTypes = GetTrimSafeTraceLoggingEventTypes();
				WriteMultiMergeInner("EventSourceMessage", ref options, eventTypes, null, null, msgString);
				return;
			}
			if (m_rawManifest == null && m_outOfBandMessageCount == 1)
			{
				ManifestBuilder manifestBuilder = new ManifestBuilder(Name, Guid, Name, null, EventManifestOptions.None);
				manifestBuilder.StartEvent("EventSourceMessage", new EventAttribute(0)
				{
					Level = eventLevel,
					Task = (EventTask)65534
				});
				manifestBuilder.AddEventParameter(typeof(string), "message");
				manifestBuilder.EndEvent();
				SendManifest(manifestBuilder.CreateManifest());
			}
			fixed (char* ptr = msgString)
			{
				EventDescriptor eventDescriptor = new EventDescriptor(0, 0, 0, (byte)eventLevel, 0, 0, keywords);
				EventProvider.EventData eventData = default(EventProvider.EventData);
				eventData.Ptr = (ulong)ptr;
				eventData.Size = (uint)(2 * (msgString.Length + 1));
				eventData.Reserved = 0u;
				if (m_etwProvider != null)
				{
					m_etwProvider.WriteEvent(ref eventDescriptor, IntPtr.Zero, null, null, 1, (IntPtr)(&eventData));
				}
				if (m_eventPipeProvider == null)
				{
					return;
				}
				if (m_writeEventStringEventHandle == IntPtr.Zero)
				{
					if (m_createEventLock == null)
					{
						Interlocked.CompareExchange(ref m_createEventLock, new object(), null);
					}
					lock (m_createEventLock)
					{
						if (m_writeEventStringEventHandle == IntPtr.Zero)
						{
							string eventName = "EventSourceMessage";
							EventParameterInfo eventParameterInfo = default(EventParameterInfo);
							eventParameterInfo.SetInfo("message", typeof(string));
							byte[] array = EventPipeMetadataGenerator.Instance.GenerateMetadata(0, eventName, keywords, (uint)eventLevel, 0u, EventOpcode.Info, new EventParameterInfo[1] { eventParameterInfo });
							uint metadataLength = ((array != null) ? ((uint)array.Length) : 0u);
							fixed (byte* pMetadata = array)
							{
								m_writeEventStringEventHandle = m_eventPipeProvider.m_eventProvider.DefineEventHandle(0u, eventName, keywords, 0u, (uint)eventLevel, pMetadata, metadataLength);
							}
						}
					}
				}
				m_eventPipeProvider.WriteEvent(ref eventDescriptor, m_writeEventStringEventHandle, null, null, 1, (IntPtr)(&eventData));
			}
			[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The call to TraceLoggingEventTypes with the below parameter values are trim safe")]
			static TraceLoggingEventTypes GetTrimSafeTraceLoggingEventTypes()
			{
				return new TraceLoggingEventTypes("EventSourceMessage", EventTags.None, typeof(string));
			}
		}

		private void WriteStringToAllListeners(string eventName, string msg)
		{
			EventWrittenEventArgs eventWrittenEventArgs = new EventWrittenEventArgs(this, 0);
			eventWrittenEventArgs.EventName = eventName;
			eventWrittenEventArgs.Message = msg;
			eventWrittenEventArgs.Payload = new ReadOnlyCollection<object>(new object[1] { msg });
			eventWrittenEventArgs.PayloadNames = new ReadOnlyCollection<string>(new string[1] { "message" });
			EventWrittenEventArgs eventData = eventWrittenEventArgs;
			for (EventDispatcher eventDispatcher = m_Dispatchers; eventDispatcher != null; eventDispatcher = eventDispatcher.m_Next)
			{
				bool flag = false;
				if (eventDispatcher.m_EventEnabled == null)
				{
					flag = true;
				}
				else
				{
					for (int i = 0; i < eventDispatcher.m_EventEnabled.Length; i++)
					{
						if (eventDispatcher.m_EventEnabled[i])
						{
							flag = true;
							break;
						}
					}
				}
				try
				{
					if (flag)
					{
						eventDispatcher.m_Listener.OnEventWritten(eventData);
					}
				}
				catch
				{
				}
			}
		}

		private bool IsEnabledByDefault(int eventNum, bool enable, EventLevel currentLevel, EventKeywords currentMatchAnyKeyword)
		{
			if (!enable)
			{
				return false;
			}
			EventLevel level = (EventLevel)m_eventData[eventNum].Descriptor.Level;
			EventKeywords eventKeywords = (EventKeywords)(m_eventData[eventNum].Descriptor.Keywords & (long)(~SessionMask.All.ToEventKeywords()));
			EventChannel channel = (EventChannel)m_eventData[eventNum].Descriptor.Channel;
			return IsEnabledCommon(enable, currentLevel, currentMatchAnyKeyword, level, eventKeywords, channel);
		}

		private bool IsEnabledCommon(bool enabled, EventLevel currentLevel, EventKeywords currentMatchAnyKeyword, EventLevel eventLevel, EventKeywords eventKeywords, EventChannel eventChannel)
		{
			if (!enabled)
			{
				return false;
			}
			if (currentLevel != 0 && currentLevel < eventLevel)
			{
				return false;
			}
			if (currentMatchAnyKeyword != EventKeywords.None && eventKeywords != EventKeywords.None)
			{
				if (eventChannel != 0 && m_channelData != null && m_channelData.Length > (int)eventChannel)
				{
					EventKeywords eventKeywords2 = (EventKeywords)((long)m_channelData[(uint)eventChannel] | (long)eventKeywords);
					if (eventKeywords2 != EventKeywords.None && (eventKeywords2 & currentMatchAnyKeyword) == EventKeywords.None)
					{
						return false;
					}
				}
				else if ((eventKeywords & currentMatchAnyKeyword) == EventKeywords.None)
				{
					return false;
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void ThrowEventSourceException(string eventName, Exception innerEx = null)
		{
			if (m_EventSourceExceptionRecurenceCount > 0)
			{
				return;
			}
			try
			{
				m_EventSourceExceptionRecurenceCount++;
				string text = "EventSourceException";
				if (eventName != null)
				{
					text = text + " while processing event \"" + eventName + "\"";
				}
				switch (EventProvider.GetLastWriteEventError())
				{
				case EventProvider.WriteEventErrorCode.EventTooBig:
					ReportOutOfBandMessage(text + ": " + SR.EventSource_EventTooBig);
					if (ThrowOnEventWriteErrors)
					{
						throw new EventSourceException(SR.EventSource_EventTooBig, innerEx);
					}
					return;
				case EventProvider.WriteEventErrorCode.NoFreeBuffers:
					ReportOutOfBandMessage(text + ": " + SR.EventSource_NoFreeBuffers);
					if (ThrowOnEventWriteErrors)
					{
						throw new EventSourceException(SR.EventSource_NoFreeBuffers, innerEx);
					}
					return;
				case EventProvider.WriteEventErrorCode.NullInput:
					ReportOutOfBandMessage(text + ": " + SR.EventSource_NullInput);
					if (ThrowOnEventWriteErrors)
					{
						throw new EventSourceException(SR.EventSource_NullInput, innerEx);
					}
					return;
				case EventProvider.WriteEventErrorCode.TooManyArgs:
					ReportOutOfBandMessage(text + ": " + SR.EventSource_TooManyArgs);
					if (ThrowOnEventWriteErrors)
					{
						throw new EventSourceException(SR.EventSource_TooManyArgs, innerEx);
					}
					return;
				}
				if (innerEx != null)
				{
					innerEx = innerEx.GetBaseException();
					ReportOutOfBandMessage(text + ": " + innerEx.GetType()?.ToString() + ":" + innerEx.Message);
				}
				else
				{
					ReportOutOfBandMessage(text);
				}
				if (ThrowOnEventWriteErrors)
				{
					throw new EventSourceException(innerEx);
				}
			}
			finally
			{
				m_EventSourceExceptionRecurenceCount--;
			}
		}

		internal static EventOpcode GetOpcodeWithDefault(EventOpcode opcode, string eventName)
		{
			if (opcode == EventOpcode.Info && eventName != null)
			{
				if (eventName.EndsWith("Start", StringComparison.Ordinal))
				{
					return EventOpcode.Start;
				}
				if (eventName.EndsWith("Stop", StringComparison.Ordinal))
				{
					return EventOpcode.Stop;
				}
			}
			return opcode;
		}

		internal void SendCommand(EventListener listener, EventProviderType eventProviderType, int perEventSourceSessionId, int etwSessionId, EventCommand command, bool enable, EventLevel level, EventKeywords matchAnyKeyword, IDictionary<string, string> commandArguments)
		{
			if (!IsSupported)
			{
				return;
			}
			EventCommandEventArgs eventCommandEventArgs = new EventCommandEventArgs(command, commandArguments, this, listener, eventProviderType, perEventSourceSessionId, etwSessionId, enable, level, matchAnyKeyword);
			lock (EventListener.EventListenersLock)
			{
				if (m_completelyInited)
				{
					m_deferredCommands = null;
					DoCommand(eventCommandEventArgs);
					return;
				}
				if (m_deferredCommands == null)
				{
					m_deferredCommands = eventCommandEventArgs;
					return;
				}
				EventCommandEventArgs eventCommandEventArgs2 = m_deferredCommands;
				while (eventCommandEventArgs2.nextCommand != null)
				{
					eventCommandEventArgs2 = eventCommandEventArgs2.nextCommand;
				}
				eventCommandEventArgs2.nextCommand = eventCommandEventArgs;
			}
		}

		internal void DoCommand(EventCommandEventArgs commandArgs)
		{
			if (!IsSupported || m_etwProvider == null || m_eventPipeProvider == null)
			{
				return;
			}
			m_outOfBandMessageCount = 0;
			try
			{
				EnsureDescriptorsInitialized();
				commandArgs.dispatcher = GetDispatcher(commandArgs.listener);
				if (commandArgs.dispatcher == null && commandArgs.listener != null)
				{
					throw new ArgumentException(SR.EventSource_ListenerNotFound);
				}
				if (commandArgs.Arguments == null)
				{
					IDictionary<string, string> dictionary2 = (commandArgs.Arguments = new Dictionary<string, string>());
				}
				if (commandArgs.Command == EventCommand.Update)
				{
					for (int i = 0; i < m_eventData.Length; i++)
					{
						EnableEventForDispatcher(commandArgs.dispatcher, commandArgs.eventProviderType, i, IsEnabledByDefault(i, commandArgs.enable, commandArgs.level, commandArgs.matchAnyKeyword));
					}
					if (commandArgs.enable)
					{
						if (!m_eventSourceEnabled)
						{
							m_level = commandArgs.level;
							m_matchAnyKeyword = commandArgs.matchAnyKeyword;
						}
						else
						{
							if (commandArgs.level > m_level)
							{
								m_level = commandArgs.level;
							}
							if (commandArgs.matchAnyKeyword == EventKeywords.None)
							{
								m_matchAnyKeyword = EventKeywords.None;
							}
							else if (m_matchAnyKeyword != EventKeywords.None)
							{
								m_matchAnyKeyword |= commandArgs.matchAnyKeyword;
							}
						}
					}
					bool flag = commandArgs.perEventSourceSessionId >= 0;
					if (commandArgs.perEventSourceSessionId == 0 && !commandArgs.enable)
					{
						flag = false;
					}
					if (commandArgs.listener == null)
					{
						if (!flag)
						{
							commandArgs.perEventSourceSessionId = -commandArgs.perEventSourceSessionId;
						}
						commandArgs.perEventSourceSessionId--;
					}
					commandArgs.Command = (flag ? EventCommand.Enable : EventCommand.Disable);
					if (flag && commandArgs.dispatcher == null && !SelfDescribingEvents)
					{
						SendManifest(m_rawManifest);
					}
					if (commandArgs.enable)
					{
						m_eventSourceEnabled = true;
					}
					OnEventCommand(commandArgs);
					m_eventCommandExecuted?.Invoke(this, commandArgs);
					if (commandArgs.enable)
					{
						return;
					}
					for (int j = 0; j < m_eventData.Length; j++)
					{
						bool enabledForAnyListener = false;
						for (EventDispatcher eventDispatcher = m_Dispatchers; eventDispatcher != null; eventDispatcher = eventDispatcher.m_Next)
						{
							if (eventDispatcher.m_EventEnabled[j])
							{
								enabledForAnyListener = true;
								break;
							}
						}
						m_eventData[j].EnabledForAnyListener = enabledForAnyListener;
					}
					if (!AnyEventEnabled())
					{
						m_level = EventLevel.LogAlways;
						m_matchAnyKeyword = EventKeywords.None;
						m_eventSourceEnabled = false;
					}
				}
				else
				{
					if (commandArgs.Command == EventCommand.SendManifest && m_rawManifest != null)
					{
						SendManifest(m_rawManifest);
					}
					OnEventCommand(commandArgs);
					m_eventCommandExecuted?.Invoke(this, commandArgs);
				}
			}
			catch (Exception ex)
			{
				ReportOutOfBandMessage("ERROR: Exception in Command Processing for EventSource " + Name + ": " + ex.Message);
			}
		}

		internal bool EnableEventForDispatcher(EventDispatcher dispatcher, EventProviderType eventProviderType, int eventId, bool value)
		{
			if (!IsSupported)
			{
				return false;
			}
			if (dispatcher == null)
			{
				if (eventId >= m_eventData.Length)
				{
					return false;
				}
				if (m_etwProvider != null && eventProviderType == EventProviderType.ETW)
				{
					m_eventData[eventId].EnabledForETW = value;
				}
				if (m_eventPipeProvider != null && eventProviderType == EventProviderType.EventPipe)
				{
					m_eventData[eventId].EnabledForEventPipe = value;
				}
			}
			else
			{
				if (eventId >= dispatcher.m_EventEnabled.Length)
				{
					return false;
				}
				dispatcher.m_EventEnabled[eventId] = value;
				if (value)
				{
					m_eventData[eventId].EnabledForAnyListener = true;
				}
			}
			return true;
		}

		private bool AnyEventEnabled()
		{
			for (int i = 0; i < m_eventData.Length; i++)
			{
				if (m_eventData[i].EnabledForETW || m_eventData[i].EnabledForAnyListener || m_eventData[i].EnabledForEventPipe)
				{
					return true;
				}
			}
			return false;
		}

		private void EnsureDescriptorsInitialized()
		{
			if (m_eventData != null)
			{
				return;
			}
			m_rawManifest = CreateManifestAndDescriptors(GetType(), Name, this);
			if (!AllowDuplicateSourceNames)
			{
				foreach (WeakReference<EventSource> s_EventSource in EventListener.s_EventSources)
				{
					if (s_EventSource.TryGetTarget(out var target) && target.Guid == m_guid && !target.IsDisposed && target != this)
					{
						throw new ArgumentException(SR.Format(SR.EventSource_EventSourceGuidInUse, m_guid));
					}
				}
			}
			for (EventDispatcher eventDispatcher = m_Dispatchers; eventDispatcher != null; eventDispatcher = eventDispatcher.m_Next)
			{
				EventDispatcher eventDispatcher2 = eventDispatcher;
				if (eventDispatcher2.m_EventEnabled == null)
				{
					eventDispatcher2.m_EventEnabled = new bool[m_eventData.Length];
				}
			}
			DefineEventPipeEvents();
		}

		private unsafe void SendManifest(byte[] rawManifest)
		{
			if (rawManifest == null)
			{
				return;
			}
			fixed (byte* ptr2 = rawManifest)
			{
				EventDescriptor eventDescriptor = new EventDescriptor(65534, 1, 0, 0, 254, 65534, 72057594037927935L);
				ManifestEnvelope manifestEnvelope = default(ManifestEnvelope);
				manifestEnvelope.Format = ManifestEnvelope.ManifestFormats.SimpleXmlFormat;
				manifestEnvelope.MajorVersion = 1;
				manifestEnvelope.MinorVersion = 0;
				manifestEnvelope.Magic = 91;
				int num = rawManifest.Length;
				manifestEnvelope.ChunkNumber = 0;
				EventProvider.EventData* ptr = stackalloc EventProvider.EventData[2];
				ptr->Ptr = (ulong)(&manifestEnvelope);
				ptr->Size = (uint)sizeof(ManifestEnvelope);
				ptr->Reserved = 0u;
				ptr[1].Ptr = (ulong)ptr2;
				ptr[1].Reserved = 0u;
				int num2 = 65280;
				while (true)
				{
					IL_00c7:
					manifestEnvelope.TotalChunks = (ushort)((num + (num2 - 1)) / num2);
					while (num > 0)
					{
						ptr[1].Size = (uint)Math.Min(num, num2);
						if (m_etwProvider != null && !m_etwProvider.WriteEvent(ref eventDescriptor, IntPtr.Zero, null, null, 2, (IntPtr)ptr))
						{
							if (EventProvider.GetLastWriteEventError() == EventProvider.WriteEventErrorCode.EventTooBig && manifestEnvelope.ChunkNumber == 0 && num2 > 256)
							{
								num2 /= 2;
								goto IL_00c7;
							}
							if (ThrowOnEventWriteErrors)
							{
								ThrowEventSourceException("SendManifest");
							}
							break;
						}
						num -= num2;
						ptr[1].Ptr += (uint)num2;
						manifestEnvelope.ChunkNumber++;
						if (manifestEnvelope.ChunkNumber % 5 == 0)
						{
							Thread.Sleep(15);
						}
					}
					break;
				}
			}
		}

		internal static bool IsCustomAttributeDefinedHelper(MemberInfo member, Type attributeType, EventManifestOptions flags = EventManifestOptions.None)
		{
			if (!member.Module.Assembly.ReflectionOnly && (flags & EventManifestOptions.AllowEventSourceOverride) == 0)
			{
				return member.IsDefined(attributeType, inherit: false);
			}
			foreach (CustomAttributeData customAttribute in CustomAttributeData.GetCustomAttributes(member))
			{
				if (AttributeTypeNamesMatch(attributeType, customAttribute.Constructor.ReflectedType))
				{
					return true;
				}
			}
			return false;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2114:ReflectionToDynamicallyAccessedMembers", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which has dynamically accessed members requirements, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		internal static Attribute GetCustomAttributeHelper(MemberInfo member, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties)] Type attributeType, EventManifestOptions flags = EventManifestOptions.None)
		{
			if (!member.Module.Assembly.ReflectionOnly && (flags & EventManifestOptions.AllowEventSourceOverride) == 0)
			{
				return member.GetCustomAttribute(attributeType, inherit: false);
			}
			foreach (CustomAttributeData customAttribute in CustomAttributeData.GetCustomAttributes(member))
			{
				if (!AttributeTypeNamesMatch(attributeType, customAttribute.Constructor.ReflectedType))
				{
					continue;
				}
				Attribute attribute = null;
				if (customAttribute.ConstructorArguments.Count == 1)
				{
					attribute = (Attribute)Activator.CreateInstance(attributeType, customAttribute.ConstructorArguments[0].Value);
				}
				else if (customAttribute.ConstructorArguments.Count == 0)
				{
					attribute = (Attribute)Activator.CreateInstance(attributeType);
				}
				if (attribute == null)
				{
					continue;
				}
				foreach (CustomAttributeNamedArgument namedArgument in customAttribute.NamedArguments)
				{
					PropertyInfo property = attributeType.GetProperty(namedArgument.MemberInfo.Name, BindingFlags.Instance | BindingFlags.Public);
					object obj = namedArgument.TypedValue.Value;
					if (property.PropertyType.IsEnum)
					{
						string value = obj.ToString();
						obj = Enum.Parse(property.PropertyType, value);
					}
					property.SetValue(attribute, obj, null);
				}
				return attribute;
			}
			return null;
		}

		private static bool AttributeTypeNamesMatch(Type attributeType, Type reflectedAttributeType)
		{
			if (!(attributeType == reflectedAttributeType) && !string.Equals(attributeType.FullName, reflectedAttributeType.FullName, StringComparison.Ordinal))
			{
				if (string.Equals(attributeType.Name, reflectedAttributeType.Name, StringComparison.Ordinal) && attributeType.Namespace.EndsWith("Diagnostics.Tracing", StringComparison.Ordinal))
				{
					return reflectedAttributeType.Namespace.EndsWith("Diagnostics.Tracing", StringComparison.Ordinal);
				}
				return false;
			}
			return true;
		}

		private static Type GetEventSourceBaseType(Type eventSourceType, bool allowEventSourceOverride, bool reflectionOnly)
		{
			Type type = eventSourceType;
			if (type.BaseType == null)
			{
				return null;
			}
			do
			{
				type = type.BaseType;
			}
			while (type != null && type.IsAbstract);
			if (type != null)
			{
				if (!allowEventSourceOverride)
				{
					if ((reflectionOnly && type.FullName != typeof(EventSource).FullName) || (!reflectionOnly && type != typeof(EventSource)))
					{
						return null;
					}
				}
				else if (type.Name != "EventSource")
				{
					return null;
				}
			}
			return type;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2114:ReflectionToDynamicallyAccessedMembers", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which has dynamically accessed members requirements, but its use of this method satisfies these requirements because it passes in the result of GetType with the same annotations.")]
		private static byte[] CreateManifestAndDescriptors([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type eventSourceType, string eventSourceDllName, EventSource source, EventManifestOptions flags = EventManifestOptions.None)
		{
			ManifestBuilder manifestBuilder = null;
			bool flag = source == null || !source.SelfDescribingEvents;
			Exception ex = null;
			byte[] result = null;
			if (eventSourceType.IsAbstract && (flags & EventManifestOptions.Strict) == 0)
			{
				return null;
			}
			try
			{
				MethodInfo[] methods = eventSourceType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = 1;
				EventMetadata[] eventData = null;
				Dictionary<string, string> eventsByName = null;
				if (source != null || (flags & EventManifestOptions.Strict) != 0)
				{
					eventData = new EventMetadata[methods.Length + 1];
					eventData[0].Name = "";
				}
				ResourceManager resources = null;
				EventSourceAttribute eventSourceAttribute = (EventSourceAttribute)GetCustomAttributeHelper(eventSourceType, typeof(EventSourceAttribute), flags);
				if (eventSourceAttribute != null && eventSourceAttribute.LocalizationResources != null)
				{
					resources = new ResourceManager(eventSourceAttribute.LocalizationResources, eventSourceType.Assembly);
				}
				manifestBuilder = ((source == null) ? new ManifestBuilder(GetName(eventSourceType, flags), GetGuid(eventSourceType), eventSourceDllName, resources, flags) : new ManifestBuilder(source.Name, source.Guid, eventSourceDllName, resources, flags));
				manifestBuilder.StartEvent("EventSourceMessage", new EventAttribute(0)
				{
					Level = EventLevel.LogAlways,
					Task = (EventTask)65534
				});
				manifestBuilder.AddEventParameter(typeof(string), "message");
				manifestBuilder.EndEvent();
				if ((flags & EventManifestOptions.Strict) != 0)
				{
					if (!(GetEventSourceBaseType(eventSourceType, (flags & EventManifestOptions.AllowEventSourceOverride) != 0, eventSourceType.Assembly.ReflectionOnly) != null))
					{
						manifestBuilder.ManifestError(SR.EventSource_TypeMustDeriveFromEventSource);
					}
					if (!eventSourceType.IsAbstract && !eventSourceType.IsSealed)
					{
						manifestBuilder.ManifestError(SR.EventSource_TypeMustBeSealedOrAbstract);
					}
				}
				string[] array = new string[3] { "Keywords", "Tasks", "Opcodes" };
				foreach (string text in array)
				{
					Type nestedType = eventSourceType.GetNestedType(text);
					if (!(nestedType != null))
					{
						continue;
					}
					if (eventSourceType.IsAbstract)
					{
						manifestBuilder.ManifestError(SR.Format(SR.EventSource_AbstractMustNotDeclareKTOC, nestedType.Name));
						continue;
					}
					FieldInfo[] fields = nestedType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (FieldInfo staticField in fields)
					{
						AddProviderEnumKind(manifestBuilder, staticField, text);
					}
				}
				manifestBuilder.AddKeyword("Session3", 17592186044416uL);
				manifestBuilder.AddKeyword("Session2", 35184372088832uL);
				manifestBuilder.AddKeyword("Session1", 70368744177664uL);
				manifestBuilder.AddKeyword("Session0", 140737488355328uL);
				if (eventSourceType != typeof(EventSource))
				{
					foreach (MethodInfo methodInfo in methods)
					{
						ParameterInfo[] args = methodInfo.GetParameters();
						EventAttribute eventAttribute = (EventAttribute)GetCustomAttributeHelper(methodInfo, typeof(EventAttribute), flags);
						if (methodInfo.IsStatic)
						{
							continue;
						}
						if (eventSourceType.IsAbstract)
						{
							if (eventAttribute != null)
							{
								manifestBuilder.ManifestError(SR.Format(SR.EventSource_AbstractMustNotDeclareEventMethods, methodInfo.Name, eventAttribute.EventId));
							}
							continue;
						}
						if (eventAttribute == null)
						{
							if (methodInfo.ReturnType != typeof(void) || methodInfo.IsVirtual || IsCustomAttributeDefinedHelper(methodInfo, typeof(NonEventAttribute), flags))
							{
								continue;
							}
							EventAttribute eventAttribute2 = new EventAttribute(num);
							eventAttribute = eventAttribute2;
						}
						else if (eventAttribute.EventId <= 0)
						{
							manifestBuilder.ManifestError(SR.Format(SR.EventSource_NeedPositiveId, methodInfo.Name), runtimeCritical: true);
							continue;
						}
						if (methodInfo.Name.LastIndexOf('.') >= 0)
						{
							manifestBuilder.ManifestError(SR.Format(SR.EventSource_EventMustNotBeExplicitImplementation, methodInfo.Name, eventAttribute.EventId));
						}
						num++;
						string name = methodInfo.Name;
						if (eventAttribute.Opcode == EventOpcode.Info)
						{
							bool flag2 = eventAttribute.Task == EventTask.None;
							if (flag2)
							{
								eventAttribute.Task = (EventTask)(65534 - eventAttribute.EventId);
							}
							if (!eventAttribute.IsOpcodeSet)
							{
								eventAttribute.Opcode = GetOpcodeWithDefault(EventOpcode.Info, name);
							}
							if (flag2)
							{
								if (eventAttribute.Opcode == EventOpcode.Start)
								{
									string text2 = name.Substring(0, name.Length - "Start".Length);
									if (string.Compare(name, 0, text2, 0, text2.Length) == 0 && string.Compare(name, text2.Length, "Start", 0, Math.Max(name.Length - text2.Length, "Start".Length)) == 0)
									{
										manifestBuilder.AddTask(text2, (int)eventAttribute.Task);
									}
								}
								else if (eventAttribute.Opcode == EventOpcode.Stop)
								{
									int num2 = eventAttribute.EventId - 1;
									if (eventData != null && num2 < eventData.Length)
									{
										EventMetadata eventMetadata = eventData[num2];
										string text3 = name.Substring(0, name.Length - "Stop".Length);
										if (eventMetadata.Descriptor.Opcode == 1 && string.Compare(eventMetadata.Name, 0, text3, 0, text3.Length) == 0 && string.Compare(eventMetadata.Name, text3.Length, "Start", 0, Math.Max(eventMetadata.Name.Length - text3.Length, "Start".Length)) == 0)
										{
											eventAttribute.Task = (EventTask)eventMetadata.Descriptor.Task;
											flag2 = false;
										}
									}
									if (flag2 && (flags & EventManifestOptions.Strict) != 0)
									{
										throw new ArgumentException(SR.EventSource_StopsFollowStarts);
									}
								}
							}
						}
						bool hasRelatedActivityID = RemoveFirstArgIfRelatedActivityId(ref args);
						if (source == null || !source.SelfDescribingEvents)
						{
							manifestBuilder.StartEvent(name, eventAttribute);
							for (int l = 0; l < args.Length; l++)
							{
								manifestBuilder.AddEventParameter(args[l].ParameterType, args[l].Name);
							}
							manifestBuilder.EndEvent();
						}
						if (source == null && (flags & EventManifestOptions.Strict) == 0)
						{
							continue;
						}
						DebugCheckEvent(ref eventsByName, eventData, methodInfo, eventAttribute, manifestBuilder, flags);
						if (eventAttribute.Channel != 0)
						{
							eventAttribute.Keywords |= (EventKeywords)manifestBuilder.GetChannelKeyword(eventAttribute.Channel, (ulong)eventAttribute.Keywords);
						}
						if (manifestBuilder.HasResources)
						{
							string key = "event_" + name;
							string localizedMessage = manifestBuilder.GetLocalizedMessage(key, CultureInfo.CurrentUICulture, etwFormat: false);
							if (localizedMessage != null)
							{
								eventAttribute.Message = localizedMessage;
							}
						}
						AddEventDescriptor(ref eventData, name, eventAttribute, args, hasRelatedActivityID);
					}
				}
				NameInfo.ReserveEventIDsBelow(num);
				if (source != null)
				{
					TrimEventDescriptors(ref eventData);
					source.m_eventData = eventData;
					source.m_channelData = manifestBuilder.GetChannelData();
				}
				if (!eventSourceType.IsAbstract && (source == null || !source.SelfDescribingEvents))
				{
					flag = (flags & EventManifestOptions.OnlyIfNeededForRegistration) == 0 || manifestBuilder.GetChannelData().Length != 0;
					if (!flag && (flags & EventManifestOptions.Strict) == 0)
					{
						return null;
					}
					result = manifestBuilder.CreateManifest();
				}
			}
			catch (Exception ex2)
			{
				if ((flags & EventManifestOptions.Strict) == 0)
				{
					throw;
				}
				ex = ex2;
			}
			if ((flags & EventManifestOptions.Strict) != 0 && ((manifestBuilder != null && manifestBuilder.Errors.Count > 0) || ex != null))
			{
				string text4 = string.Empty;
				if (manifestBuilder != null && manifestBuilder.Errors.Count > 0)
				{
					bool flag3 = true;
					foreach (string error in manifestBuilder.Errors)
					{
						if (!flag3)
						{
							text4 += Environment.NewLine;
						}
						flag3 = false;
						text4 += error;
					}
				}
				else
				{
					text4 = "Unexpected error: " + ex.Message;
				}
				throw new ArgumentException(text4, ex);
			}
			if (!flag)
			{
				return null;
			}
			return result;
		}

		private static bool RemoveFirstArgIfRelatedActivityId(ref ParameterInfo[] args)
		{
			if (args.Length != 0 && args[0].ParameterType == typeof(Guid) && string.Equals(args[0].Name, "relatedActivityId", StringComparison.OrdinalIgnoreCase))
			{
				ParameterInfo[] array = new ParameterInfo[args.Length - 1];
				Array.Copy(args, 1, array, 0, args.Length - 1);
				args = array;
				return true;
			}
			return false;
		}

		private static void AddProviderEnumKind(ManifestBuilder manifest, FieldInfo staticField, string providerEnumKind)
		{
			bool reflectionOnly = staticField.Module.Assembly.ReflectionOnly;
			Type fieldType = staticField.FieldType;
			if ((!reflectionOnly && fieldType == typeof(EventOpcode)) || AttributeTypeNamesMatch(fieldType, typeof(EventOpcode)))
			{
				if (!(providerEnumKind != "Opcodes"))
				{
					int value = (int)staticField.GetRawConstantValue();
					manifest.AddOpcode(staticField.Name, value);
					return;
				}
			}
			else if ((!reflectionOnly && fieldType == typeof(EventTask)) || AttributeTypeNamesMatch(fieldType, typeof(EventTask)))
			{
				if (!(providerEnumKind != "Tasks"))
				{
					int value2 = (int)staticField.GetRawConstantValue();
					manifest.AddTask(staticField.Name, value2);
					return;
				}
			}
			else
			{
				if ((reflectionOnly || !(fieldType == typeof(EventKeywords))) && !AttributeTypeNamesMatch(fieldType, typeof(EventKeywords)))
				{
					return;
				}
				if (!(providerEnumKind != "Keywords"))
				{
					ulong value3 = (ulong)(long)staticField.GetRawConstantValue();
					manifest.AddKeyword(staticField.Name, value3);
					return;
				}
			}
			manifest.ManifestError(SR.Format(SR.EventSource_EnumKindMismatch, staticField.Name, staticField.FieldType.Name, providerEnumKind));
		}

		private static void AddEventDescriptor([NotNull] ref EventMetadata[] eventData, string eventName, EventAttribute eventAttribute, ParameterInfo[] eventParameters, bool hasRelatedActivityID)
		{
			if (eventData.Length <= eventAttribute.EventId)
			{
				EventMetadata[] array = new EventMetadata[Math.Max(eventData.Length + 16, eventAttribute.EventId + 1)];
				Array.Copy(eventData, array, eventData.Length);
				eventData = array;
			}
			ref EventMetadata reference = ref eventData[eventAttribute.EventId];
			reference.Descriptor = new EventDescriptor(eventAttribute.EventId, eventAttribute.Version, (byte)eventAttribute.Channel, (byte)eventAttribute.Level, (byte)eventAttribute.Opcode, (int)eventAttribute.Task, (long)eventAttribute.Keywords | (long)SessionMask.All.ToEventKeywords());
			reference.Tags = eventAttribute.Tags;
			reference.Name = eventName;
			reference.Parameters = eventParameters;
			reference.Message = eventAttribute.Message;
			reference.ActivityOptions = eventAttribute.ActivityOptions;
			reference.HasRelatedActivityID = hasRelatedActivityID;
			reference.EventHandle = IntPtr.Zero;
			int num = eventParameters.Length;
			bool allParametersAreInt = true;
			bool allParametersAreString = true;
			foreach (ParameterInfo parameterInfo in eventParameters)
			{
				Type parameterType = parameterInfo.ParameterType;
				if (parameterType == typeof(string))
				{
					allParametersAreInt = false;
					continue;
				}
				if (parameterType == typeof(int) || (parameterType.IsEnum && Type.GetTypeCode(parameterType.GetEnumUnderlyingType()) <= TypeCode.UInt32))
				{
					allParametersAreString = false;
					continue;
				}
				if (parameterType == typeof(byte[]))
				{
					num++;
				}
				allParametersAreInt = false;
				allParametersAreString = false;
			}
			reference.AllParametersAreInt32 = allParametersAreInt;
			reference.AllParametersAreString = allParametersAreString;
			reference.EventListenerParameterCount = num;
		}

		private static void TrimEventDescriptors(ref EventMetadata[] eventData)
		{
			int num = eventData.Length;
			while (0 < num)
			{
				num--;
				if (eventData[num].Descriptor.EventId != 0)
				{
					break;
				}
			}
			if (eventData.Length - num > 2)
			{
				EventMetadata[] array = new EventMetadata[num + 1];
				Array.Copy(eventData, array, array.Length);
				eventData = array;
			}
		}

		internal void AddListener(EventListener listener)
		{
			lock (EventListener.EventListenersLock)
			{
				bool[] eventEnabled = null;
				if (m_eventData != null)
				{
					eventEnabled = new bool[m_eventData.Length];
				}
				m_Dispatchers = new EventDispatcher(m_Dispatchers, eventEnabled, listener);
				listener.OnEventSourceCreated(this);
			}
		}

		private static void DebugCheckEvent(ref Dictionary<string, string> eventsByName, EventMetadata[] eventData, MethodInfo method, EventAttribute eventAttribute, ManifestBuilder manifest, EventManifestOptions options)
		{
			int eventId = eventAttribute.EventId;
			string name = method.Name;
			int helperCallFirstArg = GetHelperCallFirstArg(method);
			if (helperCallFirstArg >= 0 && eventId != helperCallFirstArg)
			{
				manifest.ManifestError(SR.Format(SR.EventSource_MismatchIdToWriteEvent, name, eventId, helperCallFirstArg), runtimeCritical: true);
			}
			if (eventId < eventData.Length && eventData[eventId].Descriptor.EventId != 0)
			{
				manifest.ManifestError(SR.Format(SR.EventSource_EventIdReused, name, eventId, eventData[eventId].Name), runtimeCritical: true);
			}
			for (int i = 0; i < eventData.Length; i++)
			{
				if (eventData[i].Name != null && eventData[i].Descriptor.Task == (int)eventAttribute.Task && (EventOpcode)eventData[i].Descriptor.Opcode == eventAttribute.Opcode)
				{
					manifest.ManifestError(SR.Format(SR.EventSource_TaskOpcodePairReused, name, eventId, eventData[i].Name, i));
					if ((options & EventManifestOptions.Strict) == 0)
					{
						break;
					}
				}
			}
			if (eventAttribute.Opcode != 0)
			{
				bool flag = false;
				if (eventAttribute.Task == EventTask.None)
				{
					flag = true;
				}
				else
				{
					EventTask eventTask = (EventTask)(65534 - eventId);
					if (eventAttribute.Opcode != EventOpcode.Start && eventAttribute.Opcode != EventOpcode.Stop && eventAttribute.Task == eventTask)
					{
						flag = true;
					}
				}
				if (flag)
				{
					manifest.ManifestError(SR.Format(SR.EventSource_EventMustHaveTaskIfNonDefaultOpcode, name, eventId));
				}
			}
			if (eventsByName == null)
			{
				eventsByName = new Dictionary<string, string>();
			}
			if (eventsByName.ContainsKey(name))
			{
				manifest.ManifestError(SR.Format(SR.EventSource_EventNameReused, name), runtimeCritical: true);
			}
			eventsByName[name] = name;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The method calls MethodBase.GetMethodBody. Trimming application can change IL of various methodswhich can lead to change of behavior. This method only uses this to validate usage of event source APIs.In the worst case it will not be able to determine the value it's looking for and will not performany validation.")]
		private static int GetHelperCallFirstArg(MethodInfo method)
		{
			byte[] iLAsByteArray = method.GetMethodBody().GetILAsByteArray();
			int num = -1;
			for (int i = 0; i < iLAsByteArray.Length; i++)
			{
				switch (iLAsByteArray[i])
				{
				case 14:
				case 16:
					i++;
					continue;
				case 21:
				case 22:
				case 23:
				case 24:
				case 25:
				case 26:
				case 27:
				case 28:
				case 29:
				case 30:
					if (i > 0 && iLAsByteArray[i - 1] == 2)
					{
						num = iLAsByteArray[i] - 22;
					}
					continue;
				case 31:
					if (i > 0 && iLAsByteArray[i - 1] == 2)
					{
						num = iLAsByteArray[i + 1];
					}
					i++;
					continue;
				case 32:
					i += 4;
					continue;
				case 40:
					i += 4;
					if (num >= 0)
					{
						for (int j = i + 1; j < iLAsByteArray.Length; j++)
						{
							if (iLAsByteArray[j] == 42)
							{
								return num;
							}
							if (iLAsByteArray[j] != 0)
							{
								break;
							}
						}
					}
					num = -1;
					continue;
				case 44:
				case 45:
					num = -1;
					i++;
					continue;
				case 57:
				case 58:
					num = -1;
					i += 4;
					continue;
				case 140:
				case 141:
					i += 4;
					continue;
				case 254:
					i++;
					if (i < iLAsByteArray.Length && iLAsByteArray[i] < 6)
					{
						continue;
					}
					break;
				case 0:
				case 1:
				case 2:
				case 3:
				case 4:
				case 5:
				case 6:
				case 7:
				case 8:
				case 9:
				case 10:
				case 11:
				case 12:
				case 13:
				case 20:
				case 37:
				case 103:
				case 104:
				case 105:
				case 106:
				case 109:
				case 110:
				case 162:
					continue;
				}
				return -1;
			}
			return -1;
		}

		internal void ReportOutOfBandMessage(string msg)
		{
			try
			{
				if (m_outOfBandMessageCount < 15)
				{
					m_outOfBandMessageCount++;
				}
				else
				{
					if (m_outOfBandMessageCount == 16)
					{
						return;
					}
					m_outOfBandMessageCount = 16;
					msg = "Reached message limit.   End of EventSource error messages.";
				}
				Debugger.Log(0, null, "EventSource Error: " + msg + Environment.NewLine);
				WriteEventString(msg);
				WriteStringToAllListeners("EventSourceMessage", msg);
			}
			catch
			{
			}
		}

		private static EventSourceSettings ValidateSettings(EventSourceSettings settings)
		{
			if ((settings & (EventSourceSettings.EtwManifestEventFormat | EventSourceSettings.EtwSelfDescribingEventFormat)) == (EventSourceSettings.EtwManifestEventFormat | EventSourceSettings.EtwSelfDescribingEventFormat))
			{
				throw new ArgumentException(SR.EventSource_InvalidEventFormat, "settings");
			}
			if ((settings & (EventSourceSettings.EtwManifestEventFormat | EventSourceSettings.EtwSelfDescribingEventFormat)) == 0)
			{
				settings |= EventSourceSettings.EtwSelfDescribingEventFormat;
			}
			return settings;
		}

		public EventSource(string eventSourceName)
			: this(eventSourceName, EventSourceSettings.EtwSelfDescribingEventFormat)
		{
		}

		public EventSource(string eventSourceName, EventSourceSettings config)
			: this(eventSourceName, config, (string[]?)null)
		{
		}

		public EventSource(string eventSourceName, EventSourceSettings config, params string[]? traits)
			: this((eventSourceName == null) ? default(Guid) : GenerateGuidFromName(eventSourceName.ToUpperInvariant()), eventSourceName, config, traits)
		{
			if (eventSourceName == null)
			{
				throw new ArgumentNullException("eventSourceName");
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		public unsafe void Write(string? eventName)
		{
			if (IsEnabled())
			{
				EventSourceOptions options = default(EventSourceOptions);
				WriteImpl(eventName, ref options, null, null, null, SimpleEventTypes<EmptyStruct>.Instance);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		public unsafe void Write(string? eventName, EventSourceOptions options)
		{
			if (IsEnabled())
			{
				WriteImpl(eventName, ref options, null, null, null, SimpleEventTypes<EmptyStruct>.Instance);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		public unsafe void Write<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(string? eventName, T data)
		{
			if (IsEnabled())
			{
				EventSourceOptions options = default(EventSourceOptions);
				WriteImpl(eventName, ref options, data, null, null, SimpleEventTypes<T>.Instance);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		public unsafe void Write<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(string? eventName, EventSourceOptions options, T data)
		{
			if (IsEnabled())
			{
				WriteImpl(eventName, ref options, data, null, null, SimpleEventTypes<T>.Instance);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		public unsafe void Write<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(string? eventName, ref EventSourceOptions options, ref T data)
		{
			if (IsEnabled())
			{
				WriteImpl(eventName, ref options, data, null, null, SimpleEventTypes<T>.Instance);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2112:ReflectionToRequiresUnreferencedCode", Justification = "EnsureDescriptorsInitialized's use of GetType preserves this method which requires unreferenced code, but EnsureDescriptorsInitialized does not access this member and is safe to call.")]
		[RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		public unsafe void Write<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(string? eventName, ref EventSourceOptions options, ref Guid activityId, ref Guid relatedActivityId, ref T data)
		{
			if (!IsEnabled())
			{
				return;
			}
			fixed (Guid* pActivityId = &activityId)
			{
				fixed (Guid* ptr = &relatedActivityId)
				{
					WriteImpl(eventName, ref options, data, pActivityId, (relatedActivityId == Guid.Empty) ? null : ptr, SimpleEventTypes<T>.Instance);
				}
			}
		}

		private unsafe void WriteMultiMerge(string eventName, ref EventSourceOptions options, TraceLoggingEventTypes eventTypes, Guid* activityID, Guid* childActivityID, params object[] values)
		{
			if (IsEnabled())
			{
				byte level = (((options.valuesSet & 4u) != 0) ? options.level : eventTypes.level);
				EventKeywords keywords = ((((uint)options.valuesSet & (true ? 1u : 0u)) != 0) ? options.keywords : eventTypes.keywords);
				if (IsEnabled((EventLevel)level, keywords))
				{
					WriteMultiMergeInner(eventName, ref options, eventTypes, activityID, childActivityID, values);
				}
			}
		}

		private unsafe void WriteMultiMergeInner(string eventName, ref EventSourceOptions options, TraceLoggingEventTypes eventTypes, Guid* activityID, Guid* childActivityID, params object[] values)
		{
			int num = 0;
			byte level = (((options.valuesSet & 4u) != 0) ? options.level : eventTypes.level);
			byte opcode = (((options.valuesSet & 8u) != 0) ? options.opcode : eventTypes.opcode);
			EventTags tags = (((options.valuesSet & 2u) != 0) ? options.tags : eventTypes.Tags);
			EventKeywords keywords = ((((uint)options.valuesSet & (true ? 1u : 0u)) != 0) ? options.keywords : eventTypes.keywords);
			NameInfo nameInfo = eventTypes.GetNameInfo(eventName ?? eventTypes.Name, tags);
			if (nameInfo == null)
			{
				return;
			}
			num = nameInfo.identity;
			EventDescriptor eventDescriptor = new EventDescriptor(num, level, opcode, (long)keywords);
			IntPtr orCreateEventHandle = nameInfo.GetOrCreateEventHandle(m_eventPipeProvider, m_eventHandleTable, eventDescriptor, eventTypes);
			int pinCount = eventTypes.pinCount;
			byte* scratch = stackalloc byte[(int)(uint)eventTypes.scratchSize];
			EventData* ptr = stackalloc EventData[eventTypes.dataCount + 3];
			for (int i = 0; i < eventTypes.dataCount + 3; i++)
			{
				ptr[i] = default(EventData);
			}
			GCHandle* ptr2 = stackalloc GCHandle[pinCount];
			for (int j = 0; j < pinCount; j++)
			{
				ptr2[j] = default(GCHandle);
			}
			ReadOnlySpan<byte> providerMetadata = ProviderMetadata;
			fixed (byte* pointer = providerMetadata)
			{
				fixed (byte* pointer2 = nameInfo.nameMetadata)
				{
					fixed (byte* pointer3 = eventTypes.typeMetadata)
					{
						ptr->SetMetadata(pointer, providerMetadata.Length, 2);
						ptr[1].SetMetadata(pointer2, nameInfo.nameMetadata.Length, 1);
						ptr[2].SetMetadata(pointer3, eventTypes.typeMetadata.Length, 1);
						try
						{
							DataCollector.ThreadInstance.Enable(scratch, eventTypes.scratchSize, ptr + 3, eventTypes.dataCount, ptr2, pinCount);
							for (int k = 0; k < eventTypes.typeInfos.Length; k++)
							{
								TraceLoggingTypeInfo traceLoggingTypeInfo = eventTypes.typeInfos[k];
								traceLoggingTypeInfo.WriteData(traceLoggingTypeInfo.PropertyValueFactory(values[k]));
							}
							WriteEventRaw(eventName, ref eventDescriptor, orCreateEventHandle, activityID, childActivityID, (int)(DataCollector.ThreadInstance.Finish() - ptr), (IntPtr)ptr);
						}
						finally
						{
							WriteCleanup(ptr2, pinCount);
						}
					}
				}
			}
		}

		internal unsafe void WriteMultiMerge(string eventName, ref EventSourceOptions options, TraceLoggingEventTypes eventTypes, Guid* activityID, Guid* childActivityID, EventData* data)
		{
			if (!IsEnabled())
			{
				return;
			}
			fixed (EventSourceOptions* ptr2 = &options)
			{
				EventDescriptor descriptor;
				NameInfo nameInfo = UpdateDescriptor(eventName, eventTypes, ref options, out descriptor);
				if (nameInfo == null)
				{
					return;
				}
				IntPtr orCreateEventHandle = nameInfo.GetOrCreateEventHandle(m_eventPipeProvider, m_eventHandleTable, descriptor, eventTypes);
				int num = eventTypes.dataCount + eventTypes.typeInfos.Length * 2 + 3;
				EventData* ptr = stackalloc EventData[num];
				for (int i = 0; i < num; i++)
				{
					ptr[i] = default(EventData);
				}
				ReadOnlySpan<byte> providerMetadata = ProviderMetadata;
				fixed (byte* pointer = providerMetadata)
				{
					fixed (byte* pointer2 = nameInfo.nameMetadata)
					{
						fixed (byte* pointer3 = eventTypes.typeMetadata)
						{
							ptr->SetMetadata(pointer, providerMetadata.Length, 2);
							ptr[1].SetMetadata(pointer2, nameInfo.nameMetadata.Length, 1);
							ptr[2].SetMetadata(pointer3, eventTypes.typeMetadata.Length, 1);
							int num2 = 3;
							for (int j = 0; j < eventTypes.typeInfos.Length; j++)
							{
								ptr[num2].m_Ptr = data[j].m_Ptr;
								ptr[num2].m_Size = data[j].m_Size;
								if (data[j].m_Size == 4 && eventTypes.typeInfos[j].DataType == typeof(bool))
								{
									ptr[num2].m_Size = 1;
								}
								num2++;
							}
							WriteEventRaw(eventName, ref descriptor, orCreateEventHandle, activityID, childActivityID, num2, (IntPtr)ptr);
						}
					}
				}
			}
		}

		private unsafe void WriteImpl(string eventName, ref EventSourceOptions options, object data, Guid* pActivityId, Guid* pRelatedActivityId, TraceLoggingEventTypes eventTypes)
		{
			try
			{
				fixed (EventSourceOptions* ptr3 = &options)
				{
					options.Opcode = (options.IsOpcodeSet ? options.Opcode : GetOpcodeWithDefault(options.Opcode, eventName));
					EventDescriptor descriptor;
					NameInfo nameInfo = UpdateDescriptor(eventName, eventTypes, ref options, out descriptor);
					if (nameInfo == null)
					{
						return;
					}
					IntPtr orCreateEventHandle = nameInfo.GetOrCreateEventHandle(m_eventPipeProvider, m_eventHandleTable, descriptor, eventTypes);
					int pinCount = eventTypes.pinCount;
					byte* scratch = stackalloc byte[(int)(uint)eventTypes.scratchSize];
					EventData* ptr = stackalloc EventData[eventTypes.dataCount + 3];
					for (int i = 0; i < eventTypes.dataCount + 3; i++)
					{
						ptr[i] = default(EventData);
					}
					GCHandle* ptr2 = stackalloc GCHandle[pinCount];
					for (int j = 0; j < pinCount; j++)
					{
						ptr2[j] = default(GCHandle);
					}
					ReadOnlySpan<byte> providerMetadata = ProviderMetadata;
					fixed (byte* pointer = providerMetadata)
					{
						fixed (byte* pointer2 = nameInfo.nameMetadata)
						{
							fixed (byte* pointer3 = eventTypes.typeMetadata)
							{
								ptr->SetMetadata(pointer, providerMetadata.Length, 2);
								ptr[1].SetMetadata(pointer2, nameInfo.nameMetadata.Length, 1);
								ptr[2].SetMetadata(pointer3, eventTypes.typeMetadata.Length, 1);
								EventOpcode opcode = (EventOpcode)descriptor.Opcode;
								Guid activityId = Guid.Empty;
								Guid relatedActivityId = Guid.Empty;
								if (pActivityId == null && pRelatedActivityId == null && (options.ActivityOptions & EventActivityOptions.Disable) == 0)
								{
									switch (opcode)
									{
									case EventOpcode.Start:
										m_activityTracker.OnStart(m_name, eventName, 0, ref activityId, ref relatedActivityId, options.ActivityOptions);
										break;
									case EventOpcode.Stop:
										m_activityTracker.OnStop(m_name, eventName, 0, ref activityId);
										break;
									}
									if (activityId != Guid.Empty)
									{
										pActivityId = &activityId;
									}
									if (relatedActivityId != Guid.Empty)
									{
										pRelatedActivityId = &relatedActivityId;
									}
								}
								try
								{
									DataCollector.ThreadInstance.Enable(scratch, eventTypes.scratchSize, ptr + 3, eventTypes.dataCount, ptr2, pinCount);
									TraceLoggingTypeInfo traceLoggingTypeInfo = eventTypes.typeInfos[0];
									traceLoggingTypeInfo.WriteData(traceLoggingTypeInfo.PropertyValueFactory(data));
									WriteEventRaw(eventName, ref descriptor, orCreateEventHandle, pActivityId, pRelatedActivityId, (int)(DataCollector.ThreadInstance.Finish() - ptr), (IntPtr)ptr);
									if (m_Dispatchers != null)
									{
										EventPayload payload = (EventPayload)eventTypes.typeInfos[0].GetData(data);
										WriteToAllListeners(eventName, ref descriptor, nameInfo.tags, pActivityId, pRelatedActivityId, payload);
									}
								}
								catch (Exception ex)
								{
									if (ex is EventSourceException)
									{
										throw;
									}
									ThrowEventSourceException(eventName, ex);
								}
								finally
								{
									WriteCleanup(ptr2, pinCount);
								}
							}
						}
					}
				}
			}
			catch (Exception ex2)
			{
				if (ex2 is EventSourceException)
				{
					throw;
				}
				ThrowEventSourceException(eventName, ex2);
			}
		}

		private unsafe void WriteToAllListeners(string eventName, ref EventDescriptor eventDescriptor, EventTags tags, Guid* pActivityId, Guid* pChildActivityId, EventPayload payload)
		{
			EventWrittenEventArgs eventWrittenEventArgs = new EventWrittenEventArgs(this, -1, pActivityId, pChildActivityId)
			{
				EventName = eventName,
				Level = (EventLevel)eventDescriptor.Level,
				Keywords = (EventKeywords)eventDescriptor.Keywords,
				Opcode = (EventOpcode)eventDescriptor.Opcode,
				Tags = tags
			};
			if (payload != null)
			{
				eventWrittenEventArgs.Payload = new ReadOnlyCollection<object>((IList<object>)payload.Values);
				eventWrittenEventArgs.PayloadNames = new ReadOnlyCollection<string>((IList<string>)payload.Keys);
			}
			DispatchToAllListeners(eventWrittenEventArgs);
		}

		[NonEvent]
		private unsafe static void WriteCleanup(GCHandle* pPins, int cPins)
		{
			DataCollector.ThreadInstance.Disable();
			for (int i = 0; i < cPins; i++)
			{
				if (pPins[i].IsAllocated)
				{
					pPins[i].Free();
				}
			}
		}

		private void InitializeProviderMetadata()
		{
			if (ProviderMetadata.Length > 0)
			{
				return;
			}
			if (m_traits != null)
			{
				List<byte> list = new List<byte>(100);
				for (int i = 0; i < m_traits.Length - 1; i += 2)
				{
					if (!m_traits[i].StartsWith("ETW_", StringComparison.Ordinal))
					{
						continue;
					}
					string text = m_traits[i].Substring(4);
					if (!byte.TryParse(text, out var result))
					{
						if (!(text == "GROUP"))
						{
							throw new ArgumentException(SR.Format(SR.EventSource_UnknownEtwTrait, text), "traits");
						}
						result = 1;
					}
					string value = m_traits[i + 1];
					int count = list.Count;
					list.Add(0);
					list.Add(0);
					list.Add(result);
					int num = AddValueToMetaData(list, value) + 3;
					list[count] = (byte)num;
					list[count + 1] = (byte)(num >> 8);
				}
				byte[] array = Statics.MetadataForString(Name, 0, list.Count, 0);
				int num2 = array.Length - list.Count;
				foreach (byte item in list)
				{
					array[num2++] = item;
				}
				m_providerMetadata = array;
			}
			else
			{
				m_providerMetadata = Statics.MetadataForString(Name, 0, 0, 0);
			}
		}

		private static int AddValueToMetaData(List<byte> metaData, string value)
		{
			if (value.Length == 0)
			{
				return 0;
			}
			int count = metaData.Count;
			char c = value[0];
			switch (c)
			{
			case '@':
				metaData.AddRange(Encoding.UTF8.GetBytes(value.Substring(1)));
				break;
			case '{':
				metaData.AddRange(new Guid(value).ToByteArray());
				break;
			case '#':
			{
				for (int i = 1; i < value.Length; i++)
				{
					if (value[i] != ' ')
					{
						if (i + 1 >= value.Length)
						{
							throw new ArgumentException(SR.EventSource_EvenHexDigits, "traits");
						}
						metaData.Add((byte)(HexDigit(value[i]) * 16 + HexDigit(value[i + 1])));
						i++;
					}
				}
				break;
			}
			default:
				if ('A' <= c || ' ' == c)
				{
					metaData.AddRange(Encoding.UTF8.GetBytes(value));
					break;
				}
				throw new ArgumentException(SR.Format(SR.EventSource_IllegalValue, value), "traits");
			}
			return metaData.Count - count;
		}

		private static int HexDigit(char c)
		{
			if ('0' <= c && c <= '9')
			{
				return c - 48;
			}
			if ('a' <= c)
			{
				c = (char)(c - 32);
			}
			if ('A' <= c && c <= 'F')
			{
				return c - 65 + 10;
			}
			throw new ArgumentException(SR.Format(SR.EventSource_BadHexDigit, c), "traits");
		}

		private NameInfo UpdateDescriptor(string name, TraceLoggingEventTypes eventInfo, ref EventSourceOptions options, out EventDescriptor descriptor)
		{
			NameInfo nameInfo = null;
			int traceloggingId = 0;
			byte level = (((options.valuesSet & 4u) != 0) ? options.level : eventInfo.level);
			byte opcode = (((options.valuesSet & 8u) != 0) ? options.opcode : eventInfo.opcode);
			EventTags tags = (((options.valuesSet & 2u) != 0) ? options.tags : eventInfo.Tags);
			EventKeywords keywords = ((((uint)options.valuesSet & (true ? 1u : 0u)) != 0) ? options.keywords : eventInfo.keywords);
			if (IsEnabled((EventLevel)level, keywords))
			{
				nameInfo = eventInfo.GetNameInfo(name ?? eventInfo.Name, tags);
				traceloggingId = nameInfo.identity;
			}
			descriptor = new EventDescriptor(traceloggingId, level, opcode, (long)keywords);
			return nameInfo;
		}
	}
	[Flags]
	public enum EventSourceSettings
	{
		Default = 0,
		ThrowOnEventWriteErrors = 1,
		EtwManifestEventFormat = 4,
		EtwSelfDescribingEventFormat = 8
	}
	public class EventListener : IDisposable
	{
		[CompilerGenerated]
		private EventHandler<EventSourceCreatedEventArgs> _EventSourceCreated;

		internal volatile EventListener m_Next;

		internal static EventListener s_Listeners;

		internal static List<WeakReference<EventSource>> s_EventSources;

		private static bool s_CreatingListener;

		internal static object EventListenersLock
		{
			get
			{
				if (s_EventSources == null)
				{
					Interlocked.CompareExchange(ref s_EventSources, new List<WeakReference<EventSource>>(2), null);
				}
				return s_EventSources;
			}
		}

		public event EventHandler<EventSourceCreatedEventArgs>? EventSourceCreated
		{
			add
			{
				CallBackForExistingEventSources(addToListenersList: false, value);
				_EventSourceCreated = (EventHandler<EventSourceCreatedEventArgs>)Delegate.Combine(_EventSourceCreated, value);
			}
			remove
			{
				_EventSourceCreated = (EventHandler<EventSourceCreatedEventArgs>)Delegate.Remove(_EventSourceCreated, value);
			}
		}

		public event EventHandler<EventWrittenEventArgs>? EventWritten;

		static EventListener()
		{
			GC.KeepAlive(NativeRuntimeEventSource.Log);
		}

		public EventListener()
		{
			CallBackForExistingEventSources(addToListenersList: true, delegate(object obj, EventSourceCreatedEventArgs args)
			{
				args.EventSource.AddListener((EventListener)obj);
			});
		}

		public virtual void Dispose()
		{
			lock (EventListenersLock)
			{
				if (s_Listeners == null)
				{
					return;
				}
				if (this == s_Listeners)
				{
					EventListener listenerToRemove = s_Listeners;
					s_Listeners = m_Next;
					RemoveReferencesToListenerInEventSources(listenerToRemove);
					return;
				}
				EventListener eventListener = s_Listeners;
				EventListener next;
				while (true)
				{
					next = eventListener.m_Next;
					if (next == null)
					{
						return;
					}
					if (next == this)
					{
						break;
					}
					eventListener = next;
				}
				eventListener.m_Next = next.m_Next;
				RemoveReferencesToListenerInEventSources(next);
			}
		}

		public void EnableEvents(EventSource eventSource, EventLevel level)
		{
			EnableEvents(eventSource, level, EventKeywords.None);
		}

		public void EnableEvents(EventSource eventSource, EventLevel level, EventKeywords matchAnyKeyword)
		{
			EnableEvents(eventSource, level, matchAnyKeyword, null);
		}

		public void EnableEvents(EventSource eventSource, EventLevel level, EventKeywords matchAnyKeyword, IDictionary<string, string?>? arguments)
		{
			if (eventSource == null)
			{
				throw new ArgumentNullException("eventSource");
			}
			eventSource.SendCommand(this, EventProviderType.None, 0, 0, EventCommand.Update, enable: true, level, matchAnyKeyword, arguments);
			if (eventSource.GetType() == typeof(NativeRuntimeEventSource))
			{
				EventPipeEventDispatcher.Instance.SendCommand(this, EventCommand.Update, enable: true, level, matchAnyKeyword);
			}
		}

		public void DisableEvents(EventSource eventSource)
		{
			if (eventSource == null)
			{
				throw new ArgumentNullException("eventSource");
			}
			eventSource.SendCommand(this, EventProviderType.None, 0, 0, EventCommand.Update, enable: false, EventLevel.LogAlways, EventKeywords.None, null);
			if (eventSource.GetType() == typeof(NativeRuntimeEventSource))
			{
				EventPipeEventDispatcher.Instance.SendCommand(this, EventCommand.Update, enable: false, EventLevel.LogAlways, EventKeywords.None);
			}
		}

		public static int EventSourceIndex(EventSource eventSource)
		{
			return eventSource.m_id;
		}

		protected internal virtual void OnEventSourceCreated(EventSource eventSource)
		{
			EventHandler<EventSourceCreatedEventArgs> eventSourceCreated = _EventSourceCreated;
			if (eventSourceCreated != null)
			{
				EventSourceCreatedEventArgs eventSourceCreatedEventArgs = new EventSourceCreatedEventArgs();
				eventSourceCreatedEventArgs.EventSource = eventSource;
				eventSourceCreated(this, eventSourceCreatedEventArgs);
			}
		}

		protected internal virtual void OnEventWritten(EventWrittenEventArgs eventData)
		{
			this.EventWritten?.Invoke(this, eventData);
		}

		internal static void AddEventSource(EventSource newEventSource)
		{
			lock (EventListenersLock)
			{
				int num = -1;
				if (s_EventSources.Count % 64 == 63)
				{
					int num2 = s_EventSources.Count;
					while (0 < num2)
					{
						num2--;
						WeakReference<EventSource> weakReference = s_EventSources[num2];
						if (!weakReference.TryGetTarget(out var _))
						{
							num = num2;
							weakReference.SetTarget(newEventSource);
							break;
						}
					}
				}
				if (num < 0)
				{
					num = s_EventSources.Count;
					s_EventSources.Add(new WeakReference<EventSource>(newEventSource));
				}
				newEventSource.m_id = num;
				for (EventListener next = s_Listeners; next != null; next = next.m_Next)
				{
					newEventSource.AddListener(next);
				}
			}
		}

		internal static void DisposeOnShutdown()
		{
			List<EventSource> list = new List<EventSource>();
			lock (EventListenersLock)
			{
				foreach (WeakReference<EventSource> s_EventSource in s_EventSources)
				{
					if (s_EventSource.TryGetTarget(out var target))
					{
						list.Add(target);
					}
				}
			}
			foreach (EventSource item in list)
			{
				item.Dispose();
			}
		}

		private static void RemoveReferencesToListenerInEventSources(EventListener listenerToRemove)
		{
			foreach (WeakReference<EventSource> s_EventSource in s_EventSources)
			{
				if (!s_EventSource.TryGetTarget(out var target))
				{
					continue;
				}
				if (target.m_Dispatchers.m_Listener == listenerToRemove)
				{
					target.m_Dispatchers = target.m_Dispatchers.m_Next;
					continue;
				}
				EventDispatcher eventDispatcher = target.m_Dispatchers;
				while (true)
				{
					EventDispatcher next = eventDispatcher.m_Next;
					if (next == null)
					{
						break;
					}
					if (next.m_Listener == listenerToRemove)
					{
						eventDispatcher.m_Next = next.m_Next;
						break;
					}
					eventDispatcher = next;
				}
			}
			EventPipeEventDispatcher.Instance.RemoveEventListener(listenerToRemove);
		}

		private void CallBackForExistingEventSources(bool addToListenersList, EventHandler<EventSourceCreatedEventArgs> callback)
		{
			lock (EventListenersLock)
			{
				if (s_CreatingListener)
				{
					throw new InvalidOperationException(SR.EventSource_ListenerCreatedInsideCallback);
				}
				try
				{
					s_CreatingListener = true;
					if (addToListenersList)
					{
						m_Next = s_Listeners;
						s_Listeners = this;
					}
					if (callback == null)
					{
						return;
					}
					WeakReference<EventSource>[] array = s_EventSources.ToArray();
					foreach (WeakReference<EventSource> weakReference in array)
					{
						if (weakReference.TryGetTarget(out var target))
						{
							EventSourceCreatedEventArgs eventSourceCreatedEventArgs = new EventSourceCreatedEventArgs();
							eventSourceCreatedEventArgs.EventSource = target;
							callback(this, eventSourceCreatedEventArgs);
						}
					}
				}
				finally
				{
					s_CreatingListener = false;
				}
			}
		}
	}
	public class EventCommandEventArgs : EventArgs
	{
		internal EventSource eventSource;

		internal EventDispatcher dispatcher;

		internal EventProviderType eventProviderType;

		internal EventListener listener;

		internal int perEventSourceSessionId;

		internal int etwSessionId;

		internal bool enable;

		internal EventLevel level;

		internal EventKeywords matchAnyKeyword;

		internal EventCommandEventArgs nextCommand;

		public EventCommand Command { get; internal set; }

		public IDictionary<string, string?>? Arguments { get; internal set; }

		public bool EnableEvent(int eventId)
		{
			if (Command != EventCommand.Enable && Command != EventCommand.Disable)
			{
				throw new InvalidOperationException();
			}
			return eventSource.EnableEventForDispatcher(dispatcher, eventProviderType, eventId, value: true);
		}

		public bool DisableEvent(int eventId)
		{
			if (Command != EventCommand.Enable && Command != EventCommand.Disable)
			{
				throw new InvalidOperationException();
			}
			return eventSource.EnableEventForDispatcher(dispatcher, eventProviderType, eventId, value: false);
		}

		internal EventCommandEventArgs(EventCommand command, IDictionary<string, string> arguments, EventSource eventSource, EventListener listener, EventProviderType eventProviderType, int perEventSourceSessionId, int etwSessionId, bool enable, EventLevel level, EventKeywords matchAnyKeyword)
		{
			Command = command;
			Arguments = arguments;
			this.eventSource = eventSource;
			this.listener = listener;
			this.eventProviderType = eventProviderType;
			this.perEventSourceSessionId = perEventSourceSessionId;
			this.etwSessionId = etwSessionId;
			this.enable = enable;
			this.level = level;
			this.matchAnyKeyword = matchAnyKeyword;
		}
	}
	public class EventSourceCreatedEventArgs : EventArgs
	{
		public EventSource? EventSource { get; internal set; }
	}
	public class EventWrittenEventArgs : EventArgs
	{
		private sealed class MoreEventInfo
		{
			public string Message;

			public string EventName;

			public ReadOnlyCollection<string> PayloadNames;

			public Guid RelatedActivityId;

			public long? OsThreadId;

			public EventTags Tags;

			public EventOpcode Opcode;

			public EventLevel Level;

			public EventKeywords Keywords;
		}

		internal static readonly ReadOnlyCollection<object> EmptyPayload = new ReadOnlyCollection<object>(Array.Empty<object>());

		private Guid _activityId;

		private MoreEventInfo _moreInfo;

		private ref EventSource.EventMetadata Metadata => ref EventSource.m_eventData[EventId];

		public string? EventName
		{
			get
			{
				object obj = _moreInfo?.EventName;
				if (obj == null)
				{
					if (EventId > 0)
					{
						return Metadata.Name;
					}
					obj = null;
				}
				return (string?)obj;
			}
			internal set
			{
				MoreInfo.EventName = value;
			}
		}

		public int EventId { get; }

		public Guid ActivityId
		{
			get
			{
				if (_activityId == Guid.Empty)
				{
					_activityId = System.Diagnostics.Tracing.EventSource.CurrentThreadActivityId;
				}
				return _activityId;
			}
		}

		public Guid RelatedActivityId => _moreInfo?.RelatedActivityId ?? default(Guid);

		public ReadOnlyCollection<object?>? Payload { get; internal set; }

		public ReadOnlyCollection<string>? PayloadNames
		{
			get
			{
				object obj = _moreInfo?.PayloadNames;
				if (obj == null)
				{
					if (EventId > 0)
					{
						return Metadata.ParameterNames;
					}
					obj = null;
				}
				return (ReadOnlyCollection<string>?)obj;
			}
			internal set
			{
				MoreInfo.PayloadNames = value;
			}
		}

		public EventSource EventSource { get; }

		public EventKeywords Keywords
		{
			get
			{
				if (EventId > 0)
				{
					return (EventKeywords)Metadata.Descriptor.Keywords;
				}
				return _moreInfo?.Keywords ?? EventKeywords.None;
			}
			internal set
			{
				MoreInfo.Keywords = value;
			}
		}

		public EventOpcode Opcode
		{
			get
			{
				if (EventId > 0)
				{
					return (EventOpcode)Metadata.Descriptor.Opcode;
				}
				return _moreInfo?.Opcode ?? EventOpcode.Info;
			}
			internal set
			{
				MoreInfo.Opcode = value;
			}
		}

		public EventTask Task
		{
			get
			{
				if (EventId > 0)
				{
					return (EventTask)Metadata.Descriptor.Task;
				}
				return EventTask.None;
			}
		}

		public EventTags Tags
		{
			get
			{
				if (EventId > 0)
				{
					return Metadata.Tags;
				}
				return _moreInfo?.Tags ?? EventTags.None;
			}
			internal set
			{
				MoreInfo.Tags = value;
			}
		}

		public string? Message
		{
			get
			{
				object obj = _moreInfo?.Message;
				if (obj == null)
				{
					if (EventId > 0)
					{
						return Metadata.Message;
					}
					obj = null;
				}
				return (string?)obj;
			}
			internal set
			{
				MoreInfo.Message = value;
			}
		}

		public EventChannel Channel
		{
			get
			{
				if (EventId > 0)
				{
					return (EventChannel)Metadata.Descriptor.Channel;
				}
				return EventChannel.None;
			}
		}

		public byte Version
		{
			get
			{
				if (EventId > 0)
				{
					return Metadata.Descriptor.Version;
				}
				return 0;
			}
		}

		public EventLevel Level
		{
			get
			{
				if (EventId > 0)
				{
					return (EventLevel)Metadata.Descriptor.Level;
				}
				return _moreInfo?.Level ?? EventLevel.LogAlways;
			}
			internal set
			{
				MoreInfo.Level = value;
			}
		}

		public long OSThreadId
		{
			get
			{
				ref long? osThreadId = ref MoreInfo.OsThreadId;
				if (!osThreadId.HasValue)
				{
					osThreadId = (long)Thread.CurrentOSThreadId;
				}
				return osThreadId.Value;
			}
			internal set
			{
				MoreInfo.OsThreadId = value;
			}
		}

		public DateTime TimeStamp { get; internal set; }

		private MoreEventInfo MoreInfo => _moreInfo ?? (_moreInfo = new MoreEventInfo());

		internal EventWrittenEventArgs(EventSource eventSource, int eventId)
		{
			EventSource = eventSource;
			EventId = eventId;
			TimeStamp = DateTime.UtcNow;
		}

		internal unsafe EventWrittenEventArgs(EventSource eventSource, int eventId, Guid* pActivityID, Guid* pChildActivityID)
			: this(eventSource, eventId)
		{
			if (pActivityID != null)
			{
				_activityId = *pActivityID;
			}
			if (pChildActivityID != null)
			{
				MoreInfo.RelatedActivityId = *pChildActivityID;
			}
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public sealed class EventSourceAttribute : Attribute
	{
		public string? Name { get; set; }

		public string? Guid { get; set; }

		public string? LocalizationResources { get; set; }
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class EventAttribute : Attribute
	{
		private EventOpcode m_opcode;

		private bool m_opcodeSet;

		public int EventId { get; private set; }

		public EventLevel Level { get; set; }

		public EventKeywords Keywords { get; set; }

		public EventOpcode Opcode
		{
			get
			{
				return m_opcode;
			}
			set
			{
				m_opcode = value;
				m_opcodeSet = true;
			}
		}

		internal bool IsOpcodeSet => m_opcodeSet;

		public EventTask Task { get; set; }

		public EventChannel Channel { get; set; }

		public byte Version { get; set; }

		public string? Message { get; set; }

		public EventTags Tags { get; set; }

		public EventActivityOptions ActivityOptions { get; set; }

		public EventAttribute(int eventId)
		{
			EventId = eventId;
			Level = EventLevel.Informational;
		}
	}
	[AttributeUsage(AttributeTargets.Method)]
	public sealed class NonEventAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field)]
	internal class EventChannelAttribute : Attribute
	{
		public bool Enabled { get; set; }

		public EventChannelType EventChannelType { get; set; }
	}
	internal enum EventChannelType
	{
		Admin = 1,
		Operational,
		Analytic,
		Debug
	}
	public enum EventCommand
	{
		Update = 0,
		SendManifest = -1,
		Enable = -2,
		Disable = -3
	}
	[DefaultMember("Item")]
	internal struct SessionMask
	{
		private uint m_mask;

		public static SessionMask All => new SessionMask(15u);

		public SessionMask(uint mask = 0u)
		{
			m_mask = mask & 0xFu;
		}

		public ulong ToEventKeywords()
		{
			return (ulong)m_mask << 44;
		}

		public static SessionMask FromEventKeywords(ulong m)
		{
			return new SessionMask((uint)(m >> 44));
		}

		public static explicit operator uint(SessionMask m)
		{
			return m.m_mask;
		}
	}
	internal sealed class EventDispatcher
	{
		internal readonly EventListener m_Listener;

		internal bool[] m_EventEnabled;

		internal EventDispatcher m_Next;

		internal EventDispatcher(EventDispatcher next, bool[] eventEnabled, EventListener listener)
		{
			m_Next = next;
			m_EventEnabled = eventEnabled;
			m_Listener = listener;
		}
	}
	[Flags]
	public enum EventManifestOptions
	{
		None = 0,
		Strict = 1,
		AllCultures = 2,
		OnlyIfNeededForRegistration = 4,
		AllowEventSourceOverride = 8
	}
	internal sealed class ManifestBuilder
	{
		private sealed class ChannelInfo
		{
			public string Name;

			public ulong Keywords;

			public EventChannelAttribute Attribs;
		}

		private static readonly string[] s_escapes = new string[8] { "&amp;", "&lt;", "&gt;", "&apos;", "&quot;", "%r", "%n", "%t" };

		private readonly Dictionary<int, string> opcodeTab;

		private Dictionary<int, string> taskTab;

		private Dictionary<int, ChannelInfo> channelTab;

		private Dictionary<ulong, string> keywordTab;

		private Dictionary<string, Type> mapsTab;

		private readonly Dictionary<string, string> stringTab;

		private ulong nextChannelKeywordBit = 9223372036854775808uL;

		private readonly StringBuilder sb;

		private readonly StringBuilder events;

		private readonly StringBuilder templates;

		private readonly string providerName;

		private readonly ResourceManager resources;

		private readonly EventManifestOptions flags;

		private readonly IList<string> errors;

		private readonly Dictionary<string, List<int>> perEventByteArrayArgIndices;

		private string eventName;

		private int numParams;

		private List<int> byteArrArgIndices;

		public IList<string> Errors => errors;

		public bool HasResources => resources != null;

		public ManifestBuilder(string providerName, Guid providerGuid, string dllName, ResourceManager resources, EventManifestOptions flags)
		{
			this.providerName = providerName;
			this.flags = flags;
			this.resources = resources;
			sb = new StringBuilder();
			events = new StringBuilder();
			templates = new StringBuilder();
			opcodeTab = new Dictionary<int, string>();
			stringTab = new Dictionary<string, string>();
			errors = new List<string>();
			perEventByteArrayArgIndices = new Dictionary<string, List<int>>();
			sb.AppendLine("<instrumentationManifest xmlns=\"http://schemas.microsoft.com/win/2004/08/events\">");
			sb.AppendLine(" <instrumentation xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:win=\"http://manifests.microsoft.com/win/2004/08/windows/events\">");
			sb.AppendLine("  <events xmlns=\"http://schemas.microsoft.com/win/2004/08/events\">");
			StringBuilder stringBuilder = sb;
			StringBuilder stringBuilder2 = stringBuilder;
			StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(27, 2, stringBuilder);
			handler.AppendLiteral("<provider name=\"");
			handler.AppendFormatted(providerName);
			handler.AppendLiteral("\" guid=\"{");
			handler.AppendFormatted(providerGuid);
			handler.AppendLiteral("}\"");
			stringBuilder2.Append(ref handler);
			if (dllName != null)
			{
				stringBuilder = sb;
				StringBuilder stringBuilder3 = stringBuilder;
				StringBuilder.AppendInterpolatedStringHandler handler2 = new StringBuilder.AppendInterpolatedStringHandler(39, 2, stringBuilder);
				handler2.AppendLiteral(" resourceFileName=\"");
				handler2.AppendFormatted(dllName);
				handler2.AppendLiteral("\" messageFileName=\"");
				handler2.AppendFormatted(dllName);
				handler2.AppendLiteral("\"");
				stringBuilder3.Append(ref handler2);
			}
			string value = providerName.Replace("-", "").Replace('.', '_');
			stringBuilder = sb;
			StringBuilder stringBuilder4 = stringBuilder;
			StringBuilder.AppendInterpolatedStringHandler handler3 = new StringBuilder.AppendInterpolatedStringHandler(11, 1, stringBuilder);
			handler3.AppendLiteral(" symbol=\"");
			handler3.AppendFormatted(value);
			handler3.AppendLiteral("\">");
			stringBuilder4.AppendLine(ref handler3);
		}

		public void AddOpcode(string name, int value)
		{
			if ((flags & EventManifestOptions.Strict) != 0)
			{
				if (value <= 10 || value >= 239)
				{
					ManifestError(SR.Format(SR.EventSource_IllegalOpcodeValue, name, value));
				}
				if (opcodeTab.TryGetValue(value, out var value2) && !name.Equals(value2, StringComparison.Ordinal))
				{
					ManifestError(SR.Format(SR.EventSource_OpcodeCollision, name, value2, value));
				}
			}
			opcodeTab[value] = name;
		}

		public void AddTask(string name, int value)
		{
			if ((flags & EventManifestOptions.Strict) != 0)
			{
				if (value <= 0 || value >= 65535)
				{
					ManifestError(SR.Format(SR.EventSource_IllegalTaskValue, name, value));
				}
				if (taskTab != null && taskTab.TryGetValue(value, out var value2) && !name.Equals(value2, StringComparison.Ordinal))
				{
					ManifestError(SR.Format(SR.EventSource_TaskCollision, name, value2, value));
				}
			}
			if (taskTab == null)
			{
				taskTab = new Dictionary<int, string>();
			}
			taskTab[value] = name;
		}

		public void AddKeyword(string name, ulong value)
		{
			if ((value & (value - 1)) != 0L)
			{
				ManifestError(SR.Format(SR.EventSource_KeywordNeedPowerOfTwo, "0x" + value.ToString("x", CultureInfo.CurrentCulture), name), runtimeCritical: true);
			}
			if ((flags & EventManifestOptions.Strict) != 0)
			{
				if (value >= 17592186044416L && !name.StartsWith("Session", StringComparison.Ordinal))
				{
					ManifestError(SR.Format(SR.EventSource_IllegalKeywordsValue, name, "0x" + value.ToString("x", CultureInfo.CurrentCulture)));
				}
				if (keywordTab != null && keywordTab.TryGetValue(value, out var value2) && !name.Equals(value2, StringComparison.Ordinal))
				{
					ManifestError(SR.Format(SR.EventSource_KeywordCollision, name, value2, "0x" + value.ToString("x", CultureInfo.CurrentCulture)));
				}
			}
			if (keywordTab == null)
			{
				keywordTab = new Dictionary<ulong, string>();
			}
			keywordTab[value] = name;
		}

		public void AddChannel(string name, int value, EventChannelAttribute channelAttribute)
		{
			EventChannel eventChannel = (EventChannel)value;
			if (value < 16 || value > 255)
			{
				ManifestError(SR.Format(SR.EventSource_EventChannelOutOfRange, name, value));
			}
			else if ((int)eventChannel >= 16 && (int)eventChannel <= 19 && channelAttribute != null && EventChannelToChannelType(eventChannel) != channelAttribute.EventChannelType)
			{
				ManifestError(SR.Format(SR.EventSource_ChannelTypeDoesNotMatchEventChannelValue, name, ((EventChannel)value).ToString()));
			}
			ulong channelKeyword = GetChannelKeyword(eventChannel, 0uL);
			if (channelTab == null)
			{
				channelTab = new Dictionary<int, ChannelInfo>(4);
			}
			channelTab[value] = new ChannelInfo
			{
				Name = name,
				Keywords = channelKeyword,
				Attribs = channelAttribute
			};
		}

		private static EventChannelType EventChannelToChannelType(EventChannel channel)
		{
			return (EventChannelType)(channel - 16 + 1);
		}

		private static EventChannelAttribute GetDefaultChannelAttribute(EventChannel channel)
		{
			EventChannelAttribute eventChannelAttribute = new EventChannelAttribute();
			eventChannelAttribute.EventChannelType = EventChannelToChannelType(channel);
			if (eventChannelAttribute.EventChannelType <= EventChannelType.Operational)
			{
				eventChannelAttribute.Enabled = true;
			}
			return eventChannelAttribute;
		}

		public ulong[] GetChannelData()
		{
			if (channelTab == null)
			{
				return Array.Empty<ulong>();
			}
			int num = -1;
			foreach (int key in channelTab.Keys)
			{
				if (key > num)
				{
					num = key;
				}
			}
			ulong[] array = new ulong[num + 1];
			foreach (KeyValuePair<int, ChannelInfo> item in channelTab)
			{
				array[item.Key] = item.Value.Keywords;
			}
			return array;
		}

		public void StartEvent(string eventName, EventAttribute eventAttribute)
		{
			this.eventName = eventName;
			numParams = 0;
			byteArrArgIndices = null;
			events.Append("  <event value=\"").Append(eventAttribute.EventId).Append("\" version=\"")
				.Append(eventAttribute.Version)
				.Append("\" level=\"");
			AppendLevelName(events, eventAttribute.Level);
			events.Append("\" symbol=\"").Append(eventName).Append('"');
			WriteMessageAttrib(events, "event", eventName, eventAttribute.Message);
			if (eventAttribute.Keywords != EventKeywords.None)
			{
				events.Append(" keywords=\"");
				AppendKeywords(events, (ulong)eventAttribute.Keywords, eventName);
				events.Append('"');
			}
			if (eventAttribute.Opcode != 0)
			{
				events.Append(" opcode=\"").Append(GetOpcodeName(eventAttribute.Opcode, eventName)).Append('"');
			}
			if (eventAttribute.Task != 0)
			{
				events.Append(" task=\"").Append(GetTaskName(eventAttribute.Task, eventName)).Append('"');
			}
			if (eventAttribute.Channel != 0)
			{
				events.Append(" channel=\"").Append(GetChannelName(eventAttribute.Channel, eventName, eventAttribute.Message)).Append('"');
			}
		}

		public void AddEventParameter(Type type, string name)
		{
			if (numParams == 0)
			{
				templates.Append("  <template tid=\"").Append(eventName).AppendLine("Args\">");
			}
			if (type == typeof(byte[]))
			{
				if (byteArrArgIndices == null)
				{
					byteArrArgIndices = new List<int>(4);
				}
				byteArrArgIndices.Add(numParams);
				numParams++;
				templates.Append("   <data name=\"").Append(name).AppendLine("Size\" inType=\"win:UInt32\"/>");
			}
			numParams++;
			templates.Append("   <data name=\"").Append(name).Append("\" inType=\"")
				.Append(GetTypeName(type))
				.Append('"');
			if ((type.IsArray || type.IsPointer) && type.GetElementType() == typeof(byte))
			{
				templates.Append(" length=\"").Append(name).Append("Size\"");
			}
			if (type.IsEnum && Enum.GetUnderlyingType(type) != typeof(ulong) && Enum.GetUnderlyingType(type) != typeof(long))
			{
				templates.Append(" map=\"").Append(type.Name).Append('"');
				if (mapsTab == null)
				{
					mapsTab = new Dictionary<string, Type>();
				}
				if (!mapsTab.ContainsKey(type.Name))
				{
					mapsTab.Add(type.Name, type);
				}
			}
			templates.AppendLine("/>");
		}

		public void EndEvent()
		{
			if (numParams > 0)
			{
				templates.AppendLine("  </template>");
				events.Append(" template=\"").Append(eventName).Append("Args\"");
			}
			events.AppendLine("/>");
			if (byteArrArgIndices != null)
			{
				perEventByteArrayArgIndices[eventName] = byteArrArgIndices;
			}
			string key = "event_" + eventName;
			if (stringTab.TryGetValue(key, out var value))
			{
				value = TranslateToManifestConvention(value, eventName);
				stringTab[key] = value;
			}
			eventName = null;
			numParams = 0;
			byteArrArgIndices = null;
		}

		public ulong GetChannelKeyword(EventChannel channel, ulong channelKeyword = 0uL)
		{
			channelKeyword &= 0xF000000000000000uL;
			if (channelTab == null)
			{
				channelTab = new Dictionary<int, ChannelInfo>(4);
			}
			if (channelTab.Count == 8)
			{
				ManifestError(SR.EventSource_MaxChannelExceeded);
			}
			if (!channelTab.TryGetValue((int)channel, out var value))
			{
				if (channelKeyword == 0L)
				{
					channelKeyword = nextChannelKeywordBit;
					nextChannelKeywordBit >>= 1;
				}
			}
			else
			{
				channelKeyword = value.Keywords;
			}
			return channelKeyword;
		}

		public byte[] CreateManifest()
		{
			string s = CreateManifestString();
			return Encoding.UTF8.GetBytes(s);
		}

		public void ManifestError(string msg, bool runtimeCritical = false)
		{
			if ((flags & EventManifestOptions.Strict) != 0)
			{
				errors.Add(msg);
			}
			else if (runtimeCritical)
			{
				throw new ArgumentException(msg);
			}
		}

		private string CreateManifestString()
		{
			Span<char> destination = stackalloc char[16];
			if (channelTab != null)
			{
				sb.AppendLine(" <channels>");
				List<KeyValuePair<int, ChannelInfo>> list = new List<KeyValuePair<int, ChannelInfo>>();
				foreach (KeyValuePair<int, ChannelInfo> item in channelTab)
				{
					list.Add(item);
				}
				list.Sort((KeyValuePair<int, ChannelInfo> p1, KeyValuePair<int, ChannelInfo> p2) => -Comparer<ulong>.Default.Compare(p1.Value.Keywords, p2.Value.Keywords));
				foreach (KeyValuePair<int, ChannelInfo> item2 in list)
				{
					int key = item2.Key;
					ChannelInfo value = item2.Value;
					string text = null;
					bool flag = false;
					string text2 = null;
					if (value.Attribs != null)
					{
						EventChannelAttribute attribs = value.Attribs;
						if (Enum.IsDefined(typeof(EventChannelType), attribs.EventChannelType))
						{
							text = attribs.EventChannelType.ToString();
						}
						flag = attribs.Enabled;
					}
					if (text2 == null)
					{
						text2 = providerName + "/" + value.Name;
					}
					sb.Append("  <channel chid=\"").Append(value.Name).Append("\" name=\"")
						.Append(text2)
						.Append('"');
					WriteMessageAttrib(sb, "channel", value.Name, null);
					sb.Append(" value=\"").Append(key).Append('"');
					if (text != null)
					{
						sb.Append(" type=\"").Append(text).Append('"');
					}
					sb.Append(" enabled=\"").Append(flag ? "true" : "false").Append('"');
					sb.AppendLine("/>");
				}
				sb.AppendLine(" </channels>");
			}
			if (taskTab != null)
			{
				sb.AppendLine(" <tasks>");
				List<int> list2 = new List<int>(taskTab.Keys);
				list2.Sort();
				foreach (int item3 in list2)
				{
					sb.Append("  <task");
					WriteNameAndMessageAttribs(sb, "task", taskTab[item3]);
					sb.Append(" value=\"").Append(item3).AppendLine("\"/>");
				}
				sb.AppendLine(" </tasks>");
			}
			if (mapsTab != null)
			{
				sb.AppendLine(" <maps>");
				foreach (Type value3 in mapsTab.Values)
				{
					bool flag2 = EventSource.IsCustomAttributeDefinedHelper(value3, typeof(FlagsAttribute), flags);
					string value2 = (flag2 ? "bitMap" : "valueMap");
					sb.Append("  <").Append(value2).Append(" name=\"")
						.Append(value3.Name)
						.AppendLine("\">");
					FieldInfo[] array = GetEnumFields(value3);
					bool flag3 = false;
					FieldInfo[] array2 = array;
					foreach (FieldInfo fieldInfo in array2)
					{
						object rawConstantValue = fieldInfo.GetRawConstantValue();
						if (rawConstantValue != null)
						{
							ulong num = ((!(rawConstantValue is ulong)) ? ((ulong)Convert.ToInt64(rawConstantValue)) : ((ulong)rawConstantValue));
							if (!flag2 || ((num & (num - 1)) == 0L && num != 0L))
							{
								num.TryFormat(destination, out var charsWritten, "x");
								Span<char> span = destination.Slice(0, charsWritten);
								sb.Append("   <map value=\"0x").Append(span).Append('"');
								WriteMessageAttrib(sb, "map", value3.Name + "." + fieldInfo.Name, fieldInfo.Name);
								sb.AppendLine("/>");
								flag3 = true;
							}
						}
					}
					if (!flag3)
					{
						sb.Append("   <map value=\"0x0\"");
						WriteMessageAttrib(sb, "map", value3.Name + ".None", "None");
						sb.AppendLine("/>");
					}
					sb.Append("  </").Append(value2).AppendLine(">");
				}
				sb.AppendLine(" </maps>");
			}
			sb.AppendLine(" <opcodes>");
			List<int> list3 = new List<int>(opcodeTab.Keys);
			list3.Sort();
			foreach (int item4 in list3)
			{
				sb.Append("  <opcode");
				WriteNameAndMessageAttribs(sb, "opcode", opcodeTab[item4]);
				sb.Append(" value=\"").Append(item4).AppendLine("\"/>");
			}
			sb.AppendLine(" </opcodes>");
			if (keywordTab != null)
			{
				sb.AppendLine(" <keywords>");
				List<ulong> list4 = new List<ulong>(keywordTab.Keys);
				list4.Sort();
				foreach (ulong item5 in list4)
				{
					sb.Append("  <keyword");
					WriteNameAndMessageAttribs(sb, "keyword", keywordTab[item5]);
					item5.TryFormat(destination, out var charsWritten2, "x");
					Span<char> span2 = destination.Slice(0, charsWritten2);
					sb.Append(" mask=\"0x").Append(span2).AppendLine("\"/>");
				}
				sb.AppendLine(" </keywords>");
			}
			sb.AppendLine(" <events>");
			sb.Append(events);
			sb.AppendLine(" </events>");
			sb.AppendLine(" <templates>");
			if (templates.Length > 0)
			{
				sb.Append(templates);
			}
			else
			{
				sb.AppendLine("    <template tid=\"_empty\"></template>");
			}
			sb.AppendLine(" </templates>");
			sb.AppendLine("</provider>");
			sb.AppendLine("</events>");
			sb.AppendLine("</instrumentation>");
			sb.AppendLine("<localization>");
			string[] array3 = new string[stringTab.Keys.Count];
			stringTab.Keys.CopyTo(array3, 0);
			Array.Sort(array3, 0, array3.Length);
			CultureInfo currentUICulture = CultureInfo.CurrentUICulture;
			sb.Append(" <resources culture=\"").Append(currentUICulture.Name).AppendLine("\">");
			sb.AppendLine("  <stringTable>");
			string[] array4 = array3;
			foreach (string text3 in array4)
			{
				string localizedMessage = GetLocalizedMessage(text3, currentUICulture, etwFormat: true);
				sb.Append("   <string id=\"").Append(text3).Append("\" value=\"")
					.Append(localizedMessage)
					.AppendLine("\"/>");
			}
			sb.AppendLine("  </stringTable>");
			sb.AppendLine(" </resources>");
			sb.AppendLine("</localization>");
			sb.AppendLine("</instrumentationManifest>");
			return sb.ToString();
			[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", Justification = "Trimmer does not trim enums")]
			static FieldInfo[] GetEnumFields(Type localEnumType)
			{
				return localEnumType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public);
			}
		}

		private void WriteNameAndMessageAttribs(StringBuilder stringBuilder, string elementName, string name)
		{
			stringBuilder.Append(" name=\"").Append(name).Append('"');
			WriteMessageAttrib(sb, elementName, name, name);
		}

		private void WriteMessageAttrib(StringBuilder stringBuilder, string elementName, string name, string value)
		{
			string text = null;
			if (resources != null)
			{
				text = elementName + "_" + name;
				string @string = resources.GetString(text, CultureInfo.InvariantCulture);
				if (@string != null)
				{
					value = @string;
				}
			}
			if (value != null)
			{
				if (text == null)
				{
					text = elementName + "_" + name;
				}
				stringBuilder.Append(" message=\"$(string.").Append(text).Append(")\"");
				if (stringTab.TryGetValue(text, out var value2) && !value2.Equals(value))
				{
					ManifestError(SR.Format(SR.EventSource_DuplicateStringKey, text), runtimeCritical: true);
				}
				else
				{
					stringTab[text] = value;
				}
			}
		}

		internal string GetLocalizedMessage(string key, CultureInfo ci, bool etwFormat)
		{
			string value = null;
			if (resources != null)
			{
				string @string = resources.GetString(key, ci);
				if (@string != null)
				{
					value = @string;
					if (etwFormat && key.StartsWith("event_", StringComparison.Ordinal))
					{
						string evtName = key.Substring("event_".Length);
						value = TranslateToManifestConvention(value, evtName);
					}
				}
			}
			if (etwFormat && value == null)
			{
				stringTab.TryGetValue(key, out value);
			}
			return value;
		}

		private static void AppendLevelName(StringBuilder sb, EventLevel level)
		{
			if (level < (EventLevel)16)
			{
				sb.Append("win:");
			}
			string value;
			switch (level)
			{
			case EventLevel.LogAlways:
				value = "LogAlways";
				break;
			case EventLevel.Critical:
				value = "Critical";
				break;
			case EventLevel.Error:
				value = "Error";
				break;
			case EventLevel.Warning:
				value = "Warning";
				break;
			case EventLevel.Informational:
				value = "Informational";
				break;
			case EventLevel.Verbose:
				value = "Verbose";
				break;
			default:
			{
				int num = (int)level;
				value = num.ToString();
				break;
			}
			}
			sb.Append(value);
		}

		private string GetChannelName(EventChannel channel, string eventName, string eventMessage)
		{
			if (channelTab == null || !channelTab.TryGetValue((int)channel, out var value))
			{
				if ((int)channel < 16)
				{
					ManifestError(SR.Format(SR.EventSource_UndefinedChannel, channel, eventName));
				}
				if (channelTab == null)
				{
					channelTab = new Dictionary<int, ChannelInfo>(4);
				}
				string text = channel.ToString();
				if (19 < (int)channel)
				{
					text = "Channel" + text;
				}
				AddChannel(text, (int)channel, GetDefaultChannelAttribute(channel));
				if (!channelTab.TryGetValue((int)channel, out value))
				{
					ManifestError(SR.Format(SR.EventSource_UndefinedChannel, channel, eventName));
				}
			}
			if (resources != null && eventMessage == null)
			{
				eventMessage = resources.GetString("event_" + eventName, CultureInfo.InvariantCulture);
			}
			if (value.Attribs.EventChannelType == EventChannelType.Admin && eventMessage == null)
			{
				ManifestError(SR.Format(SR.EventSource_EventWithAdminChannelMustHaveMessage, eventName, value.Name));
			}
			return value.Name;
		}

		private string GetTaskName(EventTask task, string eventName)
		{
			if (task == EventTask.None)
			{
				return "";
			}
			if (taskTab == null)
			{
				taskTab = new Dictionary<int, string>();
			}
			if (!taskTab.TryGetValue((int)task, out var value))
			{
				return taskTab[(int)task] = eventName;
			}
			return value;
		}

		private string GetOpcodeName(EventOpcode opcode, string eventName)
		{
			switch (opcode)
			{
			case EventOpcode.Info:
				return "win:Info";
			case EventOpcode.Start:
				return "win:Start";
			case EventOpcode.Stop:
				return "win:Stop";
			case EventOpcode.DataCollectionStart:
				return "win:DC_Start";
			case EventOpcode.DataCollectionStop:
				return "win:DC_Stop";
			case EventOpcode.Extension:
				return "win:Extension";
			case EventOpcode.Reply:
				return "win:Reply";
			case EventOpcode.Resume:
				return "win:Resume";
			case EventOpcode.Suspend:
				return "win:Suspend";
			case EventOpcode.Send:
				return "win:Send";
			case EventOpcode.Receive:
				return "win:Receive";
			default:
			{
				if (opcodeTab == null || !opcodeTab.TryGetValue((int)opcode, out var value))
				{
					ManifestError(SR.Format(SR.EventSource_UndefinedOpcode, opcode, eventName), runtimeCritical: true);
					return null;
				}
				return value;
			}
			}
		}

		private void AppendKeywords(StringBuilder sb, ulong keywords, string eventName)
		{
			keywords &= 0xFFFFFFFFFFFFFFFuL;
			bool flag = false;
			for (ulong num = 1uL; num != 0L; num <<= 1)
			{
				if ((keywords & num) != 0L)
				{
					string value = null;
					if ((keywordTab == null || !keywordTab.TryGetValue(num, out value)) && num >= 281474976710656L)
					{
						value = string.Empty;
					}
					if (value == null)
					{
						ManifestError(SR.Format(SR.EventSource_UndefinedKeyword, "0x" + num.ToString("x", CultureInfo.CurrentCulture), eventName), runtimeCritical: true);
						value = string.Empty;
					}
					if (value.Length != 0)
					{
						if (flag)
						{
							sb.Append(' ');
						}
						sb.Append(value);
						flag = true;
					}
				}
			}
		}

		private string GetTypeName(Type type)
		{
			if (type.IsEnum)
			{
				string typeName = GetTypeName(type.GetEnumUnderlyingType());
				return typeName.Replace("win:Int", "win:UInt");
			}
			switch (Type.GetTypeCode(type))
			{
			case TypeCode.Boolean:
				return "win:Boolean";
			case TypeCode.Byte:
				return "win:UInt8";
			case TypeCode.Char:
			case TypeCode.UInt16:
				return "win:UInt16";
			case TypeCode.UInt32:
				return "win:UInt32";
			case TypeCode.UInt64:
				return "win:UInt64";
			case TypeCode.SByte:
				return "win:Int8";
			case TypeCode.Int16:
				return "win:Int16";
			case TypeCode.Int32:
				return "win:Int32";
			case TypeCode.Int64:
				return "win:Int64";
			case TypeCode.String:
				return "win:UnicodeString";
			case TypeCode.Single:
				return "win:Float";
			case TypeCode.Double:
				return "win:Double";
			case TypeCode.DateTime:
				return "win:FILETIME";
			default:
				if (type == typeof(Guid))
				{
					return "win:GUID";
				}
				if (type == typeof(IntPtr))
				{
					return "win:Pointer";
				}
				if ((type.IsArray || type.IsPointer) && type.GetElementType() == typeof(byte))
				{
					return "win:Binary";
				}
				ManifestError(SR.Format(SR.EventSource_UnsupportedEventTypeInManifest, type.Name), runtimeCritical: true);
				return string.Empty;
			}
		}

		private static void UpdateStringBuilder([NotNull] ref StringBuilder stringBuilder, string eventMessage, int startIndex, int count)
		{
			if (stringBuilder == null)
			{
				stringBuilder = new StringBuilder();
			}
			stringBuilder.Append(eventMessage, startIndex, count);
		}

		private string TranslateToManifestConvention(string eventMessage, string evtName)
		{
			StringBuilder stringBuilder = null;
			int num = 0;
			int i = 0;
			while (i < eventMessage.Length)
			{
				int num4;
				if (eventMessage[i] == '%')
				{
					UpdateStringBuilder(ref stringBuilder, eventMessage, num, i - num);
					stringBuilder.Append("%%");
					i++;
					num = i;
				}
				else if (i < eventMessage.Length - 1 && ((eventMessage[i] == '{' && eventMessage[i + 1] == '{') || (eventMessage[i] == '}' && eventMessage[i + 1] == '}')))
				{
					UpdateStringBuilder(ref stringBuilder, eventMessage, num, i - num);
					stringBuilder.Append(eventMessage[i]);
					i++;
					i++;
					num = i;
				}
				else if (eventMessage[i] == '{')
				{
					int num2 = i;
					i++;
					int num3 = 0;
					for (; i < eventMessage.Length && char.IsDigit(eventMessage[i]); i++)
					{
						num3 = num3 * 10 + eventMessage[i] - 48;
					}
					if (i < eventMessage.Length && eventMessage[i] == '}')
					{
						i++;
						UpdateStringBuilder(ref stringBuilder, eventMessage, num, num2 - num);
						int value = TranslateIndexToManifestConvention(num3, evtName);
						stringBuilder.Append('%').Append(value);
						if (i < eventMessage.Length && eventMessage[i] == '!')
						{
							i++;
							stringBuilder.Append("%!");
						}
						num = i;
					}
					else
					{
						ManifestError(SR.Format(SR.EventSource_UnsupportedMessageProperty, evtName, eventMessage));
					}
				}
				else if ((num4 = "&<>'\"\r\n\t".IndexOf(eventMessage[i])) >= 0)
				{
					UpdateStringBuilder(ref stringBuilder, eventMessage, num, i - num);
					i++;
					stringBuilder.Append(s_escapes[num4]);
					num = i;
				}
				else
				{
					i++;
				}
			}
			if (stringBuilder == null)
			{
				return eventMessage;
			}
			UpdateStringBuilder(ref stringBuilder, eventMessage, num, i - num);
			return stringBuilder.ToString();
		}

		private int TranslateIndexToManifestConvention(int idx, string evtName)
		{
			if (perEventByteArrayArgIndices.TryGetValue(evtName, out var value))
			{
				foreach (int item in value)
				{
					if (idx >= item)
					{
						idx++;
						continue;
					}
					break;
				}
			}
			return idx + 1;
		}
	}
	internal struct ManifestEnvelope
	{
		public enum ManifestFormats : byte
		{
			SimpleXmlFormat = 1
		}

		public ManifestFormats Format;

		public byte MajorVersion;

		public byte MinorVersion;

		public byte Magic;

		public ushort TotalChunks;

		public ushort ChunkNumber;
	}
	[Serializable]
	public class EventSourceException : Exception
	{
		public EventSourceException()
			: base(SR.EventSource_ListenerWriteFailure)
		{
		}

		public EventSourceException(string? message)
			: base(message)
		{
		}

		public EventSourceException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}

		protected EventSourceException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}

		internal EventSourceException(Exception innerException)
			: base(SR.EventSource_ListenerWriteFailure, innerException)
		{
		}
	}
	[EventSource(Guid = "8E9F5090-2D75-4d03-8A81-E5AFBF85DAF1", Name = "System.Diagnostics.Eventing.FrameworkEventSource")]
	internal sealed class FrameworkEventSource : EventSource
	{
		public static class Keywords
		{
			public const EventKeywords ThreadPool = (EventKeywords)2L;

			public const EventKeywords ThreadTransfer = (EventKeywords)16L;
		}

		public static class Tasks
		{
			public const EventTask ThreadTransfer = (EventTask)3;
		}

		private const string EventSourceSuppressMessage = "Parameters to this method are primitive and are trimmer safe";

		public static readonly FrameworkEventSource Log = new FrameworkEventSource();

		private protected override ReadOnlySpan<byte> ProviderMetadata => new byte[51]
		{
			51, 0, 83, 121, 115, 116, 101, 109, 46, 68,
			105, 97, 103, 110, 111, 115, 116, 105, 99, 115,
			46, 69, 118, 101, 110, 116, 105, 110, 103, 46,
			70, 114, 97, 109, 101, 119, 111, 114, 107, 69,
			118, 101, 110, 116, 83, 111, 117, 114, 99, 101,
			0
		};

		private FrameworkEventSource(int _)
		{
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[NonEvent]
		private unsafe void WriteEvent(int eventId, long arg1, int arg2, string arg3, bool arg4, int arg5, int arg6)
		{
			if (IsEnabled())
			{
				if (arg3 == null)
				{
					arg3 = "";
				}
				fixed (char* ptr2 = arg3)
				{
					EventData* ptr = stackalloc EventData[6];
					ptr->DataPointer = (IntPtr)(&arg1);
					ptr->Size = 8;
					ptr->Reserved = 0;
					ptr[1].DataPointer = (IntPtr)(&arg2);
					ptr[1].Size = 4;
					ptr[1].Reserved = 0;
					ptr[2].DataPointer = (IntPtr)ptr2;
					ptr[2].Size = (arg3.Length + 1) * 2;
					ptr[2].Reserved = 0;
					ptr[3].DataPointer = (IntPtr)(&arg4);
					ptr[3].Size = 4;
					ptr[3].Reserved = 0;
					ptr[4].DataPointer = (IntPtr)(&arg5);
					ptr[4].Size = 4;
					ptr[4].Reserved = 0;
					ptr[5].DataPointer = (IntPtr)(&arg6);
					ptr[5].Size = 4;
					ptr[5].Reserved = 0;
					WriteEventCore(eventId, 6, ptr);
				}
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern", Justification = "Parameters to this method are primitive and are trimmer safe")]
		[NonEvent]
		private unsafe void WriteEvent(int eventId, long arg1, int arg2, string arg3)
		{
			if (IsEnabled())
			{
				if (arg3 == null)
				{
					arg3 = "";
				}
				fixed (char* ptr2 = arg3)
				{
					EventData* ptr = stackalloc EventData[3];
					ptr->DataPointer = (IntPtr)(&arg1);
					ptr->Size = 8;
					ptr->Reserved = 0;
					ptr[1].DataPointer = (IntPtr)(&arg2);
					ptr[1].Size = 4;
					ptr[1].Reserved = 0;
					ptr[2].DataPointer = (IntPtr)ptr2;
					ptr[2].Size = (arg3.Length + 1) * 2;
					ptr[2].Reserved = 0;
					WriteEventCore(eventId, 3, ptr);
				}
			}
		}

		[Event(30, Level = EventLevel.Verbose, Keywords = (EventKeywords)18L)]
		public void ThreadPoolEnqueueWork(long workID)
		{
			WriteEvent(30, workID);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[NonEvent]
		public void ThreadPoolEnqueueWorkObject(object workID)
		{
			ThreadPoolEnqueueWork(workID.GetHashCode());
		}

		[Event(31, Level = EventLevel.Verbose, Keywords = (EventKeywords)18L)]
		public void ThreadPoolDequeueWork(long workID)
		{
			WriteEvent(31, workID);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[NonEvent]
		public void ThreadPoolDequeueWorkObject(object workID)
		{
			ThreadPoolDequeueWork(workID.GetHashCode());
		}

		[Event(150, Level = EventLevel.Informational, Keywords = (EventKeywords)16L, Task = (EventTask)3, Opcode = EventOpcode.Send)]
		public void ThreadTransferSend(long id, int kind, string info, bool multiDequeues, int intInfo1, int intInfo2)
		{
			WriteEvent(150, id, kind, info, multiDequeues, intInfo1, intInfo2);
		}

		[NonEvent]
		public void ThreadTransferSendObj(object id, int kind, string info, bool multiDequeues, int intInfo1, int intInfo2)
		{
			ThreadTransferSend(id.GetHashCode(), kind, info, multiDequeues, intInfo1, intInfo2);
		}

		[Event(151, Level = EventLevel.Informational, Keywords = (EventKeywords)16L, Task = (EventTask)3, Opcode = EventOpcode.Receive)]
		public void ThreadTransferReceive(long id, int kind, string info)
		{
			WriteEvent(151, id, kind, info);
		}

		[NonEvent]
		public void ThreadTransferReceiveObj(object id, int kind, string info)
		{
			ThreadTransferReceive(id.GetHashCode(), kind, info);
		}

		private FrameworkEventSource()
			: base(new Guid(2392805520u, 11637, 19715, 138, 129, 229, 175, 191, 133, 218, 241), "System.Diagnostics.Eventing.FrameworkEventSource")
		{
		}
	}
	internal interface IEventProvider
	{
		unsafe uint EventRegister(EventSource eventSource, Interop.Advapi32.EtwEnableCallback enableCallback, void* callbackContext, ref long registrationHandle);

		uint EventUnregister(long registrationHandle);

		unsafe EventProvider.WriteEventErrorCode EventWriteTransfer(long registrationHandle, in EventDescriptor eventDescriptor, IntPtr eventHandle, Guid* activityId, Guid* relatedActivityId, int userDataCount, EventProvider.EventData* userData);

		unsafe IntPtr DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte* pMetadata, uint metadataLength);
	}
	[UnsupportedOSPlatform("browser")]
	public class IncrementingEventCounter : DiagnosticCounter
	{
		private double _increment;

		private double _prevIncrement;

		public TimeSpan DisplayRateTimeScale { get; set; }

		public IncrementingEventCounter(string name, EventSource eventSource)
			: base(name, eventSource)
		{
			Publish();
		}

		public void Increment(double increment = 1.0)
		{
			lock (this)
			{
				_increment += increment;
			}
		}

		public override string ToString()
		{
			return $"IncrementingEventCounter '{base.Name}' Increment {_increment}";
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The DynamicDependency will preserve the properties of IncrementingCounterPayload")]
		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicProperties, typeof(IncrementingCounterPayload))]
		internal override void WritePayload(float intervalSec, int pollingIntervalMillisec)
		{
			lock (this)
			{
				IncrementingCounterPayload incrementingCounterPayload = new IncrementingCounterPayload();
				incrementingCounterPayload.Name = base.Name;
				incrementingCounterPayload.IntervalSec = intervalSec;
				incrementingCounterPayload.DisplayName = base.DisplayName ?? "";
				incrementingCounterPayload.DisplayRateTimeScale = ((DisplayRateTimeScale == TimeSpan.Zero) ? "" : DisplayRateTimeScale.ToString("c"));
				incrementingCounterPayload.Series = $"Interval={pollingIntervalMillisec}";
				incrementingCounterPayload.CounterType = "Sum";
				incrementingCounterPayload.Metadata = GetMetadataString();
				incrementingCounterPayload.Increment = _increment - _prevIncrement;
				incrementingCounterPayload.DisplayUnits = base.DisplayUnits ?? "";
				_prevIncrement = _increment;
				base.EventSource.Write("EventCounters", new EventSourceOptions
				{
					Level = EventLevel.LogAlways
				}, new IncrementingEventCounterPayloadType(incrementingCounterPayload));
			}
		}

		internal void UpdateMetric()
		{
			lock (this)
			{
				_prevIncrement = _increment;
			}
		}
	}
	[EventData]
	internal sealed class IncrementingEventCounterPayloadType
	{
		public IncrementingCounterPayload Payload { get; set; }

		public IncrementingEventCounterPayloadType(IncrementingCounterPayload payload)
		{
			Payload = payload;
		}
	}
	[UnsupportedOSPlatform("browser")]
	public class IncrementingPollingCounter : DiagnosticCounter
	{
		private double _increment;

		private double _prevIncrement;

		private readonly Func<double> _totalValueProvider;

		public TimeSpan DisplayRateTimeScale { get; set; }

		public IncrementingPollingCounter(string name, EventSource eventSource, Func<double> totalValueProvider)
			: base(name, eventSource)
		{
			if (totalValueProvider == null)
			{
				throw new ArgumentNullException("totalValueProvider");
			}
			_totalValueProvider = totalValueProvider;
			Publish();
		}

		public override string ToString()
		{
			return $"IncrementingPollingCounter '{base.Name}' Increment {_increment}";
		}

		internal void UpdateMetric()
		{
			try
			{
				lock (this)
				{
					_prevIncrement = _increment;
					_increment = _totalValueProvider();
				}
			}
			catch (Exception ex)
			{
				ReportOutOfBandMessage("ERROR: Exception during EventCounter " + base.Name + " getMetricFunction callback: " + ex.Message);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The DynamicDependency will preserve the properties of IncrementingCounterPayload")]
		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicProperties, typeof(IncrementingCounterPayload))]
		internal override void WritePayload(float intervalSec, int pollingIntervalMillisec)
		{
			UpdateMetric();
			lock (this)
			{
				IncrementingCounterPayload incrementingCounterPayload = new IncrementingCounterPayload();
				incrementingCounterPayload.Name = base.Name;
				incrementingCounterPayload.DisplayName = base.DisplayName ?? "";
				incrementingCounterPayload.DisplayRateTimeScale = ((DisplayRateTimeScale == TimeSpan.Zero) ? "" : DisplayRateTimeScale.ToString("c"));
				incrementingCounterPayload.IntervalSec = intervalSec;
				incrementingCounterPayload.Series = $"Interval={pollingIntervalMillisec}";
				incrementingCounterPayload.CounterType = "Sum";
				incrementingCounterPayload.Metadata = GetMetadataString();
				incrementingCounterPayload.Increment = _increment - _prevIncrement;
				incrementingCounterPayload.DisplayUnits = base.DisplayUnits ?? "";
				base.EventSource.Write("EventCounters", new EventSourceOptions
				{
					Level = EventLevel.LogAlways
				}, new IncrementingPollingCounterPayloadType(incrementingCounterPayload));
			}
		}
	}
	[EventData]
	internal sealed class IncrementingPollingCounterPayloadType
	{
		public IncrementingCounterPayload Payload { get; set; }

		public IncrementingPollingCounterPayloadType(IncrementingCounterPayload payload)
		{
			Payload = payload;
		}
	}
	[UnsupportedOSPlatform("browser")]
	public class PollingCounter : DiagnosticCounter
	{
		private readonly Func<double> _metricProvider;

		private double _lastVal;

		public PollingCounter(string name, EventSource eventSource, Func<double> metricProvider)
			: base(name, eventSource)
		{
			if (metricProvider == null)
			{
				throw new ArgumentNullException("metricProvider");
			}
			_metricProvider = metricProvider;
			Publish();
		}

		public override string ToString()
		{
			return $"PollingCounter '{base.Name}' Count 1 Mean {_lastVal:n3}";
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The DynamicDependency will preserve the properties of CounterPayload")]
		[DynamicDependency(DynamicallyAccessedMemberTypes.PublicProperties, typeof(CounterPayload))]
		internal override void WritePayload(float intervalSec, int pollingIntervalMillisec)
		{
			lock (this)
			{
				double num = 0.0;
				try
				{
					num = _metricProvider();
				}
				catch (Exception ex)
				{
					ReportOutOfBandMessage("ERROR: Exception during EventCounter " + base.Name + " metricProvider callback: " + ex.Message);
				}
				CounterPayload counterPayload = new CounterPayload();
				counterPayload.Name = base.Name;
				counterPayload.DisplayName = base.DisplayName ?? "";
				counterPayload.Count = 1;
				counterPayload.IntervalSec = intervalSec;
				counterPayload.Series = $"Interval={pollingIntervalMillisec}";
				counterPayload.CounterType = "Mean";
				counterPayload.Mean = num;
				counterPayload.Max = num;
				counterPayload.Min = num;
				counterPayload.Metadata = GetMetadataString();
				counterPayload.StandardDeviation = 0.0;
				counterPayload.DisplayUnits = base.DisplayUnits ?? "";
				_lastVal = num;
				base.EventSource.Write("EventCounters", new EventSourceOptions
				{
					Level = EventLevel.LogAlways
				}, new PollingPayloadType(counterPayload));
			}
		}
	}
	[EventData]
	internal sealed class PollingPayloadType
	{
		public CounterPayload Payload { get; set; }

		public PollingPayloadType(CounterPayload payload)
		{
			Payload = payload;
		}
	}
	[EventSource(Guid = "49592C0F-5A05-516D-AA4B-A64E02026C89", Name = "System.Runtime")]
	internal sealed class RuntimeEventSource : EventSource
	{
		public static class Keywords
		{
			public const EventKeywords AppContext = (EventKeywords)1L;
		}

		private enum EventId
		{
			AppContextSwitch = 1
		}

		internal const string EventSourceName = "System.Runtime";

		private static RuntimeEventSource s_RuntimeEventSource;

		private PollingCounter _gcHeapSizeCounter;

		private IncrementingPollingCounter _gen0GCCounter;

		private IncrementingPollingCounter _gen1GCCounter;

		private IncrementingPollingCounter _gen2GCCounter;

		private PollingCounter _cpuTimeCounter;

		private PollingCounter _workingSetCounter;

		private PollingCounter _threadPoolThreadCounter;

		private IncrementingPollingCounter _monitorContentionCounter;

		private PollingCounter _threadPoolQueueCounter;

		private IncrementingPollingCounter _completedItemsCounter;

		private IncrementingPollingCounter _allocRateCounter;

		private PollingCounter _timerCounter;

		private PollingCounter _fragmentationCounter;

		private PollingCounter _committedCounter;

		private IncrementingPollingCounter _exceptionCounter;

		private PollingCounter _gcTimeCounter;

		private PollingCounter _gen0SizeCounter;

		private PollingCounter _gen1SizeCounter;

		private PollingCounter _gen2SizeCounter;

		private PollingCounter _lohSizeCounter;

		private PollingCounter _pohSizeCounter;

		private PollingCounter _assemblyCounter;

		private PollingCounter _ilBytesJittedCounter;

		private PollingCounter _methodsJittedCounter;

		private IncrementingPollingCounter _jitTimeCounter;

		private protected override ReadOnlySpan<byte> ProviderMetadata => new byte[17]
		{
			17, 0, 83, 121, 115, 116, 101, 109, 46, 82,
			117, 110, 116, 105, 109, 101, 0
		};

		public static void Initialize()
		{
			s_RuntimeEventSource = new RuntimeEventSource();
		}

		private RuntimeEventSource(int _)
		{
		}

		[Event(1, Level = EventLevel.Informational, Keywords = (EventKeywords)1L)]
		internal void LogAppContextSwitch(string switchName, int value)
		{
			WriteEvent(1, switchName, value);
		}

		protected override void OnEventCommand(EventCommandEventArgs command)
		{
			if (command.Command != EventCommand.Enable)
			{
				return;
			}
			if (_cpuTimeCounter == null)
			{
				_cpuTimeCounter = new PollingCounter("cpu-usage", this, () => RuntimeEventSourceHelper.GetCpuUsage())
				{
					DisplayName = "CPU Usage",
					DisplayUnits = "%"
				};
			}
			if (_workingSetCounter == null)
			{
				_workingSetCounter = new PollingCounter("working-set", this, () => Environment.WorkingSet / 1000000)
				{
					DisplayName = "Working Set",
					DisplayUnits = "MB"
				};
			}
			if (_gcHeapSizeCounter == null)
			{
				_gcHeapSizeCounter = new PollingCounter("gc-heap-size", this, () => GC.GetTotalMemory(forceFullCollection: false) / 1000000)
				{
					DisplayName = "GC Heap Size",
					DisplayUnits = "MB"
				};
			}
			if (_gen0GCCounter == null)
			{
				_gen0GCCounter = new IncrementingPollingCounter("gen-0-gc-count", this, () => GC.CollectionCount(0))
				{
					DisplayName = "Gen 0 GC Count",
					DisplayRateTimeScale = new TimeSpan(0, 1, 0)
				};
			}
			if (_gen1GCCounter == null)
			{
				_gen1GCCounter = new IncrementingPollingCounter("gen-1-gc-count", this, () => GC.CollectionCount(1))
				{
					DisplayName = "Gen 1 GC Count",
					DisplayRateTimeScale = new TimeSpan(0, 1, 0)
				};
			}
			if (_gen2GCCounter == null)
			{
				_gen2GCCounter = new IncrementingPollingCounter("gen-2-gc-count", this, () => GC.CollectionCount(2))
				{
					DisplayName = "Gen 2 GC Count",
					DisplayRateTimeScale = new TimeSpan(0, 1, 0)
				};
			}
			if (_threadPoolThreadCounter == null)
			{
				_threadPoolThreadCounter = new PollingCounter("threadpool-thread-count", this, () => ThreadPool.ThreadCount)
				{
					DisplayName = "ThreadPool Thread Count"
				};
			}
			if (_monitorContentionCounter == null)
			{
				_monitorContentionCounter = new IncrementingPollingCounter("monitor-lock-contention-count", this, () => Monitor.LockContentionCount)
				{
					DisplayName = "Monitor Lock Contention Count",
					DisplayRateTimeScale = new TimeSpan(0, 0, 1)
				};
			}
			if (_threadPoolQueueCounter == null)
			{
				_threadPoolQueueCounter = new PollingCounter("threadpool-queue-length", this, () => ThreadPool.PendingWorkItemCount)
				{
					DisplayName = "ThreadPool Queue Length"
				};
			}
			if (_completedItemsCounter == null)
			{
				_completedItemsCounter = new IncrementingPollingCounter("threadpool-completed-items-count", this, () => ThreadPool.CompletedWorkItemCount)
				{
					DisplayName = "ThreadPool Completed Work Item Count",
					DisplayRateTimeScale = new TimeSpan(0, 0, 1)
				};
			}
			if (_allocRateCounter == null)
			{
				_allocRateCounter = new IncrementingPollingCounter("alloc-rate", this, () => GC.GetTotalAllocatedBytes())
				{
					DisplayName = "Allocation Rate",
					DisplayUnits = "B",
					DisplayRateTimeScale = new TimeSpan(0, 0, 1)
				};
			}
			if (_timerCounter == null)
			{
				_timerCounter = new PollingCounter("active-timer-count", this, () => Timer.ActiveCount)
				{
					DisplayName = "Number of Active Timers"
				};
			}
			if (_fragmentationCounter == null)
			{
				_fragmentationCounter = new PollingCounter("gc-fragmentation", this, delegate
				{
					GCMemoryInfo gCMemoryInfo = GC.GetGCMemoryInfo();
					return (gCMemoryInfo.HeapSizeBytes == 0L) ? 0.0 : ((double)gCMemoryInfo.FragmentedBytes * 100.0 / (double)gCMemoryInfo.HeapSizeBytes);
				})
				{
					DisplayName = "GC Fragmentation",
					DisplayUnits = "%"
				};
			}
			if (_committedCounter == null)
			{
				_committedCounter = new PollingCounter("gc-committed", this, () => GC.GetGCMemoryInfo().TotalCommittedBytes / 1000000)
				{
					DisplayName = "GC Committed Bytes",
					DisplayUnits = "MB"
				};
			}
			if (_exceptionCounter == null)
			{
				_exceptionCounter = new IncrementingPollingCounter("exception-count", this, () => Exception.GetExceptionCount())
				{
					DisplayName = "Exception Count",
					DisplayRateTimeScale = new TimeSpan(0, 0, 1)
				};
			}
			if (_gcTimeCounter == null)
			{
				_gcTimeCounter = new PollingCounter("time-in-gc", this, () => GC.GetLastGCPercentTimeInGC())
				{
					DisplayName = "% Time in GC since last GC",
					DisplayUnits = "%"
				};
			}
			if (_gen0SizeCounter == null)
			{
				_gen0SizeCounter = new PollingCounter("gen-0-size", this, () => GC.GetGenerationSize(0))
				{
					DisplayName = "Gen 0 Size",
					DisplayUnits = "B"
				};
			}
			if (_gen1SizeCounter == null)
			{
				_gen1SizeCounter = new PollingCounter("gen-1-size", this, () => GC.GetGenerationSize(1))
				{
					DisplayName = "Gen 1 Size",
					DisplayUnits = "B"
				};
			}
			if (_gen2SizeCounter == null)
			{
				_gen2SizeCounter = new PollingCounter("gen-2-size", this, () => GC.GetGenerationSize(2))
				{
					DisplayName = "Gen 2 Size",
					DisplayUnits = "B"
				};
			}
			if (_lohSizeCounter == null)
			{
				_lohSizeCounter = new PollingCounter("loh-size", this, () => GC.GetGenerationSize(3))
				{
					DisplayName = "LOH Size",
					DisplayUnits = "B"
				};
			}
			if (_pohSizeCounter == null)
			{
				_pohSizeCounter = new PollingCounter("poh-size", this, () => GC.GetGenerationSize(4))
				{
					DisplayName = "POH (Pinned Object Heap) Size",
					DisplayUnits = "B"
				};
			}
			if (_assemblyCounter == null)
			{
				_assemblyCounter = new PollingCounter("assembly-count", this, () => Assembly.GetAssemblyCount())
				{
					DisplayName = "Number of Assemblies Loaded"
				};
			}
			if (_ilBytesJittedCounter == null)
			{
				_ilBytesJittedCounter = new PollingCounter("il-bytes-jitted", this, () => JitInfo.GetCompiledILBytes())
				{
					DisplayName = "IL Bytes Jitted",
					DisplayUnits = "B"
				};
			}
			if (_methodsJittedCounter == null)
			{
				_methodsJittedCounter = new PollingCounter("methods-jitted-count", this, () => JitInfo.GetCompiledMethodCount())
				{
					DisplayName = "Number of Methods Jitted"
				};
			}
			if (_jitTimeCounter == null)
			{
				_jitTimeCounter = new IncrementingPollingCounter("time-in-jit", this, () => JitInfo.GetCompilationTime().TotalMilliseconds)
				{
					DisplayName = "Time spent in JIT",
					DisplayUnits = "ms",
					DisplayRateTimeScale = new TimeSpan(0, 0, 1)
				};
			}
			AppContext.LogSwitchValues(this);
		}

		private RuntimeEventSource()
			: base(new Guid(1230580751, 23045, 20845, 170, 75, 166, 78, 2, 2, 108, 137), "System.Runtime")
		{
		}
	}
	public enum EventLevel
	{
		LogAlways,
		Critical,
		Error,
		Warning,
		Informational,
		Verbose
	}
	public enum EventTask
	{
		None
	}
	public enum EventOpcode
	{
		Info = 0,
		Start = 1,
		Stop = 2,
		DataCollectionStart = 3,
		DataCollectionStop = 4,
		Extension = 5,
		Reply = 6,
		Resume = 7,
		Suspend = 8,
		Send = 9,
		Receive = 240
	}
	public enum EventChannel : byte
	{
		None = 0,
		Admin = 16,
		Operational = 17,
		Analytic = 18,
		Debug = 19
	}
	[Flags]
	public enum EventKeywords : long
	{
		None = 0L,
		All = -1L,
		MicrosoftTelemetry = 0x2000000000000L,
		WdiContext = 0x2000000000000L,
		WdiDiagnostic = 0x4000000000000L,
		Sqm = 0x8000000000000L,
		AuditFailure = 0x10000000000000L,
		AuditSuccess = 0x20000000000000L,
		CorrelationHint = 0x10000000000000L,
		EventLogClassic = 0x80000000000000L
	}
	internal sealed class ArrayTypeInfo : TraceLoggingTypeInfo
	{
		private readonly TraceLoggingTypeInfo elementInfo;

		public ArrayTypeInfo(Type type, TraceLoggingTypeInfo elementInfo)
			: base(type)
		{
			this.elementInfo = elementInfo;
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			collector.BeginBufferedArray();
			elementInfo.WriteMetadata(collector, name, format);
			collector.EndBufferedArray();
		}

		public override void WriteData(PropertyValue value)
		{
			int bookmark = TraceLoggingDataCollector.BeginBufferedArray();
			int count = 0;
			Array array = (Array)value.ReferenceValue;
			if (array != null)
			{
				count = array.Length;
				for (int i = 0; i < array.Length; i++)
				{
					elementInfo.WriteData(elementInfo.PropertyValueFactory(array.GetValue(i)));
				}
			}
			TraceLoggingDataCollector.EndBufferedArray(bookmark, count);
		}

		public override object GetData(object value)
		{
			Array array = (Array)value;
			object[] array2 = new object[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array2[i] = elementInfo.GetData(array.GetValue(i));
			}
			return array2;
		}
	}
	internal struct ConcurrentSet<KeyType, ItemType> where ItemType : ConcurrentSetItem<KeyType, ItemType>
	{
		private ItemType[] items;

		public ItemType TryGet(KeyType key)
		{
			ItemType[] array = items;
			if (array == null)
			{
				goto IL_0045;
			}
			int num = 0;
			int num2 = array.Length;
			ItemType val;
			while (true)
			{
				int num3 = (num + num2) / 2;
				val = array[num3];
				int num4 = val.Compare(key);
				if (num4 == 0)
				{
					break;
				}
				if (num4 < 0)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3;
				}
				if (num != num2)
				{
					continue;
				}
				goto IL_0045;
			}
			goto IL_004d;
			IL_004d:
			return val;
			IL_0045:
			val = null;
			goto IL_004d;
		}

		public ItemType GetOrAdd(ItemType newItem)
		{
			ItemType[] array = items;
			ItemType val;
			while (true)
			{
				ItemType[] array2;
				if (array == null)
				{
					array2 = new ItemType[1] { newItem };
					goto IL_0088;
				}
				int num = 0;
				int num2 = array.Length;
				while (true)
				{
					int num3 = (num + num2) / 2;
					val = array[num3];
					int num4 = val.Compare(newItem);
					if (num4 == 0)
					{
						break;
					}
					if (num4 < 0)
					{
						num = num3 + 1;
					}
					else
					{
						num2 = num3;
					}
					if (num != num2)
					{
						continue;
					}
					goto IL_005a;
				}
				break;
				IL_0088:
				array2 = Interlocked.CompareExchange(ref items, array2, array);
				if (array != array2)
				{
					array = array2;
					continue;
				}
				val = newItem;
				break;
				IL_005a:
				int num5 = array.Length;
				array2 = new ItemType[num5 + 1];
				Array.Copy(array, array2, num);
				array2[num] = newItem;
				Array.Copy(array, num, array2, num + 1, num5 - num);
				goto IL_0088;
			}
			return val;
		}
	}
	internal abstract class ConcurrentSetItem<KeyType, ItemType> where ItemType : ConcurrentSetItem<KeyType, ItemType>
	{
		public abstract int Compare(ItemType other);

		public abstract int Compare(KeyType key);
	}
	internal struct DataCollector
	{
		[ThreadStatic]
		internal static DataCollector ThreadInstance;

		private unsafe byte* scratchEnd;

		private unsafe EventSource.EventData* datasEnd;

		private unsafe GCHandle* pinsEnd;

		private unsafe EventSource.EventData* datasStart;

		private unsafe byte* scratch;

		private unsafe EventSource.EventData* datas;

		private unsafe GCHandle* pins;

		private byte[] buffer;

		private int bufferPos;

		private int bufferNesting;

		private bool writingScalars;

		internal unsafe void Enable(byte* scratch, int scratchSize, EventSource.EventData* datas, int dataCount, GCHandle* pins, int pinCount)
		{
			datasStart = datas;
			scratchEnd = scratch + scratchSize;
			datasEnd = datas + dataCount;
			pinsEnd = pins + pinCount;
			this.scratch = scratch;
			this.datas = datas;
			this.pins = pins;
			writingScalars = false;
		}

		internal void Disable()
		{
			this = default(DataCollector);
		}

		internal unsafe EventSource.EventData* Finish()
		{
			ScalarsEnd();
			return datas;
		}

		internal unsafe void AddScalar(void* value, int size)
		{
			if (bufferNesting == 0)
			{
				byte* ptr = scratch;
				byte* ptr2 = ptr + size;
				if (scratchEnd < ptr2)
				{
					throw new IndexOutOfRangeException(SR.EventSource_AddScalarOutOfRange);
				}
				ScalarsBegin();
				scratch = ptr2;
				for (int i = 0; i != size; i++)
				{
					ptr[i] = ((byte*)value)[i];
				}
			}
			else
			{
				int num = bufferPos;
				int num2;
				checked
				{
					bufferPos += size;
					EnsureBuffer();
					num2 = 0;
				}
				while (num2 != size)
				{
					buffer[num] = ((byte*)value)[num2];
					num2++;
					num++;
				}
			}
		}

		internal unsafe void AddNullTerminatedString(string value)
		{
			if (value == null)
			{
				value = string.Empty;
			}
			int num = value.IndexOf('\0');
			if (num < 0)
			{
				num = value.Length;
			}
			int num2 = (num + 1) * 2;
			if (bufferNesting != 0)
			{
				EnsureBuffer(num2);
			}
			if (bufferNesting == 0)
			{
				ScalarsEnd();
				PinArray(value, num2);
				return;
			}
			int startIndex = bufferPos;
			checked
			{
				bufferPos += num2;
				EnsureBuffer();
				fixed (char* ptr = value)
				{
					void* ptr2 = ptr;
					Marshal.Copy((IntPtr)ptr2, buffer, startIndex, num2);
				}
			}
		}

		internal unsafe void AddArray(Array value, int length, int itemSize)
		{
			if (length > 65535)
			{
				length = 65535;
			}
			int num = length * itemSize;
			if (bufferNesting != 0)
			{
				EnsureBuffer(num + 2);
			}
			AddScalar(&length, 2);
			checked
			{
				if (length != 0)
				{
					if (bufferNesting == 0)
					{
						ScalarsEnd();
						PinArray(value, num);
						return;
					}
					int dstOffset = bufferPos;
					bufferPos += num;
					EnsureBuffer();
					Buffer.BlockCopy(value, 0, buffer, dstOffset, num);
				}
			}
		}

		internal int BeginBufferedArray()
		{
			BeginBuffered();
			bufferPos += 2;
			return bufferPos;
		}

		internal void EndBufferedArray(int bookmark, int count)
		{
			EnsureBuffer();
			buffer[bookmark - 2] = (byte)count;
			buffer[bookmark - 1] = (byte)(count >> 8);
			EndBuffered();
		}

		internal void BeginBuffered()
		{
			ScalarsEnd();
			bufferNesting++;
		}

		internal void EndBuffered()
		{
			bufferNesting--;
			if (bufferNesting == 0)
			{
				EnsureBuffer();
				PinArray(buffer, bufferPos);
				buffer = null;
				bufferPos = 0;
			}
		}

		private void EnsureBuffer()
		{
			int num = bufferPos;
			if (buffer == null || buffer.Length < num)
			{
				GrowBuffer(num);
			}
		}

		private void EnsureBuffer(int additionalSize)
		{
			int num = bufferPos + additionalSize;
			if (buffer == null || buffer.Length < num)
			{
				GrowBuffer(num);
			}
		}

		private void GrowBuffer(int required)
		{
			int num = ((buffer == null) ? 64 : buffer.Length);
			do
			{
				num *= 2;
			}
			while (num < required);
			Array.Resize(ref buffer, num);
		}

		private unsafe void PinArray(object value, int size)
		{
			GCHandle* ptr = pins;
			if (pinsEnd <= ptr)
			{
				throw new IndexOutOfRangeException(SR.EventSource_PinArrayOutOfRange);
			}
			EventSource.EventData* ptr2 = datas;
			if (datasEnd <= ptr2)
			{
				throw new IndexOutOfRangeException(SR.EventSource_DataDescriptorsOutOfRange);
			}
			pins = ptr + 1;
			datas = ptr2 + 1;
			*ptr = GCHandle.Alloc(value, GCHandleType.Pinned);
			ptr2->DataPointer = ptr->AddrOfPinnedObject();
			ptr2->m_Size = size;
		}

		private unsafe void ScalarsBegin()
		{
			if (!writingScalars)
			{
				EventSource.EventData* ptr = datas;
				if (datasEnd <= ptr)
				{
					throw new IndexOutOfRangeException(SR.EventSource_DataDescriptorsOutOfRange);
				}
				ptr->DataPointer = (IntPtr)scratch;
				writingScalars = true;
			}
		}

		private unsafe void ScalarsEnd()
		{
			checked
			{
				if (writingScalars)
				{
					EventSource.EventData* ptr = datas;
					ptr->m_Size = (int)(scratch - unchecked((byte*)checked((nuint)ptr->m_Ptr)));
					datas = ptr + 1;
					writingScalars = false;
				}
			}
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct EmptyStruct
	{
	}
	internal sealed class EnumerableTypeInfo : TraceLoggingTypeInfo
	{
		private readonly TraceLoggingTypeInfo elementInfo;

		internal TraceLoggingTypeInfo ElementInfo => elementInfo;

		public EnumerableTypeInfo(Type type, TraceLoggingTypeInfo elementInfo)
			: base(type)
		{
			this.elementInfo = elementInfo;
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			collector.BeginBufferedArray();
			elementInfo.WriteMetadata(collector, name, format);
			collector.EndBufferedArray();
		}

		public override void WriteData(PropertyValue value)
		{
			int bookmark = TraceLoggingDataCollector.BeginBufferedArray();
			int num = 0;
			System.Collections.IEnumerable enumerable = (System.Collections.IEnumerable)value.ReferenceValue;
			if (enumerable != null)
			{
				foreach (object item in enumerable)
				{
					elementInfo.WriteData(elementInfo.PropertyValueFactory(item));
					num++;
				}
			}
			TraceLoggingDataCollector.EndBufferedArray(bookmark, num);
		}

		public override object GetData(object value)
		{
			System.Collections.IEnumerable enumerable = (System.Collections.IEnumerable)value;
			List<object> list = new List<object>();
			foreach (object item in enumerable)
			{
				list.Add(elementInfo.GetData(item));
			}
			return list.ToArray();
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
	public class EventDataAttribute : Attribute
	{
		private EventLevel level = (EventLevel)(-1);

		private EventOpcode opcode = (EventOpcode)(-1);

		public string? Name { get; set; }

		internal EventLevel Level => level;

		internal EventOpcode Opcode => opcode;

		internal EventKeywords Keywords { get; }

		internal EventTags Tags { get; }
	}
	[Flags]
	public enum EventFieldTags
	{
		None = 0
	}
	[AttributeUsage(AttributeTargets.Property)]
	public class EventFieldAttribute : Attribute
	{
		public EventFieldTags Tags { get; set; }

		internal string? Name { get; }

		public EventFieldFormat Format { get; set; }
	}
	public enum EventFieldFormat
	{
		Default = 0,
		String = 2,
		Boolean = 3,
		Hexadecimal = 4,
		Xml = 11,
		Json = 12,
		HResult = 15
	}
	[AttributeUsage(AttributeTargets.Property)]
	public class EventIgnoreAttribute : Attribute
	{
	}
	internal sealed class EventPayload : IDictionary<string, object>, ICollection<KeyValuePair<string, object>>, IEnumerable<KeyValuePair<string, object>>, System.Collections.IEnumerable
	{
		private readonly string[] m_names;

		private readonly object[] m_values;

		public ICollection<string> Keys => m_names;

		public ICollection<object> Values => m_values;

		public object this[string key]
		{
			get
			{
				if (key == null)
				{
					throw new ArgumentNullException("key");
				}
				int num = 0;
				string[] names = m_names;
				foreach (string text in names)
				{
					if (text == key)
					{
						return m_values[num];
					}
					num++;
				}
				throw new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key));
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		public int Count => m_names.Length;

		public bool IsReadOnly => true;

		internal EventPayload(string[] payloadNames, object[] payloadValues)
		{
			m_names = payloadNames;
			m_values = payloadValues;
		}

		public void Add(string key, object value)
		{
			throw new NotSupportedException();
		}

		public void Add(KeyValuePair<string, object> payloadEntry)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(KeyValuePair<string, object> entry)
		{
			return ContainsKey(entry.Key);
		}

		public bool ContainsKey(string key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			string[] names = m_names;
			foreach (string text in names)
			{
				if (text == key)
				{
					return true;
				}
			}
			return false;
		}

		public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
		{
			for (int i = 0; i < Keys.Count; i++)
			{
				yield return new KeyValuePair<string, object>(m_names[i], m_values[i]);
			}
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<KeyValuePair<string, object>>)this).GetEnumerator();
		}

		public void CopyTo(KeyValuePair<string, object>[] payloadEntries, int count)
		{
			throw new NotSupportedException();
		}

		public bool Remove(string key)
		{
			throw new NotSupportedException();
		}

		public bool Remove(KeyValuePair<string, object> entry)
		{
			throw new NotSupportedException();
		}

		public bool TryGetValue(string key, [MaybeNullWhen(false)] out object value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			int num = 0;
			string[] names = m_names;
			foreach (string text in names)
			{
				if (text == key)
				{
					value = m_values[num];
					return true;
				}
				num++;
			}
			value = null;
			return false;
		}
	}
	public struct EventSourceOptions
	{
		internal EventKeywords keywords;

		internal EventTags tags;

		internal EventActivityOptions activityOptions;

		internal byte level;

		internal byte opcode;

		internal byte valuesSet;

		public EventLevel Level
		{
			get
			{
				return (EventLevel)level;
			}
			set
			{
				level = checked((byte)value);
				valuesSet |= 4;
			}
		}

		public EventOpcode Opcode
		{
			get
			{
				return (EventOpcode)opcode;
			}
			set
			{
				opcode = checked((byte)value);
				valuesSet |= 8;
			}
		}

		internal bool IsOpcodeSet => (valuesSet & 8) != 0;

		public EventKeywords Keywords
		{
			get
			{
				return keywords;
			}
			set
			{
				keywords = value;
				valuesSet |= 1;
			}
		}

		public EventTags Tags
		{
			get
			{
				return tags;
			}
			set
			{
				tags = value;
				valuesSet |= 2;
			}
		}

		public EventActivityOptions ActivityOptions
		{
			get
			{
				return activityOptions;
			}
			set
			{
				activityOptions = value;
				valuesSet |= 16;
			}
		}
	}
	internal sealed class FieldMetadata
	{
		private readonly string name;

		private readonly int nameSize;

		private readonly EventFieldTags tags;

		private readonly byte[] custom;

		private readonly ushort fixedCount;

		private byte inType;

		private byte outType;

		public FieldMetadata(string name, TraceLoggingDataType type, EventFieldTags tags, bool variableCount)
			: this(name, type, tags, (byte)(variableCount ? 64 : 0), 0)
		{
		}

		private FieldMetadata(string name, TraceLoggingDataType dataType, EventFieldTags tags, byte countFlags, ushort fixedCount = 0, byte[] custom = null)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name", "This usually means that the object passed to Write is of a type that does not support being used as the top-level object in an event, e.g. a primitive or built-in type.");
			}
			Statics.CheckName(name);
			int num = (int)(dataType & (TraceLoggingDataType)31);
			this.name = name;
			nameSize = Encoding.UTF8.GetByteCount(this.name) + 1;
			inType = (byte)(num | countFlags);
			outType = (byte)((uint)((int)dataType >> 8) & 0x7Fu);
			this.tags = tags;
			this.fixedCount = fixedCount;
			this.custom = custom;
			if (countFlags != 0)
			{
				switch (num)
				{
				case 0:
					throw new NotSupportedException(SR.EventSource_NotSupportedArrayOfNil);
				case 14:
					throw new NotSupportedException(SR.EventSource_NotSupportedArrayOfBinary);
				case 1:
				case 2:
					throw new NotSupportedException(SR.EventSource_NotSupportedArrayOfNullTerminatedString);
				}
			}
			if ((this.tags & (EventFieldTags)268435455) != 0)
			{
				outType |= 128;
			}
			if (outType != 0)
			{
				inType |= 128;
			}
		}

		public void IncrementStructFieldCount()
		{
			inType |= 128;
			outType++;
			if ((outType & 0x7F) == 0)
			{
				throw new NotSupportedException(SR.EventSource_TooManyFields);
			}
		}

		public void Encode(ref int pos, byte[] metadata)
		{
			if (metadata != null)
			{
				Encoding.UTF8.GetBytes(name, 0, name.Length, metadata, pos);
			}
			pos += nameSize;
			if (metadata != null)
			{
				metadata[pos] = inType;
			}
			pos++;
			if ((inType & 0x80u) != 0)
			{
				if (metadata != null)
				{
					metadata[pos] = outType;
				}
				pos++;
				if ((outType & 0x80u) != 0)
				{
					Statics.EncodeTags((int)tags, ref pos, metadata);
				}
			}
			if ((inType & 0x20) == 0)
			{
				return;
			}
			if (metadata != null)
			{
				metadata[pos] = (byte)fixedCount;
				metadata[pos + 1] = (byte)(fixedCount >> 8);
			}
			pos += 2;
			if (96 == (inType & 0x60) && fixedCount != 0)
			{
				if (metadata != null)
				{
					Buffer.BlockCopy(custom, 0, metadata, pos, fixedCount);
				}
				pos += fixedCount;
			}
		}
	}
	internal sealed class InvokeTypeInfo : TraceLoggingTypeInfo
	{
		internal readonly PropertyAnalysis[] properties;

		public InvokeTypeInfo(Type type, TypeAnalysis typeAnalysis)
			: base(type, typeAnalysis.name, typeAnalysis.level, typeAnalysis.opcode, typeAnalysis.keywords, typeAnalysis.tags)
		{
			if (typeAnalysis.properties.Length != 0)
			{
				properties = typeAnalysis.properties;
			}
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			TraceLoggingMetadataCollector traceLoggingMetadataCollector = collector.AddGroup(name);
			if (properties == null)
			{
				return;
			}
			PropertyAnalysis[] array = properties;
			foreach (PropertyAnalysis propertyAnalysis in array)
			{
				EventFieldFormat format2 = EventFieldFormat.Default;
				EventFieldAttribute fieldAttribute = propertyAnalysis.fieldAttribute;
				if (fieldAttribute != null)
				{
					traceLoggingMetadataCollector.Tags = fieldAttribute.Tags;
					format2 = fieldAttribute.Format;
				}
				propertyAnalysis.typeInfo.WriteMetadata(traceLoggingMetadataCollector, propertyAnalysis.name, format2);
			}
		}

		public override void WriteData(PropertyValue value)
		{
			if (properties != null)
			{
				PropertyAnalysis[] array = properties;
				foreach (PropertyAnalysis propertyAnalysis in array)
				{
					propertyAnalysis.typeInfo.WriteData(propertyAnalysis.getter(value));
				}
			}
		}

		public override object GetData(object value)
		{
			if (properties != null)
			{
				string[] array = new string[properties.Length];
				object[] array2 = new object[properties.Length];
				for (int i = 0; i < properties.Length; i++)
				{
					object value2 = properties[i].propertyInfo.GetValue(value);
					array[i] = properties[i].name;
					array2[i] = properties[i].typeInfo.GetData(value2);
				}
				return new EventPayload(array, array2);
			}
			return null;
		}
	}
	internal sealed class NameInfo : ConcurrentSetItem<KeyValuePair<string, EventTags>, NameInfo>
	{
		private static int lastIdentity = 184549376;

		internal readonly string name;

		internal readonly EventTags tags;

		internal readonly int identity;

		internal readonly byte[] nameMetadata;

		internal static void ReserveEventIDsBelow(int eventId)
		{
			int num;
			int val;
			do
			{
				num = lastIdentity;
				val = (lastIdentity & -16777216) + eventId;
				val = Math.Max(val, num);
			}
			while (Interlocked.CompareExchange(ref lastIdentity, val, num) != num);
		}

		public NameInfo(string name, EventTags tags, int typeMetadataSize)
		{
			this.name = name;
			this.tags = tags & (EventTags)268435455;
			identity = Interlocked.Increment(ref lastIdentity);
			int pos = 0;
			Statics.EncodeTags((int)this.tags, ref pos, null);
			nameMetadata = Statics.MetadataForString(name, pos, 0, typeMetadataSize);
			pos = 2;
			Statics.EncodeTags((int)this.tags, ref pos, nameMetadata);
		}

		public override int Compare(NameInfo other)
		{
			return Compare(other.name, other.tags);
		}

		public override int Compare(KeyValuePair<string, EventTags> key)
		{
			return Compare(key.Key, key.Value & (EventTags)268435455);
		}

		private int Compare(string otherName, EventTags otherTags)
		{
			int num = StringComparer.Ordinal.Compare(name, otherName);
			if (num == 0 && tags != otherTags)
			{
				num = ((tags >= otherTags) ? 1 : (-1));
			}
			return num;
		}

		public unsafe IntPtr GetOrCreateEventHandle(EventProvider provider, TraceLoggingEventHandleTable eventHandleTable, EventDescriptor descriptor, TraceLoggingEventTypes eventTypes)
		{
			IntPtr intPtr;
			if ((intPtr = eventHandleTable[descriptor.EventId]) == IntPtr.Zero)
			{
				lock (eventHandleTable)
				{
					if ((intPtr = eventHandleTable[descriptor.EventId]) == IntPtr.Zero)
					{
						byte[] array = EventPipeMetadataGenerator.Instance.GenerateEventMetadata(descriptor.EventId, name, (EventKeywords)descriptor.Keywords, (EventLevel)descriptor.Level, descriptor.Version, (EventOpcode)descriptor.Opcode, eventTypes);
						uint metadataLength = ((array != null) ? ((uint)array.Length) : 0u);
						fixed (byte* pMetadata = array)
						{
							intPtr = provider.m_eventProvider.DefineEventHandle((uint)descriptor.EventId, name, descriptor.Keywords, descriptor.Version, descriptor.Level, pMetadata, metadataLength);
						}
						eventHandleTable.SetEventHandle(descriptor.EventId, intPtr);
					}
				}
			}
			return intPtr;
		}
	}
	internal sealed class PropertyAnalysis
	{
		internal readonly string name;

		internal readonly PropertyInfo propertyInfo;

		internal readonly Func<PropertyValue, PropertyValue> getter;

		internal readonly TraceLoggingTypeInfo typeInfo;

		internal readonly EventFieldAttribute fieldAttribute;

		public PropertyAnalysis(string name, PropertyInfo propertyInfo, TraceLoggingTypeInfo typeInfo, EventFieldAttribute fieldAttribute)
		{
			this.name = name;
			this.propertyInfo = propertyInfo;
			getter = PropertyValue.GetPropertyGetter(propertyInfo);
			this.typeInfo = typeInfo;
			this.fieldAttribute = fieldAttribute;
		}
	}
	internal readonly struct PropertyValue
	{
		[StructLayout(LayoutKind.Explicit)]
		public struct Scalar
		{
			[FieldOffset(0)]
			public bool AsBoolean;

			[FieldOffset(0)]
			public byte AsByte;

			[FieldOffset(0)]
			public sbyte AsSByte;

			[FieldOffset(0)]
			public char AsChar;

			[FieldOffset(0)]
			public short AsInt16;

			[FieldOffset(0)]
			public ushort AsUInt16;

			[FieldOffset(0)]
			public int AsInt32;

			[FieldOffset(0)]
			public uint AsUInt32;

			[FieldOffset(0)]
			public long AsInt64;

			[FieldOffset(0)]
			public ulong AsUInt64;

			[FieldOffset(0)]
			public IntPtr AsIntPtr;

			[FieldOffset(0)]
			public UIntPtr AsUIntPtr;

			[FieldOffset(0)]
			public float AsSingle;

			[FieldOffset(0)]
			public double AsDouble;

			[FieldOffset(0)]
			public Guid AsGuid;

			[FieldOffset(0)]
			public DateTime AsDateTime;

			[FieldOffset(0)]
			public DateTimeOffset AsDateTimeOffset;

			[FieldOffset(0)]
			public TimeSpan AsTimeSpan;

			[FieldOffset(0)]
			public decimal AsDecimal;
		}

		private abstract class TypeHelper
		{
			public abstract Func<PropertyValue, PropertyValue> GetPropertyGetter(PropertyInfo property);

			protected static Delegate GetGetMethod(PropertyInfo property, Type propertyType)
			{
				return property.GetMethod.CreateDelegate(typeof(Func<, >).MakeGenericType(property.DeclaringType, propertyType));
			}
		}

		private sealed class ReferenceTypeHelper<TContainer> : TypeHelper where TContainer : class
		{
			public override Func<PropertyValue, PropertyValue> GetPropertyGetter(PropertyInfo property)
			{
				Type type = property.PropertyType;
				if (!type.IsValueType)
				{
					Func<TContainer, object> getter = (Func<TContainer, object>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(getter((TContainer)container.ReferenceValue));
				}
				if (type.IsEnum)
				{
					type = Enum.GetUnderlyingType(type);
				}
				if (type == typeof(bool))
				{
					Func<TContainer, bool> f = (Func<TContainer, bool>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f((TContainer)container.ReferenceValue));
				}
				if (type == typeof(byte))
				{
					Func<TContainer, byte> f2 = (Func<TContainer, byte>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f2((TContainer)container.ReferenceValue));
				}
				if (type == typeof(sbyte))
				{
					Func<TContainer, sbyte> f3 = (Func<TContainer, sbyte>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f3((TContainer)container.ReferenceValue));
				}
				if (type == typeof(char))
				{
					Func<TContainer, char> f4 = (Func<TContainer, char>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f4((TContainer)container.ReferenceValue));
				}
				if (type == typeof(short))
				{
					Func<TContainer, short> f5 = (Func<TContainer, short>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f5((TContainer)container.ReferenceValue));
				}
				if (type == typeof(ushort))
				{
					Func<TContainer, ushort> f6 = (Func<TContainer, ushort>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f6((TContainer)container.ReferenceValue));
				}
				if (type == typeof(int))
				{
					Func<TContainer, int> f7 = (Func<TContainer, int>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f7((TContainer)container.ReferenceValue));
				}
				if (type == typeof(uint))
				{
					Func<TContainer, uint> f8 = (Func<TContainer, uint>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f8((TContainer)container.ReferenceValue));
				}
				if (type == typeof(long))
				{
					Func<TContainer, long> f9 = (Func<TContainer, long>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f9((TContainer)container.ReferenceValue));
				}
				if (type == typeof(ulong))
				{
					Func<TContainer, ulong> f10 = (Func<TContainer, ulong>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f10((TContainer)container.ReferenceValue));
				}
				if (type == typeof(IntPtr))
				{
					Func<TContainer, IntPtr> f11 = (Func<TContainer, IntPtr>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f11((TContainer)container.ReferenceValue));
				}
				if (type == typeof(UIntPtr))
				{
					Func<TContainer, UIntPtr> f12 = (Func<TContainer, UIntPtr>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f12((TContainer)container.ReferenceValue));
				}
				if (type == typeof(float))
				{
					Func<TContainer, float> f13 = (Func<TContainer, float>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f13((TContainer)container.ReferenceValue));
				}
				if (type == typeof(double))
				{
					Func<TContainer, double> f14 = (Func<TContainer, double>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f14((TContainer)container.ReferenceValue));
				}
				if (type == typeof(Guid))
				{
					Func<TContainer, Guid> f15 = (Func<TContainer, Guid>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f15((TContainer)container.ReferenceValue));
				}
				if (type == typeof(DateTime))
				{
					Func<TContainer, DateTime> f16 = (Func<TContainer, DateTime>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f16((TContainer)container.ReferenceValue));
				}
				if (type == typeof(DateTimeOffset))
				{
					Func<TContainer, DateTimeOffset> f17 = (Func<TContainer, DateTimeOffset>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f17((TContainer)container.ReferenceValue));
				}
				if (type == typeof(TimeSpan))
				{
					Func<TContainer, TimeSpan> f18 = (Func<TContainer, TimeSpan>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f18((TContainer)container.ReferenceValue));
				}
				if (type == typeof(decimal))
				{
					Func<TContainer, decimal> f19 = (Func<TContainer, decimal>)TypeHelper.GetGetMethod(property, type);
					return (PropertyValue container) => new PropertyValue(f19((TContainer)container.ReferenceValue));
				}
				return (PropertyValue container) => new PropertyValue(property.GetValue(container.ReferenceValue));
			}
		}

		private readonly object _reference;

		private readonly Scalar _scalar;

		private readonly int _scalarLength;

		public object ReferenceValue => _reference;

		public Scalar ScalarValue => _scalar;

		public int ScalarLength => _scalarLength;

		private PropertyValue(object value)
		{
			_reference = value;
			_scalar = default(Scalar);
			_scalarLength = 0;
		}

		private PropertyValue(Scalar scalar, int scalarLength)
		{
			_reference = null;
			_scalar = scalar;
			_scalarLength = scalarLength;
		}

		private PropertyValue(bool value)
			: this(new Scalar
			{
				AsBoolean = value
			}, 1)
		{
		}

		private PropertyValue(byte value)
			: this(new Scalar
			{
				AsByte = value
			}, 1)
		{
		}

		private PropertyValue(sbyte value)
			: this(new Scalar
			{
				AsSByte = value
			}, 1)
		{
		}

		private PropertyValue(char value)
			: this(new Scalar
			{
				AsChar = value
			}, 2)
		{
		}

		private PropertyValue(short value)
			: this(new Scalar
			{
				AsInt16 = value
			}, 2)
		{
		}

		private PropertyValue(ushort value)
			: this(new Scalar
			{
				AsUInt16 = value
			}, 2)
		{
		}

		private PropertyValue(int value)
			: this(new Scalar
			{
				AsInt32 = value
			}, 4)
		{
		}

		private PropertyValue(uint value)
			: this(new Scalar
			{
				AsUInt32 = value
			}, 4)
		{
		}

		private PropertyValue(long value)
			: this(new Scalar
			{
				AsInt64 = value
			}, 8)
		{
		}

		private PropertyValue(ulong value)
			: this(new Scalar
			{
				AsUInt64 = value
			}, 8)
		{
		}

		private unsafe PropertyValue(IntPtr value)
			: this(new Scalar
			{
				AsIntPtr = value
			}, sizeof(IntPtr))
		{
		}

		private unsafe PropertyValue(UIntPtr value)
			: this(new Scalar
			{
				AsUIntPtr = value
			}, sizeof(UIntPtr))
		{
		}

		private PropertyValue(float value)
			: this(new Scalar
			{
				AsSingle = value
			}, 4)
		{
		}

		private PropertyValue(double value)
			: this(new Scalar
			{
				AsDouble = value
			}, 8)
		{
		}

		private unsafe PropertyValue(Guid value)
			: this(new Scalar
			{
				AsGuid = value
			}, sizeof(Guid))
		{
		}

		private unsafe PropertyValue(DateTime value)
			: this(new Scalar
			{
				AsDateTime = value
			}, sizeof(DateTime))
		{
		}

		private unsafe PropertyValue(DateTimeOffset value)
			: this(new Scalar
			{
				AsDateTimeOffset = value
			}, sizeof(DateTimeOffset))
		{
		}

		private unsafe PropertyValue(TimeSpan value)
			: this(new Scalar
			{
				AsTimeSpan = value
			}, sizeof(TimeSpan))
		{
		}

		private PropertyValue(decimal value)
			: this(new Scalar
			{
				AsDecimal = value
			}, 16)
		{
		}

		public static Func<object, PropertyValue> GetFactory(Type type)
		{
			if (type == typeof(bool))
			{
				return (object value) => new PropertyValue((bool)value);
			}
			if (type == typeof(byte))
			{
				return (object value) => new PropertyValue((byte)value);
			}
			if (type == typeof(sbyte))
			{
				return (object value) => new PropertyValue((sbyte)value);
			}
			if (type == typeof(char))
			{
				return (object value) => new PropertyValue((char)value);
			}
			if (type == typeof(short))
			{
				return (object value) => new PropertyValue((short)value);
			}
			if (type == typeof(ushort))
			{
				return (object value) => new PropertyValue((ushort)value);
			}
			if (type == typeof(int))
			{
				return (object value) => new PropertyValue((int)value);
			}
			if (type == typeof(uint))
			{
				return (object value) => new PropertyValue((uint)value);
			}
			if (type == typeof(long))
			{
				return (object value) => new PropertyValue((long)value);
			}
			if (type == typeof(ulong))
			{
				return (object value) => new PropertyValue((ulong)value);
			}
			if (type == typeof(IntPtr))
			{
				return (object value) => new PropertyValue((IntPtr)value);
			}
			if (type == typeof(UIntPtr))
			{
				return (object value) => new PropertyValue((UIntPtr)value);
			}
			if (type == typeof(float))
			{
				return (object value) => new PropertyValue((float)value);
			}
			if (type == typeof(double))
			{
				return (object value) => new PropertyValue((double)value);
			}
			if (type == typeof(Guid))
			{
				return (object value) => new PropertyValue((Guid)value);
			}
			if (type == typeof(DateTime))
			{
				return (object value) => new PropertyValue((DateTime)value);
			}
			if (type == typeof(DateTimeOffset))
			{
				return (object value) => new PropertyValue((DateTimeOffset)value);
			}
			if (type == typeof(TimeSpan))
			{
				return (object value) => new PropertyValue((TimeSpan)value);
			}
			if (type == typeof(decimal))
			{
				return (object value) => new PropertyValue((decimal)value);
			}
			return (object value) => new PropertyValue(value);
		}

		public static Func<PropertyValue, PropertyValue> GetPropertyGetter(PropertyInfo property)
		{
			if (property.DeclaringType.IsValueType)
			{
				return GetBoxedValueTypePropertyGetter(property);
			}
			return GetReferenceTypePropertyGetter(property);
		}

		private static Func<PropertyValue, PropertyValue> GetBoxedValueTypePropertyGetter(PropertyInfo property)
		{
			Type type = property.PropertyType;
			if (type.IsEnum)
			{
				type = Enum.GetUnderlyingType(type);
			}
			Func<object, PropertyValue> factory = GetFactory(type);
			return (PropertyValue container) => factory(property.GetValue(container.ReferenceValue));
		}

		private static Func<PropertyValue, PropertyValue> GetReferenceTypePropertyGetter(PropertyInfo property)
		{
			TypeHelper typeHelper = (TypeHelper)Activator.CreateInstance(typeof(ReferenceTypeHelper<>).MakeGenericType(property.DeclaringType));
			return typeHelper.GetPropertyGetter(property);
		}
	}
	internal static class SimpleEventTypes<T>
	{
		private static TraceLoggingEventTypes instance;

		public static TraceLoggingEventTypes Instance
		{
			[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
			get
			{
				return instance ?? (instance = InitInstance());
			}
		}

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		private static TraceLoggingEventTypes InitInstance()
		{
			TraceLoggingTypeInfo traceLoggingTypeInfo = TraceLoggingTypeInfo.GetInstance(typeof(T), null);
			TraceLoggingEventTypes value = new TraceLoggingEventTypes(traceLoggingTypeInfo.Name, traceLoggingTypeInfo.Tags, traceLoggingTypeInfo);
			Interlocked.CompareExchange(ref instance, value, null);
			return instance;
		}
	}
	internal sealed class NullTypeInfo : TraceLoggingTypeInfo
	{
		private static NullTypeInfo s_instance;

		public NullTypeInfo()
			: base(typeof(EmptyStruct))
		{
		}

		public static TraceLoggingTypeInfo Instance()
		{
			return s_instance ?? (s_instance = new NullTypeInfo());
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			collector.AddGroup(name);
		}

		public override void WriteData(PropertyValue value)
		{
		}

		public override object GetData(object value)
		{
			return null;
		}
	}
	internal sealed class ScalarTypeInfo : TraceLoggingTypeInfo
	{
		private static ScalarTypeInfo s_boolean;

		private static ScalarTypeInfo s_byte;

		private static ScalarTypeInfo s_sbyte;

		private static ScalarTypeInfo s_char;

		private static ScalarTypeInfo s_int16;

		private static ScalarTypeInfo s_uint16;

		private static ScalarTypeInfo s_int32;

		private static ScalarTypeInfo s_uint32;

		private static ScalarTypeInfo s_int64;

		private static ScalarTypeInfo s_uint64;

		private static ScalarTypeInfo s_intptr;

		private static ScalarTypeInfo s_uintptr;

		private static ScalarTypeInfo s_single;

		private static ScalarTypeInfo s_double;

		private static ScalarTypeInfo s_guid;

		private readonly TraceLoggingDataType nativeFormat;

		private ScalarTypeInfo(Type type, TraceLoggingDataType nativeFormat)
			: base(type)
		{
			this.nativeFormat = nativeFormat;
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			collector.AddScalar(name, Statics.FormatScalar(format, nativeFormat));
		}

		public override void WriteData(PropertyValue value)
		{
			TraceLoggingDataCollector.AddScalar(value);
		}

		public static TraceLoggingTypeInfo Boolean()
		{
			return s_boolean ?? (s_boolean = new ScalarTypeInfo(typeof(bool), TraceLoggingDataType.Boolean8));
		}

		public static TraceLoggingTypeInfo Byte()
		{
			return s_byte ?? (s_byte = new ScalarTypeInfo(typeof(byte), TraceLoggingDataType.UInt8));
		}

		public static TraceLoggingTypeInfo SByte()
		{
			return s_sbyte ?? (s_sbyte = new ScalarTypeInfo(typeof(sbyte), TraceLoggingDataType.Int8));
		}

		public static TraceLoggingTypeInfo Char()
		{
			return s_char ?? (s_char = new ScalarTypeInfo(typeof(char), TraceLoggingDataType.Char16));
		}

		public static TraceLoggingTypeInfo Int16()
		{
			return s_int16 ?? (s_int16 = new ScalarTypeInfo(typeof(short), TraceLoggingDataType.Int16));
		}

		public static TraceLoggingTypeInfo UInt16()
		{
			return s_uint16 ?? (s_uint16 = new ScalarTypeInfo(typeof(ushort), TraceLoggingDataType.UInt16));
		}

		public static TraceLoggingTypeInfo Int32()
		{
			return s_int32 ?? (s_int32 = new ScalarTypeInfo(typeof(int), TraceLoggingDataType.Int32));
		}

		public static TraceLoggingTypeInfo UInt32()
		{
			return s_uint32 ?? (s_uint32 = new ScalarTypeInfo(typeof(uint), TraceLoggingDataType.UInt32));
		}

		public static TraceLoggingTypeInfo Int64()
		{
			return s_int64 ?? (s_int64 = new ScalarTypeInfo(typeof(long), TraceLoggingDataType.Int64));
		}

		public static TraceLoggingTypeInfo UInt64()
		{
			return s_uint64 ?? (s_uint64 = new ScalarTypeInfo(typeof(ulong), TraceLoggingDataType.UInt64));
		}

		public static TraceLoggingTypeInfo IntPtr()
		{
			return s_intptr ?? (s_intptr = new ScalarTypeInfo(typeof(IntPtr), Statics.IntPtrType));
		}

		public static TraceLoggingTypeInfo UIntPtr()
		{
			return s_uintptr ?? (s_uintptr = new ScalarTypeInfo(typeof(UIntPtr), Statics.UIntPtrType));
		}

		public static TraceLoggingTypeInfo Single()
		{
			return s_single ?? (s_single = new ScalarTypeInfo(typeof(float), TraceLoggingDataType.Float));
		}

		public static TraceLoggingTypeInfo Double()
		{
			return s_double ?? (s_double = new ScalarTypeInfo(typeof(double), TraceLoggingDataType.Double));
		}

		public static TraceLoggingTypeInfo Guid()
		{
			return s_guid ?? (s_guid = new ScalarTypeInfo(typeof(Guid), TraceLoggingDataType.Guid));
		}
	}
	internal sealed class ScalarArrayTypeInfo : TraceLoggingTypeInfo
	{
		private static ScalarArrayTypeInfo s_boolean;

		private static ScalarArrayTypeInfo s_byte;

		private static ScalarArrayTypeInfo s_sbyte;

		private static ScalarArrayTypeInfo s_char;

		private static ScalarArrayTypeInfo s_int16;

		private static ScalarArrayTypeInfo s_uint16;

		private static ScalarArrayTypeInfo s_int32;

		private static ScalarArrayTypeInfo s_uint32;

		private static ScalarArrayTypeInfo s_int64;

		private static ScalarArrayTypeInfo s_uint64;

		private static ScalarArrayTypeInfo s_intptr;

		private static ScalarArrayTypeInfo s_uintptr;

		private static ScalarArrayTypeInfo s_single;

		private static ScalarArrayTypeInfo s_double;

		private static ScalarArrayTypeInfo s_guid;

		private readonly TraceLoggingDataType nativeFormat;

		private readonly int elementSize;

		private ScalarArrayTypeInfo(Type type, TraceLoggingDataType nativeFormat, int elementSize)
			: base(type)
		{
			this.nativeFormat = nativeFormat;
			this.elementSize = elementSize;
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			collector.AddArray(name, Statics.FormatScalar(format, nativeFormat));
		}

		public override void WriteData(PropertyValue value)
		{
			TraceLoggingDataCollector.AddArray(value, elementSize);
		}

		public static TraceLoggingTypeInfo Boolean()
		{
			return s_boolean ?? (s_boolean = new ScalarArrayTypeInfo(typeof(bool[]), TraceLoggingDataType.Boolean8, 1));
		}

		public static TraceLoggingTypeInfo Byte()
		{
			return s_byte ?? (s_byte = new ScalarArrayTypeInfo(typeof(byte[]), TraceLoggingDataType.UInt8, 1));
		}

		public static TraceLoggingTypeInfo SByte()
		{
			return s_sbyte ?? (s_sbyte = new ScalarArrayTypeInfo(typeof(sbyte[]), TraceLoggingDataType.Int8, 1));
		}

		public static TraceLoggingTypeInfo Char()
		{
			return s_char ?? (s_char = new ScalarArrayTypeInfo(typeof(char[]), TraceLoggingDataType.Char16, 2));
		}

		public static TraceLoggingTypeInfo Int16()
		{
			return s_int16 ?? (s_int16 = new ScalarArrayTypeInfo(typeof(short[]), TraceLoggingDataType.Int16, 2));
		}

		public static TraceLoggingTypeInfo UInt16()
		{
			return s_uint16 ?? (s_uint16 = new ScalarArrayTypeInfo(typeof(ushort[]), TraceLoggingDataType.UInt16, 2));
		}

		public static TraceLoggingTypeInfo Int32()
		{
			return s_int32 ?? (s_int32 = new ScalarArrayTypeInfo(typeof(int[]), TraceLoggingDataType.Int32, 4));
		}

		public static TraceLoggingTypeInfo UInt32()
		{
			return s_uint32 ?? (s_uint32 = new ScalarArrayTypeInfo(typeof(uint[]), TraceLoggingDataType.UInt32, 4));
		}

		public static TraceLoggingTypeInfo Int64()
		{
			return s_int64 ?? (s_int64 = new ScalarArrayTypeInfo(typeof(long[]), TraceLoggingDataType.Int64, 8));
		}

		public static TraceLoggingTypeInfo UInt64()
		{
			return s_uint64 ?? (s_uint64 = new ScalarArrayTypeInfo(typeof(ulong[]), TraceLoggingDataType.UInt64, 8));
		}

		public static TraceLoggingTypeInfo IntPtr()
		{
			return s_intptr ?? (s_intptr = new ScalarArrayTypeInfo(typeof(IntPtr[]), Statics.IntPtrType, System.IntPtr.Size));
		}

		public static TraceLoggingTypeInfo UIntPtr()
		{
			return s_uintptr ?? (s_uintptr = new ScalarArrayTypeInfo(typeof(UIntPtr[]), Statics.UIntPtrType, System.IntPtr.Size));
		}

		public static TraceLoggingTypeInfo Single()
		{
			return s_single ?? (s_single = new ScalarArrayTypeInfo(typeof(float[]), TraceLoggingDataType.Float, 4));
		}

		public static TraceLoggingTypeInfo Double()
		{
			return s_double ?? (s_double = new ScalarArrayTypeInfo(typeof(double[]), TraceLoggingDataType.Double, 8));
		}

		public unsafe static TraceLoggingTypeInfo Guid()
		{
			return s_guid ?? (s_guid = new ScalarArrayTypeInfo(typeof(Guid[]), TraceLoggingDataType.Guid, sizeof(Guid)));
		}
	}
	internal sealed class StringTypeInfo : TraceLoggingTypeInfo
	{
		private static StringTypeInfo s_instance;

		public StringTypeInfo()
			: base(typeof(string))
		{
		}

		public static TraceLoggingTypeInfo Instance()
		{
			return s_instance ?? (s_instance = new StringTypeInfo());
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			if (name == null)
			{
				name = "message";
			}
			collector.AddNullTerminatedString(name, Statics.MakeDataType(TraceLoggingDataType.Utf16String, format));
		}

		public override void WriteData(PropertyValue value)
		{
			TraceLoggingDataCollector.AddNullTerminatedString((string)value.ReferenceValue);
		}

		public override object GetData(object value)
		{
			if (value == null)
			{
				return "";
			}
			return value;
		}
	}
	internal sealed class DateTimeTypeInfo : TraceLoggingTypeInfo
	{
		private static DateTimeTypeInfo s_instance;

		public DateTimeTypeInfo()
			: base(typeof(DateTime))
		{
		}

		public static TraceLoggingTypeInfo Instance()
		{
			return s_instance ?? (s_instance = new DateTimeTypeInfo());
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			collector.AddScalar(name, Statics.MakeDataType(TraceLoggingDataType.FileTime, format));
		}

		public override void WriteData(PropertyValue value)
		{
			DateTime asDateTime = value.ScalarValue.AsDateTime;
			long value2 = 0L;
			if (asDateTime.Ticks > 504911232000000000L)
			{
				value2 = asDateTime.ToFileTimeUtc();
			}
			TraceLoggingDataCollector.AddScalar(value2);
		}
	}
	internal sealed class DateTimeOffsetTypeInfo : TraceLoggingTypeInfo
	{
		private static DateTimeOffsetTypeInfo s_instance;

		public DateTimeOffsetTypeInfo()
			: base(typeof(DateTimeOffset))
		{
		}

		public static TraceLoggingTypeInfo Instance()
		{
			return s_instance ?? (s_instance = new DateTimeOffsetTypeInfo());
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			TraceLoggingMetadataCollector traceLoggingMetadataCollector = collector.AddGroup(name);
			traceLoggingMetadataCollector.AddScalar("Ticks", Statics.MakeDataType(TraceLoggingDataType.FileTime, format));
			traceLoggingMetadataCollector.AddScalar("Offset", TraceLoggingDataType.Int64);
		}

		public override void WriteData(PropertyValue value)
		{
			DateTimeOffset asDateTimeOffset = value.ScalarValue.AsDateTimeOffset;
			long ticks = asDateTimeOffset.Ticks;
			TraceLoggingDataCollector.AddScalar((ticks < 504911232000000000L) ? 0 : (ticks - 504911232000000000L));
			TraceLoggingDataCollector.AddScalar(asDateTimeOffset.Offset.Ticks);
		}
	}
	internal sealed class TimeSpanTypeInfo : TraceLoggingTypeInfo
	{
		private static TimeSpanTypeInfo s_instance;

		public TimeSpanTypeInfo()
			: base(typeof(TimeSpan))
		{
		}

		public static TraceLoggingTypeInfo Instance()
		{
			return s_instance ?? (s_instance = new TimeSpanTypeInfo());
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			collector.AddScalar(name, Statics.MakeDataType(TraceLoggingDataType.Int64, format));
		}

		public override void WriteData(PropertyValue value)
		{
			TraceLoggingDataCollector.AddScalar(value.ScalarValue.AsTimeSpan.Ticks);
		}
	}
	internal sealed class DecimalTypeInfo : TraceLoggingTypeInfo
	{
		private static DecimalTypeInfo s_instance;

		public DecimalTypeInfo()
			: base(typeof(decimal))
		{
		}

		public static TraceLoggingTypeInfo Instance()
		{
			return s_instance ?? (s_instance = new DecimalTypeInfo());
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			collector.AddScalar(name, Statics.MakeDataType(TraceLoggingDataType.Double, format));
		}

		public override void WriteData(PropertyValue value)
		{
			TraceLoggingDataCollector.AddScalar((double)value.ScalarValue.AsDecimal);
		}
	}
	internal sealed class NullableTypeInfo : TraceLoggingTypeInfo
	{
		private readonly TraceLoggingTypeInfo valueInfo;

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		public NullableTypeInfo(Type type, List<Type> recursionCheck)
			: base(type)
		{
			Type[] genericTypeArguments = type.GenericTypeArguments;
			valueInfo = TraceLoggingTypeInfo.GetInstance(genericTypeArguments[0], recursionCheck);
		}

		public override void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format)
		{
			TraceLoggingMetadataCollector traceLoggingMetadataCollector = collector.AddGroup(name);
			traceLoggingMetadataCollector.AddScalar("HasValue", TraceLoggingDataType.Boolean8);
			valueInfo.WriteMetadata(traceLoggingMetadataCollector, "Value", format);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2072:UnrecognizedReflectionPattern", Justification = "The underlying type of Nullable<T> must be defaultable")]
		public override void WriteData(PropertyValue value)
		{
			object referenceValue = value.ReferenceValue;
			bool flag = referenceValue != null;
			TraceLoggingDataCollector.AddScalar(flag);
			PropertyValue value2 = valueInfo.PropertyValueFactory(flag ? referenceValue : RuntimeHelpers.GetUninitializedObject(valueInfo.DataType));
			valueInfo.WriteData(value2);
		}
	}
	internal static class Statics
	{
		public static readonly TraceLoggingDataType IntPtrType;

		public static readonly TraceLoggingDataType UIntPtrType;

		public static readonly TraceLoggingDataType HexIntPtrType;

		public static byte[] MetadataForString(string name, int prefixSize, int suffixSize, int additionalSize)
		{
			CheckName(name);
			int num = Encoding.UTF8.GetByteCount(name) + 3 + prefixSize + suffixSize;
			byte[] array = new byte[num];
			ushort num2 = checked((ushort)(num + additionalSize));
			array[0] = (byte)num2;
			array[1] = (byte)(num2 >> 8);
			Encoding.UTF8.GetBytes(name, 0, name.Length, array, 2 + prefixSize);
			return array;
		}

		public static void EncodeTags(int tags, ref int pos, byte[] metadata)
		{
			int num = tags & 0xFFFFFFF;
			bool flag;
			do
			{
				byte b = (byte)((uint)(num >> 21) & 0x7Fu);
				flag = (num & 0x1FFFFF) != 0;
				b |= (byte)(flag ? 128u : 0u);
				num <<= 7;
				if (metadata != null)
				{
					metadata[pos] = b;
				}
				pos++;
			}
			while (flag);
		}

		public static byte Combine(int settingValue, byte defaultValue)
		{
			if ((byte)settingValue != settingValue)
			{
				return defaultValue;
			}
			return (byte)settingValue;
		}

		public static int Combine(int settingValue1, int settingValue2)
		{
			if ((byte)settingValue1 != settingValue1)
			{
				return settingValue2;
			}
			return settingValue1;
		}

		public static void CheckName(string name)
		{
			if (name != null && 0 <= name.IndexOf('\0'))
			{
				throw new ArgumentOutOfRangeException("name");
			}
		}

		public static bool ShouldOverrideFieldName(string fieldName)
		{
			if (fieldName.Length <= 2)
			{
				return fieldName[0] == '_';
			}
			return false;
		}

		public static TraceLoggingDataType MakeDataType(TraceLoggingDataType baseType, EventFieldFormat format)
		{
			return (TraceLoggingDataType)((int)(baseType & (TraceLoggingDataType)31) | ((int)format << 8));
		}

		public static TraceLoggingDataType Format8(EventFieldFormat format, TraceLoggingDataType native)
		{
			return format switch
			{
				EventFieldFormat.Default => native, 
				EventFieldFormat.String => TraceLoggingDataType.Char8, 
				EventFieldFormat.Boolean => TraceLoggingDataType.Boolean8, 
				EventFieldFormat.Hexadecimal => TraceLoggingDataType.HexInt8, 
				_ => MakeDataType(native, format), 
			};
		}

		public static TraceLoggingDataType Format16(EventFieldFormat format, TraceLoggingDataType native)
		{
			return format switch
			{
				EventFieldFormat.Default => native, 
				EventFieldFormat.String => TraceLoggingDataType.Char16, 
				EventFieldFormat.Hexadecimal => TraceLoggingDataType.HexInt16, 
				_ => MakeDataType(native, format), 
			};
		}

		public static TraceLoggingDataType Format32(EventFieldFormat format, TraceLoggingDataType native)
		{
			return format switch
			{
				EventFieldFormat.Default => native, 
				EventFieldFormat.Boolean => TraceLoggingDataType.Boolean32, 
				EventFieldFormat.Hexadecimal => TraceLoggingDataType.HexInt32, 
				EventFieldFormat.HResult => TraceLoggingDataType.HResult, 
				_ => MakeDataType(native, format), 
			};
		}

		public static TraceLoggingDataType Format64(EventFieldFormat format, TraceLoggingDataType native)
		{
			return format switch
			{
				EventFieldFormat.Default => native, 
				EventFieldFormat.Hexadecimal => TraceLoggingDataType.HexInt64, 
				_ => MakeDataType(native, format), 
			};
		}

		public static TraceLoggingDataType FormatScalar(EventFieldFormat format, TraceLoggingDataType nativeFormat)
		{
			switch (nativeFormat)
			{
			case TraceLoggingDataType.Int8:
			case TraceLoggingDataType.UInt8:
			case TraceLoggingDataType.Boolean8:
				return Format8(format, nativeFormat);
			case TraceLoggingDataType.Int16:
			case TraceLoggingDataType.UInt16:
			case TraceLoggingDataType.Char16:
				return Format16(format, nativeFormat);
			case TraceLoggingDataType.Int32:
			case TraceLoggingDataType.UInt32:
			case TraceLoggingDataType.Float:
				return Format32(format, nativeFormat);
			case TraceLoggingDataType.Int64:
			case TraceLoggingDataType.UInt64:
			case TraceLoggingDataType.Double:
				return Format64(format, nativeFormat);
			default:
				return MakeDataType(nativeFormat, format);
			}
		}

		public static bool HasCustomAttribute(PropertyInfo propInfo, Type attributeType)
		{
			return propInfo.IsDefined(attributeType, inherit: false);
		}

		public static AttributeType GetCustomAttribute<AttributeType>(PropertyInfo propInfo) where AttributeType : Attribute
		{
			AttributeType result = null;
			object[] customAttributes = propInfo.GetCustomAttributes(typeof(AttributeType), inherit: false);
			if (customAttributes.Length != 0)
			{
				return (AttributeType)customAttributes[0];
			}
			return result;
		}

		public static AttributeType GetCustomAttribute<AttributeType>(Type type) where AttributeType : Attribute
		{
			AttributeType result = null;
			object[] customAttributes = type.GetCustomAttributes(typeof(AttributeType), inherit: false);
			if (customAttributes.Length != 0)
			{
				return (AttributeType)customAttributes[0];
			}
			return result;
		}

		public static Type FindEnumerableElementType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type type)
		{
			Type type2 = null;
			if (IsGenericMatch(type, typeof(IEnumerable<>)))
			{
				type2 = type.GetGenericArguments()[0];
			}
			else
			{
				Type[] array = type.FindInterfaces(IsGenericMatch, typeof(IEnumerable<>));
				Type[] array2 = array;
				foreach (Type type3 in array2)
				{
					if (type2 != null)
					{
						type2 = null;
						break;
					}
					type2 = type3.GetGenericArguments()[0];
				}
			}
			return type2;
		}

		public static bool IsGenericMatch(Type type, object openType)
		{
			if (type.IsGenericType)
			{
				return type.GetGenericTypeDefinition() == (Type)openType;
			}
			return false;
		}

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		public static TraceLoggingTypeInfo CreateDefaultTypeInfo(Type dataType, List<Type> recursionCheck)
		{
			if (recursionCheck.Contains(dataType))
			{
				throw new NotSupportedException(SR.EventSource_RecursiveTypeDefinition);
			}
			recursionCheck.Add(dataType);
			EventDataAttribute customAttribute = GetCustomAttribute<EventDataAttribute>(dataType);
			if (customAttribute != null || GetCustomAttribute<CompilerGeneratedAttribute>(dataType) != null || IsGenericMatch(dataType, typeof(KeyValuePair<, >)))
			{
				TypeAnalysis typeAnalysis = new TypeAnalysis(dataType, customAttribute, recursionCheck);
				return new InvokeTypeInfo(dataType, typeAnalysis);
			}
			if (dataType.IsArray)
			{
				Type elementType = dataType.GetElementType();
				if (elementType == typeof(bool))
				{
					return ScalarArrayTypeInfo.Boolean();
				}
				if (elementType == typeof(byte))
				{
					return ScalarArrayTypeInfo.Byte();
				}
				if (elementType == typeof(sbyte))
				{
					return ScalarArrayTypeInfo.SByte();
				}
				if (elementType == typeof(short))
				{
					return ScalarArrayTypeInfo.Int16();
				}
				if (elementType == typeof(ushort))
				{
					return ScalarArrayTypeInfo.UInt16();
				}
				if (elementType == typeof(int))
				{
					return ScalarArrayTypeInfo.Int32();
				}
				if (elementType == typeof(uint))
				{
					return ScalarArrayTypeInfo.UInt32();
				}
				if (elementType == typeof(long))
				{
					return ScalarArrayTypeInfo.Int64();
				}
				if (elementType == typeof(ulong))
				{
					return ScalarArrayTypeInfo.UInt64();
				}
				if (elementType == typeof(char))
				{
					return ScalarArrayTypeInfo.Char();
				}
				if (elementType == typeof(double))
				{
					return ScalarArrayTypeInfo.Double();
				}
				if (elementType == typeof(float))
				{
					return ScalarArrayTypeInfo.Single();
				}
				if (elementType == typeof(IntPtr))
				{
					return ScalarArrayTypeInfo.IntPtr();
				}
				if (elementType == typeof(UIntPtr))
				{
					return ScalarArrayTypeInfo.UIntPtr();
				}
				if (elementType == typeof(Guid))
				{
					return ScalarArrayTypeInfo.Guid();
				}
				return new ArrayTypeInfo(dataType, TraceLoggingTypeInfo.GetInstance(elementType, recursionCheck));
			}
			if (dataType.IsEnum)
			{
				dataType = Enum.GetUnderlyingType(dataType);
			}
			if (dataType == typeof(string))
			{
				return StringTypeInfo.Instance();
			}
			if (dataType == typeof(bool))
			{
				return ScalarTypeInfo.Boolean();
			}
			if (dataType == typeof(byte))
			{
				return ScalarTypeInfo.Byte();
			}
			if (dataType == typeof(sbyte))
			{
				return ScalarTypeInfo.SByte();
			}
			if (dataType == typeof(short))
			{
				return ScalarTypeInfo.Int16();
			}
			if (dataType == typeof(ushort))
			{
				return ScalarTypeInfo.UInt16();
			}
			if (dataType == typeof(int))
			{
				return ScalarTypeInfo.Int32();
			}
			if (dataType == typeof(uint))
			{
				return ScalarTypeInfo.UInt32();
			}
			if (dataType == typeof(long))
			{
				return ScalarTypeInfo.Int64();
			}
			if (dataType == typeof(ulong))
			{
				return ScalarTypeInfo.UInt64();
			}
			if (dataType == typeof(char))
			{
				return ScalarTypeInfo.Char();
			}
			if (dataType == typeof(double))
			{
				return ScalarTypeInfo.Double();
			}
			if (dataType == typeof(float))
			{
				return ScalarTypeInfo.Single();
			}
			if (dataType == typeof(DateTime))
			{
				return DateTimeTypeInfo.Instance();
			}
			if (dataType == typeof(decimal))
			{
				return DecimalTypeInfo.Instance();
			}
			if (dataType == typeof(IntPtr))
			{
				return ScalarTypeInfo.IntPtr();
			}
			if (dataType == typeof(UIntPtr))
			{
				return ScalarTypeInfo.UIntPtr();
			}
			if (dataType == typeof(Guid))
			{
				return ScalarTypeInfo.Guid();
			}
			if (dataType == typeof(TimeSpan))
			{
				return TimeSpanTypeInfo.Instance();
			}
			if (dataType == typeof(DateTimeOffset))
			{
				return DateTimeOffsetTypeInfo.Instance();
			}
			if (dataType == typeof(EmptyStruct))
			{
				return NullTypeInfo.Instance();
			}
			if (IsGenericMatch(dataType, typeof(Nullable<>)))
			{
				return new NullableTypeInfo(dataType, recursionCheck);
			}
			Type type = FindEnumerableElementType(dataType);
			if (type != null)
			{
				return new EnumerableTypeInfo(dataType, TraceLoggingTypeInfo.GetInstance(type, recursionCheck));
			}
			throw new ArgumentException(SR.Format(SR.EventSource_NonCompliantTypeError, dataType.Name));
		}

		static Statics()
		{
			_ = IntPtr.Size;
			IntPtrType = TraceLoggingDataType.Int32;
			_ = IntPtr.Size;
			UIntPtrType = TraceLoggingDataType.UInt32;
			_ = IntPtr.Size;
			HexIntPtrType = TraceLoggingDataType.HexInt32;
		}
	}
	internal static class TraceLoggingDataCollector
	{
		public static int BeginBufferedArray()
		{
			return DataCollector.ThreadInstance.BeginBufferedArray();
		}

		public static void EndBufferedArray(int bookmark, int count)
		{
			DataCollector.ThreadInstance.EndBufferedArray(bookmark, count);
		}

		public unsafe static void AddScalar(PropertyValue value)
		{
			PropertyValue.Scalar scalarValue = value.ScalarValue;
			DataCollector.ThreadInstance.AddScalar(&scalarValue, value.ScalarLength);
		}

		public unsafe static void AddScalar(long value)
		{
			DataCollector.ThreadInstance.AddScalar(&value, 8);
		}

		public unsafe static void AddScalar(double value)
		{
			DataCollector.ThreadInstance.AddScalar(&value, 8);
		}

		public unsafe static void AddScalar(bool value)
		{
			DataCollector.ThreadInstance.AddScalar(&value, 1);
		}

		public static void AddNullTerminatedString(string value)
		{
			DataCollector.ThreadInstance.AddNullTerminatedString(value);
		}

		public static void AddArray(PropertyValue value, int elementSize)
		{
			Array array = (Array)value.ReferenceValue;
			DataCollector.ThreadInstance.AddArray(array, array?.Length ?? 0, elementSize);
		}
	}
	internal enum TraceLoggingDataType
	{
		Nil = 0,
		Utf16String = 1,
		MbcsString = 2,
		Int8 = 3,
		UInt8 = 4,
		Int16 = 5,
		UInt16 = 6,
		Int32 = 7,
		UInt32 = 8,
		Int64 = 9,
		UInt64 = 10,
		Float = 11,
		Double = 12,
		Boolean32 = 13,
		Binary = 14,
		Guid = 15,
		FileTime = 17,
		SystemTime = 18,
		HexInt32 = 20,
		HexInt64 = 21,
		CountedUtf16String = 22,
		CountedMbcsString = 23,
		Struct = 24,
		Char16 = 518,
		Char8 = 516,
		Boolean8 = 772,
		HexInt8 = 1028,
		HexInt16 = 1030,
		Utf16Xml = 2817,
		MbcsXml = 2818,
		CountedUtf16Xml = 2838,
		CountedMbcsXml = 2839,
		Utf16Json = 3073,
		MbcsJson = 3074,
		CountedUtf16Json = 3094,
		CountedMbcsJson = 3095,
		HResult = 3847
	}
	internal sealed class TraceLoggingEventHandleTable
	{
		private IntPtr[] m_innerTable;

		internal IntPtr this[int eventID]
		{
			get
			{
				IntPtr result = IntPtr.Zero;
				IntPtr[] array = Volatile.Read(ref m_innerTable);
				if (eventID >= 0 && eventID < array.Length)
				{
					result = array[eventID];
				}
				return result;
			}
		}

		internal TraceLoggingEventHandleTable()
		{
			m_innerTable = new IntPtr[10];
		}

		internal void SetEventHandle(int eventID, IntPtr eventHandle)
		{
			if (eventID >= m_innerTable.Length)
			{
				int num = m_innerTable.Length * 2;
				if (num <= eventID)
				{
					num = eventID + 1;
				}
				IntPtr[] array = new IntPtr[num];
				Array.Copy(m_innerTable, array, m_innerTable.Length);
				Volatile.Write(ref m_innerTable, array);
			}
			m_innerTable[eventID] = eventHandle;
		}
	}
	[Flags]
	public enum EventTags
	{
		None = 0
	}
	public class TraceLoggingEventTypes
	{
		internal readonly TraceLoggingTypeInfo[] typeInfos;

		internal readonly string[] paramNames;

		internal readonly string name;

		internal readonly EventTags tags;

		internal readonly byte level;

		internal readonly byte opcode;

		internal readonly EventKeywords keywords;

		internal readonly byte[] typeMetadata;

		internal readonly int scratchSize;

		internal readonly int dataCount;

		internal readonly int pinCount;

		private ConcurrentSet<KeyValuePair<string, EventTags>, NameInfo> nameInfos;

		internal string Name => name;

		internal EventTags Tags => tags;

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		internal TraceLoggingEventTypes(string name, EventTags tags, params Type[] types)
			: this(tags, name, MakeArray(types))
		{
		}

		internal TraceLoggingEventTypes(string name, EventTags tags, params TraceLoggingTypeInfo[] typeInfos)
			: this(tags, name, MakeArray(typeInfos))
		{
		}

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		internal TraceLoggingEventTypes(string name, EventTags tags, ParameterInfo[] paramInfos)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			typeInfos = MakeArray(paramInfos);
			paramNames = MakeParamNameArray(paramInfos);
			this.name = name;
			this.tags = tags;
			level = 5;
			TraceLoggingMetadataCollector traceLoggingMetadataCollector = new TraceLoggingMetadataCollector();
			for (int i = 0; i < typeInfos.Length; i++)
			{
				TraceLoggingTypeInfo traceLoggingTypeInfo = typeInfos[i];
				level = Statics.Combine((int)traceLoggingTypeInfo.Level, level);
				opcode = Statics.Combine((int)traceLoggingTypeInfo.Opcode, opcode);
				keywords |= traceLoggingTypeInfo.Keywords;
				string fieldName = paramInfos[i].Name;
				if (Statics.ShouldOverrideFieldName(fieldName))
				{
					fieldName = traceLoggingTypeInfo.Name;
				}
				traceLoggingTypeInfo.WriteMetadata(traceLoggingMetadataCollector, fieldName, EventFieldFormat.Default);
			}
			typeMetadata = traceLoggingMetadataCollector.GetMetadata();
			scratchSize = traceLoggingMetadataCollector.ScratchSize;
			dataCount = traceLoggingMetadataCollector.DataCount;
			pinCount = traceLoggingMetadataCollector.PinCount;
		}

		private TraceLoggingEventTypes(EventTags tags, string defaultName, TraceLoggingTypeInfo[] typeInfos)
		{
			if (defaultName == null)
			{
				throw new ArgumentNullException("defaultName");
			}
			this.typeInfos = typeInfos;
			name = defaultName;
			this.tags = tags;
			level = 5;
			TraceLoggingMetadataCollector traceLoggingMetadataCollector = new TraceLoggingMetadataCollector();
			foreach (TraceLoggingTypeInfo traceLoggingTypeInfo in typeInfos)
			{
				level = Statics.Combine((int)traceLoggingTypeInfo.Level, level);
				opcode = Statics.Combine((int)traceLoggingTypeInfo.Opcode, opcode);
				keywords |= traceLoggingTypeInfo.Keywords;
				traceLoggingTypeInfo.WriteMetadata(traceLoggingMetadataCollector, null, EventFieldFormat.Default);
			}
			typeMetadata = traceLoggingMetadataCollector.GetMetadata();
			scratchSize = traceLoggingMetadataCollector.ScratchSize;
			dataCount = traceLoggingMetadataCollector.DataCount;
			pinCount = traceLoggingMetadataCollector.PinCount;
		}

		internal NameInfo GetNameInfo(string name, EventTags tags)
		{
			return nameInfos.TryGet(new KeyValuePair<string, EventTags>(name, tags)) ?? nameInfos.GetOrAdd(new NameInfo(name, tags, typeMetadata.Length));
		}

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		private static TraceLoggingTypeInfo[] MakeArray(ParameterInfo[] paramInfos)
		{
			if (paramInfos == null)
			{
				throw new ArgumentNullException("paramInfos");
			}
			List<Type> recursionCheck = new List<Type>(paramInfos.Length);
			TraceLoggingTypeInfo[] array = new TraceLoggingTypeInfo[paramInfos.Length];
			for (int i = 0; i < paramInfos.Length; i++)
			{
				array[i] = TraceLoggingTypeInfo.GetInstance(paramInfos[i].ParameterType, recursionCheck);
			}
			return array;
		}

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		private static TraceLoggingTypeInfo[] MakeArray(Type[] types)
		{
			if (types == null)
			{
				throw new ArgumentNullException("types");
			}
			List<Type> recursionCheck = new List<Type>(types.Length);
			TraceLoggingTypeInfo[] array = new TraceLoggingTypeInfo[types.Length];
			for (int i = 0; i < types.Length; i++)
			{
				array[i] = TraceLoggingTypeInfo.GetInstance(types[i], recursionCheck);
			}
			return array;
		}

		private static TraceLoggingTypeInfo[] MakeArray(TraceLoggingTypeInfo[] typeInfos)
		{
			if (typeInfos == null)
			{
				throw new ArgumentNullException("typeInfos");
			}
			return (TraceLoggingTypeInfo[])typeInfos.Clone();
		}

		private static string[] MakeParamNameArray(ParameterInfo[] paramInfos)
		{
			string[] array = new string[paramInfos.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = paramInfos[i].Name;
			}
			return array;
		}
	}
	internal sealed class TraceLoggingMetadataCollector
	{
		private sealed class Impl
		{
			internal readonly List<FieldMetadata> fields = new List<FieldMetadata>();

			internal short scratchSize;

			internal sbyte dataCount;

			internal sbyte pinCount;

			private int bufferNesting;

			private bool scalar;

			public void AddScalar(int size)
			{
				checked
				{
					if (bufferNesting == 0)
					{
						if (!scalar)
						{
							dataCount++;
						}
						scalar = true;
						scratchSize = (short)(scratchSize + size);
					}
				}
			}

			public void AddNonscalar()
			{
				checked
				{
					if (bufferNesting == 0)
					{
						scalar = false;
						pinCount++;
						dataCount++;
					}
				}
			}

			public void BeginBuffered()
			{
				if (bufferNesting == 0)
				{
					AddNonscalar();
				}
				bufferNesting++;
			}

			public void EndBuffered()
			{
				bufferNesting--;
			}

			public int Encode(byte[] metadata)
			{
				int pos = 0;
				foreach (FieldMetadata field in fields)
				{
					field.Encode(ref pos, metadata);
				}
				return pos;
			}
		}

		private readonly Impl impl;

		private readonly FieldMetadata currentGroup;

		private int bufferedArrayFieldCount = int.MinValue;

		internal EventFieldTags Tags { get; set; }

		internal int ScratchSize => impl.scratchSize;

		internal int DataCount => impl.dataCount;

		internal int PinCount => impl.pinCount;

		private bool BeginningBufferedArray => bufferedArrayFieldCount == 0;

		internal TraceLoggingMetadataCollector()
		{
			impl = new Impl();
		}

		private TraceLoggingMetadataCollector(TraceLoggingMetadataCollector other, FieldMetadata group)
		{
			impl = other.impl;
			currentGroup = group;
		}

		public TraceLoggingMetadataCollector AddGroup(string name)
		{
			TraceLoggingMetadataCollector result = this;
			if (name != null || BeginningBufferedArray)
			{
				FieldMetadata fieldMetadata = new FieldMetadata(name, TraceLoggingDataType.Struct, Tags, BeginningBufferedArray);
				AddField(fieldMetadata);
				result = new TraceLoggingMetadataCollector(this, fieldMetadata);
			}
			return result;
		}

		public void AddScalar(string name, TraceLoggingDataType type)
		{
			int size;
			switch (type & (TraceLoggingDataType)31)
			{
			case TraceLoggingDataType.Int8:
			case TraceLoggingDataType.UInt8:
			case TraceLoggingDataType.Char8:
				size = 1;
				break;
			case TraceLoggingDataType.Int16:
			case TraceLoggingDataType.UInt16:
			case TraceLoggingDataType.Char16:
				size = 2;
				break;
			case TraceLoggingDataType.Int32:
			case TraceLoggingDataType.UInt32:
			case TraceLoggingDataType.Float:
			case TraceLoggingDataType.Boolean32:
			case TraceLoggingDataType.HexInt32:
				size = 4;
				break;
			case TraceLoggingDataType.Int64:
			case TraceLoggingDataType.UInt64:
			case TraceLoggingDataType.Double:
			case TraceLoggingDataType.FileTime:
			case TraceLoggingDataType.HexInt64:
				size = 8;
				break;
			case TraceLoggingDataType.Guid:
			case TraceLoggingDataType.SystemTime:
				size = 16;
				break;
			default:
				throw new ArgumentOutOfRangeException("type");
			}
			impl.AddScalar(size);
			AddField(new FieldMetadata(name, type, Tags, BeginningBufferedArray));
		}

		public void AddNullTerminatedString(string name, TraceLoggingDataType type)
		{
			TraceLoggingDataType traceLoggingDataType = type & (TraceLoggingDataType)31;
			if (traceLoggingDataType != TraceLoggingDataType.Utf16String)
			{
				throw new ArgumentOutOfRangeException("type");
			}
			impl.AddNonscalar();
			AddField(new FieldMetadata(name, type, Tags, BeginningBufferedArray));
		}

		public void AddArray(string name, TraceLoggingDataType type)
		{
			switch (type & (TraceLoggingDataType)31)
			{
			default:
				throw new ArgumentOutOfRangeException("type");
			case TraceLoggingDataType.Int8:
			case TraceLoggingDataType.UInt8:
			case TraceLoggingDataType.Int16:
			case TraceLoggingDataType.UInt16:
			case TraceLoggingDataType.Int32:
			case TraceLoggingDataType.UInt32:
			case TraceLoggingDataType.Int64:
			case TraceLoggingDataType.UInt64:
			case TraceLoggingDataType.Float:
			case TraceLoggingDataType.Double:
			case TraceLoggingDataType.Boolean32:
			case TraceLoggingDataType.Guid:
			case TraceLoggingDataType.FileTime:
			case TraceLoggingDataType.HexInt32:
			case TraceLoggingDataType.HexInt64:
			case TraceLoggingDataType.Char8:
			case TraceLoggingDataType.Char16:
				if (BeginningBufferedArray)
				{
					throw new NotSupportedException(SR.EventSource_NotSupportedNestedArraysEnums);
				}
				impl.AddScalar(2);
				impl.AddNonscalar();
				AddField(new FieldMetadata(name, type, Tags, variableCount: true));
				break;
			}
		}

		public void BeginBufferedArray()
		{
			if (bufferedArrayFieldCount >= 0)
			{
				throw new NotSupportedException(SR.EventSource_NotSupportedNestedArraysEnums);
			}
			bufferedArrayFieldCount = 0;
			impl.BeginBuffered();
		}

		public void EndBufferedArray()
		{
			if (bufferedArrayFieldCount != 1)
			{
				throw new InvalidOperationException(SR.EventSource_IncorrentlyAuthoredTypeInfo);
			}
			bufferedArrayFieldCount = int.MinValue;
			impl.EndBuffered();
		}

		internal byte[] GetMetadata()
		{
			int num = impl.Encode(null);
			byte[] array = new byte[num];
			impl.Encode(array);
			return array;
		}

		private void AddField(FieldMetadata fieldMetadata)
		{
			Tags = EventFieldTags.None;
			bufferedArrayFieldCount++;
			impl.fields.Add(fieldMetadata);
			if (currentGroup != null)
			{
				currentGroup.IncrementStructFieldCount();
			}
		}
	}
	internal abstract class TraceLoggingTypeInfo
	{
		private readonly string name;

		private readonly EventKeywords keywords;

		private readonly EventLevel level = (EventLevel)(-1);

		private readonly EventOpcode opcode = (EventOpcode)(-1);

		private readonly EventTags tags;

		private readonly Type dataType;

		private readonly Func<object, PropertyValue> propertyValueFactory;

		[ThreadStatic]
		private static Dictionary<Type, TraceLoggingTypeInfo> threadCache;

		public string Name => name;

		public EventLevel Level => level;

		public EventOpcode Opcode => opcode;

		public EventKeywords Keywords => keywords;

		public EventTags Tags => tags;

		internal Type DataType => dataType;

		internal Func<object, PropertyValue> PropertyValueFactory => propertyValueFactory;

		internal TraceLoggingTypeInfo(Type dataType)
		{
			if (dataType == null)
			{
				throw new ArgumentNullException("dataType");
			}
			name = dataType.Name;
			this.dataType = dataType;
			propertyValueFactory = PropertyValue.GetFactory(dataType);
		}

		internal TraceLoggingTypeInfo(Type dataType, string name, EventLevel level, EventOpcode opcode, EventKeywords keywords, EventTags tags)
		{
			if (dataType == null)
			{
				throw new ArgumentNullException("dataType");
			}
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			Statics.CheckName(name);
			this.name = name;
			this.keywords = keywords;
			this.level = level;
			this.opcode = opcode;
			this.tags = tags;
			this.dataType = dataType;
			propertyValueFactory = PropertyValue.GetFactory(dataType);
		}

		public abstract void WriteMetadata(TraceLoggingMetadataCollector collector, string name, EventFieldFormat format);

		public abstract void WriteData(PropertyValue value);

		public virtual object GetData(object value)
		{
			return value;
		}

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		public static TraceLoggingTypeInfo GetInstance(Type type, List<Type> recursionCheck)
		{
			Dictionary<Type, TraceLoggingTypeInfo> dictionary = threadCache ?? (threadCache = new Dictionary<Type, TraceLoggingTypeInfo>());
			if (!dictionary.TryGetValue(type, out var value))
			{
				if (recursionCheck == null)
				{
					recursionCheck = new List<Type>();
				}
				int count = recursionCheck.Count;
				value = (dictionary[type] = Statics.CreateDefaultTypeInfo(type, recursionCheck));
				recursionCheck.RemoveRange(count, recursionCheck.Count - count);
			}
			return value;
		}
	}
	internal sealed class TypeAnalysis
	{
		internal readonly PropertyAnalysis[] properties;

		internal readonly string name;

		internal readonly EventKeywords keywords;

		internal readonly EventLevel level = (EventLevel)(-1);

		internal readonly EventOpcode opcode = (EventOpcode)(-1);

		internal readonly EventTags tags;

		[RequiresUnreferencedCode("EventSource WriteEvent will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
		public TypeAnalysis(Type dataType, EventDataAttribute eventAttrib, List<Type> recursionCheck)
		{
			List<PropertyAnalysis> list = new List<PropertyAnalysis>();
			PropertyInfo[] array = dataType.GetProperties();
			foreach (PropertyInfo propertyInfo in array)
			{
				if (!Statics.HasCustomAttribute(propertyInfo, typeof(EventIgnoreAttribute)) && propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0)
				{
					MethodInfo getMethod = propertyInfo.GetGetMethod();
					if (!(getMethod == null) && !getMethod.IsStatic && getMethod.IsPublic)
					{
						Type propertyType = propertyInfo.PropertyType;
						TraceLoggingTypeInfo instance = TraceLoggingTypeInfo.GetInstance(propertyType, recursionCheck);
						EventFieldAttribute customAttribute = Statics.GetCustomAttribute<EventFieldAttribute>(propertyInfo);
						string text = ((customAttribute != null && customAttribute.Name != null) ? customAttribute.Name : (Statics.ShouldOverrideFieldName(propertyInfo.Name) ? instance.Name : propertyInfo.Name));
						list.Add(new PropertyAnalysis(text, propertyInfo, instance, customAttribute));
					}
				}
			}
			properties = list.ToArray();
			PropertyAnalysis[] array2 = properties;
			foreach (PropertyAnalysis propertyAnalysis in array2)
			{
				TraceLoggingTypeInfo typeInfo = propertyAnalysis.typeInfo;
				level = (EventLevel)Statics.Combine((int)typeInfo.Level, (int)level);
				opcode = (EventOpcode)Statics.Combine((int)typeInfo.Opcode, (int)opcode);
				keywords |= typeInfo.Keywords;
				tags |= typeInfo.Tags;
			}
			if (eventAttrib != null)
			{
				level = (EventLevel)Statics.Combine((int)eventAttrib.Level, (int)level);
				opcode = (EventOpcode)Statics.Combine((int)eventAttrib.Opcode, (int)opcode);
				keywords |= eventAttrib.Keywords;
				tags |= eventAttrib.Tags;
				name = eventAttrib.Name;
			}
			if (name == null)
			{
				name = dataType.Name;
			}
		}
	}
	internal static class RuntimeEventSourceHelper
	{
		private static long s_prevProcUserTime;

		private static long s_prevProcKernelTime;

		private static long s_prevSystemUserTime;

		private static long s_prevSystemKernelTime;

		internal static int GetCpuUsage()
		{
			int result = 0;
			if (Interop.Kernel32.GetProcessTimes(Interop.Kernel32.GetCurrentProcess(), out var _, out var exit, out var kernel, out var user) && Interop.Kernel32.GetSystemTimes(out exit, out var kernel2, out var user2))
			{
				long num = user - s_prevProcUserTime + (kernel - s_prevProcKernelTime);
				long num2 = kernel2 - s_prevSystemUserTime + (user2 - s_prevSystemKernelTime);
				if (s_prevSystemUserTime != 0L && s_prevSystemKernelTime != 0L && num2 != 0L)
				{
					result = (int)(num * 100 / num2);
				}
				s_prevProcUserTime = user;
				s_prevProcKernelTime = kernel;
				s_prevSystemUserTime = kernel2;
				s_prevSystemKernelTime = user2;
			}
			return result;
		}
	}
}
namespace System.Collections
{
	internal sealed class EmptyReadOnlyDictionaryInternal : IDictionary, ICollection, IEnumerable
	{
		private sealed class NodeEnumerator : IDictionaryEnumerator, IEnumerator
		{
			public object Current
			{
				get
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
			}

			public object Key
			{
				get
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
			}

			public object Value
			{
				get
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
			}

			public DictionaryEntry Entry
			{
				get
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
				}
			}

			public bool MoveNext()
			{
				return false;
			}

			public void Reset()
			{
			}
		}

		public int Count => 0;

		public object SyncRoot => this;

		public bool IsSynchronized => false;

		public object this[object key]
		{
			get
			{
				if (key == null)
				{
					throw new ArgumentNullException("key", SR.ArgumentNull_Key);
				}
				return null;
			}
			set
			{
				if (key == null)
				{
					throw new ArgumentNullException("key", SR.ArgumentNull_Key);
				}
				if (!key.GetType().IsSerializable)
				{
					throw new ArgumentException(SR.Argument_NotSerializable, "key");
				}
				if (value != null && !value.GetType().IsSerializable)
				{
					throw new ArgumentException(SR.Argument_NotSerializable, "value");
				}
				throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
			}
		}

		public ICollection Keys => Array.Empty<object>();

		public ICollection Values => Array.Empty<object>();

		public bool IsReadOnly => true;

		public bool IsFixedSize => true;

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new NodeEnumerator();
		}

		public void CopyTo(Array array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (array.Rank != 1)
			{
				throw new ArgumentException(SR.Arg_RankMultiDimNotSupported);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (array.Length - index < Count)
			{
				throw new ArgumentException(SR.ArgumentOutOfRange_Index, "index");
			}
		}

		public bool Contains(object key)
		{
			return false;
		}

		public void Add(object key, object value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key", SR.ArgumentNull_Key);
			}
			if (!key.GetType().IsSerializable)
			{
				throw new ArgumentException(SR.Argument_NotSerializable, "key");
			}
			if (value != null && !value.GetType().IsSerializable)
			{
				throw new ArgumentException(SR.Argument_NotSerializable, "value");
			}
			throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
		}

		public void Clear()
		{
			throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new NodeEnumerator();
		}

		public void Remove(object key)
		{
			throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
		}
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(ArrayListDebugView))]
	[DebuggerDisplay("Count = {Count}")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ArrayList : IList, ICollection, IEnumerable, ICloneable
	{
		private sealed class IListWrapper : ArrayList
		{
			private sealed class IListWrapperEnumWrapper : IEnumerator, ICloneable
			{
				private IEnumerator _en;

				private int _remaining;

				private int _initialStartIndex;

				private int _initialCount;

				private bool _firstCall;

				public object Current
				{
					get
					{
						if (_firstCall)
						{
							throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
						}
						if (_remaining < 0)
						{
							throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
						}
						return _en.Current;
					}
				}

				internal IListWrapperEnumWrapper(IListWrapper listWrapper, int startIndex, int count)
				{
					_en = listWrapper.GetEnumerator();
					_initialStartIndex = startIndex;
					_initialCount = count;
					while (startIndex-- > 0 && _en.MoveNext())
					{
					}
					_remaining = count;
					_firstCall = true;
				}

				private IListWrapperEnumWrapper()
				{
				}

				public object Clone()
				{
					IListWrapperEnumWrapper listWrapperEnumWrapper = new IListWrapperEnumWrapper();
					listWrapperEnumWrapper._en = (IEnumerator)((ICloneable)_en).Clone();
					listWrapperEnumWrapper._initialStartIndex = _initialStartIndex;
					listWrapperEnumWrapper._initialCount = _initialCount;
					listWrapperEnumWrapper._remaining = _remaining;
					listWrapperEnumWrapper._firstCall = _firstCall;
					return listWrapperEnumWrapper;
				}

				public bool MoveNext()
				{
					if (_firstCall)
					{
						_firstCall = false;
						if (_remaining-- > 0)
						{
							return _en.MoveNext();
						}
						return false;
					}
					if (_remaining < 0)
					{
						return false;
					}
					if (_en.MoveNext())
					{
						return _remaining-- > 0;
					}
					return false;
				}

				public void Reset()
				{
					_en.Reset();
					int initialStartIndex = _initialStartIndex;
					while (initialStartIndex-- > 0 && _en.MoveNext())
					{
					}
					_remaining = _initialCount;
					_firstCall = true;
				}
			}

			private readonly IList _list;

			public override int Capacity
			{
				get
				{
					return _list.Count;
				}
				set
				{
					if (value < Count)
					{
						throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_SmallCapacity);
					}
				}
			}

			public override int Count => _list.Count;

			public override bool IsReadOnly => _list.IsReadOnly;

			public override bool IsFixedSize => _list.IsFixedSize;

			public override bool IsSynchronized => _list.IsSynchronized;

			public override object this[int index]
			{
				get
				{
					return _list[index];
				}
				set
				{
					_list[index] = value;
					_version++;
				}
			}

			public override object SyncRoot => _list.SyncRoot;

			internal IListWrapper(IList list)
			{
				_list = list;
				_version = 0;
			}

			public override int Add(object obj)
			{
				int result = _list.Add(obj);
				_version++;
				return result;
			}

			public override void AddRange(ICollection c)
			{
				InsertRange(Count, c);
			}

			public override int BinarySearch(int index, int count, object value, IComparer comparer)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				if (comparer == null)
				{
					comparer = Comparer.Default;
				}
				int num = index;
				int num2 = index + count - 1;
				while (num <= num2)
				{
					int num3 = (num + num2) / 2;
					int num4 = comparer.Compare(value, _list[num3]);
					if (num4 == 0)
					{
						return num3;
					}
					if (num4 < 0)
					{
						num2 = num3 - 1;
					}
					else
					{
						num = num3 + 1;
					}
				}
				return ~num;
			}

			public override void Clear()
			{
				if (_list.IsFixedSize)
				{
					throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
				}
				_list.Clear();
				_version++;
			}

			public override object Clone()
			{
				return new IListWrapper(_list);
			}

			public override bool Contains(object obj)
			{
				return _list.Contains(obj);
			}

			public override void CopyTo(Array array, int index)
			{
				_list.CopyTo(array, index);
			}

			public override void CopyTo(int index, Array array, int arrayIndex, int count)
			{
				if (array == null)
				{
					throw new ArgumentNullException("array");
				}
				if (index < 0 || arrayIndex < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "arrayIndex", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (count < 0)
				{
					throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (array.Length - arrayIndex < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				if (array.Rank != 1)
				{
					throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
				}
				if (_list.Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				for (int i = index; i < index + count; i++)
				{
					array.SetValue(_list[i], arrayIndex++);
				}
			}

			public override IEnumerator GetEnumerator()
			{
				return _list.GetEnumerator();
			}

			public override IEnumerator GetEnumerator(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_list.Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				return new IListWrapperEnumWrapper(this, index, count);
			}

			public override int IndexOf(object value)
			{
				return _list.IndexOf(value);
			}

			public override int IndexOf(object value, int startIndex)
			{
				return IndexOf(value, startIndex, _list.Count - startIndex);
			}

			public override int IndexOf(object value, int startIndex, int count)
			{
				if (startIndex < 0 || startIndex > Count)
				{
					throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
				}
				if (count < 0 || startIndex > Count - count)
				{
					throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Count);
				}
				int num = startIndex + count;
				if (value == null)
				{
					for (int i = startIndex; i < num; i++)
					{
						if (_list[i] == null)
						{
							return i;
						}
					}
					return -1;
				}
				for (int j = startIndex; j < num; j++)
				{
					object obj = _list[j];
					if (obj != null && obj.Equals(value))
					{
						return j;
					}
				}
				return -1;
			}

			public override void Insert(int index, object obj)
			{
				_list.Insert(index, obj);
				_version++;
			}

			public override void InsertRange(int index, ICollection c)
			{
				if (c == null)
				{
					throw new ArgumentNullException("c", SR.ArgumentNull_Collection);
				}
				if (index < 0 || index > Count)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
				}
				if (c.Count <= 0)
				{
					return;
				}
				if (_list is ArrayList arrayList)
				{
					arrayList.InsertRange(index, c);
				}
				else
				{
					IEnumerator enumerator = c.GetEnumerator();
					while (enumerator.MoveNext())
					{
						_list.Insert(index++, enumerator.Current);
					}
				}
				_version++;
			}

			public override int LastIndexOf(object value)
			{
				return LastIndexOf(value, _list.Count - 1, _list.Count);
			}

			public override int LastIndexOf(object value, int startIndex)
			{
				return LastIndexOf(value, startIndex, startIndex + 1);
			}

			public override int LastIndexOf(object value, int startIndex, int count)
			{
				if (_list.Count == 0)
				{
					return -1;
				}
				if (startIndex < 0 || startIndex >= _list.Count)
				{
					throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
				}
				if (count < 0 || count > startIndex + 1)
				{
					throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Count);
				}
				int num = startIndex - count + 1;
				if (value == null)
				{
					for (int num2 = startIndex; num2 >= num; num2--)
					{
						if (_list[num2] == null)
						{
							return num2;
						}
					}
					return -1;
				}
				for (int num3 = startIndex; num3 >= num; num3--)
				{
					object obj = _list[num3];
					if (obj != null && obj.Equals(value))
					{
						return num3;
					}
				}
				return -1;
			}

			public override void Remove(object value)
			{
				int num = IndexOf(value);
				if (num >= 0)
				{
					RemoveAt(num);
				}
			}

			public override void RemoveAt(int index)
			{
				_list.RemoveAt(index);
				_version++;
			}

			public override void RemoveRange(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_list.Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				if (count > 0)
				{
					_version++;
				}
				while (count > 0)
				{
					_list.RemoveAt(index);
					count--;
				}
			}

			public override void Reverse(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_list.Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				int num = index;
				int num2 = index + count - 1;
				while (num < num2)
				{
					object value = _list[num];
					_list[num++] = _list[num2];
					_list[num2--] = value;
				}
				_version++;
			}

			public override void SetRange(int index, ICollection c)
			{
				if (c == null)
				{
					throw new ArgumentNullException("c", SR.ArgumentNull_Collection);
				}
				if (index < 0 || index > _list.Count - c.Count)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
				}
				if (c.Count > 0)
				{
					IEnumerator enumerator = c.GetEnumerator();
					while (enumerator.MoveNext())
					{
						_list[index++] = enumerator.Current;
					}
					_version++;
				}
			}

			public override ArrayList GetRange(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_list.Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				return new Range(this, index, count);
			}

			public override void Sort(int index, int count, IComparer comparer)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_list.Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				object[] array = new object[count];
				CopyTo(index, array, 0, count);
				Array.Sort(array, 0, count, comparer);
				for (int i = 0; i < count; i++)
				{
					_list[i + index] = array[i];
				}
				_version++;
			}

			public override object[] ToArray()
			{
				if (Count == 0)
				{
					return Array.Empty<object>();
				}
				object[] array = new object[Count];
				_list.CopyTo(array, 0);
				return array;
			}

			public override Array ToArray(Type type)
			{
				if (type == null)
				{
					throw new ArgumentNullException("type");
				}
				Array array = Array.CreateInstance(type, _list.Count);
				_list.CopyTo(array, 0);
				return array;
			}

			public override void TrimToSize()
			{
			}
		}

		private sealed class SyncArrayList : ArrayList
		{
			private readonly ArrayList _list;

			private readonly object _root;

			public override int Capacity
			{
				get
				{
					lock (_root)
					{
						return _list.Capacity;
					}
				}
				set
				{
					lock (_root)
					{
						_list.Capacity = value;
					}
				}
			}

			public override int Count
			{
				get
				{
					lock (_root)
					{
						return _list.Count;
					}
				}
			}

			public override bool IsReadOnly => _list.IsReadOnly;

			public override bool IsFixedSize => _list.IsFixedSize;

			public override bool IsSynchronized => true;

			public override object this[int index]
			{
				get
				{
					lock (_root)
					{
						return _list[index];
					}
				}
				set
				{
					lock (_root)
					{
						_list[index] = value;
					}
				}
			}

			public override object SyncRoot => _root;

			internal SyncArrayList(ArrayList list)
			{
				_list = list;
				_root = list.SyncRoot;
			}

			public override int Add(object value)
			{
				lock (_root)
				{
					return _list.Add(value);
				}
			}

			public override void AddRange(ICollection c)
			{
				lock (_root)
				{
					_list.AddRange(c);
				}
			}

			public override int BinarySearch(object value)
			{
				lock (_root)
				{
					return _list.BinarySearch(value);
				}
			}

			public override int BinarySearch(object value, IComparer comparer)
			{
				lock (_root)
				{
					return _list.BinarySearch(value, comparer);
				}
			}

			public override int BinarySearch(int index, int count, object value, IComparer comparer)
			{
				lock (_root)
				{
					return _list.BinarySearch(index, count, value, comparer);
				}
			}

			public override void Clear()
			{
				lock (_root)
				{
					_list.Clear();
				}
			}

			public override object Clone()
			{
				lock (_root)
				{
					return new SyncArrayList((ArrayList)_list.Clone());
				}
			}

			public override bool Contains(object item)
			{
				lock (_root)
				{
					return _list.Contains(item);
				}
			}

			public override void CopyTo(Array array)
			{
				lock (_root)
				{
					_list.CopyTo(array);
				}
			}

			public override void CopyTo(Array array, int index)
			{
				lock (_root)
				{
					_list.CopyTo(array, index);
				}
			}

			public override void CopyTo(int index, Array array, int arrayIndex, int count)
			{
				lock (_root)
				{
					_list.CopyTo(index, array, arrayIndex, count);
				}
			}

			public override IEnumerator GetEnumerator()
			{
				lock (_root)
				{
					return _list.GetEnumerator();
				}
			}

			public override IEnumerator GetEnumerator(int index, int count)
			{
				lock (_root)
				{
					return _list.GetEnumerator(index, count);
				}
			}

			public override int IndexOf(object value)
			{
				lock (_root)
				{
					return _list.IndexOf(value);
				}
			}

			public override int IndexOf(object value, int startIndex)
			{
				lock (_root)
				{
					return _list.IndexOf(value, startIndex);
				}
			}

			public override int IndexOf(object value, int startIndex, int count)
			{
				lock (_root)
				{
					return _list.IndexOf(value, startIndex, count);
				}
			}

			public override void Insert(int index, object value)
			{
				lock (_root)
				{
					_list.Insert(index, value);
				}
			}

			public override void InsertRange(int index, ICollection c)
			{
				lock (_root)
				{
					_list.InsertRange(index, c);
				}
			}

			public override int LastIndexOf(object value)
			{
				lock (_root)
				{
					return _list.LastIndexOf(value);
				}
			}

			public override int LastIndexOf(object value, int startIndex)
			{
				lock (_root)
				{
					return _list.LastIndexOf(value, startIndex);
				}
			}

			public override int LastIndexOf(object value, int startIndex, int count)
			{
				lock (_root)
				{
					return _list.LastIndexOf(value, startIndex, count);
				}
			}

			public override void Remove(object value)
			{
				lock (_root)
				{
					_list.Remove(value);
				}
			}

			public override void RemoveAt(int index)
			{
				lock (_root)
				{
					_list.RemoveAt(index);
				}
			}

			public override void RemoveRange(int index, int count)
			{
				lock (_root)
				{
					_list.RemoveRange(index, count);
				}
			}

			public override void Reverse(int index, int count)
			{
				lock (_root)
				{
					_list.Reverse(index, count);
				}
			}

			public override void SetRange(int index, ICollection c)
			{
				lock (_root)
				{
					_list.SetRange(index, c);
				}
			}

			public override ArrayList GetRange(int index, int count)
			{
				lock (_root)
				{
					return _list.GetRange(index, count);
				}
			}

			public override void Sort()
			{
				lock (_root)
				{
					_list.Sort();
				}
			}

			public override void Sort(IComparer comparer)
			{
				lock (_root)
				{
					_list.Sort(comparer);
				}
			}

			public override void Sort(int index, int count, IComparer comparer)
			{
				lock (_root)
				{
					_list.Sort(index, count, comparer);
				}
			}

			public override object[] ToArray()
			{
				lock (_root)
				{
					return _list.ToArray();
				}
			}

			public override Array ToArray(Type type)
			{
				lock (_root)
				{
					return _list.ToArray(type);
				}
			}

			public override void TrimToSize()
			{
				lock (_root)
				{
					_list.TrimToSize();
				}
			}
		}

		private sealed class SyncIList : IList, ICollection, IEnumerable
		{
			private readonly IList _list;

			private readonly object _root;

			public int Count
			{
				get
				{
					lock (_root)
					{
						return _list.Count;
					}
				}
			}

			public bool IsReadOnly => _list.IsReadOnly;

			public bool IsFixedSize => _list.IsFixedSize;

			public bool IsSynchronized => true;

			public object this[int index]
			{
				get
				{
					lock (_root)
					{
						return _list[index];
					}
				}
				set
				{
					lock (_root)
					{
						_list[index] = value;
					}
				}
			}

			public object SyncRoot => _root;

			internal SyncIList(IList list)
			{
				_list = list;
				_root = list.SyncRoot;
			}

			public int Add(object value)
			{
				lock (_root)
				{
					return _list.Add(value);
				}
			}

			public void Clear()
			{
				lock (_root)
				{
					_list.Clear();
				}
			}

			public bool Contains(object item)
			{
				lock (_root)
				{
					return _list.Contains(item);
				}
			}

			public void CopyTo(Array array, int index)
			{
				lock (_root)
				{
					_list.CopyTo(array, index);
				}
			}

			public IEnumerator GetEnumerator()
			{
				lock (_root)
				{
					return _list.GetEnumerator();
				}
			}

			public int IndexOf(object value)
			{
				lock (_root)
				{
					return _list.IndexOf(value);
				}
			}

			public void Insert(int index, object value)
			{
				lock (_root)
				{
					_list.Insert(index, value);
				}
			}

			public void Remove(object value)
			{
				lock (_root)
				{
					_list.Remove(value);
				}
			}

			public void RemoveAt(int index)
			{
				lock (_root)
				{
					_list.RemoveAt(index);
				}
			}
		}

		private sealed class FixedSizeList : IList, ICollection, IEnumerable
		{
			private readonly IList _list;

			public int Count => _list.Count;

			public bool IsReadOnly => _list.IsReadOnly;

			public bool IsFixedSize => true;

			public bool IsSynchronized => _list.IsSynchronized;

			public object this[int index]
			{
				get
				{
					return _list[index];
				}
				set
				{
					_list[index] = value;
				}
			}

			public object SyncRoot => _list.SyncRoot;

			internal FixedSizeList(IList l)
			{
				_list = l;
			}

			public int Add(object obj)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public void Clear()
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public bool Contains(object obj)
			{
				return _list.Contains(obj);
			}

			public void CopyTo(Array array, int index)
			{
				_list.CopyTo(array, index);
			}

			public IEnumerator GetEnumerator()
			{
				return _list.GetEnumerator();
			}

			public int IndexOf(object value)
			{
				return _list.IndexOf(value);
			}

			public void Insert(int index, object obj)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public void Remove(object value)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public void RemoveAt(int index)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}
		}

		private sealed class FixedSizeArrayList : ArrayList
		{
			private ArrayList _list;

			public override int Count => _list.Count;

			public override bool IsReadOnly => _list.IsReadOnly;

			public override bool IsFixedSize => true;

			public override bool IsSynchronized => _list.IsSynchronized;

			public override object this[int index]
			{
				get
				{
					return _list[index];
				}
				set
				{
					_list[index] = value;
					_version = _list._version;
				}
			}

			public override object SyncRoot => _list.SyncRoot;

			public override int Capacity
			{
				get
				{
					return _list.Capacity;
				}
				set
				{
					throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
				}
			}

			internal FixedSizeArrayList(ArrayList l)
			{
				_list = l;
				_version = _list._version;
			}

			public override int Add(object obj)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public override void AddRange(ICollection c)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public override int BinarySearch(int index, int count, object value, IComparer comparer)
			{
				return _list.BinarySearch(index, count, value, comparer);
			}

			public override void Clear()
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public override object Clone()
			{
				FixedSizeArrayList fixedSizeArrayList = new FixedSizeArrayList(_list);
				fixedSizeArrayList._list = (ArrayList)_list.Clone();
				return fixedSizeArrayList;
			}

			public override bool Contains(object obj)
			{
				return _list.Contains(obj);
			}

			public override void CopyTo(Array array, int index)
			{
				_list.CopyTo(array, index);
			}

			public override void CopyTo(int index, Array array, int arrayIndex, int count)
			{
				_list.CopyTo(index, array, arrayIndex, count);
			}

			public override IEnumerator GetEnumerator()
			{
				return _list.GetEnumerator();
			}

			public override IEnumerator GetEnumerator(int index, int count)
			{
				return _list.GetEnumerator(index, count);
			}

			public override int IndexOf(object value)
			{
				return _list.IndexOf(value);
			}

			public override int IndexOf(object value, int startIndex)
			{
				return _list.IndexOf(value, startIndex);
			}

			public override int IndexOf(object value, int startIndex, int count)
			{
				return _list.IndexOf(value, startIndex, count);
			}

			public override void Insert(int index, object obj)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public override void InsertRange(int index, ICollection c)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public override int LastIndexOf(object value)
			{
				return _list.LastIndexOf(value);
			}

			public override int LastIndexOf(object value, int startIndex)
			{
				return _list.LastIndexOf(value, startIndex);
			}

			public override int LastIndexOf(object value, int startIndex, int count)
			{
				return _list.LastIndexOf(value, startIndex, count);
			}

			public override void Remove(object value)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public override void RemoveAt(int index)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public override void RemoveRange(int index, int count)
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}

			public override void SetRange(int index, ICollection c)
			{
				_list.SetRange(index, c);
				_version = _list._version;
			}

			public override ArrayList GetRange(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				return new Range(this, index, count);
			}

			public override void Reverse(int index, int count)
			{
				_list.Reverse(index, count);
				_version = _list._version;
			}

			public override void Sort(int index, int count, IComparer comparer)
			{
				_list.Sort(index, count, comparer);
				_version = _list._version;
			}

			public override object[] ToArray()
			{
				return _list.ToArray();
			}

			public override Array ToArray(Type type)
			{
				return _list.ToArray(type);
			}

			public override void TrimToSize()
			{
				throw new NotSupportedException(SR.NotSupported_FixedSizeCollection);
			}
		}

		private sealed class ReadOnlyList : IList, ICollection, IEnumerable
		{
			private readonly IList _list;

			public int Count => _list.Count;

			public bool IsReadOnly => true;

			public bool IsFixedSize => true;

			public bool IsSynchronized => _list.IsSynchronized;

			public object this[int index]
			{
				get
				{
					return _list[index];
				}
				set
				{
					throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
				}
			}

			public object SyncRoot => _list.SyncRoot;

			internal ReadOnlyList(IList l)
			{
				_list = l;
			}

			public int Add(object obj)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public void Clear()
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public bool Contains(object obj)
			{
				return _list.Contains(obj);
			}

			public void CopyTo(Array array, int index)
			{
				_list.CopyTo(array, index);
			}

			public IEnumerator GetEnumerator()
			{
				return _list.GetEnumerator();
			}

			public int IndexOf(object value)
			{
				return _list.IndexOf(value);
			}

			public void Insert(int index, object obj)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public void Remove(object value)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public void RemoveAt(int index)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}
		}

		private sealed class ReadOnlyArrayList : ArrayList
		{
			private ArrayList _list;

			public override int Count => _list.Count;

			public override bool IsReadOnly => true;

			public override bool IsFixedSize => true;

			public override bool IsSynchronized => _list.IsSynchronized;

			public override object this[int index]
			{
				get
				{
					return _list[index];
				}
				set
				{
					throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
				}
			}

			public override object SyncRoot => _list.SyncRoot;

			public override int Capacity
			{
				get
				{
					return _list.Capacity;
				}
				set
				{
					throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
				}
			}

			internal ReadOnlyArrayList(ArrayList l)
			{
				_list = l;
			}

			public override int Add(object obj)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override void AddRange(ICollection c)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override int BinarySearch(int index, int count, object value, IComparer comparer)
			{
				return _list.BinarySearch(index, count, value, comparer);
			}

			public override void Clear()
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override object Clone()
			{
				ReadOnlyArrayList readOnlyArrayList = new ReadOnlyArrayList(_list);
				readOnlyArrayList._list = (ArrayList)_list.Clone();
				return readOnlyArrayList;
			}

			public override bool Contains(object obj)
			{
				return _list.Contains(obj);
			}

			public override void CopyTo(Array array, int index)
			{
				_list.CopyTo(array, index);
			}

			public override void CopyTo(int index, Array array, int arrayIndex, int count)
			{
				_list.CopyTo(index, array, arrayIndex, count);
			}

			public override IEnumerator GetEnumerator()
			{
				return _list.GetEnumerator();
			}

			public override IEnumerator GetEnumerator(int index, int count)
			{
				return _list.GetEnumerator(index, count);
			}

			public override int IndexOf(object value)
			{
				return _list.IndexOf(value);
			}

			public override int IndexOf(object value, int startIndex)
			{
				return _list.IndexOf(value, startIndex);
			}

			public override int IndexOf(object value, int startIndex, int count)
			{
				return _list.IndexOf(value, startIndex, count);
			}

			public override void Insert(int index, object obj)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override void InsertRange(int index, ICollection c)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override int LastIndexOf(object value)
			{
				return _list.LastIndexOf(value);
			}

			public override int LastIndexOf(object value, int startIndex)
			{
				return _list.LastIndexOf(value, startIndex);
			}

			public override int LastIndexOf(object value, int startIndex, int count)
			{
				return _list.LastIndexOf(value, startIndex, count);
			}

			public override void Remove(object value)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override void RemoveAt(int index)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override void RemoveRange(int index, int count)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override void SetRange(int index, ICollection c)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override ArrayList GetRange(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (Count - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				return new Range(this, index, count);
			}

			public override void Reverse(int index, int count)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override void Sort(int index, int count, IComparer comparer)
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}

			public override object[] ToArray()
			{
				return _list.ToArray();
			}

			public override Array ToArray(Type type)
			{
				return _list.ToArray(type);
			}

			public override void TrimToSize()
			{
				throw new NotSupportedException(SR.NotSupported_ReadOnlyCollection);
			}
		}

		private sealed class ArrayListEnumerator : IEnumerator, ICloneable
		{
			private readonly ArrayList _list;

			private int _index;

			private readonly int _endIndex;

			private readonly int _version;

			private object _currentElement;

			private readonly int _startIndex;

			public object Current
			{
				get
				{
					if (_index < _startIndex)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
					}
					if (_index > _endIndex)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
					}
					return _currentElement;
				}
			}

			internal ArrayListEnumerator(ArrayList list, int index, int count)
			{
				_list = list;
				_startIndex = index;
				_index = index - 1;
				_endIndex = _index + count;
				_version = list._version;
				_currentElement = null;
			}

			public object Clone()
			{
				return MemberwiseClone();
			}

			public bool MoveNext()
			{
				if (_version != _list._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				if (_index < _endIndex)
				{
					_currentElement = _list[++_index];
					return true;
				}
				_index = _endIndex + 1;
				return false;
			}

			public void Reset()
			{
				if (_version != _list._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				_index = _startIndex - 1;
			}
		}

		private sealed class Range : ArrayList
		{
			private ArrayList _baseList;

			private readonly int _baseIndex;

			private int _baseSize;

			private int _baseVersion;

			public override int Capacity
			{
				get
				{
					return _baseList.Capacity;
				}
				set
				{
					if (value < Count)
					{
						throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_SmallCapacity);
					}
				}
			}

			public override int Count
			{
				get
				{
					InternalUpdateRange();
					return _baseSize;
				}
			}

			public override bool IsReadOnly => _baseList.IsReadOnly;

			public override bool IsFixedSize => _baseList.IsFixedSize;

			public override bool IsSynchronized => _baseList.IsSynchronized;

			public override object SyncRoot => _baseList.SyncRoot;

			public override object this[int index]
			{
				get
				{
					InternalUpdateRange();
					if (index < 0 || index >= _baseSize)
					{
						throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
					}
					return _baseList[_baseIndex + index];
				}
				set
				{
					InternalUpdateRange();
					if (index < 0 || index >= _baseSize)
					{
						throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
					}
					_baseList[_baseIndex + index] = value;
					InternalUpdateVersion();
				}
			}

			internal Range(ArrayList list, int index, int count)
			{
				_baseList = list;
				_baseIndex = index;
				_baseSize = count;
				_baseVersion = list._version;
				_version = list._version;
			}

			private void InternalUpdateRange()
			{
				if (_baseVersion != _baseList._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_UnderlyingArrayListChanged);
				}
			}

			private void InternalUpdateVersion()
			{
				_baseVersion++;
				_version++;
			}

			public override int Add(object value)
			{
				InternalUpdateRange();
				_baseList.Insert(_baseIndex + _baseSize, value);
				InternalUpdateVersion();
				return _baseSize++;
			}

			public override void AddRange(ICollection c)
			{
				if (c == null)
				{
					throw new ArgumentNullException("c");
				}
				InternalUpdateRange();
				int count = c.Count;
				if (count > 0)
				{
					_baseList.InsertRange(_baseIndex + _baseSize, c);
					InternalUpdateVersion();
					_baseSize += count;
				}
			}

			public override int BinarySearch(int index, int count, object value, IComparer comparer)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_baseSize - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				InternalUpdateRange();
				int num = _baseList.BinarySearch(_baseIndex + index, count, value, comparer);
				if (num >= 0)
				{
					return num - _baseIndex;
				}
				return num + _baseIndex;
			}

			public override void Clear()
			{
				InternalUpdateRange();
				if (_baseSize != 0)
				{
					_baseList.RemoveRange(_baseIndex, _baseSize);
					InternalUpdateVersion();
					_baseSize = 0;
				}
			}

			public override object Clone()
			{
				InternalUpdateRange();
				Range range = new Range(_baseList, _baseIndex, _baseSize);
				range._baseList = (ArrayList)_baseList.Clone();
				return range;
			}

			public override bool Contains(object item)
			{
				InternalUpdateRange();
				if (item == null)
				{
					for (int i = 0; i < _baseSize; i++)
					{
						if (_baseList[_baseIndex + i] == null)
						{
							return true;
						}
					}
					return false;
				}
				for (int j = 0; j < _baseSize; j++)
				{
					object obj = _baseList[_baseIndex + j];
					if (obj != null && obj.Equals(item))
					{
						return true;
					}
				}
				return false;
			}

			public override void CopyTo(Array array, int index)
			{
				if (array == null)
				{
					throw new ArgumentNullException("array");
				}
				if (array.Rank != 1)
				{
					throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
				}
				if (index < 0)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (array.Length - index < _baseSize)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				InternalUpdateRange();
				_baseList.CopyTo(_baseIndex, array, index, _baseSize);
			}

			public override void CopyTo(int index, Array array, int arrayIndex, int count)
			{
				if (array == null)
				{
					throw new ArgumentNullException("array");
				}
				if (array.Rank != 1)
				{
					throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
				}
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (array.Length - arrayIndex < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				if (_baseSize - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				InternalUpdateRange();
				_baseList.CopyTo(_baseIndex + index, array, arrayIndex, count);
			}

			public override IEnumerator GetEnumerator()
			{
				return GetEnumerator(0, _baseSize);
			}

			public override IEnumerator GetEnumerator(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_baseSize - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				InternalUpdateRange();
				return _baseList.GetEnumerator(_baseIndex + index, count);
			}

			public override ArrayList GetRange(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_baseSize - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				InternalUpdateRange();
				return new Range(this, index, count);
			}

			public override int IndexOf(object value)
			{
				InternalUpdateRange();
				int num = _baseList.IndexOf(value, _baseIndex, _baseSize);
				if (num >= 0)
				{
					return num - _baseIndex;
				}
				return -1;
			}

			public override int IndexOf(object value, int startIndex)
			{
				if (startIndex < 0)
				{
					throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (startIndex > _baseSize)
				{
					throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
				}
				InternalUpdateRange();
				int num = _baseList.IndexOf(value, _baseIndex + startIndex, _baseSize - startIndex);
				if (num >= 0)
				{
					return num - _baseIndex;
				}
				return -1;
			}

			public override int IndexOf(object value, int startIndex, int count)
			{
				if (startIndex < 0 || startIndex > _baseSize)
				{
					throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
				}
				if (count < 0 || startIndex > _baseSize - count)
				{
					throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Count);
				}
				InternalUpdateRange();
				int num = _baseList.IndexOf(value, _baseIndex + startIndex, count);
				if (num >= 0)
				{
					return num - _baseIndex;
				}
				return -1;
			}

			public override void Insert(int index, object value)
			{
				if (index < 0 || index > _baseSize)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
				}
				InternalUpdateRange();
				_baseList.Insert(_baseIndex + index, value);
				InternalUpdateVersion();
				_baseSize++;
			}

			public override void InsertRange(int index, ICollection c)
			{
				if (index < 0 || index > _baseSize)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
				}
				if (c == null)
				{
					throw new ArgumentNullException("c");
				}
				InternalUpdateRange();
				int count = c.Count;
				if (count > 0)
				{
					_baseList.InsertRange(_baseIndex + index, c);
					_baseSize += count;
					InternalUpdateVersion();
				}
			}

			public override int LastIndexOf(object value)
			{
				InternalUpdateRange();
				int num = _baseList.LastIndexOf(value, _baseIndex + _baseSize - 1, _baseSize);
				if (num >= 0)
				{
					return num - _baseIndex;
				}
				return -1;
			}

			public override int LastIndexOf(object value, int startIndex)
			{
				return LastIndexOf(value, startIndex, startIndex + 1);
			}

			public override int LastIndexOf(object value, int startIndex, int count)
			{
				InternalUpdateRange();
				if (_baseSize == 0)
				{
					return -1;
				}
				if (startIndex >= _baseSize)
				{
					throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
				}
				if (startIndex < 0)
				{
					throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				int num = _baseList.LastIndexOf(value, _baseIndex + startIndex, count);
				if (num >= 0)
				{
					return num - _baseIndex;
				}
				return -1;
			}

			public override void RemoveAt(int index)
			{
				if (index < 0 || index >= _baseSize)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
				}
				InternalUpdateRange();
				_baseList.RemoveAt(_baseIndex + index);
				InternalUpdateVersion();
				_baseSize--;
			}

			public override void RemoveRange(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_baseSize - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				InternalUpdateRange();
				if (count > 0)
				{
					_baseList.RemoveRange(_baseIndex + index, count);
					InternalUpdateVersion();
					_baseSize -= count;
				}
			}

			public override void Reverse(int index, int count)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_baseSize - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				InternalUpdateRange();
				_baseList.Reverse(_baseIndex + index, count);
				InternalUpdateVersion();
			}

			public override void SetRange(int index, ICollection c)
			{
				InternalUpdateRange();
				if (index < 0 || index >= _baseSize)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
				}
				_baseList.SetRange(_baseIndex + index, c);
				if (c.Count > 0)
				{
					InternalUpdateVersion();
				}
			}

			public override void Sort(int index, int count, IComparer comparer)
			{
				if (index < 0 || count < 0)
				{
					throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (_baseSize - index < count)
				{
					throw new ArgumentException(SR.Argument_InvalidOffLen);
				}
				InternalUpdateRange();
				_baseList.Sort(_baseIndex + index, count, comparer);
				InternalUpdateVersion();
			}

			public override object[] ToArray()
			{
				InternalUpdateRange();
				if (_baseSize == 0)
				{
					return Array.Empty<object>();
				}
				object[] array = new object[_baseSize];
				_baseList.CopyTo(_baseIndex, array, 0, _baseSize);
				return array;
			}

			public override Array ToArray(Type type)
			{
				if (type == null)
				{
					throw new ArgumentNullException("type");
				}
				InternalUpdateRange();
				Array array = Array.CreateInstance(type, _baseSize);
				_baseList.CopyTo(_baseIndex, array, 0, _baseSize);
				return array;
			}

			public override void TrimToSize()
			{
				throw new NotSupportedException(SR.NotSupported_RangeCollection);
			}
		}

		private sealed class ArrayListEnumeratorSimple : IEnumerator, ICloneable
		{
			private readonly ArrayList _list;

			private int _index;

			private readonly int _version;

			private object _currentElement;

			private readonly bool _isArrayList;

			private static readonly object s_dummyObject = new object();

			public object Current
			{
				get
				{
					object currentElement = _currentElement;
					if (s_dummyObject == currentElement)
					{
						if (_index == -1)
						{
							throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
						}
						throw new InvalidOperationException(SR.InvalidOperation_EnumEnded);
					}
					return currentElement;
				}
			}

			internal ArrayListEnumeratorSimple(ArrayList list)
			{
				_list = list;
				_index = -1;
				_version = list._version;
				_isArrayList = list.GetType() == typeof(ArrayList);
				_currentElement = s_dummyObject;
			}

			public object Clone()
			{
				return MemberwiseClone();
			}

			public bool MoveNext()
			{
				if (_version != _list._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				if (_isArrayList)
				{
					if (_index < _list._size - 1)
					{
						_currentElement = _list._items[++_index];
						return true;
					}
					_currentElement = s_dummyObject;
					_index = _list._size;
					return false;
				}
				if (_index < _list.Count - 1)
				{
					_currentElement = _list[++_index];
					return true;
				}
				_index = _list.Count;
				_currentElement = s_dummyObject;
				return false;
			}

			public void Reset()
			{
				if (_version != _list._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				_currentElement = s_dummyObject;
				_index = -1;
			}
		}

		internal sealed class ArrayListDebugView
		{
			private readonly ArrayList _arrayList;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public object[] Items => _arrayList.ToArray();

			public ArrayListDebugView(ArrayList arrayList)
			{
				if (arrayList == null)
				{
					throw new ArgumentNullException("arrayList");
				}
				_arrayList = arrayList;
			}
		}

		private object[] _items;

		private int _size;

		private int _version;

		public virtual int Capacity
		{
			get
			{
				return _items.Length;
			}
			set
			{
				if (value < _size)
				{
					throw new ArgumentOutOfRangeException("value", SR.ArgumentOutOfRange_SmallCapacity);
				}
				if (value == _items.Length)
				{
					return;
				}
				if (value > 0)
				{
					object[] array = new object[value];
					if (_size > 0)
					{
						Array.Copy(_items, array, _size);
					}
					_items = array;
				}
				else
				{
					_items = new object[4];
				}
			}
		}

		public virtual int Count => _size;

		public virtual bool IsFixedSize => false;

		public virtual bool IsReadOnly => false;

		public virtual bool IsSynchronized => false;

		public virtual object SyncRoot => this;

		public virtual object? this[int index]
		{
			get
			{
				if (index < 0 || index >= _size)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
				}
				return _items[index];
			}
			set
			{
				if (index < 0 || index >= _size)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
				}
				_items[index] = value;
				_version++;
			}
		}

		public ArrayList()
		{
			_items = Array.Empty<object>();
		}

		public ArrayList(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.Format(SR.ArgumentOutOfRange_MustBeNonNegNum, "capacity"));
			}
			if (capacity == 0)
			{
				_items = Array.Empty<object>();
			}
			else
			{
				_items = new object[capacity];
			}
		}

		public ArrayList(ICollection c)
		{
			if (c == null)
			{
				throw new ArgumentNullException("c", SR.ArgumentNull_Collection);
			}
			int count = c.Count;
			if (count == 0)
			{
				_items = Array.Empty<object>();
				return;
			}
			_items = new object[count];
			AddRange(c);
		}

		public static ArrayList Adapter(IList list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			return new IListWrapper(list);
		}

		public virtual int Add(object? value)
		{
			if (_size == _items.Length)
			{
				EnsureCapacity(_size + 1);
			}
			_items[_size] = value;
			_version++;
			return _size++;
		}

		public virtual void AddRange(ICollection c)
		{
			InsertRange(_size, c);
		}

		public virtual int BinarySearch(int index, int count, object? value, IComparer? comparer)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			return Array.BinarySearch(_items, index, count, value, comparer);
		}

		public virtual int BinarySearch(object? value)
		{
			return BinarySearch(0, Count, value, null);
		}

		public virtual int BinarySearch(object? value, IComparer? comparer)
		{
			return BinarySearch(0, Count, value, comparer);
		}

		public virtual void Clear()
		{
			if (_size > 0)
			{
				Array.Clear(_items, 0, _size);
				_size = 0;
			}
			_version++;
		}

		public virtual object Clone()
		{
			ArrayList arrayList = new ArrayList(_size);
			arrayList._size = _size;
			arrayList._version = _version;
			Array.Copy(_items, arrayList._items, _size);
			return arrayList;
		}

		public virtual bool Contains(object? item)
		{
			if (item == null)
			{
				for (int i = 0; i < _size; i++)
				{
					if (_items[i] == null)
					{
						return true;
					}
				}
				return false;
			}
			for (int j = 0; j < _size; j++)
			{
				object obj = _items[j];
				if (obj != null && obj.Equals(item))
				{
					return true;
				}
			}
			return false;
		}

		public virtual void CopyTo(Array array)
		{
			CopyTo(array, 0);
		}

		public virtual void CopyTo(Array array, int arrayIndex)
		{
			if (array != null && array.Rank != 1)
			{
				throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
			}
			Array.Copy(_items, 0, array, arrayIndex, _size);
		}

		public virtual void CopyTo(int index, Array array, int arrayIndex, int count)
		{
			if (_size - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (array != null && array.Rank != 1)
			{
				throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
			}
			Array.Copy(_items, index, array, arrayIndex, count);
		}

		private void EnsureCapacity(int min)
		{
			if (_items.Length < min)
			{
				int num = ((_items.Length == 0) ? 4 : (_items.Length * 2));
				if ((uint)num > Array.MaxLength)
				{
					num = Array.MaxLength;
				}
				if (num < min)
				{
					num = min;
				}
				Capacity = num;
			}
		}

		public static IList FixedSize(IList list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			return new FixedSizeList(list);
		}

		public static ArrayList FixedSize(ArrayList list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			return new FixedSizeArrayList(list);
		}

		public virtual IEnumerator GetEnumerator()
		{
			return new ArrayListEnumeratorSimple(this);
		}

		public virtual IEnumerator GetEnumerator(int index, int count)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			return new ArrayListEnumerator(this, index, count);
		}

		public virtual int IndexOf(object? value)
		{
			return Array.IndexOf(_items, value, 0, _size);
		}

		public virtual int IndexOf(object? value, int startIndex)
		{
			if (startIndex > _size)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			return Array.IndexOf(_items, value, startIndex, _size - startIndex);
		}

		public virtual int IndexOf(object? value, int startIndex, int count)
		{
			if (startIndex > _size)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			if (count < 0 || startIndex > _size - count)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_Count);
			}
			return Array.IndexOf(_items, value, startIndex, count);
		}

		public virtual void Insert(int index, object? value)
		{
			if (index < 0 || index > _size)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (_size == _items.Length)
			{
				EnsureCapacity(_size + 1);
			}
			if (index < _size)
			{
				Array.Copy(_items, index, _items, index + 1, _size - index);
			}
			_items[index] = value;
			_size++;
			_version++;
		}

		public virtual void InsertRange(int index, ICollection c)
		{
			if (c == null)
			{
				throw new ArgumentNullException("c", SR.ArgumentNull_Collection);
			}
			if (index < 0 || index > _size)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			int count = c.Count;
			if (count > 0)
			{
				EnsureCapacity(_size + count);
				if (index < _size)
				{
					Array.Copy(_items, index, _items, index + count, _size - index);
				}
				object[] array = new object[count];
				c.CopyTo(array, 0);
				array.CopyTo(_items, index);
				_size += count;
				_version++;
			}
		}

		public virtual int LastIndexOf(object? value)
		{
			return LastIndexOf(value, _size - 1, _size);
		}

		public virtual int LastIndexOf(object? value, int startIndex)
		{
			if (startIndex >= _size)
			{
				throw new ArgumentOutOfRangeException("startIndex", SR.ArgumentOutOfRange_Index);
			}
			return LastIndexOf(value, startIndex, startIndex + 1);
		}

		public virtual int LastIndexOf(object? value, int startIndex, int count)
		{
			if (Count != 0 && (startIndex < 0 || count < 0))
			{
				throw new ArgumentOutOfRangeException((startIndex < 0) ? "startIndex" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size == 0)
			{
				return -1;
			}
			if (startIndex >= _size || count > startIndex + 1)
			{
				throw new ArgumentOutOfRangeException((startIndex >= _size) ? "startIndex" : "count", SR.ArgumentOutOfRange_BiggerThanCollection);
			}
			return Array.LastIndexOf(_items, value, startIndex, count);
		}

		public static IList ReadOnly(IList list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			return new ReadOnlyList(list);
		}

		public static ArrayList ReadOnly(ArrayList list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			return new ReadOnlyArrayList(list);
		}

		public virtual void Remove(object? obj)
		{
			int num = IndexOf(obj);
			if (num >= 0)
			{
				RemoveAt(num);
			}
		}

		public virtual void RemoveAt(int index)
		{
			if (index < 0 || index >= _size)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			_size--;
			if (index < _size)
			{
				Array.Copy(_items, index + 1, _items, index, _size - index);
			}
			_items[_size] = null;
			_version++;
		}

		public virtual void RemoveRange(int index, int count)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			if (count > 0)
			{
				int num = _size;
				_size -= count;
				if (index < _size)
				{
					Array.Copy(_items, index + count, _items, index, _size - index);
				}
				while (num > _size)
				{
					_items[--num] = null;
				}
				_version++;
			}
		}

		public static ArrayList Repeat(object? value, int count)
		{
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			ArrayList arrayList = new ArrayList((count > 4) ? count : 4);
			for (int i = 0; i < count; i++)
			{
				arrayList.Add(value);
			}
			return arrayList;
		}

		public virtual void Reverse()
		{
			Reverse(0, Count);
		}

		public virtual void Reverse(int index, int count)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			Array.Reverse(_items, index, count);
			_version++;
		}

		public virtual void SetRange(int index, ICollection c)
		{
			if (c == null)
			{
				throw new ArgumentNullException("c", SR.ArgumentNull_Collection);
			}
			int count = c.Count;
			if (index < 0 || index > _size - count)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_Index);
			}
			if (count > 0)
			{
				c.CopyTo(_items, index);
				_version++;
			}
		}

		public virtual ArrayList GetRange(int index, int count)
		{
			if (index < 0 || count < 0)
			{
				throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			return new Range(this, index, count);
		}

		public virtual void Sort()
		{
			Sort(0, Count, Comparer.Default);
		}

		public virtual void Sort(IComparer? comparer)
		{
			Sort(0, Count, comparer);
		}

		public virtual void Sort(int index, int count, IComparer? comparer)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			Array.Sort(_items, index, count, comparer);
			_version++;
		}

		public static IList Synchronized(IList list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			return new SyncIList(list);
		}

		public static ArrayList Synchronized(ArrayList list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			return new SyncArrayList(list);
		}

		public virtual object?[] ToArray()
		{
			if (_size == 0)
			{
				return Array.Empty<object>();
			}
			object[] array = new object[_size];
			Array.Copy(_items, array, _size);
			return array;
		}

		public virtual Array ToArray(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			Array array = Array.CreateInstance(type, _size);
			Array.Copy(_items, array, _size);
			return array;
		}

		public virtual void TrimToSize()
		{
			Capacity = _size;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class Comparer : IComparer, ISerializable
	{
		private readonly CompareInfo _compareInfo;

		public static readonly Comparer Default = new Comparer(CultureInfo.CurrentCulture);

		public static readonly Comparer DefaultInvariant = new Comparer(CultureInfo.InvariantCulture);

		public Comparer(CultureInfo culture)
		{
			if (culture == null)
			{
				throw new ArgumentNullException("culture");
			}
			_compareInfo = culture.CompareInfo;
		}

		private Comparer(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			_compareInfo = (CompareInfo)info.GetValue("CompareInfo", typeof(CompareInfo));
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			info.AddValue("CompareInfo", _compareInfo);
		}

		public int Compare(object? a, object? b)
		{
			if (a == b)
			{
				return 0;
			}
			if (a == null)
			{
				return -1;
			}
			if (b == null)
			{
				return 1;
			}
			if (a is string @string && b is string string2)
			{
				return _compareInfo.Compare(@string, string2);
			}
			if (a is IComparable comparable)
			{
				return comparable.CompareTo(b);
			}
			if (b is IComparable comparable2)
			{
				return -comparable2.CompareTo(a);
			}
			throw new ArgumentException(SR.Argument_ImplementIComparable);
		}
	}
	internal sealed class CompatibleComparer : IEqualityComparer
	{
		private readonly IHashCodeProvider _hcp;

		private readonly IComparer _comparer;

		internal IHashCodeProvider HashCodeProvider => _hcp;

		internal IComparer Comparer => _comparer;

		internal CompatibleComparer(IHashCodeProvider hashCodeProvider, IComparer comparer)
		{
			_hcp = hashCodeProvider;
			_comparer = comparer;
		}

		public new bool Equals(object a, object b)
		{
			return Compare(a, b) == 0;
		}

		public int Compare(object a, object b)
		{
			if (a == b)
			{
				return 0;
			}
			if (a == null)
			{
				return -1;
			}
			if (b == null)
			{
				return 1;
			}
			if (_comparer != null)
			{
				return _comparer.Compare(a, b);
			}
			if (a is IComparable comparable)
			{
				return comparable.CompareTo(b);
			}
			throw new ArgumentException(SR.Argument_ImplementIComparable);
		}

		public int GetHashCode(object obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			if (_hcp == null)
			{
				return obj.GetHashCode();
			}
			return _hcp.GetHashCode(obj);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public struct DictionaryEntry
	{
		private object _key;

		private object _value;

		public object Key
		{
			get
			{
				return _key;
			}
			set
			{
				_key = value;
			}
		}

		public object? Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
			}
		}

		public DictionaryEntry(object key, object? value)
		{
			_key = key;
			_value = value;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public void Deconstruct(out object key, out object? value)
		{
			key = Key;
			value = Value;
		}
	}
	internal static class HashHelpers
	{
		private static readonly int[] s_primes = new int[72]
		{
			3, 7, 11, 17, 23, 29, 37, 47, 59, 71,
			89, 107, 131, 163, 197, 239, 293, 353, 431, 521,
			631, 761, 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371,
			4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591, 17519, 21023,
			25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363,
			156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403,
			968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559,
			5999471, 7199369
		};

		private static ConditionalWeakTable<object, SerializationInfo> s_serializationInfoTable;

		public static ConditionalWeakTable<object, SerializationInfo> SerializationInfoTable
		{
			get
			{
				if (s_serializationInfoTable == null)
				{
					Interlocked.CompareExchange(ref s_serializationInfoTable, new ConditionalWeakTable<object, SerializationInfo>(), null);
				}
				return s_serializationInfoTable;
			}
		}

		public static bool IsPrime(int candidate)
		{
			if (((uint)candidate & (true ? 1u : 0u)) != 0)
			{
				int num = (int)Math.Sqrt(candidate);
				for (int i = 3; i <= num; i += 2)
				{
					if (candidate % i == 0)
					{
						return false;
					}
				}
				return true;
			}
			return candidate == 2;
		}

		public static int GetPrime(int min)
		{
			if (min < 0)
			{
				throw new ArgumentException(SR.Arg_HTCapacityOverflow);
			}
			int[] array = s_primes;
			foreach (int num in array)
			{
				if (num >= min)
				{
					return num;
				}
			}
			for (int j = min | 1; j < int.MaxValue; j += 2)
			{
				if (IsPrime(j) && (j - 1) % 101 != 0)
				{
					return j;
				}
			}
			return min;
		}

		public static int ExpandPrime(int oldSize)
		{
			int num = 2 * oldSize;
			if ((uint)num > 2147483587u && 2147483587 > oldSize)
			{
				return 2147483587;
			}
			return GetPrime(num);
		}
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(HashtableDebugView))]
	[DebuggerDisplay("Count = {Count}")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Hashtable : IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback, ICloneable
	{
		private struct bucket
		{
			public object key;

			public object val;

			public int hash_coll;
		}

		private sealed class KeyCollection : ICollection, IEnumerable
		{
			private readonly Hashtable _hashtable;

			public bool IsSynchronized => _hashtable.IsSynchronized;

			public object SyncRoot => _hashtable.SyncRoot;

			public int Count => _hashtable._count;

			internal KeyCollection(Hashtable hashtable)
			{
				_hashtable = hashtable;
			}

			public void CopyTo(Array array, int arrayIndex)
			{
				if (array == null)
				{
					throw new ArgumentNullException("array");
				}
				if (array.Rank != 1)
				{
					throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
				}
				if (arrayIndex < 0)
				{
					throw new ArgumentOutOfRangeException("arrayIndex", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (array.Length - arrayIndex < _hashtable._count)
				{
					throw new ArgumentException(SR.Arg_ArrayPlusOffTooSmall);
				}
				_hashtable.CopyKeys(array, arrayIndex);
			}

			public IEnumerator GetEnumerator()
			{
				return new HashtableEnumerator(_hashtable, 1);
			}
		}

		private sealed class ValueCollection : ICollection, IEnumerable
		{
			private readonly Hashtable _hashtable;

			public bool IsSynchronized => _hashtable.IsSynchronized;

			public object SyncRoot => _hashtable.SyncRoot;

			public int Count => _hashtable._count;

			internal ValueCollection(Hashtable hashtable)
			{
				_hashtable = hashtable;
			}

			public void CopyTo(Array array, int arrayIndex)
			{
				if (array == null)
				{
					throw new ArgumentNullException("array");
				}
				if (array.Rank != 1)
				{
					throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
				}
				if (arrayIndex < 0)
				{
					throw new ArgumentOutOfRangeException("arrayIndex", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (array.Length - arrayIndex < _hashtable._count)
				{
					throw new ArgumentException(SR.Arg_ArrayPlusOffTooSmall);
				}
				_hashtable.CopyValues(array, arrayIndex);
			}

			public IEnumerator GetEnumerator()
			{
				return new HashtableEnumerator(_hashtable, 2);
			}
		}

		private sealed class SyncHashtable : Hashtable, IEnumerable
		{
			private Hashtable _table;

			public override int Count => _table.Count;

			public override bool IsReadOnly => _table.IsReadOnly;

			public override bool IsFixedSize => _table.IsFixedSize;

			public override bool IsSynchronized => true;

			public override object this[object key]
			{
				get
				{
					return _table[key];
				}
				set
				{
					lock (_table.SyncRoot)
					{
						_table[key] = value;
					}
				}
			}

			public override object SyncRoot => _table.SyncRoot;

			public override ICollection Keys
			{
				get
				{
					lock (_table.SyncRoot)
					{
						return _table.Keys;
					}
				}
			}

			public override ICollection Values
			{
				get
				{
					lock (_table.SyncRoot)
					{
						return _table.Values;
					}
				}
			}

			internal SyncHashtable(Hashtable table)
				: base(trash: false)
			{
				_table = table;
			}

			internal SyncHashtable(SerializationInfo info, StreamingContext context)
				: base(info, context)
			{
				throw new PlatformNotSupportedException();
			}

			public override void GetObjectData(SerializationInfo info, StreamingContext context)
			{
				throw new PlatformNotSupportedException();
			}

			public override void Add(object key, object value)
			{
				lock (_table.SyncRoot)
				{
					_table.Add(key, value);
				}
			}

			public override void Clear()
			{
				lock (_table.SyncRoot)
				{
					_table.Clear();
				}
			}

			public override bool Contains(object key)
			{
				return _table.Contains(key);
			}

			public override bool ContainsKey(object key)
			{
				if (key == null)
				{
					throw new ArgumentNullException("key", SR.ArgumentNull_Key);
				}
				return _table.ContainsKey(key);
			}

			public override bool ContainsValue(object key)
			{
				lock (_table.SyncRoot)
				{
					return _table.ContainsValue(key);
				}
			}

			public override void CopyTo(Array array, int arrayIndex)
			{
				lock (_table.SyncRoot)
				{
					_table.CopyTo(array, arrayIndex);
				}
			}

			public override object Clone()
			{
				lock (_table.SyncRoot)
				{
					return Synchronized((Hashtable)_table.Clone());
				}
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return _table.GetEnumerator();
			}

			public override IDictionaryEnumerator GetEnumerator()
			{
				return _table.GetEnumerator();
			}

			public override void Remove(object key)
			{
				lock (_table.SyncRoot)
				{
					_table.Remove(key);
				}
			}

			public override void OnDeserialization(object sender)
			{
			}

			internal override KeyValuePairs[] ToKeyValuePairsArray()
			{
				return _table.ToKeyValuePairsArray();
			}
		}

		private sealed class HashtableEnumerator : IDictionaryEnumerator, IEnumerator, ICloneable
		{
			private readonly Hashtable _hashtable;

			private int _bucket;

			private readonly int _version;

			private bool _current;

			private readonly int _getObjectRetType;

			private object _currentKey;

			private object _currentValue;

			public object Key
			{
				get
				{
					if (!_current)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumNotStarted);
					}
					return _currentKey;
				}
			}

			public DictionaryEntry Entry
			{
				get
				{
					if (!_current)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
					}
					return new DictionaryEntry(_currentKey, _currentValue);
				}
			}

			public object Current
			{
				get
				{
					if (!_current)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
					}
					if (_getObjectRetType == 1)
					{
						return _currentKey;
					}
					if (_getObjectRetType == 2)
					{
						return _currentValue;
					}
					return new DictionaryEntry(_currentKey, _currentValue);
				}
			}

			public object Value
			{
				get
				{
					if (!_current)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
					}
					return _currentValue;
				}
			}

			internal HashtableEnumerator(Hashtable hashtable, int getObjRetType)
			{
				_hashtable = hashtable;
				_bucket = hashtable._buckets.Length;
				_version = hashtable._version;
				_current = false;
				_getObjectRetType = getObjRetType;
			}

			public object Clone()
			{
				return MemberwiseClone();
			}

			public bool MoveNext()
			{
				if (_version != _hashtable._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				while (_bucket > 0)
				{
					_bucket--;
					object key = _hashtable._buckets[_bucket].key;
					if (key != null && key != _hashtable._buckets)
					{
						_currentKey = key;
						_currentValue = _hashtable._buckets[_bucket].val;
						_current = true;
						return true;
					}
				}
				_current = false;
				return false;
			}

			public void Reset()
			{
				if (_version != _hashtable._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				_current = false;
				_bucket = _hashtable._buckets.Length;
				_currentKey = null;
				_currentValue = null;
			}
		}

		internal sealed class HashtableDebugView
		{
			private readonly Hashtable _hashtable;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public KeyValuePairs[] Items => _hashtable.ToKeyValuePairsArray();

			public HashtableDebugView(Hashtable hashtable)
			{
				if (hashtable == null)
				{
					throw new ArgumentNullException("hashtable");
				}
				_hashtable = hashtable;
			}
		}

		private bucket[] _buckets;

		private int _count;

		private int _occupancy;

		private int _loadsize;

		private float _loadFactor;

		private volatile int _version;

		private volatile bool _isWriterInProgress;

		private ICollection _keys;

		private ICollection _values;

		private IEqualityComparer _keycomparer;

		[Obsolete("Hashtable.hcp has been deprecated. Use the EqualityComparer property instead.")]
		protected IHashCodeProvider? hcp
		{
			get
			{
				if (_keycomparer is CompatibleComparer)
				{
					return ((CompatibleComparer)_keycomparer).HashCodeProvider;
				}
				if (_keycomparer == null)
				{
					return null;
				}
				throw new ArgumentException(SR.Arg_CannotMixComparisonInfrastructure);
			}
			set
			{
				if (_keycomparer is CompatibleComparer compatibleComparer)
				{
					_keycomparer = new CompatibleComparer(value, compatibleComparer.Comparer);
					return;
				}
				if (_keycomparer == null)
				{
					_keycomparer = new CompatibleComparer(value, null);
					return;
				}
				throw new ArgumentException(SR.Arg_CannotMixComparisonInfrastructure);
			}
		}

		[Obsolete("Hashtable.comparer has been deprecated. Use the KeyComparer properties instead.")]
		protected IComparer? comparer
		{
			get
			{
				if (_keycomparer is CompatibleComparer)
				{
					return ((CompatibleComparer)_keycomparer).Comparer;
				}
				if (_keycomparer == null)
				{
					return null;
				}
				throw new ArgumentException(SR.Arg_CannotMixComparisonInfrastructure);
			}
			set
			{
				if (_keycomparer is CompatibleComparer compatibleComparer)
				{
					_keycomparer = new CompatibleComparer(compatibleComparer.HashCodeProvider, value);
					return;
				}
				if (_keycomparer == null)
				{
					_keycomparer = new CompatibleComparer(null, value);
					return;
				}
				throw new ArgumentException(SR.Arg_CannotMixComparisonInfrastructure);
			}
		}

		protected IEqualityComparer? EqualityComparer => _keycomparer;

		public virtual object? this[object key]
		{
			get
			{
				if (key == null)
				{
					throw new ArgumentNullException("key", SR.ArgumentNull_Key);
				}
				bucket[] buckets = _buckets;
				uint seed;
				uint incr;
				uint num = InitHash(key, buckets.Length, out seed, out incr);
				int num2 = 0;
				int num3 = (int)(seed % (uint)buckets.Length);
				bucket bucket;
				do
				{
					SpinWait spinWait = default(SpinWait);
					while (true)
					{
						int version = _version;
						bucket = buckets[num3];
						if (!_isWriterInProgress && version == _version)
						{
							break;
						}
						spinWait.SpinOnce();
					}
					if (bucket.key == null)
					{
						return null;
					}
					if ((bucket.hash_coll & 0x7FFFFFFF) == num && KeyEquals(bucket.key, key))
					{
						return bucket.val;
					}
					num3 = (int)((num3 + incr) % (uint)buckets.Length);
				}
				while (bucket.hash_coll < 0 && ++num2 < buckets.Length);
				return null;
			}
			set
			{
				Insert(key, value, add: false);
			}
		}

		public virtual bool IsReadOnly => false;

		public virtual bool IsFixedSize => false;

		public virtual bool IsSynchronized => false;

		public virtual ICollection Keys => _keys ?? (_keys = new KeyCollection(this));

		public virtual ICollection Values => _values ?? (_values = new ValueCollection(this));

		public virtual object SyncRoot => this;

		public virtual int Count => _count;

		internal Hashtable(bool trash)
		{
		}

		public Hashtable()
			: this(0, 1f)
		{
		}

		public Hashtable(int capacity)
			: this(capacity, 1f)
		{
		}

		public Hashtable(int capacity, float loadFactor)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (!(loadFactor >= 0.1f) || !(loadFactor <= 1f))
			{
				throw new ArgumentOutOfRangeException("loadFactor", SR.Format(SR.ArgumentOutOfRange_HashtableLoadFactor, 0.1, 1.0));
			}
			_loadFactor = 0.72f * loadFactor;
			double num = (float)capacity / _loadFactor;
			if (num > 2147483647.0)
			{
				throw new ArgumentException(SR.Arg_HTCapacityOverflow, "capacity");
			}
			int num2 = ((num > 3.0) ? HashHelpers.GetPrime((int)num) : 3);
			_buckets = new bucket[num2];
			_loadsize = (int)(_loadFactor * (float)num2);
			_isWriterInProgress = false;
		}

		public Hashtable(int capacity, float loadFactor, IEqualityComparer? equalityComparer)
			: this(capacity, loadFactor)
		{
			_keycomparer = equalityComparer;
		}

		[Obsolete("This constructor has been deprecated. Use Hashtable(IEqualityComparer) instead.")]
		public Hashtable(IHashCodeProvider? hcp, IComparer? comparer)
			: this(0, 1f, hcp, comparer)
		{
		}

		public Hashtable(IEqualityComparer? equalityComparer)
			: this(0, 1f, equalityComparer)
		{
		}

		[Obsolete("This constructor has been deprecated. Use Hashtable(int, IEqualityComparer) instead.")]
		public Hashtable(int capacity, IHashCodeProvider? hcp, IComparer? comparer)
			: this(capacity, 1f, hcp, comparer)
		{
		}

		public Hashtable(int capacity, IEqualityComparer? equalityComparer)
			: this(capacity, 1f, equalityComparer)
		{
		}

		public Hashtable(IDictionary d)
			: this(d, 1f)
		{
		}

		public Hashtable(IDictionary d, float loadFactor)
			: this(d, loadFactor, null)
		{
		}

		[Obsolete("This constructor has been deprecated. Use Hashtable(IDictionary, IEqualityComparer) instead.")]
		public Hashtable(IDictionary d, IHashCodeProvider? hcp, IComparer? comparer)
			: this(d, 1f, hcp, comparer)
		{
		}

		public Hashtable(IDictionary d, IEqualityComparer? equalityComparer)
			: this(d, 1f, equalityComparer)
		{
		}

		[Obsolete("This constructor has been deprecated. Use Hashtable(int, float, IEqualityComparer) instead.")]
		public Hashtable(int capacity, float loadFactor, IHashCodeProvider? hcp, IComparer? comparer)
			: this(capacity, loadFactor)
		{
			if (hcp != null || comparer != null)
			{
				_keycomparer = new CompatibleComparer(hcp, comparer);
			}
		}

		[Obsolete("This constructor has been deprecated. Use Hashtable(IDictionary, float, IEqualityComparer) instead.")]
		public Hashtable(IDictionary d, float loadFactor, IHashCodeProvider? hcp, IComparer? comparer)
			: this(d?.Count ?? 0, loadFactor, hcp, comparer)
		{
			if (d == null)
			{
				throw new ArgumentNullException("d", SR.ArgumentNull_Dictionary);
			}
			IDictionaryEnumerator enumerator = d.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Add(enumerator.Key, enumerator.Value);
			}
		}

		public Hashtable(IDictionary d, float loadFactor, IEqualityComparer? equalityComparer)
			: this(d?.Count ?? 0, loadFactor, equalityComparer)
		{
			if (d == null)
			{
				throw new ArgumentNullException("d", SR.ArgumentNull_Dictionary);
			}
			IDictionaryEnumerator enumerator = d.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Add(enumerator.Key, enumerator.Value);
			}
		}

		protected Hashtable(SerializationInfo info, StreamingContext context)
		{
			HashHelpers.SerializationInfoTable.Add(this, info);
		}

		private uint InitHash(object key, int hashsize, out uint seed, out uint incr)
		{
			uint result = (seed = (uint)GetHash(key) & 0x7FFFFFFFu);
			incr = 1 + seed * 101 % (uint)(hashsize - 1);
			return result;
		}

		public virtual void Add(object key, object? value)
		{
			Insert(key, value, add: true);
		}

		public virtual void Clear()
		{
			if (_count != 0 || _occupancy != 0)
			{
				_isWriterInProgress = true;
				for (int i = 0; i < _buckets.Length; i++)
				{
					_buckets[i].hash_coll = 0;
					_buckets[i].key = null;
					_buckets[i].val = null;
				}
				_count = 0;
				_occupancy = 0;
				UpdateVersion();
				_isWriterInProgress = false;
			}
		}

		public virtual object Clone()
		{
			bucket[] buckets = _buckets;
			Hashtable hashtable = new Hashtable(_count, _keycomparer);
			hashtable._version = _version;
			hashtable._loadFactor = _loadFactor;
			hashtable._count = 0;
			int num = buckets.Length;
			while (num > 0)
			{
				num--;
				object key = buckets[num].key;
				if (key != null && key != buckets)
				{
					hashtable[key] = buckets[num].val;
				}
			}
			return hashtable;
		}

		public virtual bool Contains(object key)
		{
			return ContainsKey(key);
		}

		public virtual bool ContainsKey(object key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key", SR.ArgumentNull_Key);
			}
			bucket[] buckets = _buckets;
			uint seed;
			uint incr;
			uint num = InitHash(key, buckets.Length, out seed, out incr);
			int num2 = 0;
			int num3 = (int)(seed % (uint)buckets.Length);
			bucket bucket;
			do
			{
				bucket = buckets[num3];
				if (bucket.key == null)
				{
					return false;
				}
				if ((bucket.hash_coll & 0x7FFFFFFF) == num && KeyEquals(bucket.key, key))
				{
					return true;
				}
				num3 = (int)((num3 + incr) % (uint)buckets.Length);
			}
			while (bucket.hash_coll < 0 && ++num2 < buckets.Length);
			return false;
		}

		public virtual bool ContainsValue(object? value)
		{
			if (value == null)
			{
				int num = _buckets.Length;
				while (--num >= 0)
				{
					if (_buckets[num].key != null && _buckets[num].key != _buckets && _buckets[num].val == null)
					{
						return true;
					}
				}
			}
			else
			{
				int num2 = _buckets.Length;
				while (--num2 >= 0)
				{
					object val = _buckets[num2].val;
					if (val != null && val.Equals(value))
					{
						return true;
					}
				}
			}
			return false;
		}

		private void CopyKeys(Array array, int arrayIndex)
		{
			bucket[] buckets = _buckets;
			int num = buckets.Length;
			while (--num >= 0)
			{
				object key = buckets[num].key;
				if (key != null && key != _buckets)
				{
					array.SetValue(key, arrayIndex++);
				}
			}
		}

		private void CopyEntries(Array array, int arrayIndex)
		{
			bucket[] buckets = _buckets;
			int num = buckets.Length;
			while (--num >= 0)
			{
				object key = buckets[num].key;
				if (key != null && key != _buckets)
				{
					DictionaryEntry dictionaryEntry = new DictionaryEntry(key, buckets[num].val);
					array.SetValue(dictionaryEntry, arrayIndex++);
				}
			}
		}

		public virtual void CopyTo(Array array, int arrayIndex)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array", SR.ArgumentNull_Array);
			}
			if (array.Rank != 1)
			{
				throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
			}
			if (arrayIndex < 0)
			{
				throw new ArgumentOutOfRangeException("arrayIndex", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (array.Length - arrayIndex < Count)
			{
				throw new ArgumentException(SR.Arg_ArrayPlusOffTooSmall);
			}
			CopyEntries(array, arrayIndex);
		}

		internal virtual KeyValuePairs[] ToKeyValuePairsArray()
		{
			KeyValuePairs[] array = new KeyValuePairs[_count];
			int num = 0;
			bucket[] buckets = _buckets;
			int num2 = buckets.Length;
			while (--num2 >= 0)
			{
				object key = buckets[num2].key;
				if (key != null && key != _buckets)
				{
					array[num++] = new KeyValuePairs(key, buckets[num2].val);
				}
			}
			return array;
		}

		private void CopyValues(Array array, int arrayIndex)
		{
			bucket[] buckets = _buckets;
			int num = buckets.Length;
			while (--num >= 0)
			{
				object key = buckets[num].key;
				if (key != null && key != _buckets)
				{
					array.SetValue(buckets[num].val, arrayIndex++);
				}
			}
		}

		private void expand()
		{
			int newsize = HashHelpers.ExpandPrime(_buckets.Length);
			rehash(newsize);
		}

		private void rehash()
		{
			rehash(_buckets.Length);
		}

		private void UpdateVersion()
		{
			_version++;
		}

		private void rehash(int newsize)
		{
			_occupancy = 0;
			bucket[] array = new bucket[newsize];
			for (int i = 0; i < _buckets.Length; i++)
			{
				bucket bucket = _buckets[i];
				if (bucket.key != null && bucket.key != _buckets)
				{
					int hashcode = bucket.hash_coll & 0x7FFFFFFF;
					putEntry(array, bucket.key, bucket.val, hashcode);
				}
			}
			_isWriterInProgress = true;
			_buckets = array;
			_loadsize = (int)(_loadFactor * (float)newsize);
			UpdateVersion();
			_isWriterInProgress = false;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new HashtableEnumerator(this, 3);
		}

		public virtual IDictionaryEnumerator GetEnumerator()
		{
			return new HashtableEnumerator(this, 3);
		}

		protected virtual int GetHash(object key)
		{
			if (_keycomparer != null)
			{
				return _keycomparer.GetHashCode(key);
			}
			return key.GetHashCode();
		}

		protected virtual bool KeyEquals(object? item, object key)
		{
			if (_buckets == item)
			{
				return false;
			}
			if (item == key)
			{
				return true;
			}
			if (_keycomparer != null)
			{
				return _keycomparer.Equals(item, key);
			}
			return item?.Equals(key) ?? false;
		}

		private void Insert(object key, object nvalue, bool add)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key", SR.ArgumentNull_Key);
			}
			if (_count >= _loadsize)
			{
				expand();
			}
			else if (_occupancy > _loadsize && _count > 100)
			{
				rehash();
			}
			uint seed;
			uint incr;
			uint num = InitHash(key, _buckets.Length, out seed, out incr);
			int num2 = 0;
			int num3 = -1;
			int num4 = (int)(seed % (uint)_buckets.Length);
			do
			{
				if (num3 == -1 && _buckets[num4].key == _buckets && _buckets[num4].hash_coll < 0)
				{
					num3 = num4;
				}
				if (_buckets[num4].key == null || (_buckets[num4].key == _buckets && (_buckets[num4].hash_coll & 0x80000000u) == 0L))
				{
					if (num3 != -1)
					{
						num4 = num3;
					}
					_isWriterInProgress = true;
					_buckets[num4].val = nvalue;
					_buckets[num4].key = key;
					_buckets[num4].hash_coll |= (int)num;
					_count++;
					UpdateVersion();
					_isWriterInProgress = false;
					return;
				}
				if ((_buckets[num4].hash_coll & 0x7FFFFFFF) == num && KeyEquals(_buckets[num4].key, key))
				{
					if (add)
					{
						throw new ArgumentException(SR.Format(SR.Argument_AddingDuplicate__, _buckets[num4].key, key));
					}
					_isWriterInProgress = true;
					_buckets[num4].val = nvalue;
					UpdateVersion();
					_isWriterInProgress = false;
					return;
				}
				if (num3 == -1 && _buckets[num4].hash_coll >= 0)
				{
					_buckets[num4].hash_coll |= int.MinValue;
					_occupancy++;
				}
				num4 = (int)((num4 + incr) % (uint)_buckets.Length);
			}
			while (++num2 < _buckets.Length);
			if (num3 != -1)
			{
				_isWriterInProgress = true;
				_buckets[num3].val = nvalue;
				_buckets[num3].key = key;
				_buckets[num3].hash_coll |= (int)num;
				_count++;
				UpdateVersion();
				_isWriterInProgress = false;
				return;
			}
			throw new InvalidOperationException(SR.InvalidOperation_HashInsertFailed);
		}

		private void putEntry(bucket[] newBuckets, object key, object nvalue, int hashcode)
		{
			uint num = 1 + (uint)(hashcode * 101) % (uint)(newBuckets.Length - 1);
			int num2 = (int)((uint)hashcode % (uint)newBuckets.Length);
			while (newBuckets[num2].key != null && newBuckets[num2].key != _buckets)
			{
				if (newBuckets[num2].hash_coll >= 0)
				{
					newBuckets[num2].hash_coll |= int.MinValue;
					_occupancy++;
				}
				num2 = (int)((num2 + num) % (uint)newBuckets.Length);
			}
			newBuckets[num2].val = nvalue;
			newBuckets[num2].key = key;
			newBuckets[num2].hash_coll |= hashcode;
		}

		public virtual void Remove(object key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key", SR.ArgumentNull_Key);
			}
			uint seed;
			uint incr;
			uint num = InitHash(key, _buckets.Length, out seed, out incr);
			int num2 = 0;
			int num3 = (int)(seed % (uint)_buckets.Length);
			bucket bucket;
			do
			{
				bucket = _buckets[num3];
				if ((bucket.hash_coll & 0x7FFFFFFF) == num && KeyEquals(bucket.key, key))
				{
					_isWriterInProgress = true;
					_buckets[num3].hash_coll &= int.MinValue;
					if (_buckets[num3].hash_coll != 0)
					{
						_buckets[num3].key = _buckets;
					}
					else
					{
						_buckets[num3].key = null;
					}
					_buckets[num3].val = null;
					_count--;
					UpdateVersion();
					_isWriterInProgress = false;
					break;
				}
				num3 = (int)((num3 + incr) % (uint)_buckets.Length);
			}
			while (bucket.hash_coll < 0 && ++num2 < _buckets.Length);
		}

		public static Hashtable Synchronized(Hashtable table)
		{
			if (table == null)
			{
				throw new ArgumentNullException("table");
			}
			return new SyncHashtable(table);
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			lock (SyncRoot)
			{
				int version = _version;
				info.AddValue("LoadFactor", _loadFactor);
				info.AddValue("Version", _version);
				IEqualityComparer keycomparer = _keycomparer;
				if (keycomparer == null)
				{
					info.AddValue("Comparer", null, typeof(IComparer));
					info.AddValue("HashCodeProvider", null, typeof(IHashCodeProvider));
				}
				else if (keycomparer is CompatibleComparer)
				{
					CompatibleComparer compatibleComparer = keycomparer as CompatibleComparer;
					info.AddValue("Comparer", compatibleComparer.Comparer, typeof(IComparer));
					info.AddValue("HashCodeProvider", compatibleComparer.HashCodeProvider, typeof(IHashCodeProvider));
				}
				else
				{
					info.AddValue("KeyComparer", keycomparer, typeof(IEqualityComparer));
				}
				info.AddValue("HashSize", _buckets.Length);
				object[] array = new object[_count];
				object[] array2 = new object[_count];
				CopyKeys(array, 0);
				CopyValues(array2, 0);
				info.AddValue("Keys", array, typeof(object[]));
				info.AddValue("Values", array2, typeof(object[]));
				if (_version != version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
			}
		}

		public virtual void OnDeserialization(object? sender)
		{
			if (_buckets != null)
			{
				return;
			}
			HashHelpers.SerializationInfoTable.TryGetValue(this, out var value);
			if (value == null)
			{
				throw new SerializationException(SR.Serialization_InvalidOnDeser);
			}
			int num = 0;
			IComparer comparer = null;
			IHashCodeProvider hashCodeProvider = null;
			object[] array = null;
			object[] array2 = null;
			SerializationInfoEnumerator enumerator = value.GetEnumerator();
			while (enumerator.MoveNext())
			{
				switch (enumerator.Name)
				{
				case "LoadFactor":
					_loadFactor = value.GetSingle("LoadFactor");
					break;
				case "HashSize":
					num = value.GetInt32("HashSize");
					break;
				case "KeyComparer":
					_keycomparer = (IEqualityComparer)value.GetValue("KeyComparer", typeof(IEqualityComparer));
					break;
				case "Comparer":
					comparer = (IComparer)value.GetValue("Comparer", typeof(IComparer));
					break;
				case "HashCodeProvider":
					hashCodeProvider = (IHashCodeProvider)value.GetValue("HashCodeProvider", typeof(IHashCodeProvider));
					break;
				case "Keys":
					array = (object[])value.GetValue("Keys", typeof(object[]));
					break;
				case "Values":
					array2 = (object[])value.GetValue("Values", typeof(object[]));
					break;
				}
			}
			_loadsize = (int)(_loadFactor * (float)num);
			if (_keycomparer == null && (comparer != null || hashCodeProvider != null))
			{
				_keycomparer = new CompatibleComparer(hashCodeProvider, comparer);
			}
			_buckets = new bucket[num];
			if (array == null)
			{
				throw new SerializationException(SR.Serialization_MissingKeys);
			}
			if (array2 == null)
			{
				throw new SerializationException(SR.Serialization_MissingValues);
			}
			if (array.Length != array2.Length)
			{
				throw new SerializationException(SR.Serialization_KeyValueDifferentSizes);
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] == null)
				{
					throw new SerializationException(SR.Serialization_NullKey);
				}
				Insert(array[i], array2[i], add: true);
			}
			_version = value.GetInt32("Version");
			HashHelpers.SerializationInfoTable.Remove(this);
		}
	}
	public interface ICollection : IEnumerable
	{
		int Count { get; }

		object SyncRoot { get; }

		bool IsSynchronized { get; }

		void CopyTo(Array array, int index);
	}
	public interface IComparer
	{
		int Compare(object? x, object? y);
	}
	public interface IDictionary : ICollection, IEnumerable
	{
		object? this[object key] { get; set; }

		ICollection Keys { get; }

		ICollection Values { get; }

		bool IsReadOnly { get; }

		bool IsFixedSize { get; }

		bool Contains(object key);

		void Add(object key, object? value);

		void Clear();

		new IDictionaryEnumerator GetEnumerator();

		void Remove(object key);
	}
	public interface IDictionaryEnumerator : IEnumerator
	{
		object Key { get; }

		object? Value { get; }

		DictionaryEntry Entry { get; }
	}
	[Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
	[ComVisible(true)]
	public interface IEnumerable
	{
		IEnumerator GetEnumerator();
	}
	public interface IEnumerator
	{
		object Current { get; }

		bool MoveNext();

		void Reset();
	}
	public interface IEqualityComparer
	{
		new bool Equals(object? x, object? y);

		int GetHashCode(object obj);
	}
	[Obsolete("IHashCodeProvider has been deprecated. Use IEqualityComparer instead.")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public interface IHashCodeProvider
	{
		int GetHashCode(object obj);
	}
	public interface IList : ICollection, IEnumerable
	{
		object? this[int index] { get; set; }

		bool IsReadOnly { get; }

		bool IsFixedSize { get; }

		int Add(object? value);

		bool Contains(object? value);

		void Clear();

		int IndexOf(object? value);

		void Insert(int index, object? value);

		void Remove(object? value);

		void RemoveAt(int index);
	}
	public interface IStructuralComparable
	{
		int CompareTo(object? other, IComparer comparer);
	}
	public interface IStructuralEquatable
	{
		bool Equals(object? other, IEqualityComparer comparer);

		int GetHashCode(IEqualityComparer comparer);
	}
	[DebuggerDisplay("{_value}", Name = "[{_key}]")]
	internal sealed class KeyValuePairs
	{
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private readonly object _key;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private readonly object _value;

		public KeyValuePairs(object key, object value)
		{
			_value = value;
			_key = key;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ListDictionaryInternal : IDictionary, ICollection, IEnumerable
	{
		private sealed class NodeEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly ListDictionaryInternal list;

			private DictionaryNode current;

			private readonly int version;

			private bool start;

			public object Current => Entry;

			public DictionaryEntry Entry
			{
				get
				{
					if (current == null)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
					}
					return new DictionaryEntry(current.key, current.value);
				}
			}

			public object Key
			{
				get
				{
					if (current == null)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
					}
					return current.key;
				}
			}

			public object Value
			{
				get
				{
					if (current == null)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
					}
					return current.value;
				}
			}

			public NodeEnumerator(ListDictionaryInternal list)
			{
				this.list = list;
				version = list.version;
				start = true;
				current = null;
			}

			public bool MoveNext()
			{
				if (version != list.version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				if (start)
				{
					current = list.head;
					start = false;
				}
				else if (current != null)
				{
					current = current.next;
				}
				return current != null;
			}

			public void Reset()
			{
				if (version != list.version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				start = true;
				current = null;
			}
		}

		private sealed class NodeKeyValueCollection : ICollection, IEnumerable
		{
			private sealed class NodeKeyValueEnumerator : IEnumerator
			{
				private readonly ListDictionaryInternal list;

				private DictionaryNode current;

				private readonly int version;

				private readonly bool isKeys;

				private bool start;

				public object Current
				{
					get
					{
						if (current == null)
						{
							throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen);
						}
						if (!isKeys)
						{
							return current.value;
						}
						return current.key;
					}
				}

				public NodeKeyValueEnumerator(ListDictionaryInternal list, bool isKeys)
				{
					this.list = list;
					this.isKeys = isKeys;
					version = list.version;
					start = true;
					current = null;
				}

				public bool MoveNext()
				{
					if (version != list.version)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
					}
					if (start)
					{
						current = list.head;
						start = false;
					}
					else if (current != null)
					{
						current = current.next;
					}
					return current != null;
				}

				public void Reset()
				{
					if (version != list.version)
					{
						throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
					}
					start = true;
					current = null;
				}
			}

			private readonly ListDictionaryInternal list;

			private readonly bool isKeys;

			int ICollection.Count
			{
				get
				{
					int num = 0;
					for (DictionaryNode dictionaryNode = list.head; dictionaryNode != null; dictionaryNode = dictionaryNode.next)
					{
						num++;
					}
					return num;
				}
			}

			bool ICollection.IsSynchronized => false;

			object ICollection.SyncRoot => list.SyncRoot;

			public NodeKeyValueCollection(ListDictionaryInternal list, bool isKeys)
			{
				this.list = list;
				this.isKeys = isKeys;
			}

			void ICollection.CopyTo(Array array, int index)
			{
				if (array == null)
				{
					throw new ArgumentNullException("array");
				}
				if (array.Rank != 1)
				{
					throw new ArgumentException(SR.Arg_RankMultiDimNotSupported);
				}
				if (index < 0)
				{
					throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
				}
				if (array.Length - index < list.Count)
				{
					throw new ArgumentException(SR.ArgumentOutOfRange_Index, "index");
				}
				for (DictionaryNode dictionaryNode = list.head; dictionaryNode != null; dictionaryNode = dictionaryNode.next)
				{
					array.SetValue(isKeys ? dictionaryNode.key : dictionaryNode.value, index);
					index++;
				}
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return new NodeKeyValueEnumerator(list, isKeys);
			}
		}

		[Serializable]
		private sealed class DictionaryNode
		{
			public object key;

			public object value;

			public DictionaryNode next;
		}

		private DictionaryNode head;

		private int version;

		private int count;

		public object? this[object key]
		{
			get
			{
				if (key == null)
				{
					throw new ArgumentNullException("key", SR.ArgumentNull_Key);
				}
				for (DictionaryNode next = head; next != null; next = next.next)
				{
					if (next.key.Equals(key))
					{
						return next.value;
					}
				}
				return null;
			}
			set
			{
				if (key == null)
				{
					throw new ArgumentNullException("key", SR.ArgumentNull_Key);
				}
				version++;
				DictionaryNode dictionaryNode = null;
				DictionaryNode next = head;
				while (next != null && !next.key.Equals(key))
				{
					dictionaryNode = next;
					next = next.next;
				}
				if (next != null)
				{
					next.value = value;
					return;
				}
				DictionaryNode dictionaryNode2 = new DictionaryNode();
				dictionaryNode2.key = key;
				dictionaryNode2.value = value;
				if (dictionaryNode != null)
				{
					dictionaryNode.next = dictionaryNode2;
				}
				else
				{
					head = dictionaryNode2;
				}
				count++;
			}
		}

		public int Count => count;

		public ICollection Keys => new NodeKeyValueCollection(this, isKeys: true);

		public bool IsReadOnly => false;

		public bool IsFixedSize => false;

		public bool IsSynchronized => false;

		public object SyncRoot => this;

		public ICollection Values => new NodeKeyValueCollection(this, isKeys: false);

		public void Add(object key, object? value)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key", SR.ArgumentNull_Key);
			}
			version++;
			DictionaryNode dictionaryNode = null;
			for (DictionaryNode next = head; next != null; next = next.next)
			{
				if (next.key.Equals(key))
				{
					throw new ArgumentException(SR.Format(SR.Argument_AddingDuplicate__, next.key, key));
				}
				dictionaryNode = next;
			}
			DictionaryNode dictionaryNode2 = new DictionaryNode();
			dictionaryNode2.key = key;
			dictionaryNode2.value = value;
			if (dictionaryNode != null)
			{
				dictionaryNode.next = dictionaryNode2;
			}
			else
			{
				head = dictionaryNode2;
			}
			count++;
		}

		public void Clear()
		{
			count = 0;
			head = null;
			version++;
		}

		public bool Contains(object key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key", SR.ArgumentNull_Key);
			}
			for (DictionaryNode next = head; next != null; next = next.next)
			{
				if (next.key.Equals(key))
				{
					return true;
				}
			}
			return false;
		}

		public void CopyTo(Array array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (array.Rank != 1)
			{
				throw new ArgumentException(SR.Arg_RankMultiDimNotSupported);
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (array.Length - index < Count)
			{
				throw new ArgumentException(SR.ArgumentOutOfRange_Index, "index");
			}
			for (DictionaryNode next = head; next != null; next = next.next)
			{
				array.SetValue(new DictionaryEntry(next.key, next.value), index);
				index++;
			}
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new NodeEnumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new NodeEnumerator(this);
		}

		public void Remove(object key)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key", SR.ArgumentNull_Key);
			}
			version++;
			DictionaryNode dictionaryNode = null;
			DictionaryNode next = head;
			while (next != null && !next.key.Equals(key))
			{
				dictionaryNode = next;
				next = next.next;
			}
			if (next != null)
			{
				if (next == head)
				{
					head = next.next;
				}
				else
				{
					dictionaryNode.next = next.next;
				}
				count--;
			}
		}
	}
}
namespace System.Collections.ObjectModel
{
	[Serializable]
	[DebuggerTypeProxy(typeof(ICollectionDebugView<>))]
	[DebuggerDisplay("Count = {Count}")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Collection<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>
	{
		private readonly IList<T> items;

		public int Count => items.Count;

		protected IList<T> Items => items;

		public T this[int index]
		{
			get
			{
				return items[index];
			}
			set
			{
				if (items.IsReadOnly)
				{
					ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
				}
				if ((uint)index >= (uint)items.Count)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				SetItem(index, value);
			}
		}

		bool ICollection<T>.IsReadOnly => items.IsReadOnly;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot
		{
			get
			{
				if (!(items is ICollection collection))
				{
					return this;
				}
				return collection.SyncRoot;
			}
		}

		object? IList.this[int index]
		{
			get
			{
				return items[index];
			}
			set
			{
				ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(value, ExceptionArgument.value);
				T value2 = default(T);
				try
				{
					value2 = (T)value;
				}
				catch (InvalidCastException)
				{
					ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
				}
				this[index] = value2;
			}
		}

		bool IList.IsReadOnly => items.IsReadOnly;

		bool IList.IsFixedSize
		{
			get
			{
				if (items is IList list)
				{
					return list.IsFixedSize;
				}
				return items.IsReadOnly;
			}
		}

		public Collection()
		{
			items = new List<T>();
		}

		public Collection(IList<T> list)
		{
			if (list == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
			}
			items = list;
		}

		public void Add(T item)
		{
			if (items.IsReadOnly)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
			int count = items.Count;
			InsertItem(count, item);
		}

		public void Clear()
		{
			if (items.IsReadOnly)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
			ClearItems();
		}

		public void CopyTo(T[] array, int index)
		{
			items.CopyTo(array, index);
		}

		public bool Contains(T item)
		{
			return items.Contains(item);
		}

		public IEnumerator<T> GetEnumerator()
		{
			return items.GetEnumerator();
		}

		public int IndexOf(T item)
		{
			return items.IndexOf(item);
		}

		public void Insert(int index, T item)
		{
			if (items.IsReadOnly)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
			if ((uint)index > (uint)items.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			InsertItem(index, item);
		}

		public bool Remove(T item)
		{
			if (items.IsReadOnly)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
			int num = items.IndexOf(item);
			if (num < 0)
			{
				return false;
			}
			RemoveItem(num);
			return true;
		}

		public void RemoveAt(int index)
		{
			if (items.IsReadOnly)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
			if ((uint)index >= (uint)items.Count)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			RemoveItem(index);
		}

		protected virtual void ClearItems()
		{
			items.Clear();
		}

		protected virtual void InsertItem(int index, T item)
		{
			items.Insert(index, item);
		}

		protected virtual void RemoveItem(int index)
		{
			items.RemoveAt(index);
		}

		protected virtual void SetItem(int index, T item)
		{
			items[index] = item;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable)items).GetEnumerator();
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
			}
			if (array.GetLowerBound(0) != 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
			}
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (array.Length - index < Count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
			}
			if (array is T[] array2)
			{
				items.CopyTo(array2, index);
				return;
			}
			Type elementType = array.GetType().GetElementType();
			Type typeFromHandle = typeof(T);
			if (!elementType.IsAssignableFrom(typeFromHandle) && !typeFromHandle.IsAssignableFrom(elementType))
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
			object[] array3 = array as object[];
			if (array3 == null)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
			int count = items.Count;
			try
			{
				for (int i = 0; i < count; i++)
				{
					array3[index++] = items[i];
				}
			}
			catch (ArrayTypeMismatchException)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
		}

		int IList.Add(object value)
		{
			if (items.IsReadOnly)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
			ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(value, ExceptionArgument.value);
			T item = default(T);
			try
			{
				item = (T)value;
			}
			catch (InvalidCastException)
			{
				ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
			}
			Add(item);
			return Count - 1;
		}

		bool IList.Contains(object value)
		{
			if (IsCompatibleObject(value))
			{
				return Contains((T)value);
			}
			return false;
		}

		int IList.IndexOf(object value)
		{
			if (IsCompatibleObject(value))
			{
				return IndexOf((T)value);
			}
			return -1;
		}

		void IList.Insert(int index, object value)
		{
			if (items.IsReadOnly)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
			ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(value, ExceptionArgument.value);
			T item = default(T);
			try
			{
				item = (T)value;
			}
			catch (InvalidCastException)
			{
				ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
			}
			Insert(index, item);
		}

		void IList.Remove(object value)
		{
			if (items.IsReadOnly)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
			if (IsCompatibleObject(value))
			{
				Remove((T)value);
			}
		}

		private static bool IsCompatibleObject(object value)
		{
			if (!(value is T))
			{
				if (value == null)
				{
					return default(T) == null;
				}
				return false;
			}
			return true;
		}
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(ICollectionDebugView<>))]
	[DebuggerDisplay("Count = {Count}")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class ReadOnlyCollection<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>
	{
		private readonly IList<T> list;

		public int Count => list.Count;

		public T this[int index] => list[index];

		protected IList<T> Items => list;

		bool ICollection<T>.IsReadOnly => true;

		T IList<T>.this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
		}

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot
		{
			get
			{
				if (!(list is ICollection collection))
				{
					return this;
				}
				return collection.SyncRoot;
			}
		}

		bool IList.IsFixedSize => true;

		bool IList.IsReadOnly => true;

		object? IList.this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			}
		}

		public ReadOnlyCollection(IList<T> list)
		{
			if (list == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
			}
			this.list = list;
		}

		public bool Contains(T value)
		{
			return list.Contains(value);
		}

		public void CopyTo(T[] array, int index)
		{
			list.CopyTo(array, index);
		}

		public IEnumerator<T> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public int IndexOf(T value)
		{
			return list.IndexOf(value);
		}

		void ICollection<T>.Add(T value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}

		void ICollection<T>.Clear()
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}

		void IList<T>.Insert(int index, T value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}

		bool ICollection<T>.Remove(T value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			return false;
		}

		void IList<T>.RemoveAt(int index)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable)list).GetEnumerator();
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
			}
			if (array.GetLowerBound(0) != 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
			}
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (array.Length - index < Count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
			}
			if (array is T[] array2)
			{
				list.CopyTo(array2, index);
				return;
			}
			Type elementType = array.GetType().GetElementType();
			Type typeFromHandle = typeof(T);
			if (!elementType.IsAssignableFrom(typeFromHandle) && !typeFromHandle.IsAssignableFrom(elementType))
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
			object[] array3 = array as object[];
			if (array3 == null)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
			int count = list.Count;
			try
			{
				for (int i = 0; i < count; i++)
				{
					array3[index++] = list[i];
				}
			}
			catch (ArrayTypeMismatchException)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
		}

		int IList.Add(object value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
			return -1;
		}

		void IList.Clear()
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}

		private static bool IsCompatibleObject(object value)
		{
			if (!(value is T))
			{
				if (value == null)
				{
					return default(T) == null;
				}
				return false;
			}
			return true;
		}

		bool IList.Contains(object value)
		{
			if (IsCompatibleObject(value))
			{
				return Contains((T)value);
			}
			return false;
		}

		int IList.IndexOf(object value)
		{
			if (IsCompatibleObject(value))
			{
				return IndexOf((T)value);
			}
			return -1;
		}

		void IList.Insert(int index, object value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}

		void IList.Remove(object value)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}

		void IList.RemoveAt(int index)
		{
			ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ReadOnlyCollection);
		}
	}
}
namespace System.Collections.Concurrent
{
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(IProducerConsumerCollectionDebugView<>))]
	public class ConcurrentQueue<T> : IProducerConsumerCollection<T>, IEnumerable<T>, IEnumerable, ICollection, IReadOnlyCollection<T>
	{
		private readonly object _crossSegmentLock;

		private volatile ConcurrentQueueSegment<T> _tail;

		private volatile ConcurrentQueueSegment<T> _head;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot
		{
			get
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.ConcurrentCollection_SyncRoot_NotSupported);
				return null;
			}
		}

		public bool IsEmpty
		{
			get
			{
				T result;
				return !TryPeek(out result, resultUsed: false);
			}
		}

		public int Count
		{
			get
			{
				SpinWait spinWait = default(SpinWait);
				ConcurrentQueueSegment<T> head;
				ConcurrentQueueSegment<T> tail;
				int num;
				int num2;
				int num3;
				int num4;
				while (true)
				{
					head = _head;
					tail = _tail;
					num = Volatile.Read(ref head._headAndTail.Head);
					num2 = Volatile.Read(ref head._headAndTail.Tail);
					if (head == tail)
					{
						if (head == _head && tail == _tail && num == Volatile.Read(ref head._headAndTail.Head) && num2 == Volatile.Read(ref head._headAndTail.Tail))
						{
							return GetCount(head, num, num2);
						}
					}
					else if (head._nextSegment == tail)
					{
						num3 = Volatile.Read(ref tail._headAndTail.Head);
						num4 = Volatile.Read(ref tail._headAndTail.Tail);
						if (head == _head && tail == _tail && num == Volatile.Read(ref head._headAndTail.Head) && num2 == Volatile.Read(ref head._headAndTail.Tail) && num3 == Volatile.Read(ref tail._headAndTail.Head) && num4 == Volatile.Read(ref tail._headAndTail.Tail))
						{
							break;
						}
					}
					else
					{
						lock (_crossSegmentLock)
						{
							if (head == _head && tail == _tail)
							{
								int num5 = Volatile.Read(ref tail._headAndTail.Head);
								int num6 = Volatile.Read(ref tail._headAndTail.Tail);
								if (num == Volatile.Read(ref head._headAndTail.Head) && num2 == Volatile.Read(ref head._headAndTail.Tail) && num5 == Volatile.Read(ref tail._headAndTail.Head) && num6 == Volatile.Read(ref tail._headAndTail.Tail))
								{
									int num7 = GetCount(head, num, num2) + GetCount(tail, num5, num6);
									for (ConcurrentQueueSegment<T> nextSegment = head._nextSegment; nextSegment != tail; nextSegment = nextSegment._nextSegment)
									{
										num7 += nextSegment._headAndTail.Tail - nextSegment.FreezeOffset;
									}
									return num7;
								}
							}
						}
					}
					spinWait.SpinOnce();
				}
				return GetCount(head, num, num2) + GetCount(tail, num3, num4);
			}
		}

		public ConcurrentQueue()
		{
			_crossSegmentLock = new object();
			_tail = (_head = new ConcurrentQueueSegment<T>(32));
		}

		public ConcurrentQueue(IEnumerable<T> collection)
		{
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
			_crossSegmentLock = new object();
			int num = 32;
			if (collection is ICollection<T> collection2)
			{
				int count = collection2.Count;
				if (count > num)
				{
					num = (int)Math.Min(BitOperations.RoundUpToPowerOf2((uint)count), 1048576u);
				}
			}
			_tail = (_head = new ConcurrentQueueSegment<T>(num));
			foreach (T item in collection)
			{
				Enqueue(item);
			}
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array is T[] array2)
			{
				CopyTo(array2, index);
				return;
			}
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			ToArray().CopyTo(array, index);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<T>)this).GetEnumerator();
		}

		bool IProducerConsumerCollection<T>.TryAdd(T item)
		{
			Enqueue(item);
			return true;
		}

		bool IProducerConsumerCollection<T>.TryTake([MaybeNullWhen(false)] out T item)
		{
			return TryDequeue(out item);
		}

		public T[] ToArray()
		{
			SnapForObservation(out var head, out var headHead, out var tail, out var tailTail);
			long count = GetCount(head, headHead, tail, tailTail);
			T[] array = new T[count];
			using IEnumerator<T> enumerator = Enumerate(head, headHead, tail, tailTail);
			int num = 0;
			while (enumerator.MoveNext())
			{
				array[num++] = enumerator.Current;
			}
			return array;
		}

		private static int GetCount(ConcurrentQueueSegment<T> s, int head, int tail)
		{
			if (head != tail && head != tail - s.FreezeOffset)
			{
				head &= s._slotsMask;
				tail &= s._slotsMask;
				if (head >= tail)
				{
					return s._slots.Length - head + tail;
				}
				return tail - head;
			}
			return 0;
		}

		private static long GetCount(ConcurrentQueueSegment<T> head, int headHead, ConcurrentQueueSegment<T> tail, int tailTail)
		{
			long num = 0L;
			int num2 = ((head == tail) ? tailTail : Volatile.Read(ref head._headAndTail.Tail)) - head.FreezeOffset;
			if (headHead < num2)
			{
				headHead &= head._slotsMask;
				num2 &= head._slotsMask;
				num += ((headHead < num2) ? (num2 - headHead) : (head._slots.Length - headHead + num2));
			}
			if (head != tail)
			{
				for (ConcurrentQueueSegment<T> nextSegment = head._nextSegment; nextSegment != tail; nextSegment = nextSegment._nextSegment)
				{
					num += nextSegment._headAndTail.Tail - nextSegment.FreezeOffset;
				}
				num += tailTail - tail.FreezeOffset;
			}
			return num;
		}

		public void CopyTo(T[] array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			SnapForObservation(out var head, out var headHead, out var tail, out var tailTail);
			long count = GetCount(head, headHead, tail, tailTail);
			if (index > array.Length - count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
			}
			int num = index;
			using IEnumerator<T> enumerator = Enumerate(head, headHead, tail, tailTail);
			while (enumerator.MoveNext())
			{
				array[num++] = enumerator.Current;
			}
		}

		public IEnumerator<T> GetEnumerator()
		{
			SnapForObservation(out var head, out var headHead, out var tail, out var tailTail);
			return Enumerate(head, headHead, tail, tailTail);
		}

		private void SnapForObservation(out ConcurrentQueueSegment<T> head, out int headHead, out ConcurrentQueueSegment<T> tail, out int tailTail)
		{
			lock (_crossSegmentLock)
			{
				head = _head;
				tail = _tail;
				ConcurrentQueueSegment<T> concurrentQueueSegment = head;
				while (true)
				{
					concurrentQueueSegment._preservedForObservation = true;
					if (concurrentQueueSegment == tail)
					{
						break;
					}
					concurrentQueueSegment = concurrentQueueSegment._nextSegment;
				}
				tail.EnsureFrozenForEnqueues();
				headHead = Volatile.Read(ref head._headAndTail.Head);
				tailTail = Volatile.Read(ref tail._headAndTail.Tail);
			}
		}

		private static T GetItemWhenAvailable(ConcurrentQueueSegment<T> segment, int i)
		{
			int num = (i + 1) & segment._slotsMask;
			if ((segment._slots[i].SequenceNumber & segment._slotsMask) != num)
			{
				SpinWait spinWait = default(SpinWait);
				while ((Volatile.Read(ref segment._slots[i].SequenceNumber) & segment._slotsMask) != num)
				{
					spinWait.SpinOnce();
				}
			}
			return segment._slots[i].Item;
		}

		private static IEnumerator<T> Enumerate(ConcurrentQueueSegment<T> head, int headHead, ConcurrentQueueSegment<T> tail, int tailTail)
		{
			int headTail = ((head == tail) ? tailTail : Volatile.Read(ref head._headAndTail.Tail)) - head.FreezeOffset;
			if (headHead < headTail)
			{
				headHead &= head._slotsMask;
				headTail &= head._slotsMask;
				if (headHead < headTail)
				{
					for (int n = headHead; n < headTail; n++)
					{
						yield return GetItemWhenAvailable(head, n);
					}
				}
				else
				{
					for (int n = headHead; n < head._slots.Length; n++)
					{
						yield return GetItemWhenAvailable(head, n);
					}
					for (int n = 0; n < headTail; n++)
					{
						yield return GetItemWhenAvailable(head, n);
					}
				}
			}
			if (head == tail)
			{
				yield break;
			}
			for (ConcurrentQueueSegment<T> s = head._nextSegment; s != tail; s = s._nextSegment)
			{
				int n = s._headAndTail.Tail - s.FreezeOffset;
				for (int i = 0; i < n; i++)
				{
					yield return GetItemWhenAvailable(s, i);
				}
			}
			tailTail -= tail.FreezeOffset;
			for (int n = 0; n < tailTail; n++)
			{
				yield return GetItemWhenAvailable(tail, n);
			}
		}

		public void Enqueue(T item)
		{
			if (!_tail.TryEnqueue(item))
			{
				EnqueueSlow(item);
			}
		}

		private void EnqueueSlow(T item)
		{
			while (true)
			{
				ConcurrentQueueSegment<T> tail = _tail;
				if (tail.TryEnqueue(item))
				{
					break;
				}
				lock (_crossSegmentLock)
				{
					if (tail == _tail)
					{
						tail.EnsureFrozenForEnqueues();
						int boundedLength = (tail._preservedForObservation ? 32 : Math.Min(tail.Capacity * 2, 1048576));
						_tail = (tail._nextSegment = new ConcurrentQueueSegment<T>(boundedLength));
					}
				}
			}
		}

		public bool TryDequeue([MaybeNullWhen(false)] out T result)
		{
			ConcurrentQueueSegment<T> head = _head;
			if (head.TryDequeue(out result))
			{
				return true;
			}
			if (head._nextSegment == null)
			{
				result = default(T);
				return false;
			}
			return TryDequeueSlow(out result);
		}

		private bool TryDequeueSlow([MaybeNullWhen(false)] out T item)
		{
			while (true)
			{
				ConcurrentQueueSegment<T> head = _head;
				if (head.TryDequeue(out item))
				{
					return true;
				}
				if (head._nextSegment == null)
				{
					item = default(T);
					return false;
				}
				if (head.TryDequeue(out item))
				{
					break;
				}
				lock (_crossSegmentLock)
				{
					if (head == _head)
					{
						_head = head._nextSegment;
					}
				}
			}
			return true;
		}

		public bool TryPeek([MaybeNullWhen(false)] out T result)
		{
			return TryPeek(out result, resultUsed: true);
		}

		private bool TryPeek([MaybeNullWhen(false)] out T result, bool resultUsed)
		{
			ConcurrentQueueSegment<T> concurrentQueueSegment = _head;
			while (true)
			{
				ConcurrentQueueSegment<T> concurrentQueueSegment2 = Volatile.Read(ref concurrentQueueSegment._nextSegment);
				if (concurrentQueueSegment.TryPeek(out result, resultUsed))
				{
					return true;
				}
				if (concurrentQueueSegment2 != null)
				{
					concurrentQueueSegment = concurrentQueueSegment2;
				}
				else if (Volatile.Read(ref concurrentQueueSegment._nextSegment) == null)
				{
					break;
				}
			}
			result = default(T);
			return false;
		}

		public void Clear()
		{
			lock (_crossSegmentLock)
			{
				_tail.EnsureFrozenForEnqueues();
				_tail = (_head = new ConcurrentQueueSegment<T>(32));
			}
		}
	}
	[DebuggerDisplay("Capacity = {Capacity}")]
	internal sealed class ConcurrentQueueSegment<T>
	{
		[StructLayout(LayoutKind.Auto)]
		[DebuggerDisplay("Item = {Item}, SequenceNumber = {SequenceNumber}")]
		internal struct Slot
		{
			public T Item;

			public int SequenceNumber;
		}

		internal readonly Slot[] _slots;

		internal readonly int _slotsMask;

		internal PaddedHeadAndTail _headAndTail;

		internal bool _preservedForObservation;

		internal bool _frozenForEnqueues;

		internal ConcurrentQueueSegment<T> _nextSegment;

		internal int Capacity => _slots.Length;

		internal int FreezeOffset => _slots.Length * 2;

		internal ConcurrentQueueSegment(int boundedLength)
		{
			_slots = new Slot[boundedLength];
			_slotsMask = boundedLength - 1;
			for (int i = 0; i < _slots.Length; i++)
			{
				_slots[i].SequenceNumber = i;
			}
		}

		internal void EnsureFrozenForEnqueues()
		{
			if (!_frozenForEnqueues)
			{
				_frozenForEnqueues = true;
				Interlocked.Add(ref _headAndTail.Tail, FreezeOffset);
			}
		}

		public bool TryDequeue([MaybeNullWhen(false)] out T item)
		{
			Slot[] slots = _slots;
			SpinWait spinWait = default(SpinWait);
			while (true)
			{
				int num = Volatile.Read(ref _headAndTail.Head);
				int num2 = num & _slotsMask;
				int num3 = Volatile.Read(ref slots[num2].SequenceNumber);
				int num4 = num3 - (num + 1);
				if (num4 == 0)
				{
					if (Interlocked.CompareExchange(ref _headAndTail.Head, num + 1, num) != num)
					{
						continue;
					}
					item = slots[num2].Item;
					if (!Volatile.Read(ref _preservedForObservation))
					{
						if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
						{
							slots[num2].Item = default(T);
						}
						Volatile.Write(ref slots[num2].SequenceNumber, num + slots.Length);
					}
					return true;
				}
				if (num4 < 0)
				{
					bool frozenForEnqueues = _frozenForEnqueues;
					int num5 = Volatile.Read(ref _headAndTail.Tail);
					if (num5 - num <= 0 || (frozenForEnqueues && num5 - FreezeOffset - num <= 0))
					{
						break;
					}
					spinWait.SpinOnce(-1);
				}
			}
			item = default(T);
			return false;
		}

		public bool TryPeek([MaybeNullWhen(false)] out T result, bool resultUsed)
		{
			if (resultUsed)
			{
				_preservedForObservation = true;
				Interlocked.MemoryBarrier();
			}
			Slot[] slots = _slots;
			SpinWait spinWait = default(SpinWait);
			while (true)
			{
				int num = Volatile.Read(ref _headAndTail.Head);
				int num2 = num & _slotsMask;
				int num3 = Volatile.Read(ref slots[num2].SequenceNumber);
				int num4 = num3 - (num + 1);
				if (num4 == 0)
				{
					result = (resultUsed ? slots[num2].Item : default(T));
					return true;
				}
				if (num4 < 0)
				{
					bool frozenForEnqueues = _frozenForEnqueues;
					int num5 = Volatile.Read(ref _headAndTail.Tail);
					if (num5 - num <= 0 || (frozenForEnqueues && num5 - FreezeOffset - num <= 0))
					{
						break;
					}
					spinWait.SpinOnce(-1);
				}
			}
			result = default(T);
			return false;
		}

		public bool TryEnqueue(T item)
		{
			Slot[] slots = _slots;
			while (true)
			{
				int num = Volatile.Read(ref _headAndTail.Tail);
				int num2 = num & _slotsMask;
				int num3 = Volatile.Read(ref slots[num2].SequenceNumber);
				int num4 = num3 - num;
				if (num4 == 0)
				{
					if (Interlocked.CompareExchange(ref _headAndTail.Tail, num + 1, num) == num)
					{
						slots[num2].Item = item;
						Volatile.Write(ref slots[num2].SequenceNumber, num + 1);
						return true;
					}
				}
				else if (num4 < 0)
				{
					break;
				}
			}
			return false;
		}
	}
	[StructLayout(LayoutKind.Explicit, Size = 192)]
	[DebuggerDisplay("Head = {Head}, Tail = {Tail}")]
	internal struct PaddedHeadAndTail
	{
		[FieldOffset(64)]
		public int Head;

		[FieldOffset(128)]
		public int Tail;
	}
	public interface IProducerConsumerCollection<T> : IEnumerable<T>, IEnumerable, ICollection
	{
		void CopyTo(T[] array, int index);

		bool TryAdd(T item);

		bool TryTake([MaybeNullWhen(false)] out T item);

		T[] ToArray();
	}
	internal sealed class IProducerConsumerCollectionDebugView<T>
	{
		private readonly IProducerConsumerCollection<T> _collection;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items => _collection.ToArray();

		public IProducerConsumerCollectionDebugView(IProducerConsumerCollection<T> collection)
		{
			_collection = collection ?? throw new ArgumentNullException("collection");
		}
	}
}
namespace System.Collections.Generic
{
	internal interface IArraySortHelper<TKey>
	{
		void Sort(Span<TKey> keys, IComparer<TKey> comparer);

		int BinarySearch(TKey[] keys, int index, int length, TKey value, IComparer<TKey> comparer);
	}
	[TypeDependency("System.Collections.Generic.GenericArraySortHelper`1")]
	internal sealed class ArraySortHelper<T> : IArraySortHelper<T>
	{
		private static readonly IArraySortHelper<T> s_defaultArraySortHelper = CreateArraySortHelper();

		public static IArraySortHelper<T> Default => s_defaultArraySortHelper;

		[DynamicDependency("#ctor", typeof(GenericArraySortHelper<>))]
		private static IArraySortHelper<T> CreateArraySortHelper()
		{
			if (typeof(IComparable<T>).IsAssignableFrom(typeof(T)))
			{
				return (IArraySortHelper<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericArraySortHelper<string>), (RuntimeType)typeof(T));
			}
			return new ArraySortHelper<T>();
		}

		public void Sort(Span<T> keys, IComparer<T> comparer)
		{
			try
			{
				if (comparer == null)
				{
					comparer = Comparer<T>.Default;
				}
				IntrospectiveSort(keys, comparer.Compare);
			}
			catch (IndexOutOfRangeException)
			{
				ThrowHelper.ThrowArgumentException_BadComparer(comparer);
			}
			catch (Exception e)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
			}
		}

		public int BinarySearch(T[] array, int index, int length, T value, IComparer<T> comparer)
		{
			try
			{
				if (comparer == null)
				{
					comparer = Comparer<T>.Default;
				}
				return InternalBinarySearch(array, index, length, value, comparer);
			}
			catch (Exception e)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
				return 0;
			}
		}

		internal static void Sort(Span<T> keys, Comparison<T> comparer)
		{
			try
			{
				IntrospectiveSort(keys, comparer);
			}
			catch (IndexOutOfRangeException)
			{
				ThrowHelper.ThrowArgumentException_BadComparer(comparer);
			}
			catch (Exception e)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
			}
		}

		internal static int InternalBinarySearch(T[] array, int index, int length, T value, IComparer<T> comparer)
		{
			int num = index;
			int num2 = index + length - 1;
			while (num <= num2)
			{
				int num3 = num + (num2 - num >> 1);
				int num4 = comparer.Compare(array[num3], value);
				if (num4 == 0)
				{
					return num3;
				}
				if (num4 < 0)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return ~num;
		}

		private static void SwapIfGreater(Span<T> keys, Comparison<T> comparer, int i, int j)
		{
			if (comparer(keys[i], keys[j]) > 0)
			{
				T val = keys[i];
				keys[i] = keys[j];
				keys[j] = val;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void Swap(Span<T> a, int i, int j)
		{
			T val = a[i];
			a[i] = a[j];
			a[j] = val;
		}

		internal static void IntrospectiveSort(Span<T> keys, Comparison<T> comparer)
		{
			if (keys.Length > 1)
			{
				IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer);
			}
		}

		private static void IntroSort(Span<T> keys, int depthLimit, Comparison<T> comparer)
		{
			int num = keys.Length;
			while (num > 1)
			{
				if (num <= 16)
				{
					switch (num)
					{
					case 2:
						SwapIfGreater(keys, comparer, 0, 1);
						break;
					case 3:
						SwapIfGreater(keys, comparer, 0, 1);
						SwapIfGreater(keys, comparer, 0, 2);
						SwapIfGreater(keys, comparer, 1, 2);
						break;
					default:
						InsertionSort(keys.Slice(0, num), comparer);
						break;
					}
					break;
				}
				if (depthLimit == 0)
				{
					HeapSort(keys.Slice(0, num), comparer);
					break;
				}
				depthLimit--;
				int num2 = PickPivotAndPartition(keys.Slice(0, num), comparer);
				Span<T> span = keys;
				IntroSort(span[(num2 + 1)..num], depthLimit, comparer);
				num = num2;
			}
		}

		private static int PickPivotAndPartition(Span<T> keys, Comparison<T> comparer)
		{
			int num = keys.Length - 1;
			int num2 = num >> 1;
			SwapIfGreater(keys, comparer, 0, num2);
			SwapIfGreater(keys, comparer, 0, num);
			SwapIfGreater(keys, comparer, num2, num);
			T val = keys[num2];
			Swap(keys, num2, num - 1);
			int num3 = 0;
			int num4 = num - 1;
			while (num3 < num4)
			{
				while (comparer(keys[++num3], val) < 0)
				{
				}
				while (comparer(val, keys[--num4]) < 0)
				{
				}
				if (num3 >= num4)
				{
					break;
				}
				Swap(keys, num3, num4);
			}
			if (num3 != num - 1)
			{
				Swap(keys, num3, num - 1);
			}
			return num3;
		}

		private static void HeapSort(Span<T> keys, Comparison<T> comparer)
		{
			int length = keys.Length;
			for (int num = length >> 1; num >= 1; num--)
			{
				DownHeap(keys, num, length, comparer);
			}
			for (int num2 = length; num2 > 1; num2--)
			{
				Swap(keys, 0, num2 - 1);
				DownHeap(keys, 1, num2 - 1, comparer);
			}
		}

		private static void DownHeap(Span<T> keys, int i, int n, Comparison<T> comparer)
		{
			T val = keys[i - 1];
			while (i <= n >> 1)
			{
				int num = 2 * i;
				if (num < n && comparer(keys[num - 1], keys[num]) < 0)
				{
					num++;
				}
				if (comparer(val, keys[num - 1]) >= 0)
				{
					break;
				}
				keys[i - 1] = keys[num - 1];
				i = num;
			}
			keys[i - 1] = val;
		}

		private static void InsertionSort(Span<T> keys, Comparison<T> comparer)
		{
			for (int i = 0; i < keys.Length - 1; i++)
			{
				T val = keys[i + 1];
				int num = i;
				while (num >= 0 && comparer(val, keys[num]) < 0)
				{
					keys[num + 1] = keys[num];
					num--;
				}
				keys[num + 1] = val;
			}
		}
	}
	internal sealed class GenericArraySortHelper<T> : IArraySortHelper<T> where T : IComparable<T>
	{
		public void Sort(Span<T> keys, IComparer<T> comparer)
		{
			try
			{
				if (comparer == null || comparer == Comparer<T>.Default)
				{
					if (keys.Length <= 1)
					{
						return;
					}
					if (typeof(T) == typeof(double) || typeof(T) == typeof(float) || typeof(T) == typeof(Half))
					{
						int num = SortUtils.MoveNansToFront(keys, default(Span<byte>));
						if (num == keys.Length)
						{
							return;
						}
						keys = keys.Slice(num);
					}
					IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1));
				}
				else
				{
					ArraySortHelper<T>.IntrospectiveSort(keys, comparer.Compare);
				}
			}
			catch (IndexOutOfRangeException)
			{
				ThrowHelper.ThrowArgumentException_BadComparer(comparer);
			}
			catch (Exception e)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
			}
		}

		public int BinarySearch(T[] array, int index, int length, T value, IComparer<T> comparer)
		{
			try
			{
				if (comparer == null || comparer == Comparer<T>.Default)
				{
					return BinarySearch(array, index, length, value);
				}
				return ArraySortHelper<T>.InternalBinarySearch(array, index, length, value, comparer);
			}
			catch (Exception e)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
				return 0;
			}
		}

		private static int BinarySearch(T[] array, int index, int length, T value)
		{
			int num = index;
			int num2 = index + length - 1;
			while (num <= num2)
			{
				int num3 = num + (num2 - num >> 1);
				int num4 = ((array[num3] != null) ? array[num3].CompareTo(value) : ((value != null) ? (-1) : 0));
				if (num4 == 0)
				{
					return num3;
				}
				if (num4 < 0)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return ~num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void SwapIfGreater(ref T i, ref T j)
		{
			if (i != null && GreaterThan(ref i, ref j))
			{
				Swap(ref i, ref j);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void Swap(ref T i, ref T j)
		{
			T val = i;
			i = j;
			j = val;
		}

		private static void IntroSort(Span<T> keys, int depthLimit)
		{
			int num = keys.Length;
			while (num > 1)
			{
				if (num <= 16)
				{
					switch (num)
					{
					case 2:
						SwapIfGreater(ref keys[0], ref keys[1]);
						break;
					case 3:
					{
						ref T j = ref keys[2];
						ref T reference = ref keys[1];
						ref T i = ref keys[0];
						SwapIfGreater(ref i, ref reference);
						SwapIfGreater(ref i, ref j);
						SwapIfGreater(ref reference, ref j);
						break;
					}
					default:
						InsertionSort(keys.Slice(0, num));
						break;
					}
					break;
				}
				if (depthLimit == 0)
				{
					HeapSort(keys.Slice(0, num));
					break;
				}
				depthLimit--;
				int num2 = PickPivotAndPartition(keys.Slice(0, num));
				Span<T> span = keys;
				IntroSort(span[(num2 + 1)..num], depthLimit);
				num = num2;
			}
		}

		private static int PickPivotAndPartition(Span<T> keys)
		{
			ref T reference = ref MemoryMarshal.GetReference(keys);
			ref T j = ref Unsafe.Add(ref reference, keys.Length - 1);
			ref T reference2 = ref Unsafe.Add(ref reference, keys.Length - 1 >> 1);
			SwapIfGreater(ref reference, ref reference2);
			SwapIfGreater(ref reference, ref j);
			SwapIfGreater(ref reference2, ref j);
			ref T reference3 = ref Unsafe.Add(ref reference, keys.Length - 2);
			T left = reference2;
			Swap(ref reference2, ref reference3);
			ref T reference4 = ref reference;
			ref T reference5 = ref reference3;
			while (Unsafe.IsAddressLessThan(ref reference4, ref reference5))
			{
				if (left == null)
				{
					while (Unsafe.IsAddressLessThan(ref reference4, ref reference3))
					{
						ref T reference6 = ref Unsafe.Add(ref reference4, 1);
						reference4 = ref reference6;
						if (reference6 != null)
						{
							break;
						}
					}
					while (Unsafe.IsAddressGreaterThan(ref reference5, ref reference))
					{
						ref T reference7 = ref Unsafe.Add(ref reference5, -1);
						reference5 = ref reference7;
						if (reference7 == null)
						{
							break;
						}
					}
				}
				else
				{
					while (Unsafe.IsAddressLessThan(ref reference4, ref reference3))
					{
						ref T reference8 = ref Unsafe.Add(ref reference4, 1);
						reference4 = ref reference8;
						if (!GreaterThan(ref left, ref reference8))
						{
							break;
						}
					}
					while (Unsafe.IsAddressGreaterThan(ref reference5, ref reference))
					{
						ref T reference9 = ref Unsafe.Add(ref reference5, -1);
						reference5 = ref reference9;
						if (!LessThan(ref left, ref reference9))
						{
							break;
						}
					}
				}
				if (!Unsafe.IsAddressLessThan(ref reference4, ref reference5))
				{
					break;
				}
				Swap(ref reference4, ref reference5);
			}
			if (!Unsafe.AreSame(ref reference4, ref reference3))
			{
				Swap(ref reference4, ref reference3);
			}
			return (int)((nint)Unsafe.ByteOffset(ref reference, ref reference4) / Unsafe.SizeOf<T>());
		}

		private static void HeapSort(Span<T> keys)
		{
			int length = keys.Length;
			for (int num = length >> 1; num >= 1; num--)
			{
				DownHeap(keys, num, length);
			}
			for (int num2 = length; num2 > 1; num2--)
			{
				Swap(ref keys[0], ref keys[num2 - 1]);
				DownHeap(keys, 1, num2 - 1);
			}
		}

		private static void DownHeap(Span<T> keys, int i, int n)
		{
			T left = keys[i - 1];
			while (i <= n >> 1)
			{
				int num = 2 * i;
				if (num < n && (keys[num - 1] == null || LessThan(ref keys[num - 1], ref keys[num])))
				{
					num++;
				}
				if (keys[num - 1] == null || !LessThan(ref left, ref keys[num - 1]))
				{
					break;
				}
				keys[i - 1] = keys[num - 1];
				i = num;
			}
			keys[i - 1] = left;
		}

		private static void InsertionSort(Span<T> keys)
		{
			for (int i = 0; i < keys.Length - 1; i++)
			{
				T left = Unsafe.Add(ref MemoryMarshal.GetReference(keys), i + 1);
				int num = i;
				while (num >= 0 && (left == null || LessThan(ref left, ref Unsafe.Add(ref MemoryMarshal.GetReference(keys), num))))
				{
					Unsafe.Add(ref MemoryMarshal.GetReference(keys), num + 1) = Unsafe.Add(ref MemoryMarshal.GetReference(keys), num);
					num--;
				}
				Unsafe.Add(ref MemoryMarshal.GetReference(keys), num + 1) = left;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool LessThan(ref T left, ref T right)
		{
			if (typeof(T) == typeof(byte))
			{
				if ((byte)(object)left >= (byte)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(sbyte))
			{
				if ((sbyte)(object)left >= (sbyte)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(ushort))
			{
				if ((ushort)(object)left >= (ushort)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(short))
			{
				if ((short)(object)left >= (short)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(uint))
			{
				if ((uint)(object)left >= (uint)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(int))
			{
				if ((int)(object)left >= (int)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(ulong))
			{
				if ((ulong)(object)left >= (ulong)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(long))
			{
				if ((long)(object)left >= (long)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				if ((nuint)(UIntPtr)(object)left >= (nuint)(UIntPtr)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				if ((nint)(IntPtr)(object)left >= (nint)(IntPtr)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(float))
			{
				if (!((float)(object)left < (float)(object)right))
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(double))
			{
				if (!((double)(object)left < (double)(object)right))
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(Half))
			{
				if (!((Half)(object)left < (Half)(object)right))
				{
					return false;
				}
				return true;
			}
			if (left.CompareTo(right) >= 0)
			{
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool GreaterThan(ref T left, ref T right)
		{
			if (typeof(T) == typeof(byte))
			{
				if ((byte)(object)left <= (byte)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(sbyte))
			{
				if ((sbyte)(object)left <= (sbyte)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(ushort))
			{
				if ((ushort)(object)left <= (ushort)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(short))
			{
				if ((short)(object)left <= (short)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(uint))
			{
				if ((uint)(object)left <= (uint)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(int))
			{
				if ((int)(object)left <= (int)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(ulong))
			{
				if ((ulong)(object)left <= (ulong)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(long))
			{
				if ((long)(object)left <= (long)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(UIntPtr))
			{
				if ((nuint)(UIntPtr)(object)left <= (nuint)(UIntPtr)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(IntPtr))
			{
				if ((nint)(IntPtr)(object)left <= (nint)(IntPtr)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(float))
			{
				if (!((float)(object)left > (float)(object)right))
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(double))
			{
				if (!((double)(object)left > (double)(object)right))
				{
					return false;
				}
				return true;
			}
			if (typeof(T) == typeof(Half))
			{
				if (!((Half)(object)left > (Half)(object)right))
				{
					return false;
				}
				return true;
			}
			if (left.CompareTo(right) <= 0)
			{
				return false;
			}
			return true;
		}
	}
	internal interface IArraySortHelper<TKey, TValue>
	{
		void Sort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer);
	}
	[TypeDependency("System.Collections.Generic.GenericArraySortHelper`2")]
	internal sealed class ArraySortHelper<TKey, TValue> : IArraySortHelper<TKey, TValue>
	{
		private static readonly IArraySortHelper<TKey, TValue> s_defaultArraySortHelper = CreateArraySortHelper();

		public static IArraySortHelper<TKey, TValue> Default => s_defaultArraySortHelper;

		[DynamicDependency("#ctor", typeof(GenericArraySortHelper<, >))]
		private static IArraySortHelper<TKey, TValue> CreateArraySortHelper()
		{
			if (typeof(IComparable<TKey>).IsAssignableFrom(typeof(TKey)))
			{
				return (IArraySortHelper<TKey, TValue>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericArraySortHelper<string, string>), (RuntimeType)typeof(TKey), (RuntimeType)typeof(TValue));
			}
			return new ArraySortHelper<TKey, TValue>();
		}

		public void Sort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
		{
			try
			{
				IntrospectiveSort(keys, values, comparer ?? Comparer<TKey>.Default);
			}
			catch (IndexOutOfRangeException)
			{
				ThrowHelper.ThrowArgumentException_BadComparer(comparer);
			}
			catch (Exception e)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
			}
		}

		private static void SwapIfGreaterWithValues(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer, int i, int j)
		{
			if (comparer.Compare(keys[i], keys[j]) > 0)
			{
				TKey val = keys[i];
				keys[i] = keys[j];
				keys[j] = val;
				TValue val2 = values[i];
				values[i] = values[j];
				values[j] = val2;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void Swap(Span<TKey> keys, Span<TValue> values, int i, int j)
		{
			TKey val = keys[i];
			keys[i] = keys[j];
			keys[j] = val;
			TValue val2 = values[i];
			values[i] = values[j];
			values[j] = val2;
		}

		internal static void IntrospectiveSort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
		{
			if (keys.Length > 1)
			{
				IntroSort(keys, values, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer);
			}
		}

		private static void IntroSort(Span<TKey> keys, Span<TValue> values, int depthLimit, IComparer<TKey> comparer)
		{
			int num = keys.Length;
			while (num > 1)
			{
				if (num <= 16)
				{
					switch (num)
					{
					case 2:
						SwapIfGreaterWithValues(keys, values, comparer, 0, 1);
						break;
					case 3:
						SwapIfGreaterWithValues(keys, values, comparer, 0, 1);
						SwapIfGreaterWithValues(keys, values, comparer, 0, 2);
						SwapIfGreaterWithValues(keys, values, comparer, 1, 2);
						break;
					default:
						InsertionSort(keys.Slice(0, num), values.Slice(0, num), comparer);
						break;
					}
					break;
				}
				if (depthLimit == 0)
				{
					HeapSort(keys.Slice(0, num), values.Slice(0, num), comparer);
					break;
				}
				depthLimit--;
				int num2 = PickPivotAndPartition(keys.Slice(0, num), values.Slice(0, num), comparer);
				Span<TKey> span = keys;
				Span<TKey> keys2 = span[(num2 + 1)..num];
				Span<TValue> span2 = values;
				IntroSort(keys2, span2[(num2 + 1)..num], depthLimit, comparer);
				num = num2;
			}
		}

		private static int PickPivotAndPartition(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
		{
			int num = keys.Length - 1;
			int num2 = num >> 1;
			SwapIfGreaterWithValues(keys, values, comparer, 0, num2);
			SwapIfGreaterWithValues(keys, values, comparer, 0, num);
			SwapIfGreaterWithValues(keys, values, comparer, num2, num);
			TKey val = keys[num2];
			Swap(keys, values, num2, num - 1);
			int num3 = 0;
			int num4 = num - 1;
			while (num3 < num4)
			{
				while (comparer.Compare(keys[++num3], val) < 0)
				{
				}
				while (comparer.Compare(val, keys[--num4]) < 0)
				{
				}
				if (num3 >= num4)
				{
					break;
				}
				Swap(keys, values, num3, num4);
			}
			if (num3 != num - 1)
			{
				Swap(keys, values, num3, num - 1);
			}
			return num3;
		}

		private static void HeapSort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
		{
			int length = keys.Length;
			for (int num = length >> 1; num >= 1; num--)
			{
				DownHeap(keys, values, num, length, comparer);
			}
			for (int num2 = length; num2 > 1; num2--)
			{
				Swap(keys, values, 0, num2 - 1);
				DownHeap(keys, values, 1, num2 - 1, comparer);
			}
		}

		private static void DownHeap(Span<TKey> keys, Span<TValue> values, int i, int n, IComparer<TKey> comparer)
		{
			TKey val = keys[i - 1];
			TValue val2 = values[i - 1];
			while (i <= n >> 1)
			{
				int num = 2 * i;
				if (num < n && comparer.Compare(keys[num - 1], keys[num]) < 0)
				{
					num++;
				}
				if (comparer.Compare(val, keys[num - 1]) >= 0)
				{
					break;
				}
				keys[i - 1] = keys[num - 1];
				values[i - 1] = values[num - 1];
				i = num;
			}
			keys[i - 1] = val;
			values[i - 1] = val2;
		}

		private static void InsertionSort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
		{
			for (int i = 0; i < keys.Length - 1; i++)
			{
				TKey val = keys[i + 1];
				TValue val2 = values[i + 1];
				int num = i;
				while (num >= 0 && comparer.Compare(val, keys[num]) < 0)
				{
					keys[num + 1] = keys[num];
					values[num + 1] = values[num];
					num--;
				}
				keys[num + 1] = val;
				values[num + 1] = val2;
			}
		}
	}
	internal sealed class GenericArraySortHelper<TKey, TValue> : IArraySortHelper<TKey, TValue> where TKey : IComparable<TKey>
	{
		public void Sort(Span<TKey> keys, Span<TValue> values, IComparer<TKey> comparer)
		{
			try
			{
				if (comparer == null || comparer == Comparer<TKey>.Default)
				{
					if (keys.Length <= 1)
					{
						return;
					}
					if (typeof(TKey) == typeof(double) || typeof(TKey) == typeof(float) || typeof(TKey) == typeof(Half))
					{
						int num = SortUtils.MoveNansToFront(keys, values);
						if (num == keys.Length)
						{
							return;
						}
						keys = keys.Slice(num);
						values = values.Slice(num);
					}
					IntroSort(keys, values, 2 * (BitOperations.Log2((uint)keys.Length) + 1));
				}
				else
				{
					ArraySortHelper<TKey, TValue>.IntrospectiveSort(keys, values, comparer);
				}
			}
			catch (IndexOutOfRangeException)
			{
				ThrowHelper.ThrowArgumentException_BadComparer(comparer);
			}
			catch (Exception e)
			{
				ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
			}
		}

		private static void SwapIfGreaterWithValues(Span<TKey> keys, Span<TValue> values, int i, int j)
		{
			ref TKey reference = ref keys[i];
			if (reference != null && GreaterThan(ref reference, ref keys[j]))
			{
				TKey val = reference;
				keys[i] = keys[j];
				keys[j] = val;
				TValue val2 = values[i];
				values[i] = values[j];
				values[j] = val2;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void Swap(Span<TKey> keys, Span<TValue> values, int i, int j)
		{
			TKey val = keys[i];
			keys[i] = keys[j];
			keys[j] = val;
			TValue val2 = values[i];
			values[i] = values[j];
			values[j] = val2;
		}

		private static void IntroSort(Span<TKey> keys, Span<TValue> values, int depthLimit)
		{
			int num = keys.Length;
			while (num > 1)
			{
				if (num <= 16)
				{
					switch (num)
					{
					case 2:
						SwapIfGreaterWithValues(keys, values, 0, 1);
						break;
					case 3:
						SwapIfGreaterWithValues(keys, values, 0, 1);
						SwapIfGreaterWithValues(keys, values, 0, 2);
						SwapIfGreaterWithValues(keys, values, 1, 2);
						break;
					default:
						InsertionSort(keys.Slice(0, num), values.Slice(0, num));
						break;
					}
					break;
				}
				if (depthLimit == 0)
				{
					HeapSort(keys.Slice(0, num), values.Slice(0, num));
					break;
				}
				depthLimit--;
				int num2 = PickPivotAndPartition(keys.Slice(0, num), values.Slice(0, num));
				Span<TKey> span = keys;
				Span<TKey> keys2 = span[(num2 + 1)..num];
				Span<TValue> span2 = values;
				IntroSort(keys2, span2[(num2 + 1)..num], depthLimit);
				num = num2;
			}
		}

		private static int PickPivotAndPartition(Span<TKey> keys, Span<TValue> values)
		{
			int num = keys.Length - 1;
			int num2 = num >> 1;
			SwapIfGreaterWithValues(keys, values, 0, num2);
			SwapIfGreaterWithValues(keys, values, 0, num);
			SwapIfGreaterWithValues(keys, values, num2, num);
			TKey left = keys[num2];
			Swap(keys, values, num2, num - 1);
			int num3 = 0;
			int num4 = num - 1;
			while (num3 < num4)
			{
				if (left == null)
				{
					while (num3 < num - 1 && keys[++num3] == null)
					{
					}
					while (num4 > 0 && keys[--num4] != null)
					{
					}
				}
				else
				{
					while (GreaterThan(ref left, ref keys[++num3]))
					{
					}
					while (LessThan(ref left, ref keys[--num4]))
					{
					}
				}
				if (num3 >= num4)
				{
					break;
				}
				Swap(keys, values, num3, num4);
			}
			if (num3 != num - 1)
			{
				Swap(keys, values, num3, num - 1);
			}
			return num3;
		}

		private static void HeapSort(Span<TKey> keys, Span<TValue> values)
		{
			int length = keys.Length;
			for (int num = length >> 1; num >= 1; num--)
			{
				DownHeap(keys, values, num, length);
			}
			for (int num2 = length; num2 > 1; num2--)
			{
				Swap(keys, values, 0, num2 - 1);
				DownHeap(keys, values, 1, num2 - 1);
			}
		}

		private static void DownHeap(Span<TKey> keys, Span<TValue> values, int i, int n)
		{
			TKey left = keys[i - 1];
			TValue val = values[i - 1];
			while (i <= n >> 1)
			{
				int num = 2 * i;
				if (num < n && (keys[num - 1] == null || LessThan(ref keys[num - 1], ref keys[num])))
				{
					num++;
				}
				if (keys[num - 1] == null || !LessThan(ref left, ref keys[num - 1]))
				{
					break;
				}
				keys[i - 1] = keys[num - 1];
				values[i - 1] = values[num - 1];
				i = num;
			}
			keys[i - 1] = left;
			values[i - 1] = val;
		}

		private static void InsertionSort(Span<TKey> keys, Span<TValue> values)
		{
			for (int i = 0; i < keys.Length - 1; i++)
			{
				TKey left = keys[i + 1];
				TValue val = values[i + 1];
				int num = i;
				while (num >= 0 && (left == null || LessThan(ref left, ref keys[num])))
				{
					keys[num + 1] = keys[num];
					values[num + 1] = values[num];
					num--;
				}
				keys[num + 1] = left;
				values[num + 1] = val;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool LessThan(ref TKey left, ref TKey right)
		{
			if (typeof(TKey) == typeof(byte))
			{
				if ((byte)(object)left >= (byte)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(sbyte))
			{
				if ((sbyte)(object)left >= (sbyte)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(ushort))
			{
				if ((ushort)(object)left >= (ushort)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(short))
			{
				if ((short)(object)left >= (short)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(uint))
			{
				if ((uint)(object)left >= (uint)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(int))
			{
				if ((int)(object)left >= (int)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(ulong))
			{
				if ((ulong)(object)left >= (ulong)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(long))
			{
				if ((long)(object)left >= (long)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(UIntPtr))
			{
				if ((nuint)(UIntPtr)(object)left >= (nuint)(UIntPtr)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(IntPtr))
			{
				if ((nint)(IntPtr)(object)left >= (nint)(IntPtr)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(float))
			{
				if (!((float)(object)left < (float)(object)right))
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(double))
			{
				if (!((double)(object)left < (double)(object)right))
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(Half))
			{
				if (!((Half)(object)left < (Half)(object)right))
				{
					return false;
				}
				return true;
			}
			if (left.CompareTo(right) >= 0)
			{
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool GreaterThan(ref TKey left, ref TKey right)
		{
			if (typeof(TKey) == typeof(byte))
			{
				if ((byte)(object)left <= (byte)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(sbyte))
			{
				if ((sbyte)(object)left <= (sbyte)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(ushort))
			{
				if ((ushort)(object)left <= (ushort)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(short))
			{
				if ((short)(object)left <= (short)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(uint))
			{
				if ((uint)(object)left <= (uint)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(int))
			{
				if ((int)(object)left <= (int)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(ulong))
			{
				if ((ulong)(object)left <= (ulong)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(long))
			{
				if ((long)(object)left <= (long)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(UIntPtr))
			{
				if ((nuint)(UIntPtr)(object)left <= (nuint)(UIntPtr)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(IntPtr))
			{
				if ((nint)(IntPtr)(object)left <= (nint)(IntPtr)(object)right)
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(float))
			{
				if (!((float)(object)left > (float)(object)right))
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(double))
			{
				if (!((double)(object)left > (double)(object)right))
				{
					return false;
				}
				return true;
			}
			if (typeof(TKey) == typeof(Half))
			{
				if (!((Half)(object)left > (Half)(object)right))
				{
					return false;
				}
				return true;
			}
			if (left.CompareTo(right) <= 0)
			{
				return false;
			}
			return true;
		}
	}
	[Serializable]
	[TypeDependency("System.Collections.Generic.ObjectComparer`1")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public abstract class Comparer<T> : IComparer, IComparer<T>
	{
		public static Comparer<T> Default
		{
			[Intrinsic]
			get;
		} = (Comparer<T>)ComparerHelpers.CreateDefaultComparer(typeof(T));


		public static Comparer<T> Create(Comparison<T> comparison)
		{
			if (comparison == null)
			{
				throw new ArgumentNullException("comparison");
			}
			return new ComparisonComparer<T>(comparison);
		}

		public abstract int Compare(T? x, T? y);

		int IComparer.Compare(object x, object y)
		{
			if (x == null)
			{
				if (y != null)
				{
					return -1;
				}
				return 0;
			}
			if (y == null)
			{
				return 1;
			}
			if (x is T && y is T)
			{
				return Compare((T)x, (T)y);
			}
			ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArgumentForComparison);
			return 0;
		}
	}
	[Serializable]
	internal sealed class EnumComparer<T> : Comparer<T>, ISerializable where T : struct, Enum
	{
		public override int Compare(T x, T y)
		{
			return RuntimeHelpers.EnumCompareTo(x, y);
		}

		public EnumComparer()
		{
		}

		private EnumComparer(SerializationInfo info, StreamingContext context)
		{
		}

		public override bool Equals([NotNullWhen(true)] object obj)
		{
			if (obj != null)
			{
				return GetType() == obj.GetType();
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetType().GetHashCode();
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.SetType(typeof(ObjectComparer<T>));
		}
	}
	internal static class ComparerHelpers
	{
		internal static object CreateDefaultComparer(Type type)
		{
			object obj = null;
			RuntimeType runtimeType = (RuntimeType)type;
			if (typeof(IComparable<>).MakeGenericType(type).IsAssignableFrom(type))
			{
				obj = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericComparer<int>), runtimeType);
			}
			else if (type.IsGenericType)
			{
				if (type.GetGenericTypeDefinition() == typeof(Nullable<>))
				{
					obj = TryCreateNullableComparer(runtimeType);
				}
			}
			else if (type.IsEnum)
			{
				obj = TryCreateEnumComparer(runtimeType);
			}
			return obj ?? RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(ObjectComparer<object>), runtimeType);
		}

		private static object TryCreateNullableComparer(RuntimeType nullableType)
		{
			RuntimeType runtimeType = (RuntimeType)nullableType.GetGenericArguments()[0];
			if (typeof(IComparable<>).MakeGenericType(runtimeType).IsAssignableFrom(runtimeType))
			{
				return RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableComparer<int>), runtimeType);
			}
			return null;
		}

		private static object TryCreateEnumComparer(RuntimeType enumType)
		{
			TypeCode typeCode = Type.GetTypeCode(Enum.GetUnderlyingType(enumType));
			if ((uint)(typeCode - 5) <= 7u)
			{
				return RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumComparer<>), enumType);
			}
			return null;
		}

		internal static object CreateDefaultEqualityComparer(Type type)
		{
			object obj = null;
			RuntimeType runtimeType = (RuntimeType)type;
			if (type == typeof(byte))
			{
				obj = new ByteEqualityComparer();
			}
			else if (type == typeof(string))
			{
				obj = new GenericEqualityComparer<string>();
			}
			else if (type.IsAssignableTo(typeof(IEquatable<>).MakeGenericType(type)))
			{
				obj = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer<string>), runtimeType);
			}
			else if (type.IsGenericType)
			{
				if (type.GetGenericTypeDefinition() == typeof(Nullable<>))
				{
					obj = TryCreateNullableEqualityComparer(runtimeType);
				}
			}
			else if (type.IsEnum)
			{
				obj = TryCreateEnumEqualityComparer(runtimeType);
			}
			return obj ?? RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(ObjectEqualityComparer<object>), runtimeType);
		}

		private static object TryCreateNullableEqualityComparer(RuntimeType nullableType)
		{
			RuntimeType runtimeType = (RuntimeType)nullableType.GetGenericArguments()[0];
			if (typeof(IEquatable<>).MakeGenericType(runtimeType).IsAssignableFrom(runtimeType))
			{
				return RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer<int>), runtimeType);
			}
			return null;
		}

		private static object TryCreateEnumEqualityComparer(RuntimeType enumType)
		{
			TypeCode typeCode = Type.GetTypeCode(Enum.GetUnderlyingType(enumType));
			if ((uint)(typeCode - 5) <= 7u)
			{
				return RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer<>), enumType);
			}
			return null;
		}
	}
	[Serializable]
	[TypeDependency("System.Collections.Generic.ObjectEqualityComparer`1")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public abstract class EqualityComparer<T> : IEqualityComparer, IEqualityComparer<T>
	{
		public static EqualityComparer<T> Default
		{
			[Intrinsic]
			get;
		} = (EqualityComparer<T>)ComparerHelpers.CreateDefaultEqualityComparer(typeof(T));


		public abstract bool Equals(T? x, T? y);

		public abstract int GetHashCode([DisallowNull] T obj);

		int IEqualityComparer.GetHashCode(object obj)
		{
			if (obj == null)
			{
				return 0;
			}
			if (obj is T)
			{
				return GetHashCode((T)obj);
			}
			ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArgumentForComparison);
			return 0;
		}

		bool IEqualityComparer.Equals(object x, object y)
		{
			if (x == y)
			{
				return true;
			}
			if (x == null || y == null)
			{
				return false;
			}
			if (x is T && y is T)
			{
				return Equals((T)x, (T)y);
			}
			ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidArgumentForComparison);
			return false;
		}

		internal virtual int IndexOf(T[] array, T value, int startIndex, int count)
		{
			int num = startIndex + count;
			for (int i = startIndex; i < num; i++)
			{
				if (Equals(array[i], value))
				{
					return i;
				}
			}
			return -1;
		}

		internal virtual int LastIndexOf(T[] array, T value, int startIndex, int count)
		{
			int num = startIndex - count + 1;
			for (int num2 = startIndex; num2 >= num; num2--)
			{
				if (Equals(array[num2], value))
				{
					return num2;
				}
			}
			return -1;
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class GenericEqualityComparer<T> : EqualityComparer<T> where T : IEquatable<T>
	{
		internal override int IndexOf(T[] array, T value, int startIndex, int count)
		{
			int num = startIndex + count;
			if (value == null)
			{
				for (int i = startIndex; i < num; i++)
				{
					if (array[i] == null)
					{
						return i;
					}
				}
			}
			else
			{
				for (int j = startIndex; j < num; j++)
				{
					if (array[j] != null && array[j].Equals(value))
					{
						return j;
					}
				}
			}
			return -1;
		}

		internal override int LastIndexOf(T[] array, T value, int startIndex, int count)
		{
			int num = startIndex - count + 1;
			if (value == null)
			{
				for (int num2 = startIndex; num2 >= num; num2--)
				{
					if (array[num2] == null)
					{
						return num2;
					}
				}
			}
			else
			{
				for (int num3 = startIndex; num3 >= num; num3--)
				{
					if (array[num3] != null && array[num3].Equals(value))
					{
						return num3;
					}
				}
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override bool Equals(T? x, T? y)
		{
			if (x != null)
			{
				if (y != null)
				{
					return x.Equals(y);
				}
				return false;
			}
			if (y != null)
			{
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode([DisallowNull] T obj)
		{
			return obj?.GetHashCode() ?? 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			return obj is GenericEqualityComparer<T>;
		}

		public override int GetHashCode()
		{
			return typeof(GenericEqualityComparer<T>).GetHashCode();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class NullableEqualityComparer<T> : EqualityComparer<T?> where T : struct, IEquatable<T>
	{
		internal override int IndexOf(T?[] array, T? value, int startIndex, int count)
		{
			int num = startIndex + count;
			if (!value.HasValue)
			{
				for (int i = startIndex; i < num; i++)
				{
					if (!array[i].HasValue)
					{
						return i;
					}
				}
			}
			else
			{
				for (int j = startIndex; j < num; j++)
				{
					if (array[j].HasValue && array[j].value.Equals(value.value))
					{
						return j;
					}
				}
			}
			return -1;
		}

		internal override int LastIndexOf(T?[] array, T? value, int startIndex, int count)
		{
			int num = startIndex - count + 1;
			if (!value.HasValue)
			{
				for (int num2 = startIndex; num2 >= num; num2--)
				{
					if (!array[num2].HasValue)
					{
						return num2;
					}
				}
			}
			else
			{
				for (int num3 = startIndex; num3 >= num; num3--)
				{
					if (array[num3].HasValue && array[num3].value.Equals(value.value))
					{
						return num3;
					}
				}
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override bool Equals(T? x, T? y)
		{
			if (x.HasValue)
			{
				if (y.HasValue)
				{
					return x.value.Equals(y.value);
				}
				return false;
			}
			if (y.HasValue)
			{
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode(T? obj)
		{
			return obj.GetHashCode();
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj != null)
			{
				return GetType() == obj.GetType();
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetType().GetHashCode();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class ObjectEqualityComparer<T> : EqualityComparer<T>
	{
		internal override int IndexOf(T[] array, T value, int startIndex, int count)
		{
			int num = startIndex + count;
			if (value == null)
			{
				for (int i = startIndex; i < num; i++)
				{
					if (array[i] == null)
					{
						return i;
					}
				}
			}
			else
			{
				for (int j = startIndex; j < num; j++)
				{
					if (array[j] != null && array[j].Equals(value))
					{
						return j;
					}
				}
			}
			return -1;
		}

		internal override int LastIndexOf(T[] array, T value, int startIndex, int count)
		{
			int num = startIndex - count + 1;
			if (value == null)
			{
				for (int num2 = startIndex; num2 >= num; num2--)
				{
					if (array[num2] == null)
					{
						return num2;
					}
				}
			}
			else
			{
				for (int num3 = startIndex; num3 >= num; num3--)
				{
					if (array[num3] != null && array[num3].Equals(value))
					{
						return num3;
					}
				}
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override bool Equals(T? x, T? y)
		{
			if (x != null)
			{
				if (y != null)
				{
					return x.Equals(y);
				}
				return false;
			}
			if (y != null)
			{
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode([DisallowNull] T obj)
		{
			return obj?.GetHashCode() ?? 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj != null)
			{
				return GetType() == obj.GetType();
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetType().GetHashCode();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class ByteEqualityComparer : EqualityComparer<byte>
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override bool Equals(byte x, byte y)
		{
			return x == y;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode(byte b)
		{
			return b.GetHashCode();
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj != null)
			{
				return GetType() == obj.GetType();
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetType().GetHashCode();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class EnumEqualityComparer<T> : EqualityComparer<T>, ISerializable where T : struct, Enum
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override bool Equals(T x, T y)
		{
			return RuntimeHelpers.EnumEquals(x, y);
		}

		internal override int IndexOf(T[] array, T value, int startIndex, int count)
		{
			int num = startIndex + count;
			for (int i = startIndex; i < num; i++)
			{
				if (RuntimeHelpers.EnumEquals(array[i], value))
				{
					return i;
				}
			}
			return -1;
		}

		internal override int LastIndexOf(T[] array, T value, int startIndex, int count)
		{
			int num = startIndex - count + 1;
			for (int num2 = startIndex; num2 >= num; num2--)
			{
				if (RuntimeHelpers.EnumEquals(array[num2], value))
				{
					return num2;
				}
			}
			return -1;
		}

		public EnumEqualityComparer()
		{
		}

		private EnumEqualityComparer(SerializationInfo information, StreamingContext context)
		{
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (Type.GetTypeCode(Enum.GetUnderlyingType(typeof(T))) != TypeCode.Int32)
			{
				info.SetType(typeof(ObjectEqualityComparer<T>));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode(T obj)
		{
			return obj.GetHashCode();
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj != null)
			{
				return GetType() == obj.GetType();
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetType().GetHashCode();
		}
	}
	internal static class SortUtils
	{
		public static int MoveNansToFront<TKey, TValue>(Span<TKey> keys, Span<TValue> values)
		{
			int num = 0;
			for (int i = 0; i < keys.Length; i++)
			{
				if ((typeof(TKey) == typeof(double) && double.IsNaN((double)(object)keys[i])) || (typeof(TKey) == typeof(float) && float.IsNaN((float)(object)keys[i])) || (typeof(TKey) == typeof(Half) && Half.IsNaN((Half)(object)keys[i])))
				{
					TKey val = keys[num];
					keys[num] = keys[i];
					keys[i] = val;
					if ((uint)i < (uint)values.Length)
					{
						TValue val2 = values[num];
						values[num] = values[i];
						values[i] = val2;
					}
					num++;
				}
			}
			return num;
		}
	}
	internal sealed class ComparisonComparer<T> : Comparer<T>
	{
		private readonly Comparison<T> _comparison;

		public ComparisonComparer(Comparison<T> comparison)
		{
			_comparison = comparison;
		}

		public override int Compare(T x, T y)
		{
			return _comparison(x, y);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class GenericComparer<T> : Comparer<T> where T : IComparable<T>
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int Compare(T? x, T? y)
		{
			if (x != null)
			{
				if (y != null)
				{
					return x.CompareTo(y);
				}
				return 1;
			}
			if (y != null)
			{
				return -1;
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj != null)
			{
				return GetType() == obj.GetType();
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetType().GetHashCode();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class NullableComparer<T> : Comparer<T?> where T : struct, IComparable<T>
	{
		public override int Compare(T? x, T? y)
		{
			if (x.HasValue)
			{
				if (y.HasValue)
				{
					return x.value.CompareTo(y.value);
				}
				return 1;
			}
			if (y.HasValue)
			{
				return -1;
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj != null)
			{
				return GetType() == obj.GetType();
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetType().GetHashCode();
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public sealed class ObjectComparer<T> : Comparer<T>
	{
		public override int Compare(T? x, T? y)
		{
			return Comparer.Default.Compare(x, y);
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj != null)
			{
				return GetType() == obj.GetType();
			}
			return false;
		}

		public override int GetHashCode()
		{
			return GetType().GetHashCode();
		}
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(IDictionaryDebugView<, >))]
	[DebuggerDisplay("Count = {Count}")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IDictionary, ICollection, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, ISerializable, IDeserializationCallback where TKey : notnull
	{
		internal static class CollectionsMarshalHelper
		{
			public static ref TValue GetValueRefOrAddDefault(Dictionary<TKey, TValue> dictionary, TKey key, out bool exists)
			{
				if (key == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
				}
				if (dictionary._buckets == null)
				{
					dictionary.Initialize(0);
				}
				Entry[] entries = dictionary._entries;
				IEqualityComparer<TKey> comparer = dictionary._comparer;
				uint num = (uint)(comparer?.GetHashCode(key) ?? key.GetHashCode());
				uint num2 = 0u;
				ref int bucket = ref dictionary.GetBucket(num);
				int num3 = bucket - 1;
				if (comparer == null)
				{
					if (typeof(TKey).IsValueType)
					{
						while ((uint)num3 < (uint)entries.Length)
						{
							if (entries[num3].hashCode == num && EqualityComparer<TKey>.Default.Equals(entries[num3].key, key))
							{
								exists = true;
								return ref entries[num3].value;
							}
							num3 = entries[num3].next;
							num2++;
							if (num2 > (uint)entries.Length)
							{
								ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
							}
						}
					}
					else
					{
						EqualityComparer<TKey> @default = EqualityComparer<TKey>.Default;
						while ((uint)num3 < (uint)entries.Length)
						{
							if (entries[num3].hashCode == num && @default.Equals(entries[num3].key, key))
							{
								exists = true;
								return ref entries[num3].value;
							}
							num3 = entries[num3].next;
							num2++;
							if (num2 > (uint)entries.Length)
							{
								ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
							}
						}
					}
				}
				else
				{
					while ((uint)num3 < (uint)entries.Length)
					{
						if (entries[num3].hashCode == num && comparer.Equals(entries[num3].key, key))
						{
							exists = true;
							return ref entries[num3].value;
						}
						num3 = entries[num3].next;
						num2++;
						if (num2 > (uint)entries.Length)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
					}
				}
				int num4;
				if (dictionary._freeCount > 0)
				{
					num4 = dictionary._freeList;
					dictionary._freeList = -3 - entries[dictionary._freeList].next;
					dictionary._freeCount--;
				}
				else
				{
					int count = dictionary._count;
					if (count == entries.Length)
					{
						dictionary.Resize();
						bucket = ref dictionary.GetBucket(num);
					}
					num4 = count;
					dictionary._count = count + 1;
					entries = dictionary._entries;
				}
				ref Entry reference = ref entries[num4];
				reference.hashCode = num;
				reference.next = bucket - 1;
				reference.key = key;
				reference.value = default(TValue);
				bucket = num4 + 1;
				dictionary._version++;
				if (!typeof(TKey).IsValueType && num2 > 100 && comparer is NonRandomizedStringEqualityComparer)
				{
					dictionary.Resize(entries.Length, forceNewHashCodes: true);
					exists = false;
					return ref dictionary.FindValue(key);
				}
				exists = false;
				return ref reference.value;
			}
		}

		private struct Entry
		{
			public uint hashCode;

			public int next;

			public TKey key;

			public TValue value;
		}

		public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IDisposable, IEnumerator, IDictionaryEnumerator
		{
			private readonly Dictionary<TKey, TValue> _dictionary;

			private readonly int _version;

			private int _index;

			private KeyValuePair<TKey, TValue> _current;

			private readonly int _getEnumeratorRetType;

			public KeyValuePair<TKey, TValue> Current => _current;

			object? IEnumerator.Current
			{
				get
				{
					if (_index == 0 || _index == _dictionary._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					if (_getEnumeratorRetType == 1)
					{
						return new DictionaryEntry(_current.Key, _current.Value);
					}
					return new KeyValuePair<TKey, TValue>(_current.Key, _current.Value);
				}
			}

			DictionaryEntry IDictionaryEnumerator.Entry
			{
				get
				{
					if (_index == 0 || _index == _dictionary._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return new DictionaryEntry(_current.Key, _current.Value);
				}
			}

			object IDictionaryEnumerator.Key
			{
				get
				{
					if (_index == 0 || _index == _dictionary._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return _current.Key;
				}
			}

			object? IDictionaryEnumerator.Value
			{
				get
				{
					if (_index == 0 || _index == _dictionary._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return _current.Value;
				}
			}

			internal Enumerator(Dictionary<TKey, TValue> dictionary, int getEnumeratorRetType)
			{
				_dictionary = dictionary;
				_version = dictionary._version;
				_index = 0;
				_getEnumeratorRetType = getEnumeratorRetType;
				_current = default(KeyValuePair<TKey, TValue>);
			}

			public bool MoveNext()
			{
				if (_version != _dictionary._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				while ((uint)_index < (uint)_dictionary._count)
				{
					ref Entry reference = ref _dictionary._entries[_index++];
					if (reference.next >= -1)
					{
						_current = new KeyValuePair<TKey, TValue>(reference.key, reference.value);
						return true;
					}
				}
				_index = _dictionary._count + 1;
				_current = default(KeyValuePair<TKey, TValue>);
				return false;
			}

			public void Dispose()
			{
			}

			void IEnumerator.Reset()
			{
				if (_version != _dictionary._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				_index = 0;
				_current = default(KeyValuePair<TKey, TValue>);
			}
		}

		[DebuggerTypeProxy(typeof(DictionaryKeyCollectionDebugView<, >))]
		[DebuggerDisplay("Count = {Count}")]
		public sealed class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable, ICollection, IReadOnlyCollection<TKey>
		{
			public struct Enumerator : IEnumerator<TKey>, IDisposable, IEnumerator
			{
				private readonly Dictionary<TKey, TValue> _dictionary;

				private int _index;

				private readonly int _version;

				private TKey _currentKey;

				public TKey Current => _currentKey;

				object? IEnumerator.Current
				{
					get
					{
						if (_index == 0 || _index == _dictionary._count + 1)
						{
							ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
						}
						return _currentKey;
					}
				}

				internal Enumerator(Dictionary<TKey, TValue> dictionary)
				{
					_dictionary = dictionary;
					_version = dictionary._version;
					_index = 0;
					_currentKey = default(TKey);
				}

				public void Dispose()
				{
				}

				public bool MoveNext()
				{
					if (_version != _dictionary._version)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
					}
					while ((uint)_index < (uint)_dictionary._count)
					{
						ref Entry reference = ref _dictionary._entries[_index++];
						if (reference.next >= -1)
						{
							_currentKey = reference.key;
							return true;
						}
					}
					_index = _dictionary._count + 1;
					_currentKey = default(TKey);
					return false;
				}

				void IEnumerator.Reset()
				{
					if (_version != _dictionary._version)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
					}
					_index = 0;
					_currentKey = default(TKey);
				}
			}

			private readonly Dictionary<TKey, TValue> _dictionary;

			public int Count => _dictionary.Count;

			bool ICollection<TKey>.IsReadOnly => true;

			bool ICollection.IsSynchronized => false;

			object ICollection.SyncRoot => ((ICollection)_dictionary).SyncRoot;

			public KeyCollection(Dictionary<TKey, TValue> dictionary)
			{
				if (dictionary == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
				}
				_dictionary = dictionary;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			public void CopyTo(TKey[] array, int index)
			{
				if (array == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				if (index < 0 || index > array.Length)
				{
					ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
				}
				if (array.Length - index < _dictionary.Count)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
				}
				int count = _dictionary._count;
				Entry[] entries = _dictionary._entries;
				for (int i = 0; i < count; i++)
				{
					if (entries[i].next >= -1)
					{
						array[index++] = entries[i].key;
					}
				}
			}

			void ICollection<TKey>.Add(TKey item)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
			}

			void ICollection<TKey>.Clear()
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
			}

			bool ICollection<TKey>.Contains(TKey item)
			{
				return _dictionary.ContainsKey(item);
			}

			bool ICollection<TKey>.Remove(TKey item)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_KeyCollectionSet);
				return false;
			}

			IEnumerator<TKey> IEnumerable<TKey>.GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			void ICollection.CopyTo(Array array, int index)
			{
				if (array == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				if (array.Rank != 1)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
				}
				if (array.GetLowerBound(0) != 0)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
				}
				if ((uint)index > (uint)array.Length)
				{
					ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
				}
				if (array.Length - index < _dictionary.Count)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
				}
				if (array is TKey[] array2)
				{
					CopyTo(array2, index);
					return;
				}
				object[] array3 = array as object[];
				if (array3 == null)
				{
					ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
				}
				int count = _dictionary._count;
				Entry[] entries = _dictionary._entries;
				try
				{
					for (int i = 0; i < count; i++)
					{
						if (entries[i].next >= -1)
						{
							array3[index++] = entries[i].key;
						}
					}
				}
				catch (ArrayTypeMismatchException)
				{
					ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
				}
			}
		}

		[DebuggerTypeProxy(typeof(DictionaryValueCollectionDebugView<, >))]
		[DebuggerDisplay("Count = {Count}")]
		public sealed class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable, ICollection, IReadOnlyCollection<TValue>
		{
			public struct Enumerator : IEnumerator<TValue>, IDisposable, IEnumerator
			{
				private readonly Dictionary<TKey, TValue> _dictionary;

				private int _index;

				private readonly int _version;

				private TValue _currentValue;

				public TValue Current => _currentValue;

				object? IEnumerator.Current
				{
					get
					{
						if (_index == 0 || _index == _dictionary._count + 1)
						{
							ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
						}
						return _currentValue;
					}
				}

				internal Enumerator(Dictionary<TKey, TValue> dictionary)
				{
					_dictionary = dictionary;
					_version = dictionary._version;
					_index = 0;
					_currentValue = default(TValue);
				}

				public void Dispose()
				{
				}

				public bool MoveNext()
				{
					if (_version != _dictionary._version)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
					}
					while ((uint)_index < (uint)_dictionary._count)
					{
						ref Entry reference = ref _dictionary._entries[_index++];
						if (reference.next >= -1)
						{
							_currentValue = reference.value;
							return true;
						}
					}
					_index = _dictionary._count + 1;
					_currentValue = default(TValue);
					return false;
				}

				void IEnumerator.Reset()
				{
					if (_version != _dictionary._version)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
					}
					_index = 0;
					_currentValue = default(TValue);
				}
			}

			private readonly Dictionary<TKey, TValue> _dictionary;

			public int Count => _dictionary.Count;

			bool ICollection<TValue>.IsReadOnly => true;

			bool ICollection.IsSynchronized => false;

			object ICollection.SyncRoot => ((ICollection)_dictionary).SyncRoot;

			public ValueCollection(Dictionary<TKey, TValue> dictionary)
			{
				if (dictionary == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
				}
				_dictionary = dictionary;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			public void CopyTo(TValue[] array, int index)
			{
				if (array == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				if ((uint)index > array.Length)
				{
					ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
				}
				if (array.Length - index < _dictionary.Count)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
				}
				int count = _dictionary._count;
				Entry[] entries = _dictionary._entries;
				for (int i = 0; i < count; i++)
				{
					if (entries[i].next >= -1)
					{
						array[index++] = entries[i].value;
					}
				}
			}

			void ICollection<TValue>.Add(TValue item)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
			}

			bool ICollection<TValue>.Remove(TValue item)
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
				return false;
			}

			void ICollection<TValue>.Clear()
			{
				ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_ValueCollectionSet);
			}

			bool ICollection<TValue>.Contains(TValue item)
			{
				return _dictionary.ContainsValue(item);
			}

			IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return new Enumerator(_dictionary);
			}

			void ICollection.CopyTo(Array array, int index)
			{
				if (array == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
				}
				if (array.Rank != 1)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
				}
				if (array.GetLowerBound(0) != 0)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
				}
				if ((uint)index > (uint)array.Length)
				{
					ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
				}
				if (array.Length - index < _dictionary.Count)
				{
					ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
				}
				if (array is TValue[] array2)
				{
					CopyTo(array2, index);
					return;
				}
				object[] array3 = array as object[];
				if (array3 == null)
				{
					ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
				}
				int count = _dictionary._count;
				Entry[] entries = _dictionary._entries;
				try
				{
					for (int i = 0; i < count; i++)
					{
						if (entries[i].next >= -1)
						{
							array3[index++] = entries[i].value;
						}
					}
				}
				catch (ArrayTypeMismatchException)
				{
					ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
				}
			}
		}

		private int[] _buckets;

		private Entry[] _entries;

		private int _count;

		private int _freeList;

		private int _freeCount;

		private int _version;

		private IEqualityComparer<TKey> _comparer;

		private KeyCollection _keys;

		private ValueCollection _values;

		public IEqualityComparer<TKey> Comparer
		{
			get
			{
				if (typeof(TKey) == typeof(string))
				{
					return (IEqualityComparer<TKey>)IInternalStringEqualityComparer.GetUnderlyingEqualityComparer((IEqualityComparer<string>)_comparer);
				}
				return _comparer ?? EqualityComparer<TKey>.Default;
			}
		}

		public int Count => _count - _freeCount;

		public KeyCollection Keys => _keys ?? (_keys = new KeyCollection(this));

		ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys;

		IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => Keys;

		public ValueCollection Values => _values ?? (_values = new ValueCollection(this));

		ICollection<TValue> IDictionary<TKey, TValue>.Values => Values;

		IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => Values;

		public TValue this[TKey key]
		{
			get
			{
				ref TValue reference = ref FindValue(key);
				if (!Unsafe.IsNullRef(ref reference))
				{
					return reference;
				}
				ThrowHelper.ThrowKeyNotFoundException(key);
				return default(TValue);
			}
			set
			{
				bool flag = TryInsert(key, value, InsertionBehavior.OverwriteExisting);
			}
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		bool IDictionary.IsFixedSize => false;

		bool IDictionary.IsReadOnly => false;

		ICollection IDictionary.Keys => Keys;

		ICollection IDictionary.Values => Values;

		object? IDictionary.this[object key]
		{
			get
			{
				if (IsCompatibleKey(key))
				{
					ref TValue reference = ref FindValue((TKey)key);
					if (!Unsafe.IsNullRef(ref reference))
					{
						return reference;
					}
				}
				return null;
			}
			set
			{
				if (key == null)
				{
					ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
				}
				ThrowHelper.IfNullAndNullsAreIllegalThenThrow<TValue>(value, ExceptionArgument.value);
				try
				{
					TKey key2 = (TKey)key;
					try
					{
						this[key2] = (TValue)value;
					}
					catch (InvalidCastException)
					{
						ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));
					}
				}
				catch (InvalidCastException)
				{
					ThrowHelper.ThrowWrongKeyTypeArgumentException(key, typeof(TKey));
				}
			}
		}

		public Dictionary()
			: this(0, (IEqualityComparer<TKey>?)null)
		{
		}

		public Dictionary(int capacity)
			: this(capacity, (IEqualityComparer<TKey>?)null)
		{
		}

		public Dictionary(IEqualityComparer<TKey>? comparer)
			: this(0, comparer)
		{
		}

		public Dictionary(int capacity, IEqualityComparer<TKey>? comparer)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
			}
			if (capacity > 0)
			{
				Initialize(capacity);
			}
			if (comparer != null && comparer != EqualityComparer<TKey>.Default)
			{
				_comparer = comparer;
			}
			if (typeof(TKey) == typeof(string))
			{
				IEqualityComparer<string> stringComparer = NonRandomizedStringEqualityComparer.GetStringComparer(_comparer);
				if (stringComparer != null)
				{
					_comparer = (IEqualityComparer<TKey>)stringComparer;
				}
			}
		}

		public Dictionary(IDictionary<TKey, TValue> dictionary)
			: this(dictionary, (IEqualityComparer<TKey>?)null)
		{
		}

		public Dictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey>? comparer)
			: this(dictionary?.Count ?? 0, comparer)
		{
			if (dictionary == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
			}
			AddRange(dictionary);
		}

		public Dictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection)
			: this(collection, (IEqualityComparer<TKey>?)null)
		{
		}

		public Dictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey>? comparer)
			: this((collection as ICollection<KeyValuePair<TKey, TValue>>)?.Count ?? 0, comparer)
		{
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
			AddRange(collection);
		}

		private void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> collection)
		{
			if (collection.GetType() == typeof(Dictionary<TKey, TValue>))
			{
				Dictionary<TKey, TValue> dictionary = (Dictionary<TKey, TValue>)collection;
				if (dictionary.Count == 0)
				{
					return;
				}
				Entry[] entries = dictionary._entries;
				if (dictionary._comparer == _comparer)
				{
					CopyEntries(entries, dictionary._count);
					return;
				}
				int count = dictionary._count;
				for (int i = 0; i < count; i++)
				{
					if (entries[i].next >= -1)
					{
						Add(entries[i].key, entries[i].value);
					}
				}
				return;
			}
			foreach (KeyValuePair<TKey, TValue> item in collection)
			{
				Add(item.Key, item.Value);
			}
		}

		protected Dictionary(SerializationInfo info, StreamingContext context)
		{
			HashHelpers.SerializationInfoTable.Add(this, info);
		}

		public void Add(TKey key, TValue value)
		{
			bool flag = TryInsert(key, value, InsertionBehavior.ThrowOnExisting);
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> keyValuePair)
		{
			Add(keyValuePair.Key, keyValuePair.Value);
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair)
		{
			ref TValue reference = ref FindValue(keyValuePair.Key);
			if (!Unsafe.IsNullRef(ref reference) && EqualityComparer<TValue>.Default.Equals(reference, keyValuePair.Value))
			{
				return true;
			}
			return false;
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> keyValuePair)
		{
			ref TValue reference = ref FindValue(keyValuePair.Key);
			if (!Unsafe.IsNullRef(ref reference) && EqualityComparer<TValue>.Default.Equals(reference, keyValuePair.Value))
			{
				Remove(keyValuePair.Key);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			int count = _count;
			if (count > 0)
			{
				Array.Clear(_buckets);
				_count = 0;
				_freeList = -1;
				_freeCount = 0;
				Array.Clear(_entries, 0, count);
			}
		}

		public bool ContainsKey(TKey key)
		{
			return !Unsafe.IsNullRef(ref FindValue(key));
		}

		public bool ContainsValue(TValue value)
		{
			Entry[] entries = _entries;
			if (value == null)
			{
				for (int i = 0; i < _count; i++)
				{
					if (entries[i].next >= -1 && entries[i].value == null)
					{
						return true;
					}
				}
			}
			else if (typeof(TValue).IsValueType)
			{
				for (int j = 0; j < _count; j++)
				{
					if (entries[j].next >= -1 && EqualityComparer<TValue>.Default.Equals(entries[j].value, value))
					{
						return true;
					}
				}
			}
			else
			{
				EqualityComparer<TValue> @default = EqualityComparer<TValue>.Default;
				for (int k = 0; k < _count; k++)
				{
					if (entries[k].next >= -1 && @default.Equals(entries[k].value, value))
					{
						return true;
					}
				}
			}
			return false;
		}

		private void CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if ((uint)index > (uint)array.Length)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (array.Length - index < Count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
			}
			int count = _count;
			Entry[] entries = _entries;
			for (int i = 0; i < count; i++)
			{
				if (entries[i].next >= -1)
				{
					array[index++] = new KeyValuePair<TKey, TValue>(entries[i].key, entries[i].value);
				}
			}
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this, 2);
		}

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			return new Enumerator(this, 2);
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.info);
			}
			info.AddValue("Version", _version);
			info.AddValue("Comparer", Comparer, typeof(IEqualityComparer<TKey>));
			info.AddValue("HashSize", (_buckets != null) ? _buckets.Length : 0);
			if (_buckets != null)
			{
				KeyValuePair<TKey, TValue>[] array = new KeyValuePair<TKey, TValue>[Count];
				CopyTo(array, 0);
				info.AddValue("KeyValuePairs", array, typeof(KeyValuePair<TKey, TValue>[]));
			}
		}

		internal ref TValue FindValue(TKey key)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			ref Entry reference = ref Unsafe.NullRef<Entry>();
			if (_buckets != null)
			{
				IEqualityComparer<TKey> comparer = _comparer;
				if (comparer == null)
				{
					uint hashCode = (uint)key.GetHashCode();
					int bucket = GetBucket(hashCode);
					Entry[] entries = _entries;
					uint num = 0u;
					if (typeof(TKey).IsValueType)
					{
						bucket--;
						while ((uint)bucket < (uint)entries.Length)
						{
							reference = ref entries[bucket];
							if (reference.hashCode != hashCode || !EqualityComparer<TKey>.Default.Equals(reference.key, key))
							{
								bucket = reference.next;
								num++;
								if (num <= (uint)entries.Length)
								{
									continue;
								}
								goto IL_0171;
							}
							goto IL_0176;
						}
					}
					else
					{
						EqualityComparer<TKey> @default = EqualityComparer<TKey>.Default;
						bucket--;
						while ((uint)bucket < (uint)entries.Length)
						{
							reference = ref entries[bucket];
							if (reference.hashCode != hashCode || !@default.Equals(reference.key, key))
							{
								bucket = reference.next;
								num++;
								if (num <= (uint)entries.Length)
								{
									continue;
								}
								goto IL_0171;
							}
							goto IL_0176;
						}
					}
				}
				else
				{
					uint hashCode2 = (uint)comparer.GetHashCode(key);
					int bucket2 = GetBucket(hashCode2);
					Entry[] entries2 = _entries;
					uint num2 = 0u;
					bucket2--;
					while ((uint)bucket2 < (uint)entries2.Length)
					{
						reference = ref entries2[bucket2];
						if (reference.hashCode != hashCode2 || !comparer.Equals(reference.key, key))
						{
							bucket2 = reference.next;
							num2++;
							if (num2 <= (uint)entries2.Length)
							{
								continue;
							}
							goto IL_0171;
						}
						goto IL_0176;
					}
				}
			}
			return ref Unsafe.NullRef<TValue>();
			IL_0176:
			return ref reference.value;
			IL_0171:
			ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
			goto IL_0176;
		}

		private int Initialize(int capacity)
		{
			int prime = HashHelpers.GetPrime(capacity);
			int[] buckets = new int[prime];
			Entry[] entries = new Entry[prime];
			_freeList = -1;
			_buckets = buckets;
			_entries = entries;
			return prime;
		}

		private bool TryInsert(TKey key, TValue value, InsertionBehavior behavior)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			if (_buckets == null)
			{
				Initialize(0);
			}
			Entry[] entries = _entries;
			IEqualityComparer<TKey> comparer = _comparer;
			uint num = (uint)(comparer?.GetHashCode(key) ?? key.GetHashCode());
			uint num2 = 0u;
			ref int bucket = ref GetBucket(num);
			int num3 = bucket - 1;
			if (comparer == null)
			{
				if (typeof(TKey).IsValueType)
				{
					while ((uint)num3 < (uint)entries.Length)
					{
						if (entries[num3].hashCode == num && EqualityComparer<TKey>.Default.Equals(entries[num3].key, key))
						{
							switch (behavior)
							{
							case InsertionBehavior.OverwriteExisting:
								entries[num3].value = value;
								return true;
							case InsertionBehavior.ThrowOnExisting:
								ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
								break;
							}
							return false;
						}
						num3 = entries[num3].next;
						num2++;
						if (num2 > (uint)entries.Length)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
					}
				}
				else
				{
					EqualityComparer<TKey> @default = EqualityComparer<TKey>.Default;
					while ((uint)num3 < (uint)entries.Length)
					{
						if (entries[num3].hashCode == num && @default.Equals(entries[num3].key, key))
						{
							switch (behavior)
							{
							case InsertionBehavior.OverwriteExisting:
								entries[num3].value = value;
								return true;
							case InsertionBehavior.ThrowOnExisting:
								ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
								break;
							}
							return false;
						}
						num3 = entries[num3].next;
						num2++;
						if (num2 > (uint)entries.Length)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
					}
				}
			}
			else
			{
				while ((uint)num3 < (uint)entries.Length)
				{
					if (entries[num3].hashCode == num && comparer.Equals(entries[num3].key, key))
					{
						switch (behavior)
						{
						case InsertionBehavior.OverwriteExisting:
							entries[num3].value = value;
							return true;
						case InsertionBehavior.ThrowOnExisting:
							ThrowHelper.ThrowAddingDuplicateWithKeyArgumentException(key);
							break;
						}
						return false;
					}
					num3 = entries[num3].next;
					num2++;
					if (num2 > (uint)entries.Length)
					{
						ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
					}
				}
			}
			int num4;
			if (_freeCount > 0)
			{
				num4 = _freeList;
				_freeList = -3 - entries[_freeList].next;
				_freeCount--;
			}
			else
			{
				int count = _count;
				if (count == entries.Length)
				{
					Resize();
					bucket = ref GetBucket(num);
				}
				num4 = count;
				_count = count + 1;
				entries = _entries;
			}
			ref Entry reference = ref entries[num4];
			reference.hashCode = num;
			reference.next = bucket - 1;
			reference.key = key;
			reference.value = value;
			bucket = num4 + 1;
			_version++;
			if (!typeof(TKey).IsValueType && num2 > 100 && comparer is NonRandomizedStringEqualityComparer)
			{
				Resize(entries.Length, forceNewHashCodes: true);
			}
			return true;
		}

		public virtual void OnDeserialization(object? sender)
		{
			HashHelpers.SerializationInfoTable.TryGetValue(this, out var value);
			if (value == null)
			{
				return;
			}
			int @int = value.GetInt32("Version");
			int int2 = value.GetInt32("HashSize");
			_comparer = (IEqualityComparer<TKey>)value.GetValue("Comparer", typeof(IEqualityComparer<TKey>));
			if (int2 != 0)
			{
				Initialize(int2);
				KeyValuePair<TKey, TValue>[] array = (KeyValuePair<TKey, TValue>[])value.GetValue("KeyValuePairs", typeof(KeyValuePair<TKey, TValue>[]));
				if (array == null)
				{
					ThrowHelper.ThrowSerializationException(ExceptionResource.Serialization_MissingKeys);
				}
				for (int i = 0; i < array.Length; i++)
				{
					if (array[i].Key == null)
					{
						ThrowHelper.ThrowSerializationException(ExceptionResource.Serialization_NullKey);
					}
					Add(array[i].Key, array[i].Value);
				}
			}
			else
			{
				_buckets = null;
			}
			_version = @int;
			HashHelpers.SerializationInfoTable.Remove(this);
		}

		private void Resize()
		{
			Resize(HashHelpers.ExpandPrime(_count), forceNewHashCodes: false);
		}

		private void Resize(int newSize, bool forceNewHashCodes)
		{
			Entry[] array = new Entry[newSize];
			int count = _count;
			Array.Copy(_entries, array, count);
			if (!typeof(TKey).IsValueType && forceNewHashCodes)
			{
				_comparer = (IEqualityComparer<TKey>)((NonRandomizedStringEqualityComparer)_comparer).GetRandomizedEqualityComparer();
				for (int i = 0; i < count; i++)
				{
					if (array[i].next >= -1)
					{
						array[i].hashCode = (uint)_comparer.GetHashCode(array[i].key);
					}
				}
				if (_comparer == EqualityComparer<TKey>.Default)
				{
					_comparer = null;
				}
			}
			_buckets = new int[newSize];
			for (int j = 0; j < count; j++)
			{
				if (array[j].next >= -1)
				{
					ref int bucket = ref GetBucket(array[j].hashCode);
					array[j].next = bucket - 1;
					bucket = j + 1;
				}
			}
			_entries = array;
		}

		public bool Remove(TKey key)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			if (_buckets != null)
			{
				uint num = 0u;
				uint num2 = (uint)(_comparer?.GetHashCode(key) ?? key.GetHashCode());
				ref int bucket = ref GetBucket(num2);
				Entry[] entries = _entries;
				int num3 = -1;
				int num4 = bucket - 1;
				while (num4 >= 0)
				{
					ref Entry reference = ref entries[num4];
					if (reference.hashCode == num2 && (_comparer?.Equals(reference.key, key) ?? EqualityComparer<TKey>.Default.Equals(reference.key, key)))
					{
						if (num3 < 0)
						{
							bucket = reference.next + 1;
						}
						else
						{
							entries[num3].next = reference.next;
						}
						reference.next = -3 - _freeList;
						if (RuntimeHelpers.IsReferenceOrContainsReferences<TKey>())
						{
							reference.key = default(TKey);
						}
						if (RuntimeHelpers.IsReferenceOrContainsReferences<TValue>())
						{
							reference.value = default(TValue);
						}
						_freeList = num4;
						_freeCount++;
						return true;
					}
					num3 = num4;
					num4 = reference.next;
					num++;
					if (num > (uint)entries.Length)
					{
						ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
					}
				}
			}
			return false;
		}

		public bool Remove(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			if (_buckets != null)
			{
				uint num = 0u;
				uint num2 = (uint)(_comparer?.GetHashCode(key) ?? key.GetHashCode());
				ref int bucket = ref GetBucket(num2);
				Entry[] entries = _entries;
				int num3 = -1;
				int num4 = bucket - 1;
				while (num4 >= 0)
				{
					ref Entry reference = ref entries[num4];
					if (reference.hashCode == num2 && (_comparer?.Equals(reference.key, key) ?? EqualityComparer<TKey>.Default.Equals(reference.key, key)))
					{
						if (num3 < 0)
						{
							bucket = reference.next + 1;
						}
						else
						{
							entries[num3].next = reference.next;
						}
						value = reference.value;
						reference.next = -3 - _freeList;
						if (RuntimeHelpers.IsReferenceOrContainsReferences<TKey>())
						{
							reference.key = default(TKey);
						}
						if (RuntimeHelpers.IsReferenceOrContainsReferences<TValue>())
						{
							reference.value = default(TValue);
						}
						_freeList = num4;
						_freeCount++;
						return true;
					}
					num3 = num4;
					num4 = reference.next;
					num++;
					if (num > (uint)entries.Length)
					{
						ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
					}
				}
			}
			value = default(TValue);
			return false;
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			ref TValue reference = ref FindValue(key);
			if (!Unsafe.IsNullRef(ref reference))
			{
				value = reference;
				return true;
			}
			value = default(TValue);
			return false;
		}

		public bool TryAdd(TKey key, TValue value)
		{
			return TryInsert(key, value, InsertionBehavior.None);
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
		{
			CopyTo(array, index);
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (array.Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
			}
			if (array.GetLowerBound(0) != 0)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_NonZeroLowerBound);
			}
			if ((uint)index > (uint)array.Length)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (array.Length - index < Count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
			}
			if (array is KeyValuePair<TKey, TValue>[] array2)
			{
				CopyTo(array2, index);
				return;
			}
			if (array is DictionaryEntry[] array3)
			{
				Entry[] entries = _entries;
				for (int i = 0; i < _count; i++)
				{
					if (entries[i].next >= -1)
					{
						array3[index++] = new DictionaryEntry(entries[i].key, entries[i].value);
					}
				}
				return;
			}
			object[] array4 = array as object[];
			if (array4 == null)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
			try
			{
				int count = _count;
				Entry[] entries2 = _entries;
				for (int j = 0; j < count; j++)
				{
					if (entries2[j].next >= -1)
					{
						array4[index++] = new KeyValuePair<TKey, TValue>(entries2[j].key, entries2[j].value);
					}
				}
			}
			catch (ArrayTypeMismatchException)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new Enumerator(this, 2);
		}

		public int EnsureCapacity(int capacity)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
			}
			int num = ((_entries != null) ? _entries.Length : 0);
			if (num >= capacity)
			{
				return num;
			}
			_version++;
			if (_buckets == null)
			{
				return Initialize(capacity);
			}
			int prime = HashHelpers.GetPrime(capacity);
			Resize(prime, forceNewHashCodes: false);
			return prime;
		}

		public void TrimExcess()
		{
			TrimExcess(Count);
		}

		public void TrimExcess(int capacity)
		{
			if (capacity < Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
			}
			int prime = HashHelpers.GetPrime(capacity);
			Entry[] entries = _entries;
			int num = ((entries != null) ? entries.Length : 0);
			if (prime < num)
			{
				int count = _count;
				_version++;
				Initialize(prime);
				CopyEntries(entries, count);
			}
		}

		private void CopyEntries(Entry[] entries, int count)
		{
			Entry[] entries2 = _entries;
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				uint hashCode = entries[i].hashCode;
				if (entries[i].next >= -1)
				{
					ref Entry reference = ref entries2[num];
					reference = entries[i];
					ref int bucket = ref GetBucket(hashCode);
					reference.next = bucket - 1;
					bucket = num + 1;
					num++;
				}
			}
			_count = num;
			_freeCount = 0;
		}

		private static bool IsCompatibleKey(object key)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			return key is TKey;
		}

		void IDictionary.Add(object key, object value)
		{
			if (key == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
			}
			ThrowHelper.IfNullAndNullsAreIllegalThenThrow<TValue>(value, ExceptionArgument.value);
			try
			{
				TKey key2 = (TKey)key;
				try
				{
					Add(key2, (TValue)value);
				}
				catch (InvalidCastException)
				{
					ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(TValue));
				}
			}
			catch (InvalidCastException)
			{
				ThrowHelper.ThrowWrongKeyTypeArgumentException(key, typeof(TKey));
			}
		}

		bool IDictionary.Contains(object key)
		{
			if (IsCompatibleKey(key))
			{
				return ContainsKey((TKey)key);
			}
			return false;
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new Enumerator(this, 1);
		}

		void IDictionary.Remove(object key)
		{
			if (IsCompatibleKey(key))
			{
				Remove((TKey)key);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ref int GetBucket(uint hashCode)
		{
			int[] buckets = _buckets;
			return ref buckets[hashCode % (uint)buckets.Length];
		}
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(ICollectionDebugView<>))]
	[DebuggerDisplay("Count = {Count}")]
	[TypeForwardedFrom("System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class HashSet<T> : ICollection<T>, IEnumerable<T>, IEnumerable, ISet<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISerializable, IDeserializationCallback
	{
		private struct Entry
		{
			public int HashCode;

			public int Next;

			public T Value;
		}

		public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
		{
			private readonly HashSet<T> _hashSet;

			private readonly int _version;

			private int _index;

			private T _current;

			public T Current => _current;

			object? IEnumerator.Current
			{
				get
				{
					if (_index == 0 || _index == _hashSet._count + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return _current;
				}
			}

			internal Enumerator(HashSet<T> hashSet)
			{
				_hashSet = hashSet;
				_version = hashSet._version;
				_index = 0;
				_current = default(T);
			}

			public bool MoveNext()
			{
				if (_version != _hashSet._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				while ((uint)_index < (uint)_hashSet._count)
				{
					ref Entry reference = ref _hashSet._entries[_index++];
					if (reference.Next >= -1)
					{
						_current = reference.Value;
						return true;
					}
				}
				_index = _hashSet._count + 1;
				_current = default(T);
				return false;
			}

			public void Dispose()
			{
			}

			void IEnumerator.Reset()
			{
				if (_version != _hashSet._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				_index = 0;
				_current = default(T);
			}
		}

		private int[] _buckets;

		private Entry[] _entries;

		private int _count;

		private int _freeList;

		private int _freeCount;

		private int _version;

		private IEqualityComparer<T> _comparer;

		public int Count => _count - _freeCount;

		bool ICollection<T>.IsReadOnly => false;

		public IEqualityComparer<T> Comparer
		{
			get
			{
				if (typeof(T) == typeof(string))
				{
					return (IEqualityComparer<T>)IInternalStringEqualityComparer.GetUnderlyingEqualityComparer((IEqualityComparer<string>)_comparer);
				}
				return _comparer ?? EqualityComparer<T>.Default;
			}
		}

		public HashSet()
			: this((IEqualityComparer<T>?)null)
		{
		}

		public HashSet(IEqualityComparer<T>? comparer)
		{
			if (comparer != null && comparer != EqualityComparer<T>.Default)
			{
				_comparer = comparer;
			}
			if (typeof(T) == typeof(string))
			{
				IEqualityComparer<string> stringComparer = NonRandomizedStringEqualityComparer.GetStringComparer(_comparer);
				if (stringComparer != null)
				{
					_comparer = (IEqualityComparer<T>)stringComparer;
				}
			}
		}

		public HashSet(int capacity)
			: this(capacity, (IEqualityComparer<T>?)null)
		{
		}

		public HashSet(IEnumerable<T> collection)
			: this(collection, (IEqualityComparer<T>?)null)
		{
		}

		public HashSet(IEnumerable<T> collection, IEqualityComparer<T>? comparer)
			: this(comparer)
		{
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
			if (collection is HashSet<T> hashSet && EqualityComparersAreEqual(this, hashSet))
			{
				ConstructFrom(hashSet);
				return;
			}
			if (collection is ICollection<T> collection2)
			{
				int count = collection2.Count;
				if (count > 0)
				{
					Initialize(count);
				}
			}
			UnionWith(collection);
			if (_count > 0 && _entries.Length / _count > 3)
			{
				TrimExcess();
			}
		}

		public HashSet(int capacity, IEqualityComparer<T>? comparer)
			: this(comparer)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
			}
			if (capacity > 0)
			{
				Initialize(capacity);
			}
		}

		protected HashSet(SerializationInfo info, StreamingContext context)
		{
			HashHelpers.SerializationInfoTable.Add(this, info);
		}

		private void ConstructFrom(HashSet<T> source)
		{
			if (source.Count == 0)
			{
				return;
			}
			int num = source._buckets.Length;
			int num2 = HashHelpers.ExpandPrime(source.Count + 1);
			if (num2 >= num)
			{
				_buckets = (int[])source._buckets.Clone();
				_entries = (Entry[])source._entries.Clone();
				_freeList = source._freeList;
				_freeCount = source._freeCount;
				_count = source._count;
				return;
			}
			Initialize(source.Count);
			Entry[] entries = source._entries;
			for (int i = 0; i < source._count; i++)
			{
				ref Entry reference = ref entries[i];
				if (reference.Next >= -1)
				{
					AddIfNotPresent(reference.Value, out var _);
				}
			}
		}

		void ICollection<T>.Add(T item)
		{
			AddIfNotPresent(item, out var _);
		}

		public void Clear()
		{
			int count = _count;
			if (count > 0)
			{
				Array.Clear(_buckets);
				_count = 0;
				_freeList = -1;
				_freeCount = 0;
				Array.Clear(_entries, 0, count);
			}
		}

		public bool Contains(T item)
		{
			return FindItemIndex(item) >= 0;
		}

		private int FindItemIndex(T item)
		{
			int[] buckets = _buckets;
			if (buckets != null)
			{
				Entry[] entries = _entries;
				uint num = 0u;
				IEqualityComparer<T> comparer = _comparer;
				if (comparer == null)
				{
					int num2 = item?.GetHashCode() ?? 0;
					if (typeof(T).IsValueType)
					{
						int num3 = GetBucketRef(num2) - 1;
						while (num3 >= 0)
						{
							ref Entry reference = ref entries[num3];
							if (reference.HashCode == num2 && EqualityComparer<T>.Default.Equals(reference.Value, item))
							{
								return num3;
							}
							num3 = reference.Next;
							num++;
							if (num > (uint)entries.Length)
							{
								ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
							}
						}
					}
					else
					{
						EqualityComparer<T> @default = EqualityComparer<T>.Default;
						int num4 = GetBucketRef(num2) - 1;
						while (num4 >= 0)
						{
							ref Entry reference2 = ref entries[num4];
							if (reference2.HashCode == num2 && @default.Equals(reference2.Value, item))
							{
								return num4;
							}
							num4 = reference2.Next;
							num++;
							if (num > (uint)entries.Length)
							{
								ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
							}
						}
					}
				}
				else
				{
					int num5 = ((item != null) ? comparer.GetHashCode(item) : 0);
					int num6 = GetBucketRef(num5) - 1;
					while (num6 >= 0)
					{
						ref Entry reference3 = ref entries[num6];
						if (reference3.HashCode == num5 && comparer.Equals(reference3.Value, item))
						{
							return num6;
						}
						num6 = reference3.Next;
						num++;
						if (num > (uint)entries.Length)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
					}
				}
			}
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ref int GetBucketRef(int hashCode)
		{
			int[] buckets = _buckets;
			return ref buckets[(uint)hashCode % (uint)buckets.Length];
		}

		public bool Remove(T item)
		{
			if (_buckets != null)
			{
				Entry[] entries = _entries;
				uint num = 0u;
				int num2 = -1;
				int num3 = ((item != null) ? (_comparer?.GetHashCode(item) ?? item.GetHashCode()) : 0);
				ref int bucketRef = ref GetBucketRef(num3);
				int num4 = bucketRef - 1;
				while (num4 >= 0)
				{
					ref Entry reference = ref entries[num4];
					if (reference.HashCode == num3 && (_comparer?.Equals(reference.Value, item) ?? EqualityComparer<T>.Default.Equals(reference.Value, item)))
					{
						if (num2 < 0)
						{
							bucketRef = reference.Next + 1;
						}
						else
						{
							entries[num2].Next = reference.Next;
						}
						reference.Next = -3 - _freeList;
						if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
						{
							reference.Value = default(T);
						}
						_freeList = num4;
						_freeCount++;
						return true;
					}
					num2 = num4;
					num4 = reference.Next;
					num++;
					if (num > (uint)entries.Length)
					{
						ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
					}
				}
			}
			return false;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			return GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (info == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.info);
			}
			info.AddValue("Version", _version);
			info.AddValue("Comparer", Comparer, typeof(IEqualityComparer<T>));
			info.AddValue("Capacity", (_buckets != null) ? _buckets.Length : 0);
			if (_buckets != null)
			{
				T[] array = new T[Count];
				CopyTo(array);
				info.AddValue("Elements", array, typeof(T[]));
			}
		}

		public virtual void OnDeserialization(object? sender)
		{
			HashHelpers.SerializationInfoTable.TryGetValue(this, out var value);
			if (value == null)
			{
				return;
			}
			int @int = value.GetInt32("Capacity");
			_comparer = (IEqualityComparer<T>)value.GetValue("Comparer", typeof(IEqualityComparer<T>));
			_freeList = -1;
			_freeCount = 0;
			if (@int != 0)
			{
				_buckets = new int[@int];
				_entries = new Entry[@int];
				T[] array = (T[])value.GetValue("Elements", typeof(T[]));
				if (array == null)
				{
					ThrowHelper.ThrowSerializationException(ExceptionResource.Serialization_MissingKeys);
				}
				for (int i = 0; i < array.Length; i++)
				{
					AddIfNotPresent(array[i], out var _);
				}
			}
			else
			{
				_buckets = null;
			}
			_version = value.GetInt32("Version");
			HashHelpers.SerializationInfoTable.Remove(this);
		}

		public bool Add(T item)
		{
			int location;
			return AddIfNotPresent(item, out location);
		}

		public bool TryGetValue(T equalValue, [MaybeNullWhen(false)] out T actualValue)
		{
			if (_buckets != null)
			{
				int num = FindItemIndex(equalValue);
				if (num >= 0)
				{
					actualValue = _entries[num].Value;
					return true;
				}
			}
			actualValue = default(T);
			return false;
		}

		public void UnionWith(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			foreach (T item in other)
			{
				AddIfNotPresent(item, out var _);
			}
		}

		public void IntersectWith(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (Count == 0 || other == this)
			{
				return;
			}
			if (other is ICollection<T> collection)
			{
				if (collection.Count == 0)
				{
					Clear();
					return;
				}
				if (other is HashSet<T> hashSet && EqualityComparersAreEqual(this, hashSet))
				{
					IntersectWithHashSetWithSameComparer(hashSet);
					return;
				}
			}
			IntersectWithEnumerable(other);
		}

		public void ExceptWith(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (Count == 0)
			{
				return;
			}
			if (other == this)
			{
				Clear();
				return;
			}
			foreach (T item in other)
			{
				Remove(item);
			}
		}

		public void SymmetricExceptWith(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (Count == 0)
			{
				UnionWith(other);
			}
			else if (other == this)
			{
				Clear();
			}
			else if (other is HashSet<T> hashSet && EqualityComparersAreEqual(this, hashSet))
			{
				SymmetricExceptWithUniqueHashSet(hashSet);
			}
			else
			{
				SymmetricExceptWithEnumerable(other);
			}
		}

		public bool IsSubsetOf(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (Count == 0 || other == this)
			{
				return true;
			}
			if (other is HashSet<T> hashSet && EqualityComparersAreEqual(this, hashSet))
			{
				if (Count > hashSet.Count)
				{
					return false;
				}
				return IsSubsetOfHashSetWithSameComparer(hashSet);
			}
			var (num, num2) = CheckUniqueAndUnfoundElements(other, returnIfUnfound: false);
			if (num == Count)
			{
				return num2 >= 0;
			}
			return false;
		}

		public bool IsProperSubsetOf(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (other == this)
			{
				return false;
			}
			if (other is ICollection<T> collection)
			{
				if (collection.Count == 0)
				{
					return false;
				}
				if (Count == 0)
				{
					return collection.Count > 0;
				}
				if (other is HashSet<T> hashSet && EqualityComparersAreEqual(this, hashSet))
				{
					if (Count >= hashSet.Count)
					{
						return false;
					}
					return IsSubsetOfHashSetWithSameComparer(hashSet);
				}
			}
			var (num, num2) = CheckUniqueAndUnfoundElements(other, returnIfUnfound: false);
			if (num == Count)
			{
				return num2 > 0;
			}
			return false;
		}

		public bool IsSupersetOf(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (other == this)
			{
				return true;
			}
			if (other is ICollection<T> collection)
			{
				if (collection.Count == 0)
				{
					return true;
				}
				if (other is HashSet<T> hashSet && EqualityComparersAreEqual(this, hashSet) && hashSet.Count > Count)
				{
					return false;
				}
			}
			return ContainsAllElements(other);
		}

		public bool IsProperSupersetOf(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (Count == 0 || other == this)
			{
				return false;
			}
			if (other is ICollection<T> collection)
			{
				if (collection.Count == 0)
				{
					return true;
				}
				if (other is HashSet<T> hashSet && EqualityComparersAreEqual(this, hashSet))
				{
					if (hashSet.Count >= Count)
					{
						return false;
					}
					return ContainsAllElements(hashSet);
				}
			}
			var (num, num2) = CheckUniqueAndUnfoundElements(other, returnIfUnfound: true);
			if (num < Count)
			{
				return num2 == 0;
			}
			return false;
		}

		public bool Overlaps(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (Count == 0)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			foreach (T item in other)
			{
				if (Contains(item))
				{
					return true;
				}
			}
			return false;
		}

		public bool SetEquals(IEnumerable<T> other)
		{
			if (other == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.other);
			}
			if (other == this)
			{
				return true;
			}
			if (other is HashSet<T> hashSet && EqualityComparersAreEqual(this, hashSet))
			{
				if (Count != hashSet.Count)
				{
					return false;
				}
				return ContainsAllElements(hashSet);
			}
			if (Count == 0 && other is ICollection<T> collection && collection.Count > 0)
			{
				return false;
			}
			var (num, num2) = CheckUniqueAndUnfoundElements(other, returnIfUnfound: true);
			if (num == Count)
			{
				return num2 == 0;
			}
			return false;
		}

		public void CopyTo(T[] array)
		{
			CopyTo(array, 0, Count);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			CopyTo(array, arrayIndex, Count);
		}

		public void CopyTo(T[] array, int arrayIndex, int count)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
			}
			if (arrayIndex < 0)
			{
				throw new ArgumentOutOfRangeException("arrayIndex", arrayIndex, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", count, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (arrayIndex > array.Length || count > array.Length - arrayIndex)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_ArrayPlusOffTooSmall);
			}
			Entry[] entries = _entries;
			for (int i = 0; i < _count; i++)
			{
				if (count == 0)
				{
					break;
				}
				ref Entry reference = ref entries[i];
				if (reference.Next >= -1)
				{
					array[arrayIndex++] = reference.Value;
					count--;
				}
			}
		}

		public int RemoveWhere(Predicate<T> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			Entry[] entries = _entries;
			int num = 0;
			for (int i = 0; i < _count; i++)
			{
				ref Entry reference = ref entries[i];
				if (reference.Next >= -1)
				{
					T value = reference.Value;
					if (match(value) && Remove(value))
					{
						num++;
					}
				}
			}
			return num;
		}

		public int EnsureCapacity(int capacity)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
			}
			int num = ((_entries != null) ? _entries.Length : 0);
			if (num >= capacity)
			{
				return num;
			}
			if (_buckets == null)
			{
				return Initialize(capacity);
			}
			int prime = HashHelpers.GetPrime(capacity);
			Resize(prime, forceNewHashCodes: false);
			return prime;
		}

		private void Resize()
		{
			Resize(HashHelpers.ExpandPrime(_count), forceNewHashCodes: false);
		}

		private void Resize(int newSize, bool forceNewHashCodes)
		{
			Entry[] array = new Entry[newSize];
			int count = _count;
			Array.Copy(_entries, array, count);
			if (!typeof(T).IsValueType && forceNewHashCodes)
			{
				_comparer = (IEqualityComparer<T>)((NonRandomizedStringEqualityComparer)_comparer).GetRandomizedEqualityComparer();
				for (int i = 0; i < count; i++)
				{
					ref Entry reference = ref array[i];
					if (reference.Next >= -1)
					{
						reference.HashCode = ((reference.Value != null) ? _comparer.GetHashCode(reference.Value) : 0);
					}
				}
				if (_comparer == EqualityComparer<T>.Default)
				{
					_comparer = null;
				}
			}
			_buckets = new int[newSize];
			for (int j = 0; j < count; j++)
			{
				ref Entry reference2 = ref array[j];
				if (reference2.Next >= -1)
				{
					ref int bucketRef = ref GetBucketRef(reference2.HashCode);
					reference2.Next = bucketRef - 1;
					bucketRef = j + 1;
				}
			}
			_entries = array;
		}

		public void TrimExcess()
		{
			int count = Count;
			int prime = HashHelpers.GetPrime(count);
			Entry[] entries = _entries;
			int num = ((entries != null) ? entries.Length : 0);
			if (prime >= num)
			{
				return;
			}
			int count2 = _count;
			_version++;
			Initialize(prime);
			Entry[] entries2 = _entries;
			int num2 = 0;
			for (int i = 0; i < count2; i++)
			{
				int hashCode = entries[i].HashCode;
				if (entries[i].Next >= -1)
				{
					ref Entry reference = ref entries2[num2];
					reference = entries[i];
					ref int bucketRef = ref GetBucketRef(hashCode);
					reference.Next = bucketRef - 1;
					bucketRef = num2 + 1;
					num2++;
				}
			}
			_count = count;
			_freeCount = 0;
		}

		public static IEqualityComparer<HashSet<T>> CreateSetComparer()
		{
			return new HashSetEqualityComparer<T>();
		}

		private int Initialize(int capacity)
		{
			int prime = HashHelpers.GetPrime(capacity);
			int[] buckets = new int[prime];
			Entry[] entries = new Entry[prime];
			_freeList = -1;
			_buckets = buckets;
			_entries = entries;
			return prime;
		}

		private bool AddIfNotPresent(T value, out int location)
		{
			if (_buckets == null)
			{
				Initialize(0);
			}
			Entry[] entries = _entries;
			IEqualityComparer<T> comparer = _comparer;
			uint num = 0u;
			ref int reference = ref Unsafe.NullRef<int>();
			int num2;
			if (comparer == null)
			{
				num2 = value?.GetHashCode() ?? 0;
				reference = ref GetBucketRef(num2);
				int num3 = reference - 1;
				if (typeof(T).IsValueType)
				{
					while (num3 >= 0)
					{
						ref Entry reference2 = ref entries[num3];
						if (reference2.HashCode == num2 && EqualityComparer<T>.Default.Equals(reference2.Value, value))
						{
							location = num3;
							return false;
						}
						num3 = reference2.Next;
						num++;
						if (num > (uint)entries.Length)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
					}
				}
				else
				{
					EqualityComparer<T> @default = EqualityComparer<T>.Default;
					while (num3 >= 0)
					{
						ref Entry reference3 = ref entries[num3];
						if (reference3.HashCode == num2 && @default.Equals(reference3.Value, value))
						{
							location = num3;
							return false;
						}
						num3 = reference3.Next;
						num++;
						if (num > (uint)entries.Length)
						{
							ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
						}
					}
				}
			}
			else
			{
				num2 = ((value != null) ? comparer.GetHashCode(value) : 0);
				reference = ref GetBucketRef(num2);
				int num4 = reference - 1;
				while (num4 >= 0)
				{
					ref Entry reference4 = ref entries[num4];
					if (reference4.HashCode == num2 && comparer.Equals(reference4.Value, value))
					{
						location = num4;
						return false;
					}
					num4 = reference4.Next;
					num++;
					if (num > (uint)entries.Length)
					{
						ThrowHelper.ThrowInvalidOperationException_ConcurrentOperationsNotSupported();
					}
				}
			}
			int num5;
			if (_freeCount > 0)
			{
				num5 = _freeList;
				_freeCount--;
				_freeList = -3 - entries[_freeList].Next;
			}
			else
			{
				int count = _count;
				if (count == entries.Length)
				{
					Resize();
					reference = ref GetBucketRef(num2);
				}
				num5 = count;
				_count = count + 1;
				entries = _entries;
			}
			ref Entry reference5 = ref entries[num5];
			reference5.HashCode = num2;
			reference5.Next = reference - 1;
			reference5.Value = value;
			reference = num5 + 1;
			_version++;
			location = num5;
			if (!typeof(T).IsValueType && num > 100 && comparer is NonRandomizedStringEqualityComparer)
			{
				Resize(entries.Length, forceNewHashCodes: true);
				location = FindItemIndex(value);
			}
			return true;
		}

		private bool ContainsAllElements(IEnumerable<T> other)
		{
			foreach (T item in other)
			{
				if (!Contains(item))
				{
					return false;
				}
			}
			return true;
		}

		internal bool IsSubsetOfHashSetWithSameComparer(HashSet<T> other)
		{
			using (Enumerator enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					if (!other.Contains(current))
					{
						return false;
					}
				}
			}
			return true;
		}

		private void IntersectWithHashSetWithSameComparer(HashSet<T> other)
		{
			Entry[] entries = _entries;
			for (int i = 0; i < _count; i++)
			{
				ref Entry reference = ref entries[i];
				if (reference.Next >= -1)
				{
					T value = reference.Value;
					if (!other.Contains(value))
					{
						Remove(value);
					}
				}
			}
		}

		private void IntersectWithEnumerable(IEnumerable<T> other)
		{
			int count = _count;
			int num = BitHelper.ToIntArrayLength(count);
			Span<int> span = stackalloc int[100];
			BitHelper bitHelper = ((num <= 100) ? new BitHelper(span.Slice(0, num), clear: true) : new BitHelper(new int[num], clear: false));
			foreach (T item in other)
			{
				int num2 = FindItemIndex(item);
				if (num2 >= 0)
				{
					bitHelper.MarkBit(num2);
				}
			}
			for (int i = 0; i < count; i++)
			{
				ref Entry reference = ref _entries[i];
				if (reference.Next >= -1 && !bitHelper.IsMarked(i))
				{
					Remove(reference.Value);
				}
			}
		}

		private void SymmetricExceptWithUniqueHashSet(HashSet<T> other)
		{
			foreach (T item in other)
			{
				if (!Remove(item))
				{
					AddIfNotPresent(item, out var _);
				}
			}
		}

		private void SymmetricExceptWithEnumerable(IEnumerable<T> other)
		{
			int count = _count;
			int num = BitHelper.ToIntArrayLength(count);
			Span<int> span = stackalloc int[50];
			BitHelper bitHelper = ((num <= 50) ? new BitHelper(span.Slice(0, num), clear: true) : new BitHelper(new int[num], clear: false));
			Span<int> span2 = stackalloc int[50];
			BitHelper bitHelper2 = ((num <= 50) ? new BitHelper(span2.Slice(0, num), clear: true) : new BitHelper(new int[num], clear: false));
			foreach (T item in other)
			{
				if (AddIfNotPresent(item, out var location))
				{
					bitHelper2.MarkBit(location);
				}
				else if (location < count && !bitHelper2.IsMarked(location))
				{
					bitHelper.MarkBit(location);
				}
			}
			for (int i = 0; i < count; i++)
			{
				if (bitHelper.IsMarked(i))
				{
					Remove(_entries[i].Value);
				}
			}
		}

		private (int UniqueCount, int UnfoundCount) CheckUniqueAndUnfoundElements(IEnumerable<T> other, bool returnIfUnfound)
		{
			if (_count == 0)
			{
				int num = 0;
				using (IEnumerator<T> enumerator = other.GetEnumerator())
				{
					if (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						num++;
					}
				}
				return (0, num);
			}
			int count = _count;
			int num2 = BitHelper.ToIntArrayLength(count);
			Span<int> span = stackalloc int[100];
			BitHelper bitHelper = ((num2 <= 100) ? new BitHelper(span.Slice(0, num2), clear: true) : new BitHelper(new int[num2], clear: false));
			int num3 = 0;
			int num4 = 0;
			foreach (T item in other)
			{
				int num5 = FindItemIndex(item);
				if (num5 >= 0)
				{
					if (!bitHelper.IsMarked(num5))
					{
						bitHelper.MarkBit(num5);
						num4++;
					}
				}
				else
				{
					num3++;
					if (returnIfUnfound)
					{
						break;
					}
				}
			}
			return (num4, num3);
		}

		internal static bool EqualityComparersAreEqual(HashSet<T> set1, HashSet<T> set2)
		{
			return set1.Comparer.Equals(set2.Comparer);
		}
	}
	internal sealed class HashSetEqualityComparer<T> : IEqualityComparer<HashSet<T>>
	{
		public bool Equals(HashSet<T> x, HashSet<T> y)
		{
			if (x == y)
			{
				return true;
			}
			if (x == null || y == null)
			{
				return false;
			}
			EqualityComparer<T> @default = EqualityComparer<T>.Default;
			if (HashSet<T>.EqualityComparersAreEqual(x, y))
			{
				if (x.Count == y.Count)
				{
					return y.IsSubsetOfHashSetWithSameComparer(x);
				}
				return false;
			}
			foreach (T item in y)
			{
				bool flag = false;
				foreach (T item2 in x)
				{
					if (@default.Equals(item, item2))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					return false;
				}
			}
			return true;
		}

		public int GetHashCode(HashSet<T> obj)
		{
			int num = 0;
			if (obj != null)
			{
				foreach (T item in obj)
				{
					if (item != null)
					{
						num ^= item.GetHashCode();
					}
				}
			}
			return num;
		}

		public override bool Equals([NotNullWhen(true)] object obj)
		{
			return obj is HashSetEqualityComparer<T>;
		}

		public override int GetHashCode()
		{
			return EqualityComparer<T>.Default.GetHashCode();
		}
	}
	public interface IAsyncEnumerable<out T>
	{
		IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken));
	}
	public interface IAsyncEnumerator<out T> : IAsyncDisposable
	{
		T Current { get; }

		ValueTask<bool> MoveNextAsync();
	}
	public interface ICollection<T> : IEnumerable<T>, IEnumerable
	{
		int Count { get; }

		bool IsReadOnly { get; }

		void Add(T item);

		void Clear();

		bool Contains(T item);

		void CopyTo(T[] array, int arrayIndex);

		bool Remove(T item);
	}
	internal sealed class ICollectionDebugView<T>
	{
		private readonly ICollection<T> _collection;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items
		{
			get
			{
				T[] array = new T[_collection.Count];
				_collection.CopyTo(array, 0);
				return array;
			}
		}

		public ICollectionDebugView(ICollection<T> collection)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			_collection = collection;
		}
	}
	public interface IComparer<in T>
	{
		int Compare(T? x, T? y);
	}
	public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		TValue this[TKey key] { get; set; }

		ICollection<TKey> Keys { get; }

		ICollection<TValue> Values { get; }

		bool ContainsKey(TKey key);

		void Add(TKey key, TValue value);

		bool Remove(TKey key);

		bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value);
	}
	internal sealed class IDictionaryDebugView<K, V>
	{
		private readonly IDictionary<K, V> _dict;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public KeyValuePair<K, V>[] Items
		{
			get
			{
				KeyValuePair<K, V>[] array = new KeyValuePair<K, V>[_dict.Count];
				_dict.CopyTo(array, 0);
				return array;
			}
		}

		public IDictionaryDebugView(IDictionary<K, V> dictionary)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			_dict = dictionary;
		}
	}
	internal sealed class DictionaryKeyCollectionDebugView<TKey, TValue>
	{
		private readonly ICollection<TKey> _collection;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public TKey[] Items
		{
			get
			{
				TKey[] array = new TKey[_collection.Count];
				_collection.CopyTo(array, 0);
				return array;
			}
		}

		public DictionaryKeyCollectionDebugView(ICollection<TKey> collection)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			_collection = collection;
		}
	}
	internal sealed class DictionaryValueCollectionDebugView<TKey, TValue>
	{
		private readonly ICollection<TValue> _collection;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public TValue[] Items
		{
			get
			{
				TValue[] array = new TValue[_collection.Count];
				_collection.CopyTo(array, 0);
				return array;
			}
		}

		public DictionaryValueCollectionDebugView(ICollection<TValue> collection)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			_collection = collection;
		}
	}
	public interface IEnumerable<out T> : IEnumerable
	{
		new IEnumerator<T> GetEnumerator();
	}
	public interface IEnumerator<out T> : IDisposable, IEnumerator
	{
		new T Current { get; }
	}
	public interface IEqualityComparer<in T>
	{
		bool Equals(T? x, T? y);

		int GetHashCode([DisallowNull] T obj);
	}
	internal interface IInternalStringEqualityComparer : IEqualityComparer<string>
	{
		IEqualityComparer<string> GetUnderlyingEqualityComparer();

		internal static IEqualityComparer<string> GetUnderlyingEqualityComparer(IEqualityComparer<string> outerComparer)
		{
			if (outerComparer == null)
			{
				return EqualityComparer<string>.Default;
			}
			if (outerComparer is IInternalStringEqualityComparer internalStringEqualityComparer)
			{
				return internalStringEqualityComparer.GetUnderlyingEqualityComparer();
			}
			return outerComparer;
		}
	}
	public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
	{
		T this[int index] { get; set; }

		int IndexOf(T item);

		void Insert(int index, T item);

		void RemoveAt(int index);
	}
	internal enum InsertionBehavior : byte
	{
		None,
		OverwriteExisting,
		ThrowOnExisting
	}
	public interface IReadOnlyCollection<out T> : IEnumerable<T>, IEnumerable
	{
		int Count { get; }
	}
	public interface IReadOnlyDictionary<TKey, TValue> : IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		TValue this[TKey key] { get; }

		IEnumerable<TKey> Keys { get; }

		IEnumerable<TValue> Values { get; }

		bool ContainsKey(TKey key);

		bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value);
	}
	public interface IReadOnlyList<out T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable
	{
		T this[int index] { get; }
	}
	public interface ISet<T> : ICollection<T>, IEnumerable<T>, IEnumerable
	{
		new bool Add(T item);

		void UnionWith(IEnumerable<T> other);

		void IntersectWith(IEnumerable<T> other);

		void ExceptWith(IEnumerable<T> other);

		void SymmetricExceptWith(IEnumerable<T> other);

		bool IsSubsetOf(IEnumerable<T> other);

		bool IsSupersetOf(IEnumerable<T> other);

		bool IsProperSupersetOf(IEnumerable<T> other);

		bool IsProperSubsetOf(IEnumerable<T> other);

		bool Overlaps(IEnumerable<T> other);

		bool SetEquals(IEnumerable<T> other);
	}
	public interface IReadOnlySet<T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable
	{
		bool Contains(T item);

		bool IsProperSubsetOf(IEnumerable<T> other);

		bool IsProperSupersetOf(IEnumerable<T> other);

		bool IsSubsetOf(IEnumerable<T> other);

		bool IsSupersetOf(IEnumerable<T> other);

		bool Overlaps(IEnumerable<T> other);

		bool SetEquals(IEnumerable<T> other);
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class KeyNotFoundException : SystemException
	{
		public KeyNotFoundException()
			: base(SR.Arg_KeyNotFound)
		{
			base.HResult = -2146232969;
		}

		public KeyNotFoundException(string? message)
			: base(message)
		{
			base.HResult = -2146232969;
		}

		public KeyNotFoundException(string? message, Exception? innerException)
			: base(message, innerException)
		{
			base.HResult = -2146232969;
		}

		protected KeyNotFoundException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public static class KeyValuePair
	{
		public static KeyValuePair<TKey, TValue> Create<TKey, TValue>(TKey key, TValue value)
		{
			return new KeyValuePair<TKey, TValue>(key, value);
		}

		internal static string PairToString(object key, object value)
		{
			IFormatProvider formatProvider = null;
			IFormatProvider provider = formatProvider;
			Span<char> initialBuffer = stackalloc char[256];
			DefaultInterpolatedStringHandler handler = new DefaultInterpolatedStringHandler(4, 2, formatProvider, initialBuffer);
			handler.AppendLiteral("[");
			handler.AppendFormatted<object>(key);
			handler.AppendLiteral(", ");
			handler.AppendFormatted<object>(value);
			handler.AppendLiteral("]");
			return string.Create(provider, initialBuffer, ref handler);
		}
	}
	[Serializable]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public readonly struct KeyValuePair<TKey, TValue>
	{
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private readonly TKey key;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private readonly TValue value;

		public TKey Key => key;

		public TValue Value => value;

		public KeyValuePair(TKey key, TValue value)
		{
			this.key = key;
			this.value = value;
		}

		public override string ToString()
		{
			return KeyValuePair.PairToString(Key, Value);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public void Deconstruct(out TKey key, out TValue value)
		{
			key = Key;
			value = Value;
		}
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(ICollectionDebugView<>))]
	[DebuggerDisplay("Count = {Count}")]
	[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IReadOnlyList<T>, IReadOnlyCollection<T>
	{
		public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
		{
			private readonly List<T> _list;

			private int _index;

			private readonly int _version;

			private T _current;

			public T Current => _current;

			object? IEnumerator.Current
			{
				get
				{
					if (_index == 0 || _index == _list._size + 1)
					{
						ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
					}
					return Current;
				}
			}

			internal Enumerator(List<T> list)
			{
				_list = list;
				_index = 0;
				_version = list._version;
				_current = default(T);
			}

			public void Dispose()
			{
			}

			public bool MoveNext()
			{
				List<T> list = _list;
				if (_version == list._version && (uint)_index < (uint)list._size)
				{
					_current = list._items[_index];
					_index++;
					return true;
				}
				return MoveNextRare();
			}

			private bool MoveNextRare()
			{
				if (_version != _list._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				_index = _list._size + 1;
				_current = default(T);
				return false;
			}

			void IEnumerator.Reset()
			{
				if (_version != _list._version)
				{
					ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
				}
				_index = 0;
				_current = default(T);
			}
		}

		internal T[] _items;

		internal int _size;

		private int _version;

		private static readonly T[] s_emptyArray = new T[0];

		public int Capacity
		{
			get
			{
				return _items.Length;
			}
			set
			{
				if (value < _size)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_SmallCapacity);
				}
				if (value == _items.Length)
				{
					return;
				}
				if (value > 0)
				{
					T[] array = new T[value];
					if (_size > 0)
					{
						Array.Copy(_items, array, _size);
					}
					_items = array;
				}
				else
				{
					_items = s_emptyArray;
				}
			}
		}

		public int Count => _size;

		bool IList.IsFixedSize => false;

		bool ICollection<T>.IsReadOnly => false;

		bool IList.IsReadOnly => false;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		public T this[int index]
		{
			get
			{
				if ((uint)index >= (uint)_size)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				return _items[index];
			}
			set
			{
				if ((uint)index >= (uint)_size)
				{
					ThrowHelper.ThrowArgumentOutOfRange_IndexException();
				}
				_items[index] = value;
				_version++;
			}
		}

		object? IList.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(value, ExceptionArgument.value);
				try
				{
					this[index] = (T)value;
				}
				catch (InvalidCastException)
				{
					ThrowHelper.ThrowWrongValueTypeArgumentException(value, typeof(T));
				}
			}
		}

		public List()
		{
			_items = s_emptyArray;
		}

		public List(int capacity)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (capacity == 0)
			{
				_items = s_emptyArray;
			}
			else
			{
				_items = new T[capacity];
			}
		}

		public List(IEnumerable<T> collection)
		{
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
			if (collection is ICollection<T> collection2)
			{
				int count = collection2.Count;
				if (count == 0)
				{
					_items = s_emptyArray;
					return;
				}
				_items = new T[count];
				collection2.CopyTo(_items, 0);
				_size = count;
				return;
			}
			_items = s_emptyArray;
			foreach (T item in collection)
			{
				Add(item);
			}
		}

		private static bool IsCompatibleObject(object value)
		{
			if (!(value is T))
			{
				if (value == null)
				{
					return default(T) == null;
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Add(T item)
		{
			_version++;
			T[] items = _items;
			int size = _size;
			if ((uint)size < (uint)items.Length)
			{
				_size = size + 1;
				items[size] = item;
			}
			else
			{
				AddWithResize(item);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void AddWithResize(T item)
		{
			int size = _size;
			Grow(size + 1);
			_size = size + 1;
			_items[size] = item;
		}

		int IList.Add(object item)
		{
			ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(item, ExceptionArgument.item);
			try
			{
				Add((T)item);
			}
			catch (InvalidCastException)
			{
				ThrowHelper.ThrowWrongValueTypeArgumentException(item, typeof(T));
			}
			return Count - 1;
		}

		public void AddRange(IEnumerable<T> collection)
		{
			InsertRange(_size, collection);
		}

		public ReadOnlyCollection<T> AsReadOnly()
		{
			return new ReadOnlyCollection<T>(this);
		}

		public int BinarySearch(int index, int count, T item, IComparer<T>? comparer)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			return Array.BinarySearch(_items, index, count, item, comparer);
		}

		public int BinarySearch(T item)
		{
			return BinarySearch(0, Count, item, null);
		}

		public int BinarySearch(T item, IComparer<T>? comparer)
		{
			return BinarySearch(0, Count, item, comparer);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Clear()
		{
			_version++;
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				int size = _size;
				_size = 0;
				if (size > 0)
				{
					Array.Clear(_items, 0, size);
				}
			}
			else
			{
				_size = 0;
			}
		}

		public bool Contains(T item)
		{
			if (_size != 0)
			{
				return IndexOf(item) != -1;
			}
			return false;
		}

		bool IList.Contains(object item)
		{
			if (IsCompatibleObject(item))
			{
				return Contains((T)item);
			}
			return false;
		}

		public List<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter)
		{
			if (converter == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.converter);
			}
			List<TOutput> list = new List<TOutput>(_size);
			for (int i = 0; i < _size; i++)
			{
				list._items[i] = converter(_items[i]);
			}
			list._size = _size;
			return list;
		}

		public void CopyTo(T[] array)
		{
			CopyTo(array, 0);
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			if (array != null && array.Rank != 1)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RankMultiDimNotSupported);
			}
			try
			{
				Array.Copy(_items, 0, array, arrayIndex, _size);
			}
			catch (ArrayTypeMismatchException)
			{
				ThrowHelper.ThrowArgumentException_Argument_InvalidArrayType();
			}
		}

		public void CopyTo(int index, T[] array, int arrayIndex, int count)
		{
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			Array.Copy(_items, index, array, arrayIndex, count);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			Array.Copy(_items, 0, array, arrayIndex, _size);
		}

		public int EnsureCapacity(int capacity)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_items.Length < capacity)
			{
				Grow(capacity);
				_version++;
			}
			return _items.Length;
		}

		private void Grow(int capacity)
		{
			int num = ((_items.Length == 0) ? 4 : (2 * _items.Length));
			if ((uint)num > Array.MaxLength)
			{
				num = Array.MaxLength;
			}
			if (num < capacity)
			{
				num = capacity;
			}
			Capacity = num;
		}

		public bool Exists(Predicate<T> match)
		{
			return FindIndex(match) != -1;
		}

		public T? Find(Predicate<T> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int i = 0; i < _size; i++)
			{
				if (match(_items[i]))
				{
					return _items[i];
				}
			}
			return default(T);
		}

		public List<T> FindAll(Predicate<T> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			List<T> list = new List<T>();
			for (int i = 0; i < _size; i++)
			{
				if (match(_items[i]))
				{
					list.Add(_items[i]);
				}
			}
			return list;
		}

		public int FindIndex(Predicate<T> match)
		{
			return FindIndex(0, _size, match);
		}

		public int FindIndex(int startIndex, Predicate<T> match)
		{
			return FindIndex(startIndex, _size - startIndex, match);
		}

		public int FindIndex(int startIndex, int count, Predicate<T> match)
		{
			if ((uint)startIndex > (uint)_size)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0 || startIndex > _size - count)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			int num = startIndex + count;
			for (int i = startIndex; i < num; i++)
			{
				if (match(_items[i]))
				{
					return i;
				}
			}
			return -1;
		}

		public T? FindLast(Predicate<T> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int num = _size - 1; num >= 0; num--)
			{
				if (match(_items[num]))
				{
					return _items[num];
				}
			}
			return default(T);
		}

		public int FindLastIndex(Predicate<T> match)
		{
			return FindLastIndex(_size - 1, _size, match);
		}

		public int FindLastIndex(int startIndex, Predicate<T> match)
		{
			return FindLastIndex(startIndex, startIndex + 1, match);
		}

		public int FindLastIndex(int startIndex, int count, Predicate<T> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			if (_size == 0)
			{
				if (startIndex != -1)
				{
					ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
				}
			}
			else if ((uint)startIndex >= (uint)_size)
			{
				ThrowHelper.ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index();
			}
			if (count < 0 || startIndex - count + 1 < 0)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			int num = startIndex - count;
			for (int num2 = startIndex; num2 > num; num2--)
			{
				if (match(_items[num2]))
				{
					return num2;
				}
			}
			return -1;
		}

		public void ForEach(Action<T> action)
		{
			if (action == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.action);
			}
			int version = _version;
			for (int i = 0; i < _size; i++)
			{
				if (version != _version)
				{
					break;
				}
				action(_items[i]);
			}
			if (version != _version)
			{
				ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();
			}
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new Enumerator(this);
		}

		public List<T> GetRange(int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			List<T> list = new List<T>(count);
			Array.Copy(_items, index, list._items, 0, count);
			list._size = count;
			return list;
		}

		public int IndexOf(T item)
		{
			return Array.IndexOf(_items, item, 0, _size);
		}

		int IList.IndexOf(object item)
		{
			if (IsCompatibleObject(item))
			{
				return IndexOf((T)item);
			}
			return -1;
		}

		public int IndexOf(T item, int index)
		{
			if (index > _size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return Array.IndexOf(_items, item, index, _size - index);
		}

		public int IndexOf(T item, int index, int count)
		{
			if (index > _size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			if (count < 0 || index > _size - count)
			{
				ThrowHelper.ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count();
			}
			return Array.IndexOf(_items, item, index, count);
		}

		public void Insert(int index, T item)
		{
			if ((uint)index > (uint)_size)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_ListInsert);
			}
			if (_size == _items.Length)
			{
				Grow(_size + 1);
			}
			if (index < _size)
			{
				Array.Copy(_items, index, _items, index + 1, _size - index);
			}
			_items[index] = item;
			_size++;
			_version++;
		}

		void IList.Insert(int index, object item)
		{
			ThrowHelper.IfNullAndNullsAreIllegalThenThrow<T>(item, ExceptionArgument.item);
			try
			{
				Insert(index, (T)item);
			}
			catch (InvalidCastException)
			{
				ThrowHelper.ThrowWrongValueTypeArgumentException(item, typeof(T));
			}
		}

		public void InsertRange(int index, IEnumerable<T> collection)
		{
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
			}
			if ((uint)index > (uint)_size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			if (collection is ICollection<T> collection2)
			{
				int count = collection2.Count;
				if (count > 0)
				{
					if (_items.Length - _size < count)
					{
						Grow(_size + count);
					}
					if (index < _size)
					{
						Array.Copy(_items, index, _items, index + count, _size - index);
					}
					if (this == collection2)
					{
						Array.Copy(_items, 0, _items, index, index);
						Array.Copy(_items, index + count, _items, index * 2, _size - index);
					}
					else
					{
						collection2.CopyTo(_items, index);
					}
					_size += count;
				}
			}
			else
			{
				using IEnumerator<T> enumerator = collection.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Insert(index++, enumerator.Current);
				}
			}
			_version++;
		}

		public int LastIndexOf(T item)
		{
			if (_size == 0)
			{
				return -1;
			}
			return LastIndexOf(item, _size - 1, _size);
		}

		public int LastIndexOf(T item, int index)
		{
			if (index >= _size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			return LastIndexOf(item, index, index + 1);
		}

		public int LastIndexOf(T item, int index, int count)
		{
			if (Count != 0 && index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (Count != 0 && count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size == 0)
			{
				return -1;
			}
			if (index >= _size)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_BiggerThanCollection);
			}
			if (count > index + 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_BiggerThanCollection);
			}
			return Array.LastIndexOf(_items, item, index, count);
		}

		public bool Remove(T item)
		{
			int num = IndexOf(item);
			if (num >= 0)
			{
				RemoveAt(num);
				return true;
			}
			return false;
		}

		void IList.Remove(object item)
		{
			if (IsCompatibleObject(item))
			{
				Remove((T)item);
			}
		}

		public int RemoveAll(Predicate<T> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			int i;
			for (i = 0; i < _size && !match(_items[i]); i++)
			{
			}
			if (i >= _size)
			{
				return 0;
			}
			int j = i + 1;
			while (j < _size)
			{
				for (; j < _size && match(_items[j]); j++)
				{
				}
				if (j < _size)
				{
					_items[i++] = _items[j++];
				}
			}
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				Array.Clear(_items, i, _size - i);
			}
			int result = _size - i;
			_size = i;
			_version++;
			return result;
		}

		public void RemoveAt(int index)
		{
			if ((uint)index >= (uint)_size)
			{
				ThrowHelper.ThrowArgumentOutOfRange_IndexException();
			}
			_size--;
			if (index < _size)
			{
				Array.Copy(_items, index + 1, _items, index, _size - index);
			}
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				_items[_size] = default(T);
			}
			_version++;
		}

		public void RemoveRange(int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (count > 0)
			{
				_size -= count;
				if (index < _size)
				{
					Array.Copy(_items, index + count, _items, index, _size - index);
				}
				_version++;
				if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
				{
					Array.Clear(_items, _size, count);
				}
			}
		}

		public void Reverse()
		{
			Reverse(0, Count);
		}

		public void Reverse(int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (count > 1)
			{
				Array.Reverse(_items, index, count);
			}
			_version++;
		}

		public void Sort()
		{
			Sort(0, Count, null);
		}

		public void Sort(IComparer<T>? comparer)
		{
			Sort(0, Count, comparer);
		}

		public void Sort(int index, int count, IComparer<T>? comparer)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowIndexArgumentOutOfRange_NeedNonNegNumException();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_size - index < count)
			{
				ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
			}
			if (count > 1)
			{
				Array.Sort(_items, index, count, comparer);
			}
			_version++;
		}

		public void Sort(Comparison<T> comparison)
		{
			if (comparison == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparison);
			}
			if (_size > 1)
			{
				ArraySortHelper<T>.Sort(new Span<T>(_items, 0, _size), comparison);
			}
			_version++;
		}

		public T[] ToArray()
		{
			if (_size == 0)
			{
				return s_emptyArray;
			}
			T[] array = new T[_size];
			Array.Copy(_items, array, _size);
			return array;
		}

		public void TrimExcess()
		{
			int num = (int)((double)_items.Length * 0.9);
			if (_size < num)
			{
				Capacity = _size;
			}
		}

		public bool TrueForAll(Predicate<T> match)
		{
			if (match == null)
			{
				ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
			}
			for (int i = 0; i < _size; i++)
			{
				if (!match(_items[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	[Serializable]
	[DebuggerTypeProxy(typeof(QueueDebugView<>))]
	[DebuggerDisplay("Count = {Count}")]
	[TypeForwardedFrom("System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
	public class Queue<T> : IEnumerable<T>, IEnumerable, ICollection, IReadOnlyCollection<T>
	{
		public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
		{
			private readonly Queue<T> _q;

			private readonly int _version;

			private int _index;

			private T _currentElement;

			public T Current
			{
				get
				{
					if (_index < 0)
					{
						ThrowEnumerationNotStartedOrEnded();
					}
					return _currentElement;
				}
			}

			object? IEnumerator.Current => Current;

			internal Enumerator(Queue<T> q)
			{
				_q = q;
				_version = q._version;
				_index = -1;
				_currentElement = default(T);
			}

			public void Dispose()
			{
				_index = -2;
				_currentElement = default(T);
			}

			public bool MoveNext()
			{
				if (_version != _q._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				if (_index == -2)
				{
					return false;
				}
				_index++;
				if (_index == _q._size)
				{
					_index = -2;
					_currentElement = default(T);
					return false;
				}
				T[] array = _q._array;
				int num = array.Length;
				int num2 = _q._head + _index;
				if (num2 >= num)
				{
					num2 -= num;
				}
				_currentElement = array[num2];
				return true;
			}

			private void ThrowEnumerationNotStartedOrEnded()
			{
				throw new InvalidOperationException((_index == -1) ? SR.InvalidOperation_EnumNotStarted : SR.InvalidOperation_EnumEnded);
			}

			void IEnumerator.Reset()
			{
				if (_version != _q._version)
				{
					throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
				}
				_index = -1;
				_currentElement = default(T);
			}
		}

		private T[] _array;

		private int _head;

		private int _tail;

		private int _size;

		private int _version;

		public int Count => _size;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		public Queue()
		{
			_array = Array.Empty<T>();
		}

		public Queue(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", capacity, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			_array = new T[capacity];
		}

		public Queue(IEnumerable<T> collection)
		{
			if (collection == null)
			{
				throw new ArgumentNullException("collection");
			}
			_array = EnumerableHelpers.ToArray(collection, out _size);
			if (_size != _array.Length)
			{
				_tail = _size;
			}
		}

		public void Clear()
		{
			if (_size != 0)
			{
				if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
				{
					if (_head < _tail)
					{
						Array.Clear(_array, _head, _size);
					}
					else
					{
						Array.Clear(_array, _head, _array.Length - _head);
						Array.Clear(_array, 0, _tail);
					}
				}
				_size = 0;
			}
			_head = 0;
			_tail = 0;
			_version++;
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (arrayIndex < 0 || arrayIndex > array.Length)
			{
				throw new ArgumentOutOfRangeException("arrayIndex", arrayIndex, SR.ArgumentOutOfRange_Index);
			}
			if (array.Length - arrayIndex < _size)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			int size = _size;
			if (size != 0)
			{
				int num = Math.Min(_array.Length - _head, size);
				Array.Copy(_array, _head, array, arrayIndex, num);
				size -= num;
				if (size > 0)
				{
					Array.Copy(_array, 0, array, arrayIndex + _array.Length - _head, size);
				}
			}
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (array.Rank != 1)
			{
				throw new ArgumentException(SR.Arg_RankMultiDimNotSupported, "array");
			}
			if (array.GetLowerBound(0) != 0)
			{
				throw new ArgumentException(SR.Arg_NonZeroLowerBound, "array");
			}
			int length = array.Length;
			if (index < 0 || index > length)
			{
				throw new ArgumentOutOfRangeException("index", index, SR.ArgumentOutOfRange_Index);
			}
			if (length - index < _size)
			{
				throw new ArgumentException(SR.Argument_InvalidOffLen);
			}
			int size = _size;
			if (size == 0)
			{
				return;
			}
			try
			{
				int num = ((_array.Length - _head < size) ? (_array.Length - _head) : size);
				Array.Copy(_array, _head, array, index, num);
				size -= num;
				if (size > 0)
				{
					Array.Copy(_array, 0, array, index + _array.Length - _head, size);
				}
			}
			catch (ArrayTypeMismatchException)
			{
				throw new ArgumentException(SR.Argument_InvalidArrayType, "array");
			}
		}

		public void Enqueue(T item)
		{
			if (_size == _array.Length)
			{
				Grow(_size + 1);
			}
			_array[_tail] = item;
			MoveNext(ref _tail);
			_size++;
			_version++;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new Enumerator(this);
		}

		public T Dequeue()
		{
			int head = _head;
			T[] array = _array;
			if (_size == 0)
			{
				ThrowForEmptyQueue();
			}
			T result = array[head];
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				array[head] = default(T);
			}
			MoveNext(ref _head);
			_size--;
			_version++;
			return result;
		}

		public bool TryDequeue([MaybeNullWhen(false)] out T result)
		{
			int head = _head;
			T[] array = _array;
			if (_size == 0)
			{
				result = default(T);
				return false;
			}
			result = array[head];
			if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
			{
				array[head] = default(T);
			}
			MoveNext(ref _head);
			_size--;
			_version++;
			return true;
		}

		public T Peek()
		{
			if (_size == 0)
			{
				ThrowForEmptyQueue();
			}
			return _array[_head];
		}

		public bool TryPeek([MaybeNullWhen(false)] out T result)
		{
			if (_size == 0)
			{
				result = default(T);
				return false;
			}
			result = _array[_head];
			return true;
		}

		public bool Contains(T item)
		{
			if (_size == 0)
			{
				return false;
			}
			if (_head < _tail)
			{
				return Array.IndexOf(_array, item, _head, _size) >= 0;
			}
			if (Array.IndexOf(_array, item, _head, _array.Length - _head) < 0)
			{
				return Array.IndexOf(_array, item, 0, _tail) >= 0;
			}
			return true;
		}

		public T[] ToArray()
		{
			if (_size == 0)
			{
				return Array.Empty<T>();
			}
			T[] array = new T[_size];
			if (_head < _tail)
			{
				Array.Copy(_array, _head, array, 0, _size);
			}
			else
			{
				Array.Copy(_array, _head, array, 0, _array.Length - _head);
				Array.Copy(_array, 0, array, _array.Length - _head, _tail);
			}
			return array;
		}

		private void SetCapacity(int capacity)
		{
			T[] array = new T[capacity];
			if (_size > 0)
			{
				if (_head < _tail)
				{
					Array.Copy(_array, _head, array, 0, _size);
				}
				else
				{
					Array.Copy(_array, _head, array, 0, _array.Length - _head);
					Array.Copy(_array, 0, array, _array.Length - _head, _tail);
				}
			}
			_array = array;
			_head = 0;
			_tail = ((_size != capacity) ? _size : 0);
			_version++;
		}

		private void MoveNext(ref int index)
		{
			int num = index + 1;
			if (num == _array.Length)
			{
				num = 0;
			}
			index = num;
		}

		private void ThrowForEmptyQueue()
		{
			throw new InvalidOperationException(SR.InvalidOperation_EmptyQueue);
		}

		public void TrimExcess()
		{
			int num = (int)((double)_array.Length * 0.9);
			if (_size < num)
			{
				SetCapacity(_size);
			}
		}

		public int EnsureCapacity(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", capacity, SR.ArgumentOutOfRange_NeedNonNegNum);
			}
			if (_array.Length < capacity)
			{
				Grow(capacity);
			}
			return _array.Length;
		}

		private void Grow(int capacity)
		{
			int num = 2 * _array.Length;
			if ((uint)num > Array.MaxLength)
			{
				num = Array.MaxLength;
			}
			num = Math.Max(num, _array.Length + 4);
			if (num < capacity)
			{
				num = capacity;
			}
			SetCapacity(num);
		}
	}
	internal sealed class QueueDebugView<T>
	{
		private readonly Queue<T> _queue;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items => _queue.ToArray();

		public QueueDebugView(Queue<T> queue)
		{
			if (queue == null)
			{
				throw new ArgumentNullException("queue");
			}
			_queue = queue;
		}
	}
	internal abstract class RandomizedStringEqualityComparer : EqualityComparer<string>, IInternalStringEqualityComparer, IEqualityComparer<string>
	{
		private struct MarvinSeed
		{
			internal uint p0;

			internal uint p1;
		}

		private sealed class OrdinalComparer : RandomizedStringEqualityComparer
		{
			internal OrdinalComparer(IEqualityComparer<string> wrappedComparer)
				: base(wrappedComparer)
			{
			}

			public override bool Equals(string x, string y)
			{
				return string.Equals(x, y);
			}

			public override int GetHashCode(string obj)
			{
				if (obj == null)
				{
					return 0;
				}
				return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref obj.GetRawStringData()), (uint)(obj.Length * 2), _seed.p0, _seed.p1);
			}
		}

		private sealed class OrdinalIgnoreCaseComparer : RandomizedStringEqualityComparer
		{
			internal OrdinalIgnoreCaseComparer(IEqualityComparer<string> wrappedComparer)
				: base(wrappedComparer)
			{
			}

			public override bool Equals(string x, string y)
			{
				return string.EqualsOrdinalIgnoreCase(x, y);
			}

			public override int GetHashCode(string obj)
			{
				if (obj == null)
				{
					return 0;
				}
				return Marvin.ComputeHash32OrdinalIgnoreCase(ref obj.GetRawStringData(), obj.Length, _seed.p0, _seed.p1);
			}
		}

		private readonly MarvinSeed _seed;

		private readonly IEqualityComparer<string> _underlyingComparer;

		private unsafe RandomizedStringEqualityComparer(IEqualityComparer<string> underlyingComparer)
		{
			_underlyingComparer = underlyingComparer;
			fixed (MarvinSeed* buffer = &_seed)
			{
				Interop.GetRandomBytes((byte*)buffer, sizeof(MarvinSeed));
			}
		}

		internal static RandomizedStringEqualityComparer Create(IEqualityComparer<string> underlyingComparer, bool ignoreCase)
		{
			if (!ignoreCase)
			{
				return new OrdinalComparer(underlyingComparer);
			}
			return new OrdinalIgnoreCaseComparer(underlyingComparer);
		}

		public IEqualityComparer<string> GetUnderlyingEqualityComparer()
		{
			return _underlyingComparer;
		}
	}
	[Serializable]
	public class NonRandomizedStringEqualityComparer : IEqualityComparer<string?>, IInternalStringEqualityComparer, ISerializable
	{
		private sealed class OrdinalComparer : NonRandomizedStringEqualityComparer
		{
			internal OrdinalComparer(IEqualityComparer<string> wrappedComparer)
				: base(wrappedComparer)
			{
			}

			public override bool Equals(string x, string y)
			{
				return string.Equals(x, y);
			}

			public override int GetHashCode(string obj)
			{
				return obj.GetNonRandomizedHashCode();
			}
		}

		private sealed class OrdinalIgnoreCaseComparer : NonRandomizedStringEqualityComparer
		{
			internal OrdinalIgnoreCaseComparer(IEqualityComparer<string> wrappedComparer)
				: base(wrappedComparer)
			{
			}

			public override bool Equals(string x, string y)
			{
				return string.EqualsOrdinalIgnoreCase(x, y);
			}

			public override int GetHashCode(string obj)
			{
				return obj.GetNonRandomizedHashCodeOrdinalIgnoreCase();
			}

			internal override RandomizedStringEqualityComparer GetRandomizedEqualityComparer()
			{
				return RandomizedStringEqualityComparer.Create(_underlyingComparer, ignoreCase: true);
			}
		}

		private static readonly NonRandomizedStringEqualityComparer WrappedAroundDefaultComparer = new OrdinalComparer(EqualityComparer<string>.Default);

		private static readonly NonRandomizedStringEqualityComparer WrappedAroundStringComparerOrdinal = new OrdinalComparer(StringComparer.Ordinal);

		private static readonly NonRandomizedStringEqualityComparer WrappedAroundStringComparerOrdinalIgnoreCase = new OrdinalIgnoreCaseComparer(StringComparer.OrdinalIgnoreCase);

		private readonly IEqualityComparer<string> _underlyingComparer;

		private NonRandomizedStringEqualityComparer(IEqualityComparer<string> underlyingComparer)
		{
			_underlyingComparer = underlyingComparer;
		}

		protected NonRandomizedStringEqualityComparer(SerializationInfo information, StreamingContext context)
			: this(EqualityComparer<string>.Default)
		{
		}

		public virtual bool Equals(string? x, string? y)
		{
			return string.Equals(x, y);
		}

		public virtual int GetHashCode(string? obj)
		{
			return obj?.GetNonRandomizedHashCode() ?? 0;
		}

		internal virtual RandomizedStringEqualityComparer GetRandomizedEqualityComparer()
		{
			return RandomizedStringEqualityComparer.Create(_underlyingComparer, ignoreCase: false);
		}

		public virtual IEqualityComparer<string?> GetUnderlyingEqualityComparer()
		{
			return _underlyingComparer;
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.SetType(typeof(GenericEqualityComparer<string>));
		}

		public static IEqualityComparer<string>? GetStringComparer(object? comparer)
		{
			if (comparer == null)
			{
				return WrappedAroundDefaultComparer;
			}
			if (comparer == StringComparer.Ordinal)
			{
				return WrappedAroundStringComparerOrdinal;
			}
			if (comparer == StringComparer.OrdinalIgnoreCase)
			{
				return WrappedAroundStringComparerOrdinalIgnoreCase;
			}
			return null;
		}
	}
	[DefaultMember("Item")]
	internal ref struct ValueListBuilder<T>
	{
		private Span<T> _span;

		private T[] _arrayFromPool;

		private int _pos;

		public int Length => _pos;

		public ValueListBuilder(Span<T> initialSpan)
		{
			_span = initialSpan;
			_arrayFromPool = null;
			_pos = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(T item)
		{
			int pos = _pos;
			if (pos >= _span.Length)
			{
				Grow();
			}
			_span[pos] = item;
			_pos = pos + 1;
		}

		public ReadOnlySpan<T> AsSpan()
		{
			return _span.Slice(0, _pos);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Dispose()
		{
			T[] arrayFromPool = _arrayFromPool;
			if (arrayFromPool != null)
			{
				_arrayFromPool = null;
				ArrayPool<T>.Shared.Return(arrayFromPool);
			}
		}

		private void Grow()
		{
			T[] array = ArrayPool<T>.Shared.Rent(_span.Length * 2);
			bool flag = _span.TryCopyTo(array);
			T[] arrayFromPool = _arrayFromPool;
			_span = (_arrayFromPool = array);
			if (arrayFromPool != null)
			{
				ArrayPool<T>.Shared.Return(arrayFromPool);
			}
		}
	}
	internal static class EnumerableHelpers
	{
		internal static T[] ToArray<T>(IEnumerable<T> source, out int length)
		{
			if (source is ICollection<T> collection)
			{
				int count = collection.Count;
				if (count != 0)
				{
					T[] array = new T[count];
					collection.CopyTo(array, 0);
					length = count;
					return array;
				}
			}
			else
			{
				using IEnumerator<T> enumerator = source.GetEnumerator();
				if (enumerator.MoveNext())
				{
					T[] array2 = new T[4]
					{
						enumerator.Current,
						default(T),
						default(T),
						default(T)
					};
					int num = 1;
					while (enumerator.MoveNext())
					{
						if (num == array2.Length)
						{
							int num2 = num << 1;
							if ((uint)num2 > Array.MaxLength)
							{
								num2 = ((Array.MaxLength <= num) ? (num + 1) : Array.MaxLength);
							}
							Array.Resize(ref array2, num2);
						}
						array2[num++] = enumerator.Current;
					}
					length = num;
					return array2;
				}
			}
			length = 0;
			return Array.Empty<T>();
		}
	}
	public sealed class ReferenceEqualityComparer : IEqualityComparer<object?>, IEqualityComparer
	{
		public static ReferenceEqualityComparer Instance { get; } = new ReferenceEqualityComparer();


		private ReferenceEqualityComparer()
		{
		}

		public new bool Equals(object? x, object? y)
		{
			return x == y;
		}

		public int GetHashCode(object? obj)
		{
			return RuntimeHelpers.GetHashCode(obj);
		}
	}
	internal ref struct BitHelper
	{
		private readonly Span<int> _span;

		internal BitHelper(Span<int> span, bool clear)
		{
			if (clear)
			{
				span.Clear();
			}
			_span = span;
		}

		internal void MarkBit(int bitPosition)
		{
			int num = bitPosition / 32;
			if ((uint)num < (uint)_span.Length)
			{
				_span[num] |= 1 << bitPosition % 32;
			}
		}

		internal bool IsMarked(int bitPosition)
		{
			int num = bitPosition / 32;
			if ((uint)num < (uint)_span.Length)
			{
				return (_span[num] & (1 << bitPosition % 32)) != 0;
			}
			return false;
		}

		internal static int ToIntArrayLength(int n)
		{
			if (n <= 0)
			{
				return 0;
			}
			return (n - 1) / 32 + 1;
		}
	}
}
namespace Internal
{
	public static class Console
	{
		private static readonly IntPtr s_outputHandle = Interop.Kernel32.GetStdHandle(-11);

		public static void WriteLine(string? s)
		{
			Write(s + "\r\n");
		}

		public static void WriteLine()
		{
			Write("\r\n");
		}

		public unsafe static void Write(string s)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(s);
			fixed (byte* bytes2 = bytes)
			{
				Interop.Kernel32.WriteFile(s_outputHandle, bytes2, bytes.Length, out var _, IntPtr.Zero);
			}
		}
	}
	[StructLayout(LayoutKind.Explicit, Size = 60)]
	internal struct PaddingFor32
	{
	}
	[StructLayout(LayoutKind.Explicit, Size = 64)]
	internal struct PaddedReference
	{
		[FieldOffset(0)]
		public object Object;
	}
}
namespace Internal.Win32
{
	internal sealed class RegistryKey : IDisposable
	{
		private readonly SafeRegistryHandle _hkey;

		private RegistryKey(SafeRegistryHandle hkey)
		{
			_hkey = hkey;
		}

		void IDisposable.Dispose()
		{
			if (_hkey != null)
			{
				_hkey.Dispose();
			}
		}

		public void DeleteValue(string name, bool throwOnMissingValue)
		{
			int num = Interop.Advapi32.RegDeleteValue(_hkey, name);
			if (num == 2 || num == 206)
			{
				if (throwOnMissingValue)
				{
					throw new ArgumentException(SR.Arg_RegSubKeyValueAbsent);
				}
				num = 0;
			}
		}

		internal static RegistryKey OpenBaseKey(IntPtr hKey)
		{
			return new RegistryKey(new SafeRegistryHandle(hKey, ownsHandle: false));
		}

		public RegistryKey OpenSubKey(string name)
		{
			return OpenSubKey(name, writable: false);
		}

		public RegistryKey OpenSubKey(string name, bool writable)
		{
			SafeRegistryHandle hkResult;
			int num = Interop.Advapi32.RegOpenKeyEx(_hkey, name, 0, writable ? 131103 : 131097, out hkResult);
			if (num == 0 && !hkResult.IsInvalid)
			{
				return new RegistryKey(hkResult);
			}
			if (num == 5 || num == 1346)
			{
				throw new SecurityException(SR.Security_RegistryPermission);
			}
			return null;
		}

		public string[] GetSubKeyNames()
		{
			List<string> list = new List<string>();
			char[] array = ArrayPool<char>.Shared.Rent(256);
			try
			{
				int lpcbName = array.Length;
				int num;
				while ((num = Interop.Advapi32.RegEnumKeyEx(_hkey, list.Count, array, ref lpcbName, null, null, null, null)) != 259)
				{
					if (num == 0)
					{
						list.Add(new string(array, 0, lpcbName));
						lpcbName = array.Length;
					}
					else
					{
						Win32Error(num, null);
					}
				}
			}
			finally
			{
				ArrayPool<char>.Shared.Return(array);
			}
			return list.ToArray();
		}

		public string[] GetValueNames()
		{
			List<string> list = new List<string>();
			char[] array = ArrayPool<char>.Shared.Rent(100);
			try
			{
				int lpcbValueName = array.Length;
				int num;
				while ((num = Interop.Advapi32.RegEnumValue(_hkey, list.Count, array, ref lpcbValueName, IntPtr.Zero, null, null, null)) != 259)
				{
					switch (num)
					{
					case 0:
						list.Add(new string(array, 0, lpcbValueName));
						break;
					case 234:
					{
						char[] array2 = array;
						int num2 = array2.Length;
						array = null;
						ArrayPool<char>.Shared.Return(array2);
						array = ArrayPool<char>.Shared.Rent(checked(num2 * 2));
						break;
					}
					default:
						Win32Error(num, null);
						break;
					}
					lpcbValueName = array.Length;
				}
			}
			finally
			{
				if (array != null)
				{
					ArrayPool<char>.Shared.Return(array);
				}
			}
			return list.ToArray();
		}

		public object GetValue(string name)
		{
			return GetValue(name, null);
		}

		[return: NotNullIfNotNull("defaultValue")]
		public object GetValue(string name, object defaultValue)
		{
			object result = defaultValue;
			int lpType = 0;
			int lpcbData = 0;
			int num = Interop.Advapi32.RegQueryValueEx(_hkey, name, (int[])null, ref lpType, (byte[])null, ref lpcbData);
			if (num != 0 && num != 234)
			{
				return result;
			}
			if (lpcbData < 0)
			{
				lpcbData = 0;
			}
			switch (lpType)
			{
			case 0:
			case 3:
			case 5:
			{
				byte[] array3 = new byte[lpcbData];
				num = Interop.Advapi32.RegQueryValueEx(_hkey, name, null, ref lpType, array3, ref lpcbData);
				result = array3;
				break;
			}
			case 11:
				if (lpcbData <= 8)
				{
					long lpData = 0L;
					num = Interop.Advapi32.RegQueryValueEx(_hkey, name, null, ref lpType, ref lpData, ref lpcbData);
					result = lpData;
					break;
				}
				goto case 0;
			case 4:
				if (lpcbData <= 4)
				{
					int lpData2 = 0;
					num = Interop.Advapi32.RegQueryValueEx(_hkey, name, null, ref lpType, ref lpData2, ref lpcbData);
					result = lpData2;
					break;
				}
				goto case 11;
			case 1:
			{
				if (lpcbData % 2 == 1)
				{
					try
					{
						lpcbData = checked(lpcbData + 1);
					}
					catch (OverflowException innerException2)
					{
						throw new IOException(SR.Arg_RegGetOverflowBug, innerException2);
					}
				}
				char[] array4 = new char[lpcbData / 2];
				num = Interop.Advapi32.RegQueryValueEx(_hkey, name, null, ref lpType, array4, ref lpcbData);
				result = ((array4.Length == 0 || array4[^1] != 0) ? new string(array4) : new string(array4, 0, array4.Length - 1));
				break;
			}
			case 2:
			{
				if (lpcbData % 2 == 1)
				{
					try
					{
						lpcbData = checked(lpcbData + 1);
					}
					catch (OverflowException innerException3)
					{
						throw new IOException(SR.Arg_RegGetOverflowBug, innerException3);
					}
				}
				char[] array5 = new char[lpcbData / 2];
				num = Interop.Advapi32.RegQueryValueEx(_hkey, name, null, ref lpType, array5, ref lpcbData);
				result = ((array5.Length == 0 || array5[^1] != 0) ? new string(array5) : new string(array5, 0, array5.Length - 1));
				result = Environment.ExpandEnvironmentVariables((string)result);
				break;
			}
			case 7:
			{
				if (lpcbData % 2 == 1)
				{
					try
					{
						lpcbData = checked(lpcbData + 1);
					}
					catch (OverflowException innerException)
					{
						throw new IOException(SR.Arg_RegGetOverflowBug, innerException);
					}
				}
				char[] array = new char[lpcbData / 2];
				num = Interop.Advapi32.RegQueryValueEx(_hkey, name, null, ref lpType, array, ref lpcbData);
				if (array.Length != 0 && array[^1] != 0)
				{
					Array.Resize(ref array, array.Length + 1);
				}
				string[] array2 = Array.Empty<string>();
				int num2 = 0;
				int num3 = 0;
				int num4 = array.Length;
				while (num == 0 && num3 < num4)
				{
					int i;
					for (i = num3; i < num4 && array[i] != 0; i++)
					{
					}
					string text = null;
					if (i < num4)
					{
						if (i - num3 > 0)
						{
							text = new string(array, num3, i - num3);
						}
						else if (i != num4 - 1)
						{
							text = string.Empty;
						}
					}
					else
					{
						text = new string(array, num3, num4 - num3);
					}
					num3 = i + 1;
					if (text != null)
					{
						if (array2.Length == num2)
						{
							Array.Resize(ref array2, (num2 > 0) ? (num2 * 2) : 4);
						}
						array2[num2++] = text;
					}
				}
				Array.Resize(ref array2, num2);
				result = array2;
				break;
			}
			}
			return result;
		}

		internal void SetValue(string name, string value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (name != null && name.Length > 16383)
			{
				throw new ArgumentException(SR.Arg_RegValStrLenBug, "name");
			}
			int num = Interop.Advapi32.RegSetValueEx(_hkey, name, 0, 1, value, checked(value.Length * 2 + 2));
			if (num != 0)
			{
				Win32Error(num, null);
			}
		}

		internal static void Win32Error(int errorCode, string str)
		{
			switch (errorCode)
			{
			case 5:
				if (str != null)
				{
					throw new UnauthorizedAccessException(SR.Format(SR.UnauthorizedAccess_RegistryKeyGeneric_Key, str));
				}
				throw new UnauthorizedAccessException();
			case 2:
				throw new IOException(SR.Arg_RegKeyNotFound, errorCode);
			default:
				throw new IOException(Interop.Kernel32.GetMessage(errorCode), errorCode);
			}
		}
	}
	internal static class Registry
	{
		public static readonly RegistryKey CurrentUser = RegistryKey.OpenBaseKey((IntPtr)(-2147483647));

		public static readonly RegistryKey LocalMachine = RegistryKey.OpenBaseKey((IntPtr)(-2147483646));
	}
}
namespace Internal.Win32.SafeHandles
{
	internal sealed class SafeRegistryHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		public SafeRegistryHandle()
			: base(ownsHandle: true)
		{
		}

		public SafeRegistryHandle(IntPtr preexistingHandle, bool ownsHandle)
			: base(ownsHandle)
		{
			SetHandle(preexistingHandle);
		}

		protected override bool ReleaseHandle()
		{
			return Interop.Advapi32.RegCloseKey(handle) == 0;
		}
	}
}
namespace Internal.Runtime.CompilerServices
{
	[CLSCompliant(false)]
	public static class Unsafe
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static void* AsPointer<T>(ref T value)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static int SizeOf<T>()
		{
			typeof(T).ToString();
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		[return: NotNullIfNotNull("value")]
		public static T As<T>(object? value) where T : class?
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static ref TTo As<TFrom, TTo>(ref TFrom source)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static ref T Add<T>(ref T source, int elementOffset)
		{
			typeof(T).ToString();
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static ref T Add<T>(ref T source, IntPtr elementOffset)
		{
			typeof(T).ToString();
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static void* Add<T>(void* source, int elementOffset)
		{
			typeof(T).ToString();
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		internal unsafe static ref T AddByteOffset<T>(ref T source, nuint byteOffset)
		{
			return ref AddByteOffset(ref source, (IntPtr)(void*)byteOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static bool AreSame<T>([AllowNull] ref T left, [AllowNull] ref T right)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static bool IsAddressGreaterThan<T>([AllowNull] ref T left, [AllowNull] ref T right)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static bool IsAddressLessThan<T>([AllowNull] ref T left, [AllowNull] ref T right)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount)
		{
			for (uint num = 0u; num < byteCount; num++)
			{
				AddByteOffset(ref startAddress, num) = value;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static T ReadUnaligned<T>(void* source)
		{
			typeof(T).ToString();
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static T ReadUnaligned<T>(ref byte source)
		{
			typeof(T).ToString();
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static void WriteUnaligned<T>(void* destination, T value)
		{
			typeof(T).ToString();
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static void WriteUnaligned<T>(ref byte destination, T value)
		{
			typeof(T).ToString();
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static ref T AddByteOffset<T>(ref T source, IntPtr byteOffset)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static T Read<T>(void* source)
		{
			return As<byte, T>(ref *(byte*)source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static T Read<T>(ref byte source)
		{
			return As<byte, T>(ref source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static void Write<T>(void* destination, T value)
		{
			As<byte, T>(ref *(byte*)destination) = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static void Write<T>(ref byte destination, T value)
		{
			As<byte, T>(ref destination) = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static ref T AsRef<T>(void* source)
		{
			return ref As<byte, T>(ref *(byte*)source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static ref T AsRef<T>(in T source)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static IntPtr ByteOffset<T>([AllowNull] ref T origin, [AllowNull] ref T target)
		{
			throw new PlatformNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static ref T NullRef<T>()
		{
			return ref AsRef<T>(null);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public unsafe static bool IsNullRef<T>(ref T source)
		{
			return AsPointer(ref source) == null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Intrinsic]
		[NonVersionable]
		public static void SkipInit<T>(out T value)
		{
			throw new PlatformNotSupportedException();
		}
	}
}
namespace Internal.Runtime.InteropServices
{
	[CLSCompliant(false)]
	public struct ComActivationContextInternal
	{
		public Guid ClassId;

		public Guid InterfaceId;

		public unsafe char* AssemblyPathBuffer;

		public unsafe char* AssemblyNameBuffer;

		public unsafe char* TypeNameBuffer;

		public IntPtr ClassFactoryDest;
	}
	public struct ComActivationContext
	{
		public Guid ClassId;

		public Guid InterfaceId;

		public string AssemblyPath;

		public string AssemblyName;

		public string TypeName;

		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		[CLSCompliant(false)]
		public unsafe static ComActivationContext Create(ref ComActivationContextInternal cxtInt)
		{
			if (!Marshal.IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			ComActivationContext result = default(ComActivationContext);
			result.ClassId = cxtInt.ClassId;
			result.InterfaceId = cxtInt.InterfaceId;
			result.AssemblyPath = Marshal.PtrToStringUni(new IntPtr(cxtInt.AssemblyPathBuffer));
			result.AssemblyName = Marshal.PtrToStringUni(new IntPtr(cxtInt.AssemblyNameBuffer));
			result.TypeName = Marshal.PtrToStringUni(new IntPtr(cxtInt.TypeNameBuffer));
			return result;
		}
	}
	[ComImport]
	[ComVisible(false)]
	[Guid("00000001-0000-0000-C000-000000000046")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	public interface IClassFactory
	{
		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		void CreateInstance([MarshalAs(UnmanagedType.Interface)] object? pUnkOuter, ref Guid riid, out IntPtr ppvObject);

		void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock);
	}
	public static class ComponentActivator
	{
		public delegate int ComponentEntryPoint(IntPtr args, int sizeBytes);

		private static readonly Dictionary<string, IsolatedComponentLoadContext> s_assemblyLoadContexts = new Dictionary<string, IsolatedComponentLoadContext>(StringComparer.InvariantCulture);

		private static readonly Dictionary<IntPtr, Delegate> s_delegates = new Dictionary<IntPtr, Delegate>();

		private static bool IsSupported { get; } = InitializeIsSupported();


		private static bool InitializeIsSupported()
		{
			if (!AppContext.TryGetSwitch("System.Runtime.InteropServices.EnableConsumingManagedCodeFromNativeHosting", out var isEnabled))
			{
				return true;
			}
			return isEnabled;
		}

		private static string MarshalToString(IntPtr arg, string argName)
		{
			string text = Marshal.PtrToStringAuto(arg);
			if (text == null)
			{
				throw new ArgumentNullException(argName);
			}
			return text;
		}

		[RequiresUnreferencedCode("Native hosting is not trim compatible and this warning will be seen if trimming is enabled.", Url = "https://aka.ms/dotnet-illink/nativehost")]
		[UnmanagedCallersOnly]
		public unsafe static int LoadAssemblyAndGetFunctionPointer(IntPtr assemblyPathNative, IntPtr typeNameNative, IntPtr methodNameNative, IntPtr delegateTypeNative, IntPtr reserved, IntPtr functionHandle)
		{
			if (!IsSupported)
			{
				return -2147450713;
			}
			try
			{
				string assemblyPath = MarshalToString(assemblyPathNative, "assemblyPathNative");
				string typeName = MarshalToString(typeNameNative, "typeNameNative");
				string methodName = MarshalToString(methodNameNative, "methodNameNative");
				if (reserved != IntPtr.Zero)
				{
					throw new ArgumentOutOfRangeException("reserved");
				}
				if (functionHandle == IntPtr.Zero)
				{
					throw new ArgumentNullException("functionHandle");
				}
				AssemblyLoadContext isolatedComponentLoadContext = GetIsolatedComponentLoadContext(assemblyPath);
				*(IntPtr*)(void*)functionHandle = InternalGetFunctionPointer(isolatedComponentLoadContext, typeName, methodName, delegateTypeNative);
			}
			catch (Exception ex)
			{
				return ex.HResult;
			}
			return 0;
		}

		[UnmanagedCallersOnly]
		public unsafe static int GetFunctionPointer(IntPtr typeNameNative, IntPtr methodNameNative, IntPtr delegateTypeNative, IntPtr loadContext, IntPtr reserved, IntPtr functionHandle)
		{
			if (!IsSupported)
			{
				return -2147450713;
			}
			try
			{
				string typeName = MarshalToString(typeNameNative, "typeNameNative");
				string methodName = MarshalToString(methodNameNative, "methodNameNative");
				if (loadContext != IntPtr.Zero)
				{
					throw new ArgumentOutOfRangeException("loadContext");
				}
				if (reserved != IntPtr.Zero)
				{
					throw new ArgumentOutOfRangeException("reserved");
				}
				if (functionHandle == IntPtr.Zero)
				{
					throw new ArgumentNullException("functionHandle");
				}
				*(IntPtr*)(void*)functionHandle = InternalGetFunctionPointer(AssemblyLoadContext.Default, typeName, methodName, delegateTypeNative);
			}
			catch (Exception ex)
			{
				return ex.HResult;
			}
			return 0;
		}

		[RequiresUnreferencedCode("Native hosting is not trim compatible and this warning will be seen if trimming is enabled.", Url = "https://aka.ms/dotnet-illink/nativehost")]
		private static IsolatedComponentLoadContext GetIsolatedComponentLoadContext(string assemblyPath)
		{
			IsolatedComponentLoadContext value;
			lock (s_assemblyLoadContexts)
			{
				if (!s_assemblyLoadContexts.TryGetValue(assemblyPath, out value))
				{
					value = new IsolatedComponentLoadContext(assemblyPath);
					s_assemblyLoadContexts.Add(assemblyPath, value);
				}
			}
			return value;
		}

		[RequiresUnreferencedCode("Native hosting is not trim compatible and this warning will be seen if trimming is enabled.", Url = "https://aka.ms/dotnet-illink/nativehost")]
		private static IntPtr InternalGetFunctionPointer(AssemblyLoadContext alc, string typeName, string methodName, IntPtr delegateTypeNative)
		{
			Func<AssemblyName, Assembly> assemblyResolver = (AssemblyName name) => alc.LoadFromAssemblyName(name);
			Type type;
			if (delegateTypeNative == IntPtr.Zero)
			{
				type = typeof(ComponentEntryPoint);
			}
			else if (delegateTypeNative == (IntPtr)(-1))
			{
				type = null;
			}
			else
			{
				string typeName2 = MarshalToString(delegateTypeNative, "delegateTypeNative");
				type = Type.GetType(typeName2, assemblyResolver, null, throwOnError: true);
			}
			Type type2 = Type.GetType(typeName, assemblyResolver, null, throwOnError: true);
			IntPtr intPtr;
			if (type == null)
			{
				BindingFlags bindingAttr = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
				MethodInfo method = type2.GetMethod(methodName, bindingAttr);
				if (method == null)
				{
					throw new MissingMethodException(typeName, methodName);
				}
				if (method.GetCustomAttribute<UnmanagedCallersOnlyAttribute>() == null)
				{
					throw new InvalidOperationException(SR.InvalidOperation_FunctionMissingUnmanagedCallersOnly);
				}
				intPtr = method.MethodHandle.GetFunctionPointer();
			}
			else
			{
				Delegate @delegate = Delegate.CreateDelegate(type, type2, methodName);
				intPtr = Marshal.GetFunctionPointerForDelegate(@delegate);
				lock (s_delegates)
				{
					s_delegates[intPtr] = @delegate;
				}
			}
			return intPtr;
		}
	}
	public static class InMemoryAssemblyLoader
	{
		private static bool IsSupported { get; } = InitializeIsSupported();


		private static bool InitializeIsSupported()
		{
			if (!AppContext.TryGetSwitch("System.Runtime.InteropServices.EnableCppCLIHostActivation", out var isEnabled))
			{
				return true;
			}
			return isEnabled;
		}

		public static void LoadInMemoryAssembly(IntPtr moduleHandle, IntPtr assemblyPath)
		{
			if (!IsSupported)
			{
				throw new NotSupportedException("This API is not enabled in trimmed scenarios. see https://aka.ms/dotnet-illink/nativehost for more details");
			}
			string text = Marshal.PtrToStringUni(assemblyPath);
			if (text == null)
			{
				throw new ArgumentOutOfRangeException("assemblyPath");
			}
			AssemblyLoadContext assemblyLoadContext = new IsolatedComponentLoadContext(text);
			assemblyLoadContext.LoadFromInMemoryModule(moduleHandle);
		}
	}
	internal sealed class IsolatedComponentLoadContext : AssemblyLoadContext
	{
		private readonly AssemblyDependencyResolver _resolver;

		[RequiresUnreferencedCode("The trimmer might remove assemblies that are loaded by this class", Url = "https://aka.ms/dotnet-illink/nativehost")]
		public IsolatedComponentLoadContext(string componentAssemblyPath)
			: base("IsolatedComponentLoadContext(" + componentAssemblyPath + ")")
		{
			_resolver = new AssemblyDependencyResolver(componentAssemblyPath);
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The trimmer warning is added to the constructor of this class since this method is a virtual one.")]
		protected override Assembly Load(AssemblyName assemblyName)
		{
			string text = _resolver.ResolveAssemblyToPath(assemblyName);
			if (text != null)
			{
				return LoadFromAssemblyPath(text);
			}
			return null;
		}

		protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
		{
			string text = _resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
			if (text != null)
			{
				return LoadUnmanagedDllFromPath(text);
			}
			return IntPtr.Zero;
		}
	}
	internal struct LICINFO
	{
		public int cbLicInfo;

		[MarshalAs(UnmanagedType.Bool)]
		public bool fRuntimeKeyAvail;

		[MarshalAs(UnmanagedType.Bool)]
		public bool fLicVerified;
	}
	[ComImport]
	[ComVisible(false)]
	[Guid("B196B28F-BAB4-101A-B69C-00AA00341D07")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface IClassFactory2 : IClassFactory
	{
		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		new void CreateInstance([MarshalAs(UnmanagedType.Interface)] object pUnkOuter, ref Guid riid, out IntPtr ppvObject);

		new void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock);

		void GetLicInfo(ref LICINFO pLicInfo);

		void RequestLicKey(int dwReserved, [MarshalAs(UnmanagedType.BStr)] out string pBstrKey);

		void CreateInstanceLic([MarshalAs(UnmanagedType.Interface)] object pUnkOuter, [MarshalAs(UnmanagedType.Interface)] object pUnkReserved, ref Guid riid, [MarshalAs(UnmanagedType.BStr)] string bstrKey, out IntPtr ppvObject);
	}
	[SupportedOSPlatform("windows")]
	public static class ComActivator
	{
		[ComVisible(true)]
		private sealed class BasicClassFactory : IClassFactory
		{
			private readonly Guid _classId;

			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)]
			private readonly Type _classType;

			public BasicClassFactory(Guid clsid, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type classType)
			{
				_classId = clsid;
				_classType = classType;
			}

			public static Type GetValidatedInterfaceType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type classType, ref Guid riid, object outer)
			{
				if (riid == Marshal.IID_IUnknown)
				{
					return typeof(object);
				}
				if (outer != null)
				{
					throw new COMException(string.Empty, -2147221232);
				}
				Type[] interfaces = classType.GetInterfaces();
				foreach (Type type in interfaces)
				{
					if (type.GUID == riid)
					{
						return type;
					}
				}
				throw new InvalidCastException();
			}

			public static IntPtr GetObjectAsInterface(object obj, Type interfaceType)
			{
				if (interfaceType == typeof(object))
				{
					return Marshal.GetIUnknownForObject(obj);
				}
				IntPtr comInterfaceForObject = Marshal.GetComInterfaceForObject(obj, interfaceType, CustomQueryInterfaceMode.Ignore);
				if (comInterfaceForObject == IntPtr.Zero)
				{
					throw new InvalidCastException();
				}
				return comInterfaceForObject;
			}

			public static object CreateAggregatedObject(object pUnkOuter, object comObject)
			{
				IntPtr iUnknownForObject = Marshal.GetIUnknownForObject(pUnkOuter);
				try
				{
					IntPtr pUnk = Marshal.CreateAggregatedObject(iUnknownForObject, comObject);
					return Marshal.GetObjectForIUnknown(pUnk);
				}
				finally
				{
					Marshal.Release(iUnknownForObject);
				}
			}

			[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
			public void CreateInstance([MarshalAs(UnmanagedType.Interface)] object pUnkOuter, ref Guid riid, out IntPtr ppvObject)
			{
				Type validatedInterfaceType = GetValidatedInterfaceType(_classType, ref riid, pUnkOuter);
				object obj = Activator.CreateInstance(_classType);
				if (pUnkOuter != null)
				{
					obj = CreateAggregatedObject(pUnkOuter, obj);
				}
				ppvObject = GetObjectAsInterface(obj, validatedInterfaceType);
			}

			public void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock)
			{
			}
		}

		[ComVisible(true)]
		private sealed class LicenseClassFactory : IClassFactory2, IClassFactory
		{
			private readonly LicenseInteropProxy _licenseProxy = new LicenseInteropProxy();

			private readonly Guid _classId;

			[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.Interfaces)]
			private readonly Type _classType;

			public LicenseClassFactory(Guid clsid, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.Interfaces)] Type classType)
			{
				_classId = clsid;
				_classType = classType;
			}

			[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
			public void CreateInstance([MarshalAs(UnmanagedType.Interface)] object pUnkOuter, ref Guid riid, out IntPtr ppvObject)
			{
				CreateInstanceInner(pUnkOuter, ref riid, null, isDesignTime: true, out ppvObject);
			}

			public void LockServer([MarshalAs(UnmanagedType.Bool)] bool fLock)
			{
			}

			public void GetLicInfo(ref LICINFO licInfo)
			{
				_licenseProxy.GetLicInfo(_classType, out var runtimeKeyAvail, out var licVerified);
				licInfo.cbLicInfo = 12;
				licInfo.fRuntimeKeyAvail = runtimeKeyAvail;
				licInfo.fLicVerified = licVerified;
			}

			public void RequestLicKey(int dwReserved, [MarshalAs(UnmanagedType.BStr)] out string pBstrKey)
			{
				pBstrKey = _licenseProxy.RequestLicKey(_classType);
			}

			public void CreateInstanceLic([MarshalAs(UnmanagedType.Interface)] object pUnkOuter, [MarshalAs(UnmanagedType.Interface)] object pUnkReserved, ref Guid riid, [MarshalAs(UnmanagedType.BStr)] string bstrKey, out IntPtr ppvObject)
			{
				CreateInstanceInner(pUnkOuter, ref riid, bstrKey, isDesignTime: false, out ppvObject);
			}

			private void CreateInstanceInner(object pUnkOuter, ref Guid riid, string key, bool isDesignTime, out IntPtr ppvObject)
			{
				Type validatedInterfaceType = BasicClassFactory.GetValidatedInterfaceType(_classType, ref riid, pUnkOuter);
				object obj = _licenseProxy.AllocateAndValidateLicense(_classType, key, isDesignTime);
				if (pUnkOuter != null)
				{
					obj = BasicClassFactory.CreateAggregatedObject(pUnkOuter, obj);
				}
				ppvObject = BasicClassFactory.GetObjectAsInterface(obj, validatedInterfaceType);
			}
		}

		private static readonly Dictionary<string, AssemblyLoadContext> s_assemblyLoadContexts = new Dictionary<string, AssemblyLoadContext>(StringComparer.InvariantCultureIgnoreCase);

		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		public static object GetClassFactoryForType(ComActivationContext cxt)
		{
			if (!Marshal.IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			if (cxt.InterfaceId != typeof(IClassFactory).GUID && cxt.InterfaceId != typeof(IClassFactory2).GUID)
			{
				throw new NotSupportedException();
			}
			if (!Path.IsPathRooted(cxt.AssemblyPath))
			{
				throw new ArgumentException(null, "cxt");
			}
			Type type = FindClassType(cxt.ClassId, cxt.AssemblyPath, cxt.AssemblyName, cxt.TypeName);
			if (LicenseInteropProxy.HasLicense(type))
			{
				return new LicenseClassFactory(cxt.ClassId, type);
			}
			return new BasicClassFactory(cxt.ClassId, type);
		}

		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		public static void ClassRegistrationScenarioForType(ComActivationContext cxt, bool register)
		{
			if (!Marshal.IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			string text = (register ? "ComRegisterFunctionAttribute" : "ComUnregisterFunctionAttribute");
			Type type = Type.GetType("System.Runtime.InteropServices." + text + ", System.Runtime.InteropServices", throwOnError: false);
			if (type == null)
			{
				return;
			}
			if (!Path.IsPathRooted(cxt.AssemblyPath))
			{
				throw new ArgumentException(null, "cxt");
			}
			Type type2 = FindClassType(cxt.ClassId, cxt.AssemblyPath, cxt.AssemblyName, cxt.TypeName);
			Type type3 = type2;
			bool flag = false;
			while (type3 != null && !flag)
			{
				MethodInfo[] methods = type3.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo[] array = methods;
				foreach (MethodInfo methodInfo in array)
				{
					if (methodInfo.GetCustomAttributes(type, inherit: true).Length != 0)
					{
						if (!methodInfo.IsStatic)
						{
							string resourceFormat = (register ? SR.InvalidOperation_NonStaticComRegFunction : SR.InvalidOperation_NonStaticComUnRegFunction);
							throw new InvalidOperationException(SR.Format(resourceFormat));
						}
						ParameterInfo[] parameters = methodInfo.GetParameters();
						if (methodInfo.ReturnType != typeof(void) || parameters == null || parameters.Length != 1 || (parameters[0].ParameterType != typeof(string) && parameters[0].ParameterType != typeof(Type)))
						{
							string resourceFormat2 = (register ? SR.InvalidOperation_InvalidComRegFunctionSig : SR.InvalidOperation_InvalidComUnRegFunctionSig);
							throw new InvalidOperationException(SR.Format(resourceFormat2));
						}
						if (flag)
						{
							string resourceFormat3 = (register ? SR.InvalidOperation_MultipleComRegFunctions : SR.InvalidOperation_MultipleComUnRegFunctions);
							throw new InvalidOperationException(SR.Format(resourceFormat3));
						}
						object[] array2 = new object[1];
						if (parameters[0].ParameterType == typeof(string))
						{
							array2[0] = $"HKEY_LOCAL_MACHINE\\SOFTWARE\\Classes\\CLSID\\{cxt.ClassId:B}";
						}
						else
						{
							array2[0] = type2;
						}
						methodInfo.Invoke(null, array2);
						flag = true;
					}
				}
				type3 = type3.BaseType;
			}
		}

		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		[CLSCompliant(false)]
		[UnmanagedCallersOnly]
		public unsafe static int GetClassFactoryForTypeInternal(ComActivationContextInternal* pCxtInt)
		{
			if (!Marshal.IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			ref ComActivationContextInternal reference = ref *pCxtInt;
			if (IsLoggingEnabled())
			{
			}
			try
			{
				ComActivationContext cxt = ComActivationContext.Create(ref reference);
				object classFactoryForType = GetClassFactoryForType(cxt);
				IntPtr iUnknownForObject = Marshal.GetIUnknownForObject(classFactoryForType);
				Marshal.WriteIntPtr(reference.ClassFactoryDest, iUnknownForObject);
			}
			catch (Exception ex)
			{
				return ex.HResult;
			}
			return 0;
		}

		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		[CLSCompliant(false)]
		[UnmanagedCallersOnly]
		public unsafe static int RegisterClassForTypeInternal(ComActivationContextInternal* pCxtInt)
		{
			if (!Marshal.IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			ref ComActivationContextInternal reference = ref *pCxtInt;
			if (IsLoggingEnabled())
			{
			}
			if (reference.InterfaceId != Guid.Empty || reference.ClassFactoryDest != IntPtr.Zero)
			{
				throw new ArgumentException(null, "pCxtInt");
			}
			try
			{
				ComActivationContext cxt = ComActivationContext.Create(ref reference);
				ClassRegistrationScenarioForType(cxt, register: true);
			}
			catch (Exception ex)
			{
				return ex.HResult;
			}
			return 0;
		}

		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		[CLSCompliant(false)]
		[UnmanagedCallersOnly]
		public unsafe static int UnregisterClassForTypeInternal(ComActivationContextInternal* pCxtInt)
		{
			if (!Marshal.IsBuiltInComSupported)
			{
				throw new NotSupportedException(SR.NotSupported_COM);
			}
			ref ComActivationContextInternal reference = ref *pCxtInt;
			if (IsLoggingEnabled())
			{
			}
			if (reference.InterfaceId != Guid.Empty || reference.ClassFactoryDest != IntPtr.Zero)
			{
				throw new ArgumentException(null, "pCxtInt");
			}
			try
			{
				ComActivationContext cxt = ComActivationContext.Create(ref reference);
				ClassRegistrationScenarioForType(cxt, register: false);
			}
			catch (Exception ex)
			{
				return ex.HResult;
			}
			return 0;
		}

		private static bool IsLoggingEnabled()
		{
			return false;
		}

		[RequiresUnreferencedCode("Built-in COM support is not trim compatible", Url = "https://aka.ms/dotnet-illink/com")]
		private static Type FindClassType(Guid clsid, string assemblyPath, string assemblyName, string typeName)
		{
			try
			{
				AssemblyLoadContext aLC = GetALC(assemblyPath);
				AssemblyName assemblyName2 = new AssemblyName(assemblyName);
				Assembly assembly = aLC.LoadFromAssemblyName(assemblyName2);
				Type type = assembly.GetType(typeName);
				if (type != null)
				{
					return type;
				}
			}
			catch (Exception)
			{
				if (!IsLoggingEnabled())
				{
				}
			}
			throw new COMException(string.Empty, -2147221231);
		}

		[RequiresUnreferencedCode("The trimmer might remove types which are needed by the assemblies loaded in this method.")]
		private static AssemblyLoadContext GetALC(string assemblyPath)
		{
			AssemblyLoadContext value;
			lock (s_assemblyLoadContexts)
			{
				if (!s_assemblyLoadContexts.TryGetValue(assemblyPath, out value))
				{
					value = new IsolatedComponentLoadContext(assemblyPath);
					s_assemblyLoadContexts.Add(assemblyPath, value);
				}
			}
			return value;
		}
	}
	internal sealed class LicenseInteropProxy
	{
		private static readonly Type s_licenseAttrType = Type.GetType("System.ComponentModel.LicenseProviderAttribute, System.ComponentModel.TypeConverter", throwOnError: false);

		private static readonly Type s_licenseExceptionType = Type.GetType("System.ComponentModel.LicenseException, System.ComponentModel.TypeConverter", throwOnError: false);

		private readonly MethodInfo _createWithContext;

		private readonly MethodInfo _validateTypeAndReturnDetails;

		private readonly MethodInfo _getCurrentContextInfo;

		private readonly MethodInfo _createDesignContext;

		private readonly MethodInfo _createRuntimeContext;

		private readonly MethodInfo _setSavedLicenseKey;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicMethods)]
		private readonly Type _licInfoHelper;

		private readonly MethodInfo _licInfoHelperContains;

		private object _licContext;

		private Type _targetRcwType;

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2111:ReflectionToDynamicallyAccessedMembers", Justification = "The type parameter to LicenseManager.CreateWithContext method has PublicConstructors annotation. We only invoke this methodfrom AllocateAndValidateLicense which annotates the value passed in with the same annotation.")]
		public LicenseInteropProxy()
		{
			Type type = Type.GetType("System.ComponentModel.LicenseManager, System.ComponentModel.TypeConverter", throwOnError: true);
			Type type2 = Type.GetType("System.ComponentModel.LicenseContext, System.ComponentModel.TypeConverter", throwOnError: true);
			_setSavedLicenseKey = type2.GetMethod("SetSavedLicenseKey", BindingFlags.Instance | BindingFlags.Public);
			_createWithContext = type.GetMethod("CreateWithContext", new Type[2]
			{
				typeof(Type),
				type2
			});
			Type nestedType = type.GetNestedType("LicenseInteropHelper", BindingFlags.NonPublic);
			_validateTypeAndReturnDetails = nestedType.GetMethod("ValidateAndRetrieveLicenseDetails", BindingFlags.Static | BindingFlags.Public);
			_getCurrentContextInfo = nestedType.GetMethod("GetCurrentContextInfo", BindingFlags.Static | BindingFlags.Public);
			Type nestedType2 = type.GetNestedType("CLRLicenseContext", BindingFlags.NonPublic);
			_createDesignContext = nestedType2.GetMethod("CreateDesignContext", BindingFlags.Static | BindingFlags.Public);
			_createRuntimeContext = nestedType2.GetMethod("CreateRuntimeContext", BindingFlags.Static | BindingFlags.Public);
			_licInfoHelper = type.GetNestedType("LicInfoHelperLicenseContext", BindingFlags.NonPublic);
			_licInfoHelperContains = _licInfoHelper.GetMethod("Contains", BindingFlags.Instance | BindingFlags.Public);
		}

		public static object Create()
		{
			return new LicenseInteropProxy();
		}

		public static bool HasLicense(Type type)
		{
			if (s_licenseAttrType == null)
			{
				return false;
			}
			return type.IsDefined(s_licenseAttrType, inherit: true);
		}

		public void GetLicInfo(Type type, out bool runtimeKeyAvail, out bool licVerified)
		{
			runtimeKeyAvail = false;
			licVerified = false;
			object obj = Activator.CreateInstance(_licInfoHelper);
			object[] array = new object[4] { obj, type, null, null };
			if ((bool)_validateTypeAndReturnDetails.Invoke(null, BindingFlags.DoNotWrapExceptions, null, array, null))
			{
				IDisposable disposable = (IDisposable)array[2];
				if (disposable != null)
				{
					disposable.Dispose();
					licVerified = true;
				}
				array = new object[1] { type.AssemblyQualifiedName };
				runtimeKeyAvail = (bool)_licInfoHelperContains.Invoke(obj, BindingFlags.DoNotWrapExceptions, null, array, null);
			}
		}

		public string RequestLicKey(Type type)
		{
			object[] array = new object[4] { null, type, null, null };
			if (!(bool)_validateTypeAndReturnDetails.Invoke(null, BindingFlags.DoNotWrapExceptions, null, array, null))
			{
				throw new COMException();
			}
			((IDisposable)array[2])?.Dispose();
			string text = (string)array[3];
			if (text == null)
			{
				throw new COMException();
			}
			return text;
		}

		public object AllocateAndValidateLicense([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type, string key, bool isDesignTime)
		{
			object obj;
			if (isDesignTime)
			{
				object[] parameters = new object[1] { type };
				obj = _createDesignContext.Invoke(null, BindingFlags.DoNotWrapExceptions, null, parameters, null);
			}
			else
			{
				object[] parameters = new object[2] { type, key };
				obj = _createRuntimeContext.Invoke(null, BindingFlags.DoNotWrapExceptions, null, parameters, null);
			}
			try
			{
				object[] parameters = new object[2] { type, obj };
				return _createWithContext.Invoke(null, BindingFlags.DoNotWrapExceptions, null, parameters, null);
			}
			catch (Exception ex) when (ex.GetType() == s_licenseExceptionType)
			{
				throw new COMException(ex.Message, -2147221230);
			}
		}

		public void GetCurrentContextInfo(RuntimeTypeHandle rth, out bool isDesignTime, out IntPtr bstrKey)
		{
			Type typeFromHandle = Type.GetTypeFromHandle(rth);
			object[] array = new object[3] { typeFromHandle, null, null };
			_licContext = _getCurrentContextInfo.Invoke(null, BindingFlags.DoNotWrapExceptions, null, array, null);
			_targetRcwType = typeFromHandle;
			isDesignTime = (bool)array[1];
			bstrKey = Marshal.StringToBSTR((string)array[2]);
		}

		public void SaveKeyInCurrentContext(IntPtr bstrKey)
		{
			if (!(bstrKey == IntPtr.Zero))
			{
				string text = Marshal.PtrToStringBSTR(bstrKey);
				object[] parameters = new object[2] { _targetRcwType, text };
				_setSavedLicenseKey.Invoke(_licContext, BindingFlags.DoNotWrapExceptions, null, parameters, null);
			}
		}
	}
}